diff --git a/.cargo/config b/.cargo/config
deleted file mode 100644
index 35da7a4853b8637ea4dda4a35ea51d762f82b4f3..0000000000000000000000000000000000000000
--- a/.cargo/config
+++ /dev/null
@@ -1,20 +0,0 @@
-[target.x86_64-unknown-redox]
-linker = "x86_64-unknown-redox-gcc"
-
-[target.'cfg(feature = "cargo-clippy")']
-rustflags = [
- "-Wclippy::use_self",
- "-Wclippy::needless_pass_by_value",
- "-Wclippy::semicolon_if_nothing_returned",
- "-Wclippy::single_char_pattern",
- "-Wclippy::explicit_iter_loop",
-]
-
-[build]
-# See https://github.com/time-rs/time/issues/293#issuecomment-1005002386. The
-# unsoundness here is not in the `time` library, but in the Rust stdlib, and as
-# such it needs to be fixed there.
-rustflags = ["--cfg", "unsound_local_offset"]
-
-[target.'cfg(target_os = "linux")']
-rustflags = ["--cfg", "unsound_local_offset"]
diff --git a/.cargo/config.toml b/.cargo/config.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d7db3025da8982d99590ec39d917306ca752749c
--- /dev/null
+++ b/.cargo/config.toml
@@ -0,0 +1,13 @@
+[target.x86_64-unknown-redox]
+linker = "x86_64-unknown-redox-gcc"
+
+[target.'cfg(clippy)']
+rustflags = [
+ "-Wclippy::use_self",
+ "-Wclippy::needless_pass_by_value",
+ "-Wclippy::semicolon_if_nothing_returned",
+ "-Wclippy::single_char_pattern",
+ "-Wclippy::explicit_iter_loop",
+ "-Wclippy::if_not_else",
+]
+
diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
new file mode 100644
index 0000000000000000000000000000000000000000..a1da738c653966d3fd9ee824b0c6122567208816
--- /dev/null
+++ b/.cargo_vcs_info.json
@@ -0,0 +1,6 @@
+{
+ "git": {
+ "sha1": "17a4a224f3f2f3f4ae465a210ba2260e9c47db17"
+ },
+ "path_in_vcs": ""
+}
\ No newline at end of file
diff --git a/.clippy.toml b/.clippy.toml
index 16caf02ee91918c3d9a3abb3d8080136c23b6d80..b1552463edde4a892d7e7ef3973906f47969cd2a 100644
--- a/.clippy.toml
+++ b/.clippy.toml
@@ -1 +1,2 @@
-msrv = "1.60.0"
+msrv = "1.70.0"
+cognitive-complexity-threshold = 24
diff --git a/.config/nextest.toml b/.config/nextest.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3ba8bb393a4e78f6770ac635ea6292f1166c143d
--- /dev/null
+++ b/.config/nextest.toml
@@ -0,0 +1,6 @@
+[profile.ci]
+retries = 2
+status-level = "all"
+final-status-level = "skip"
+failure-output = "immediate-final"
+fail-fast = false
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 0000000000000000000000000000000000000000..ccae1f831302505a947f1fda1eb66325fe0d308a
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1 @@
+github: uutils
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
deleted file mode 100644
index c29a77873b18fcce42ca9d5cc8350285d70b8177..0000000000000000000000000000000000000000
--- a/.github/dependabot.yml
+++ /dev/null
@@ -1,12 +0,0 @@
-version: 2
-updates:
- - package-ecosystem: "cargo"
- directory: "/"
- schedule:
- interval: weekly
- open-pull-requests-limit: 10
- - package-ecosystem: "github-actions"
- directory: "/"
- schedule:
- interval: weekly
- open-pull-requests-limit: 5
diff --git a/.github/stale.yml b/.github/stale.yml
index b614226dca16a9d3200c6f41b4e6cfdd3cf5de98..cef0e1a87a01d4bd679671adaa5f434f4d05ede7 100644
--- a/.github/stale.yml
+++ b/.github/stale.yml
@@ -1,8 +1,8 @@
# spell-checker:ignore (labels) wontfix
# Number of days of inactivity before an issue/PR becomes stale
-daysUntilStale: 365
+daysUntilStale: 1095
# Number of days of inactivity before a stale issue/PR is closed
-daysUntilClose: 365
+daysUntilClose: 1095
# Issues with these labels will never be considered stale
exemptLabels:
- pinned
diff --git a/.github/workflows/CICD.yml b/.github/workflows/CICD.yml
index 79f8dd93383b48e551691995d687604b45a5f3ac..b09366d7fe1fb49bcece657cd7315ea35e8a0266 100644
--- a/.github/workflows/CICD.yml
+++ b/.github/workflows/CICD.yml
@@ -1,39 +1,48 @@
name: CICD
-# spell-checker:ignore (acronyms) CICD MSVC musl
-# spell-checker:ignore (env/flags) Awarnings Ccodegen Coverflow Cpanic Dwarnings RUSTDOCFLAGS RUSTFLAGS Zpanic
-# spell-checker:ignore (jargon) SHAs deps dequote softprops subshell toolchain
-# spell-checker:ignore (names) CodeCOV MacOS MinGW Peltoche rivy
-# spell-checker:ignore (shell/tools) choco clippy dmake dpkg esac fakeroot gmake grcov halium lcov libssl mkdir popd printf pushd rsync rustc rustfmt rustup shopt xargs
-# spell-checker:ignore (misc) aarch alnum armhf bindir busytest coreutils gnueabihf issuecomment maint nullglob onexitbegin onexitend pell runtest tempfile testsuite uutils DESTDIR multisize Swatinem
+# spell-checker:ignore (abbrev/names) CICD CodeCOV MacOS MinGW MSVC musl taiki
+# spell-checker:ignore (env/flags) Awarnings Ccodegen Coverflow Cpanic Dwarnings RUSTDOCFLAGS RUSTFLAGS Zpanic CARGOFLAGS
+# spell-checker:ignore (jargon) SHAs deps dequote softprops subshell toolchain fuzzers
+# spell-checker:ignore (people) Peltoche rivy dtolnay
+# spell-checker:ignore (shell/tools) choco clippy dmake dpkg esac fakeroot fdesc fdescfs gmake grcov halium lcov libssl mkdir popd printf pushd rsync rustc rustfmt rustup shopt utmpdump xargs
+# spell-checker:ignore (misc) aarch alnum armhf bindir busytest coreutils defconfig DESTDIR gecos gnueabihf issuecomment maint multisize nullglob onexitbegin onexitend pell runtest Swatinem tempfile testsuite toybox uutils
env:
PROJECT_NAME: coreutils
PROJECT_DESC: "Core universal (cross-platform) utilities"
PROJECT_AUTH: "uutils"
- RUST_MIN_SRV: "1.60.0" ## MSRV v1.60.0
+ RUST_MIN_SRV: "1.70.0"
# * style job configuration
STYLE_FAIL_ON_FAULT: true ## (bool) fail the build if a style job contains a fault (error or warning); may be overridden on a per-job basis
-on: [push, pull_request]
+on:
+ pull_request:
+ push:
+ tags:
+ - '*'
+ branches:
+ - main
permissions:
contents: read # to fetch code (actions/checkout)
+# End the current execution if there is a new changeset in the PR.
+concurrency:
+ group: ${{ github.workflow }}-${{ github.ref }}
+ cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
jobs:
cargo-deny:
name: Style/cargo-deny
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@v3
+ - uses: actions/checkout@v4
- uses: EmbarkStudios/cargo-deny-action@v1
style_deps:
## ToDO: [2021-11-10; rivy] 'Style/deps' needs more informative output and better integration of results into the GHA dashboard
name: Style/deps
runs-on: ${{ matrix.job.os }}
- # env:
- # STYLE_FAIL_ON_FAULT: false # overrides workflow default
strategy:
fail-fast: false
matrix:
@@ -44,13 +53,18 @@ jobs:
- { os: macos-latest , features: "feat_Tier1,feat_require_unix,feat_require_unix_utmpx" }
- { os: windows-latest , features: feat_os_windows }
steps:
- - uses: actions/checkout@v3
+ - uses: actions/checkout@v4
+ - uses: dtolnay/rust-toolchain@nightly
+ ## note: requires 'nightly' toolchain b/c `cargo-udeps` uses the `rustc` '-Z save-analysis' option
+ ## * ... ref: <https://github.com/est31/cargo-udeps/issues/73>
+ - uses: taiki-e/install-action@cargo-udeps
+ - uses: Swatinem/rust-cache@v2
- name: Initialize workflow variables
id: vars
shell: bash
run: |
## VARs setup
- outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
+ outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
# failure mode
unset FAIL_ON_FAULT ; case '${{ env.STYLE_FAIL_ON_FAULT }}' in
''|0|f|false|n|no|off) FAULT_TYPE=warning ;;
@@ -62,17 +76,6 @@ jobs:
CARGO_FEATURES_OPTION='' ;
if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
outputs CARGO_FEATURES_OPTION
- ## note: requires 'nightly' toolchain b/c `cargo-udeps` uses the `rustc` '-Z save-analysis' option
- ## * ... ref: <https://github.com/est31/cargo-udeps/issues/73>
- - name: Install `rust` toolchain
- run: |
- rustup toolchain install nightly --profile minimal
- rustup default nightly
- - uses: Swatinem/rust-cache@v2
- - name: Install `cargo-udeps`
- run: cargo install cargo-udeps
- env:
- RUSTUP_TOOLCHAIN: stable
- name: Detect unused dependencies
shell: bash
run: |
@@ -85,161 +88,12 @@ jobs:
grep --ignore-case "all deps seem to have been used" udeps.log || { printf "%s\n" "::${fault_type} ::${fault_prefix}: \`cargo udeps\`: style violation (unused dependency found)" ; fault=true ; }
if [ -n "${{ steps.vars.outputs.FAIL_ON_FAULT }}" ] && [ -n "$fault" ]; then exit 1 ; fi
- style_format:
- name: Style/format
- runs-on: ${{ matrix.job.os }}
- # env:
- # STYLE_FAIL_ON_FAULT: false # overrides workflow default
- strategy:
- fail-fast: false
- matrix:
- job:
- - { os: ubuntu-latest , features: feat_os_unix }
- steps:
- - uses: actions/checkout@v3
- - name: Initialize workflow variables
- id: vars
- shell: bash
- run: |
- ## VARs setup
- outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
- # failure mode
- unset FAIL_ON_FAULT ; case '${{ env.STYLE_FAIL_ON_FAULT }}' in
- ''|0|f|false|n|no|off) FAULT_TYPE=warning ;;
- *) FAIL_ON_FAULT=true ; FAULT_TYPE=error ;;
- esac;
- outputs FAIL_ON_FAULT FAULT_TYPE
- # target-specific options
- # * CARGO_FEATURES_OPTION
- CARGO_FEATURES_OPTION='' ;
- if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
- outputs CARGO_FEATURES_OPTION
- - name: Install `rust` toolchain
- run: |
- rm -f "${HOME}/.cargo/bin/"{rustfmt,cargo-fmt}
- rustup toolchain install stable -c rustfmt --profile minimal
- rustup default stable
- - uses: Swatinem/rust-cache@v2
- - name: "`cargo fmt` testing"
- shell: bash
- run: |
- ## `cargo fmt` testing
- unset fault
- fault_type="${{ steps.vars.outputs.FAULT_TYPE }}"
- fault_prefix=$(echo "$fault_type" | tr '[:lower:]' '[:upper:]')
- # * convert any errors/warnings to GHA UI annotations; ref: <https://help.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-a-warning-message>
- S=$(cargo fmt -- --check) && printf "%s\n" "$S" || { printf "%s\n" "$S" ; printf "%s\n" "$S" | sed -E -n -e "s/^Diff[[:space:]]+in[[:space:]]+${PWD//\//\\/}\/(.*)[[:space:]]+at[[:space:]]+[^0-9]+([0-9]+).*$/::${fault_type} file=\1,line=\2::${fault_prefix}: \`cargo fmt\`: style violation (file:'\1', line:\2; use \`cargo fmt -- \"\1\"\`)/p" ; fault=true ; }
- if [ -n "${{ steps.vars.outputs.FAIL_ON_FAULT }}" ] && [ -n "$fault" ]; then exit 1 ; fi
-
- style_lint:
- name: Style/lint
- runs-on: ${{ matrix.job.os }}
- # env:
- # STYLE_FAIL_ON_FAULT: false # overrides workflow default
- strategy:
- fail-fast: false
- matrix:
- job:
- - { os: ubuntu-latest , features: feat_os_unix }
- - { os: macos-latest , features: feat_os_macos }
- - { os: windows-latest , features: feat_os_windows }
- steps:
- - uses: actions/checkout@v3
- - name: Initialize workflow variables
- id: vars
- shell: bash
- run: |
- ## VARs setup
- outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
- # failure mode
- unset FAIL_ON_FAULT ; case '${{ env.STYLE_FAIL_ON_FAULT }}' in
- ''|0|f|false|n|no|off) FAULT_TYPE=warning ;;
- *) FAIL_ON_FAULT=true ; FAULT_TYPE=error ;;
- esac;
- outputs FAIL_ON_FAULT FAULT_TYPE
- # target-specific options
- # * CARGO_FEATURES_OPTION
- CARGO_FEATURES_OPTION='--all-features' ;
- if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
- outputs CARGO_FEATURES_OPTION
- # * determine sub-crate utility list
- UTILITY_LIST="$(./util/show-utils.sh ${CARGO_FEATURES_OPTION})"
- echo UTILITY_LIST=${UTILITY_LIST}
- CARGO_UTILITY_LIST_OPTIONS="$(for u in ${UTILITY_LIST}; do echo -n "-puu_${u} "; done;)"
- outputs CARGO_UTILITY_LIST_OPTIONS
- - name: Install/setup prerequisites
- shell: bash
- run: |
- case '${{ matrix.job.os }}' in
- macos-latest) brew install coreutils ;; # needed for show-utils.sh
- esac
- - name: Install `rust` toolchain
- run: |
- rustup toolchain install stable -c clippy --profile minimal
- rustup default stable
- - uses: Swatinem/rust-cache@v2
- - name: "`cargo clippy` lint testing"
- shell: bash
- run: |
- ## `cargo clippy` lint testing
- unset fault
- fault_type="${{ steps.vars.outputs.FAULT_TYPE }}"
- fault_prefix=$(echo "$fault_type" | tr '[:lower:]' '[:upper:]')
- # * convert any warnings to GHA UI annotations; ref: <https://help.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-a-warning-message>
- S=$(cargo clippy --all-targets ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} ${{ steps.vars.outputs.CARGO_UTILITY_LIST_OPTIONS }} -- -W clippy::manual_string_new -D warnings 2>&1) && printf "%s\n" "$S" || { printf "%s\n" "$S" ; printf "%s" "$S" | sed -E -n -e '/^error:/{' -e "N; s/^error:[[:space:]]+(.*)\\n[[:space:]]+-->[[:space:]]+(.*):([0-9]+):([0-9]+).*$/::${fault_type} file=\2,line=\3,col=\4::${fault_prefix}: \`cargo clippy\`: \1 (file:'\2', line:\3)/p;" -e '}' ; fault=true ; }
- if [ -n "${{ steps.vars.outputs.FAIL_ON_FAULT }}" ] && [ -n "$fault" ]; then exit 1 ; fi
-
- style_spellcheck:
- name: Style/spelling
- runs-on: ${{ matrix.job.os }}
- # env:
- # STYLE_FAIL_ON_FAULT: false # overrides workflow default
- strategy:
- matrix:
- job:
- - { os: ubuntu-latest , features: feat_os_unix }
- steps:
- - uses: actions/checkout@v3
- - uses: Swatinem/rust-cache@v2
- - name: Initialize workflow variables
- id: vars
- shell: bash
- run: |
- ## VARs setup
- outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
- # failure mode
- unset FAIL_ON_FAULT ; case '${{ env.STYLE_FAIL_ON_FAULT }}' in
- ''|0|f|false|n|no|off) FAULT_TYPE=warning ;;
- *) FAIL_ON_FAULT=true ; FAULT_TYPE=error ;;
- esac;
- outputs FAIL_ON_FAULT FAULT_TYPE
- - name: Install/setup prerequisites
- shell: bash
- run: |
- ## Install/setup prerequisites
- # * pin installed cspell to v4.2.8 (cspell v5+ is broken for NodeJS < v12)
- ## maint: [2021-11-10; rivy] `cspell` version may be advanced to v5 when used with NodeJS >= v12
- sudo apt-get -y update ; sudo apt-get -y install npm ; sudo npm install cspell@4.2.8 -g ;
- - name: Run `cspell`
- shell: bash
- run: |
- ## Run `cspell`
- unset fault
- fault_type="${{ steps.vars.outputs.FAULT_TYPE }}"
- fault_prefix=$(echo "$fault_type" | tr '[:lower:]' '[:upper:]')
- # * find cspell configuration ; note: avoid quotes around ${cfg_file} b/c `cspell` (v4) doesn't correctly dequote the config argument (or perhaps a subshell expansion issue?)
- cfg_files=($(shopt -s nullglob ; echo {.vscode,.}/{,.}c[sS]pell{.json,.config{.js,.cjs,.json,.yaml,.yml},.yaml,.yml} ;))
- cfg_file=${cfg_files[0]}
- unset CSPELL_CFG_OPTION ; if [ -n "$cfg_file" ]; then CSPELL_CFG_OPTION="--config $cfg_file" ; fi
- # * `cspell`
- ## maint: [2021-11-10; rivy] the `--no-progress` option for `cspell` is a `cspell` v5+ option
- # S=$(cspell ${CSPELL_CFG_OPTION} --no-summary --no-progress "**/*") && printf "%s\n" "$S" || { printf "%s\n" "$S" ; printf "%s" "$S" | sed -E -n "s/${PWD//\//\\/}\/(.*):(.*):(.*) - (.*)/::${fault_type} file=\1,line=\2,col=\3::${fault_type^^}: \4 (file:'\1', line:\2)/p" ; fault=true ; true ; }
- S=$(cspell ${CSPELL_CFG_OPTION} --no-summary "**/*") && printf "%s\n" "$S" || { printf "%s\n" "$S" ; printf "%s" "$S" | sed -E -n "s/${PWD//\//\\/}\/(.*):(.*):(.*) - (.*)/::${fault_type} file=\1,line=\2,col=\3::${fault_type^^}: \4 (file:'\1', line:\2)/p" ; fault=true ; true ; }
- if [ -n "${{ steps.vars.outputs.FAIL_ON_FAULT }}" ] && [ -n "$fault" ]; then exit 1 ; fi
-
doc_warnings:
name: Documentation/warnings
runs-on: ${{ matrix.job.os }}
+ env:
+ SCCACHE_GHA_ENABLED: "true"
+ RUSTC_WRAPPER: "sccache"
strategy:
fail-fast: false
matrix:
@@ -251,13 +105,20 @@ jobs:
# - { os: macos-latest , features: feat_os_macos }
# - { os: windows-latest , features: feat_os_windows }
steps:
- - uses: actions/checkout@v3
+ - uses: actions/checkout@v4
+ - uses: dtolnay/rust-toolchain@master
+ with:
+ toolchain: stable
+ components: clippy
+ - uses: Swatinem/rust-cache@v2
+ - name: Run sccache-cache
+ uses: mozilla-actions/sccache-action@v0.0.5
- name: Initialize workflow variables
id: vars
shell: bash
run: |
## VARs setup
- outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
+ outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
# failure mode
unset FAIL_ON_FAULT ; case '${{ env.STYLE_FAIL_ON_FAULT }}' in
''|0|f|false|n|no|off) FAULT_TYPE=warning ;;
@@ -267,49 +128,56 @@ jobs:
# target-specific options
# * CARGO_FEATURES_OPTION
CARGO_FEATURES_OPTION='--all-features' ;
- if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
+ if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features ${{ matrix.job.features }}' ; fi
outputs CARGO_FEATURES_OPTION
# * determine sub-crate utility list
UTILITY_LIST="$(./util/show-utils.sh ${CARGO_FEATURES_OPTION})"
echo UTILITY_LIST=${UTILITY_LIST}
CARGO_UTILITY_LIST_OPTIONS="$(for u in ${UTILITY_LIST}; do echo -n "-puu_${u} "; done;)"
outputs CARGO_UTILITY_LIST_OPTIONS
- - name: Install `rust` toolchain
- run: |
- rustup toolchain install stable -c clippy --profile minimal
- rustup default stable
- - uses: Swatinem/rust-cache@v2
- name: "`cargo doc` with warnings"
shell: bash
run: |
RUSTDOCFLAGS="-Dwarnings" cargo doc ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} --no-deps --workspace --document-private-items
-
+ - uses: DavidAnson/markdownlint-cli2-action@v16
+ with:
+ fix: "true"
+ globs: |
+ *.md
+ docs/src/*.md
+ src/uu/*/*.md
min_version:
name: MinRustV # Minimum supported rust version (aka, MinSRV or MSRV)
runs-on: ${{ matrix.job.os }}
+ env:
+ SCCACHE_GHA_ENABLED: "true"
+ RUSTC_WRAPPER: "sccache"
strategy:
matrix:
job:
- { os: ubuntu-latest , features: feat_os_unix }
steps:
- - uses: actions/checkout@v3
+ - uses: actions/checkout@v4
+ - uses: dtolnay/rust-toolchain@master
+ with:
+ toolchain: ${{ env.RUST_MIN_SRV }}
+ components: rustfmt
+ - uses: taiki-e/install-action@nextest
+ - uses: Swatinem/rust-cache@v2
+ - name: Run sccache-cache
+ uses: mozilla-actions/sccache-action@v0.0.5
- name: Initialize workflow variables
id: vars
shell: bash
run: |
## VARs setup
- outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
+ outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
# target-specific options
# * CARGO_FEATURES_OPTION
unset CARGO_FEATURES_OPTION
if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
outputs CARGO_FEATURES_OPTION
- - name: Install `rust` toolchain (v${{ env.RUST_MIN_SRV }})
- run: |
- rustup toolchain install ${{ env.RUST_MIN_SRV }} --profile minimal
- rustup default ${{ env.RUST_MIN_SRV }}
- - uses: Swatinem/rust-cache@v2
- name: Confirm MinSRV compatible 'Cargo.lock'
shell: bash
run: |
@@ -342,11 +210,11 @@ jobs:
echo "## dependency list"
## * using the 'stable' toolchain is necessary to avoid "unexpected '--filter-platform'" errors
RUSTUP_TOOLCHAIN=stable cargo fetch --locked --quiet
- RUSTUP_TOOLCHAIN=stable cargo tree --all --locked --no-dev-dependencies --no-indent ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} | grep -vE "$PWD" | sort --unique
+ RUSTUP_TOOLCHAIN=stable cargo tree --no-dedupe --locked -e=no-dev --prefix=none ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} | grep -vE "$PWD" | sort --unique
- name: Test
- run: cargo test -v ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} -p uucore -p coreutils
+ run: cargo nextest run --hide-progress-bar --profile ci ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} -p uucore -p coreutils
env:
- RUSTFLAGS: "-Awarnings --cfg unsound_local_offset"
+ RUSTFLAGS: "-Awarnings"
RUST_BACKTRACE: "1"
deps:
@@ -358,11 +226,8 @@ jobs:
job:
- { os: ubuntu-latest , features: feat_os_unix }
steps:
- - uses: actions/checkout@v3
- - name: Install `rust` toolchain
- run: |
- rustup toolchain install stable --profile minimal
- rustup default stable
+ - uses: actions/checkout@v4
+ - uses: dtolnay/rust-toolchain@stable
- uses: Swatinem/rust-cache@v2
- name: "`cargo update` testing"
shell: bash
@@ -375,35 +240,61 @@ jobs:
name: Build/Makefile
needs: [ min_version, deps ]
runs-on: ${{ matrix.job.os }}
+ env:
+ SCCACHE_GHA_ENABLED: "true"
+ RUSTC_WRAPPER: "sccache"
strategy:
fail-fast: false
matrix:
job:
- { os: ubuntu-latest , features: feat_os_unix }
steps:
- - uses: actions/checkout@v3
- - name: Install `rust` toolchain
- run: |
- rustup toolchain install stable --profile minimal
- rustup default stable
+ - uses: actions/checkout@v4
+ - uses: dtolnay/rust-toolchain@stable
+ - uses: taiki-e/install-action@nextest
- uses: Swatinem/rust-cache@v2
+ - name: Run sccache-cache
+ uses: mozilla-actions/sccache-action@v0.0.5
- name: "`make build`"
shell: bash
run: |
make build
- - name: "`make test`"
+ - name: "`make nextest`"
+ shell: bash
+ run: make nextest CARGOFLAGS="--profile ci --hide-progress-bar"
+ env:
+ RUST_BACKTRACE: "1"
+ - name: "`make install`"
shell: bash
run: |
- make test
+ DESTDIR=/tmp/ make PROFILE=release install
+ # Check that the manpage is present
+ test -f /tmp/usr/local/share/man/man1/whoami.1
+ # Check that the completion is present
+ test -f /tmp/usr/local/share/zsh/site-functions/_install
+ test -f /tmp/usr/local/share/bash-completion/completions/head
+ test -f /tmp/usr/local/share/fish/vendor_completions.d/cat.fish
env:
RUST_BACKTRACE: "1"
-
+ - name: "`make uninstall`"
+ shell: bash
+ run: |
+ DESTDIR=/tmp/ make uninstall
+ # Check that the manpage is not present
+ ! test -f /tmp/usr/local/share/man/man1/whoami.1
+ # Check that the completion is not present
+ ! test -f /tmp/usr/local/share/zsh/site-functions/_install
+ ! test -f /tmp/usr/local/share/bash-completion/completions/head
+ ! test -f /tmp/usr/local/share/fish/vendor_completions.d/cat.fish
build_rust_stable:
name: Build/stable
needs: [ min_version, deps ]
runs-on: ${{ matrix.job.os }}
timeout-minutes: 90
+ env:
+ SCCACHE_GHA_ENABLED: "true"
+ RUSTC_WRAPPER: "sccache"
strategy:
fail-fast: false
matrix:
@@ -412,14 +303,14 @@ jobs:
- { os: macos-latest , features: feat_os_macos }
- { os: windows-latest , features: feat_os_windows }
steps:
- - uses: actions/checkout@v3
- - name: Install `rust` toolchain
- run: |
- rustup toolchain install stable --profile minimal
- rustup default stable
+ - uses: actions/checkout@v4
+ - uses: dtolnay/rust-toolchain@stable
+ - uses: taiki-e/install-action@nextest
- uses: Swatinem/rust-cache@v2
+ - name: Run sccache-cache
+ uses: mozilla-actions/sccache-action@v0.0.5
- name: Test
- run: cargo test ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
+ run: cargo nextest run --hide-progress-bar --profile ci --features ${{ matrix.job.features }}
env:
RUST_BACKTRACE: "1"
@@ -428,6 +319,9 @@ jobs:
needs: [ min_version, deps ]
runs-on: ${{ matrix.job.os }}
timeout-minutes: 90
+ env:
+ SCCACHE_GHA_ENABLED: "true"
+ RUSTC_WRAPPER: "sccache"
strategy:
fail-fast: false
matrix:
@@ -436,14 +330,14 @@ jobs:
- { os: macos-latest , features: feat_os_macos }
- { os: windows-latest , features: feat_os_windows }
steps:
- - uses: actions/checkout@v3
- - name: Install `rust` toolchain
- run: |
- rustup toolchain install nightly --profile minimal
- rustup default nightly
+ - uses: actions/checkout@v4
+ - uses: dtolnay/rust-toolchain@nightly
+ - uses: taiki-e/install-action@nextest
- uses: Swatinem/rust-cache@v2
+ - name: Run sccache-cache
+ uses: mozilla-actions/sccache-action@v0.0.5
- name: Test
- run: cargo test ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
+ run: cargo nextest run --hide-progress-bar --profile ci --features ${{ matrix.job.features }}
env:
RUST_BACKTRACE: "1"
@@ -451,43 +345,108 @@ jobs:
name: Binary sizes
needs: [ min_version, deps ]
runs-on: ${{ matrix.job.os }}
+ env:
+ SCCACHE_GHA_ENABLED: "true"
+ RUSTC_WRAPPER: "sccache"
strategy:
fail-fast: false
matrix:
job:
- { os: ubuntu-latest , features: feat_os_unix }
steps:
- - uses: actions/checkout@v3
+ - uses: actions/checkout@v4
+ - uses: dtolnay/rust-toolchain@stable
+ - uses: Swatinem/rust-cache@v2
+ - name: Run sccache-cache
+ uses: mozilla-actions/sccache-action@v0.0.5
- name: Install dependencies
shell: bash
run: |
## Install dependencies
sudo apt-get update
sudo apt-get install jq
- - name: Install `rust` toolchain
- run: |
- rustup toolchain install stable --profile minimal
- rustup default stable
- - uses: Swatinem/rust-cache@v2
- name: "`make install`"
shell: bash
run: |
+ ## `make install`
make install DESTDIR=target/size-release/
make install MULTICALL=y DESTDIR=target/size-multi-release/
# strip the results
strip target/size*/usr/local/bin/*
- - name: "Compute sizes"
+ - name: Compute uutil release sizes
shell: bash
run: |
- SIZE=$(du -s target/size-release/usr/local/bin/|awk '{print $1}')
- SIZEMULTI=$(du -s target/size-multi-release/usr/local/bin/|awk '{print $1}')
+ ## Compute uutil release sizes
+ DATE=$(date --rfc-email)
+ find target/size-release/usr/local/bin -type f -printf '%f\0' | sort -z |
+ while IFS= read -r -d '' name; do
+ size=$(du -s target/size-release/usr/local/bin/$name | awk '{print $1}')
+ echo "\"$name\""
+ echo "$size"
+ done | \
+ jq -n \
+ --arg date "$DATE" \
+ --arg sha "$GITHUB_SHA" \
+ 'reduce inputs as $name ({}; . + { ($name): input }) | { ($date): {sha: $sha, sizes: map_values(.)} }' > individual-size-result.json
+ SIZE=$(cat individual-size-result.json | jq '[.[] | .sizes | .[]] | reduce .[] as $num (0; . + $num)')
+ SIZE_MULTI=$(du -s target/size-multi-release/usr/local/bin/coreutils | awk '{print $1}')
jq -n \
- --arg date "$(date --rfc-email)" \
+ --arg date "$DATE" \
--arg sha "$GITHUB_SHA" \
--arg size "$SIZE" \
- --arg multisize "$SIZEMULTI" \
+ --arg multisize "$SIZE_MULTI" \
'{($date): { sha: $sha, size: $size, multisize: $multisize, }}' > size-result.json
- - uses: actions/upload-artifact@v3
+ - name: Download the previous individual size result
+ uses: dawidd6/action-download-artifact@v6
+ with:
+ workflow: CICD.yml
+ name: individual-size-result
+ repo: uutils/coreutils
+ path: dl
+ - name: Download the previous size result
+ uses: dawidd6/action-download-artifact@v6
+ with:
+ workflow: CICD.yml
+ name: size-result
+ repo: uutils/coreutils
+ path: dl
+ - name: Check uutil release sizes
+ shell: bash
+ run: |
+ check() {
+ # Warn if the size increases by more than 5%
+ threshold='1.05'
+
+ if [[ "$2" -eq 0 || "$3" -eq 0 ]]; then
+ echo "::warning file=$4::Invalid size for $1. Sizes cannot be 0."
+ return
+ fi
+
+ ratio=$(jq -n "$2 / $3")
+ echo "$1: size=$2, previous_size=$3, ratio=$ratio, threshold=$threshold"
+ if [[ "$(jq -n "$ratio > $threshold")" == 'true' ]]; then
+ echo "::warning file=$4::Size of $1 increases by more than 5%"
+ fi
+ }
+ ## Check individual size result
+ while read -r name previous_size; do
+ size=$(cat individual-size-result.json | jq -r ".[] | .sizes | .\"$name\"")
+ check "\`$name\` binary" "$size" "$previous_size" 'individual-size-result.json'
+ done < <(cat dl/individual-size-result.json | jq -r '.[] | .sizes | to_entries[] | "\(.key) \(.value)"')
+ ## Check size result
+ size=$(cat size-result.json | jq -r '.[] | .size')
+ previous_size=$(cat dl/size-result.json | jq -r '.[] | .size')
+ check 'multiple binaries' "$size" "$previous_size" 'size-result.json'
+ multisize=$(cat size-result.json | jq -r '.[] | .multisize')
+ previous_multisize=$(cat dl/size-result.json | jq -r '.[] | .multisize')
+ check 'multicall binary' "$multisize" "$previous_multisize" 'size-result.json'
+ - name: Upload the individual size result
+ uses: actions/upload-artifact@v4
+ with:
+ name: individual-size-result
+ path: individual-size-result.json
+ - name: Upload the size result
+ uses: actions/upload-artifact@v4
with:
name: size-result
path: size-result.json
@@ -502,38 +461,44 @@ jobs:
timeout-minutes: 90
env:
DOCKER_OPTS: '--volume /etc/passwd:/etc/passwd --volume /etc/group:/etc/group'
+ SCCACHE_GHA_ENABLED: "true"
+ RUSTC_WRAPPER: "sccache"
strategy:
fail-fast: false
matrix:
job:
- # { os , target , cargo-options , features , use-cross , toolchain }
- - { os: ubuntu-latest , target: arm-unknown-linux-gnueabihf, features: feat_os_unix_gnueabihf, use-cross: use-cross, }
- - { os: ubuntu-latest , target: aarch64-unknown-linux-gnu , features: feat_os_unix_gnueabihf , use-cross: use-cross }
- - { os: ubuntu-latest , target: x86_64-unknown-linux-gnu , features: feat_os_unix , use-cross: use-cross }
+ # - { os , target , cargo-options , features , use-cross , toolchain, skip-tests }
+ - { os: ubuntu-latest , target: arm-unknown-linux-gnueabihf, features: feat_os_unix_gnueabihf, use-cross: use-cross, skip-tests: true }
+ - { os: ubuntu-latest , target: aarch64-unknown-linux-gnu , features: feat_os_unix_gnueabihf , use-cross: use-cross , skip-tests: true }
+ - { os: ubuntu-latest , target: aarch64-unknown-linux-musl , features: feat_os_unix_musl , use-cross: use-cross , skip-tests: true }
# - { os: ubuntu-latest , target: x86_64-unknown-linux-gnu , features: feat_selinux , use-cross: use-cross }
- # - { os: ubuntu-18.04 , target: i586-unknown-linux-gnu , features: feat_os_unix , use-cross: use-cross } ## note: older windows platform; not required, dev-FYI only
- # - { os: ubuntu-18.04 , target: i586-unknown-linux-gnu , features: feat_os_unix , use-cross: use-cross } ## note: older windows platform; not required, dev-FYI only
- - { os: ubuntu-latest , target: i686-unknown-linux-gnu , features: feat_os_unix , use-cross: use-cross }
- - { os: ubuntu-latest , target: i686-unknown-linux-musl , features: feat_os_unix_musl , use-cross: use-cross }
- - { os: ubuntu-latest , target: x86_64-unknown-linux-gnu , features: feat_os_unix , use-cross: use-cross }
- - { os: ubuntu-latest , target: x86_64-unknown-linux-musl , features: feat_os_unix_musl , use-cross: use-cross }
- # Commented until https://github.com/uutils/coreutils/issues/3210 is fixed
- #- { os: ubuntu-18.04 , target: i686-unknown-linux-gnu , features: feat_os_unix , use-cross: use-cross }
- #- { os: ubuntu-18.04 , target: i686-unknown-linux-musl , features: feat_os_unix_musl , use-cross: use-cross }
- #- { os: ubuntu-18.04 , target: x86_64-unknown-linux-gnu , features: feat_os_unix , use-cross: use-cross }
- #- { os: ubuntu-18.04 , target: x86_64-unknown-linux-musl , features: feat_os_unix_musl , use-cross: use-cross }
- - { os: macos-latest , target: x86_64-apple-darwin , features: feat_os_macos }
+ - { os: ubuntu-latest , target: i686-unknown-linux-gnu , features: feat_os_unix , use-cross: use-cross }
+ - { os: ubuntu-latest , target: i686-unknown-linux-musl , features: feat_os_unix_musl , use-cross: use-cross }
+ - { os: ubuntu-latest , target: x86_64-unknown-linux-gnu , features: feat_os_unix , use-cross: use-cross }
+ - { os: ubuntu-latest , target: x86_64-unknown-linux-musl , features: feat_os_unix_musl , use-cross: use-cross }
+ - { os: ubuntu-latest , target: x86_64-unknown-redox , features: feat_os_unix_redox , use-cross: redoxer , skip-tests: true }
+ - { os: macos-latest , target: aarch64-apple-darwin , features: feat_os_macos } # M1 CPU
+ - { os: macos-13 , target: x86_64-apple-darwin , features: feat_os_macos }
- { os: windows-latest , target: i686-pc-windows-msvc , features: feat_os_windows }
- - { os: windows-latest , target: x86_64-pc-windows-gnu , features: feat_os_windows } ## note: requires rust >= 1.43.0 to link correctly
+ - { os: windows-latest , target: x86_64-pc-windows-gnu , features: feat_os_windows }
- { os: windows-latest , target: x86_64-pc-windows-msvc , features: feat_os_windows }
steps:
- - uses: actions/checkout@v3
+ - uses: actions/checkout@v4
+ - uses: dtolnay/rust-toolchain@master
+ with:
+ toolchain: ${{ env.RUST_MIN_SRV }}
+ targets: ${{ matrix.job.target }}
+ - uses: Swatinem/rust-cache@v2
+ with:
+ key: "${{ matrix.job.os }}_${{ matrix.job.target }}"
+ - name: Run sccache-cache
+ uses: mozilla-actions/sccache-action@v0.0.5
- name: Initialize workflow variables
id: vars
shell: bash
run: |
## VARs setup
- outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
+ outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
# toolchain
TOOLCHAIN="stable" ## default to "stable" toolchain
# * specify alternate/non-default TOOLCHAIN for *-pc-windows-gnu targets; gnu targets on Windows are broken for the standard *-pc-windows-msvc toolchain (refs: GH:rust-lang/rust#47048, GH:rust-lang/rust#53454, GH:rust-lang/cargo#6754)
@@ -553,7 +518,7 @@ jobs:
REF_NAME=${GITHUB_REF#refs/*/}
unset REF_BRANCH ; case "${GITHUB_REF}" in refs/heads/*) REF_BRANCH=${GITHUB_REF#refs/heads/} ;; esac;
unset REF_TAG ; case "${GITHUB_REF}" in refs/tags/*) REF_TAG=${GITHUB_REF#refs/tags/} ;; esac;
- REF_SHAS=${GITHUB_SHA:0:8}
+ REF_SHAS=${GITHUB_SHA:0:10}
outputs REF_NAME REF_BRANCH REF_TAG REF_SHAS
# parse target
unset TARGET_ARCH
@@ -564,7 +529,13 @@ jobs:
i686-*) TARGET_ARCH=i686 ;;
x86_64-*) TARGET_ARCH=x86_64 ;;
esac;
- unset TARGET_OS ; case '${{ matrix.job.target }}' in *-linux-*) TARGET_OS=linux ;; *-apple-*) TARGET_OS=macos ;; *-windows-*) TARGET_OS=windows ;; esac;
+ unset TARGET_OS
+ case '${{ matrix.job.target }}' in
+ *-linux-*) TARGET_OS=linux ;;
+ *-apple-*) TARGET_OS=macos ;;
+ *-windows-*) TARGET_OS=windows ;;
+ *-redox*) TARGET_OS=redox ;;
+ esac
outputs TARGET_ARCH TARGET_OS
# package name
PKG_suffix=".tar.gz" ; case '${{ matrix.job.target }}' in *-pc-windows-*) PKG_suffix=".zip" ;; esac;
@@ -599,24 +570,35 @@ jobs:
if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features=${{ matrix.job.features }}' ; fi
outputs CARGO_FEATURES_OPTION
# * CARGO_CMD
- CARGO_CMD='cross' ; case '${{ matrix.job.use-cross }}' in ''|0|f|false|n|no) CARGO_CMD='cargo' ;; esac;
+ CARGO_CMD='cross'
+ CARGO_CMD_OPTIONS='+${{ env.RUST_MIN_SRV }}'
+ case '${{ matrix.job.use-cross }}' in
+ ''|0|f|false|n|no)
+ CARGO_CMD='cargo'
+ ;;
+ redoxer)
+ CARGO_CMD='redoxer'
+ CARGO_CMD_OPTIONS=''
+ ;;
+ esac
outputs CARGO_CMD
+ outputs CARGO_CMD_OPTIONS
# ** pass needed environment into `cross` container (iff `cross` not already configured via "Cross.toml")
if [ "${CARGO_CMD}" = 'cross' ] && [ ! -e "Cross.toml" ] ; then
- cargo install --version 0.2.1 cross
- printf "[build.env]\npassthrough = [\"CI\", \"RUST_BACKTRACE\"]\n" > Cross.toml
+ printf "[build.env]\npassthrough = [\"CI\", \"RUST_BACKTRACE\", \"CARGO_TERM_COLOR\"]\n" > Cross.toml
fi
- # * test only library and/or binaries for arm-type targets
- unset CARGO_TEST_OPTIONS ; case '${{ matrix.job.target }}' in aarch64-* | arm-*) CARGO_TEST_OPTIONS="--bins" ;; esac;
- outputs CARGO_TEST_OPTIONS
# * executable for `strip`?
STRIP="strip"
case ${{ matrix.job.target }} in
- aarch64-*-linux-gnu) STRIP="aarch64-linux-gnu-strip" ;;
+ aarch64-*-linux-*) STRIP="aarch64-linux-gnu-strip" ;;
arm-*-linux-gnueabihf) STRIP="arm-linux-gnueabihf-strip" ;;
*-pc-windows-msvc) STRIP="" ;;
esac;
outputs STRIP
+ - uses: taiki-e/install-action@v2
+ if: steps.vars.outputs.CARGO_CMD == 'cross'
+ with:
+ tool: cross@0.2.5
- name: Create all needed build/work directories
shell: bash
run: |
@@ -629,8 +611,23 @@ jobs:
run: |
## Install/setup prerequisites
case '${{ matrix.job.target }}' in
- arm-unknown-linux-gnueabihf) sudo apt-get -y update ; sudo apt-get -y install gcc-arm-linux-gnueabihf ;;
- aarch64-unknown-linux-gnu) sudo apt-get -y update ; sudo apt-get -y install gcc-aarch64-linux-gnu ;;
+ arm-unknown-linux-gnueabihf)
+ sudo apt-get -y update
+ sudo apt-get -y install gcc-arm-linux-gnueabihf
+ ;;
+ aarch64-unknown-linux-*)
+ sudo apt-get -y update
+ sudo apt-get -y install gcc-aarch64-linux-gnu
+ ;;
+ *-redox*)
+ sudo apt-get -y update
+ sudo apt-get -y install fuse3 libfuse-dev
+ ;;
+ # Update binutils if MinGW due to https://github.com/rust-lang/rust/issues/112368
+ x86_64-pc-windows-gnu)
+ C:/msys64/usr/bin/pacman.exe -Sy --needed mingw-w64-x86_64-gcc --noconfirm
+ echo "C:\msys64\mingw64\bin" >> $GITHUB_PATH
+ ;;
esac
case '${{ matrix.job.os }}' in
macos-latest) brew install coreutils ;; # needed for testing
@@ -650,19 +647,16 @@ jobs:
echo "foo" > /home/runner/.plan
;;
esac
- - name: rust toolchain ~ install
- run: |
- rustup toolchain install ${{ env.RUST_MIN_SRV }} -t ${{ matrix.job.target }} --profile minimal
- rustup default ${{ env.RUST_MIN_SRV }}
- - uses: Swatinem/rust-cache@v2
+ - uses: taiki-e/install-action@v2
+ if: steps.vars.outputs.CARGO_CMD == 'redoxer'
with:
- key: ${{ matrix.job.os }}-${{ matrix.job.target }}
+ tool: redoxer@0.2.37
- name: Initialize toolchain-dependent workflow variables
id: dep_vars
shell: bash
run: |
## Dependent VARs setup
- outputs() { step_id="dep_vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
+ outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
# * determine sub-crate utility list
UTILITY_LIST="$(./util/show-utils.sh ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }})"
echo UTILITY_LIST=${UTILITY_LIST}
@@ -690,28 +684,33 @@ jobs:
# dependencies
echo "## dependency list"
cargo fetch --locked --quiet
- cargo tree --locked --target=${{ matrix.job.target }} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} --all --no-dev-dependencies --no-indent | grep -vE "$PWD" | sort --unique
+ cargo tree --locked --target=${{ matrix.job.target }} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} --no-dedupe -e=no-dev --prefix=none | grep -vE "$PWD" | sort --unique
- name: Build
shell: bash
run: |
- ${{ steps.vars.outputs.CARGO_CMD }} +${{ env.RUST_MIN_SRV }} build --release \
+ ## Build
+ ${{ steps.vars.outputs.CARGO_CMD }} ${{ steps.vars.outputs.CARGO_CMD_OPTIONS }} build --release \
--target=${{ matrix.job.target }} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
- name: Test
+ if: matrix.job.skip-tests != true
shell: bash
run: |
- ${{ steps.vars.outputs.CARGO_CMD }} +${{ env.RUST_MIN_SRV }} test --target=${{ matrix.job.target }} \
+ ## Test
+ ${{ steps.vars.outputs.CARGO_CMD }} ${{ steps.vars.outputs.CARGO_CMD_OPTIONS }} test --target=${{ matrix.job.target }} \
${{ steps.vars.outputs.CARGO_TEST_OPTIONS}} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
env:
RUST_BACKTRACE: "1"
- name: Test individual utilities
+ if: matrix.job.skip-tests != true
shell: bash
run: |
- ${{ steps.vars.outputs.CARGO_CMD }} +${{ env.RUST_MIN_SRV }} test --target=${{ matrix.job.target }} \
- ${{ steps.vars.outputs.CARGO_TEST_OPTIONS}} ${{ matrix.job.cargo-options }} ${{ steps.dep_vars.outputs.CARGO_UTILITY_LIST_OPTIONS }}
+ ## Test individual utilities
+ ${{ steps.vars.outputs.CARGO_CMD }} ${{ steps.vars.outputs.CARGO_CMD_OPTIONS }} test --target=${{ matrix.job.target }} \
+ ${{ matrix.job.cargo-options }} ${{ steps.dep_vars.outputs.CARGO_UTILITY_LIST_OPTIONS }}
env:
RUST_BACKTRACE: "1"
- name: Archive executable artifacts
- uses: actions/upload-artifact@v3
+ uses: actions/upload-artifact@v4
with:
name: ${{ env.PROJECT_NAME }}-${{ matrix.job.target }}
path: target/${{ matrix.job.target }}/release/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}
@@ -750,7 +749,7 @@ jobs:
fakeroot dpkg-deb --build "${DPKG_DIR}" "${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.DPKG_NAME }}"
fi
- name: Publish
- uses: softprops/action-gh-release@v1
+ uses: softprops/action-gh-release@v2
if: steps.vars.outputs.DEPLOY
with:
files: |
@@ -763,6 +762,9 @@ jobs:
name: Tests/BusyBox test suite
needs: [ min_version, deps ]
runs-on: ${{ matrix.job.os }}
+ env:
+ SCCACHE_GHA_ENABLED: "true"
+ RUSTC_WRAPPER: "sccache"
strategy:
fail-fast: false
matrix:
@@ -775,17 +777,20 @@ jobs:
run: |
## VARs setup
echo "TEST_SUMMARY_FILE=busybox-result.json" >> $GITHUB_OUTPUT
- - uses: actions/checkout@v3
+ - uses: actions/checkout@v4
- uses: Swatinem/rust-cache@v2
+ - name: Run sccache-cache
+ uses: mozilla-actions/sccache-action@v0.0.5
- name: Install/setup prerequisites
shell: bash
run: |
## Install/setup prerequisites
make prepare-busytest
- - name: "Run BusyBox test suite"
+ - name: Run BusyBox test suite
id: summary
shell: bash
run: |
+ ## Run BusyBox test suite
set -v
cp .busybox-config target/debug/.config
## Run BusyBox test suite
@@ -816,17 +821,17 @@ jobs:
HASH=$(sha1sum '${{ steps.vars.outputs.TEST_SUMMARY_FILE }}' | cut --delim=" " -f 1)
echo "HASH=${HASH}" >> $GITHUB_OUTPUT
- name: Reserve SHA1/ID of 'test-summary'
- uses: actions/upload-artifact@v3
+ uses: actions/upload-artifact@v4
with:
name: "${{ steps.summary.outputs.HASH }}"
path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
- name: Reserve test results summary
- uses: actions/upload-artifact@v3
+ uses: actions/upload-artifact@v4
with:
- name: test-summary
+ name: busybox-test-summary
path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
- name: Upload json results
- uses: actions/upload-artifact@v3
+ uses: actions/upload-artifact@v4
with:
name: busybox-result.json
path: ${{ steps.vars.outputs.TEST_SUMMARY_FILE }}
@@ -835,6 +840,9 @@ jobs:
name: Tests/Toybox test suite
needs: [ min_version, deps ]
runs-on: ${{ matrix.job.os }}
+ env:
+ SCCACHE_GHA_ENABLED: "true"
+ RUSTC_WRAPPER: "sccache"
strategy:
fail-fast: false
matrix:
@@ -846,16 +854,21 @@ jobs:
shell: bash
run: |
## VARs setup
- echo "TEST_SUMMARY_FILE=toybox-result.json" >> $GITHUB_OUTPUT
- - uses: actions/checkout@v3
+ outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
+ TEST_SUMMARY_FILE="toybox-result.json"
+ outputs TEST_SUMMARY_FILE
+ - uses: actions/checkout@v4
+ - uses: dtolnay/rust-toolchain@master
+ with:
+ toolchain: ${{ env.RUST_MIN_SRV }}
+ components: rustfmt
- uses: Swatinem/rust-cache@v2
- - name: rust toolchain ~ install
- run: |
- rustup toolchain install ${{ env.RUST_MIN_SRV }} --profile minimal
- rustup default ${{ env.RUST_MIN_SRV }}
- - name: "Build coreutils as multiple binaries"
+ - name: Run sccache-cache
+ uses: mozilla-actions/sccache-action@v0.0.5
+ - name: Build coreutils as multiple binaries
shell: bash
run: |
+ ## Build individual uutil binaries
set -v
make
- name: Install/setup prerequisites
@@ -863,12 +876,12 @@ jobs:
run: |
## Install/setup prerequisites
make toybox-src
- - name: "Run Toybox test suite"
+ - name: Run Toybox test suite
id: summary
shell: bash
run: |
- set -v
## Run Toybox test suite
+ set -v
cd tmp/toybox-*/
make defconfig
make tests &> tmp.log || true
@@ -896,165 +909,46 @@ jobs:
HASH=$(sha1sum '${{ steps.vars.outputs.TEST_SUMMARY_FILE }}' | cut --delim=" " -f 1)
echo "HASH=${HASH}" >> $GITHUB_OUTPUT
- name: Reserve SHA1/ID of 'test-summary'
- uses: actions/upload-artifact@v3
+ uses: actions/upload-artifact@v4
with:
name: "${{ steps.summary.outputs.HASH }}"
path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
- name: Reserve test results summary
- uses: actions/upload-artifact@v3
+ uses: actions/upload-artifact@v4
with:
- name: test-summary
+ name: toybox-test-summary
path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
- name: Upload json results
- uses: actions/upload-artifact@v3
+ uses: actions/upload-artifact@v4
with:
name: toybox-result.json
path: ${{ steps.vars.outputs.TEST_SUMMARY_FILE }}
- test_android:
- name: Test Android builds
- needs: [ min_version, deps ]
- runs-on: macos-latest
- timeout-minutes: 90
- strategy:
- fail-fast: false
- matrix:
- api-level: [28]
- target: [default]
- arch: [x86] # , arm64-v8a
- env:
- TERMUX: v0.118.0
- steps:
- - uses: actions/checkout@v3
- - name: AVD cache
- uses: actions/cache@v3
- id: avd-cache
- with:
- path: |
- ~/.android/avd/*
- ~/.android/avd/*/snapshots/*
- ~/.android/adb*
- key: avd-${{ matrix.api-level }}-${{ matrix.arch }}+termux-${{ env.TERMUX }}
- - name: Create and cache emulator image
- if: steps.avd-cache.outputs.cache-hit != 'true'
- uses: reactivecircus/android-emulator-runner@v2
- with:
- api-level: ${{ matrix.api-level }}
- target: ${{ matrix.target }}
- arch: ${{ matrix.arch }}
- ram-size: 2048M
- disk-size: 5120M
- force-avd-creation: true
- emulator-options: -no-snapshot-load -noaudio -no-boot-anim -camera-back none
- script: |
- wget https://github.com/termux/termux-app/releases/download/${{ env.TERMUX }}/termux-app_${{ env.TERMUX }}+github-debug_${{ matrix.arch }}.apk
- util/android-commands.sh snapshot termux-app_${{ env.TERMUX }}+github-debug_${{ matrix.arch }}.apk
- adb -s emulator-5554 emu avd snapshot save ${{ matrix.api-level }}-${{ matrix.arch }}+termux-${{ env.TERMUX }}
- echo "Emulator image created."
- pkill -9 qemu-system-x86_64
- - name: Build and Test on Android
- uses: reactivecircus/android-emulator-runner@v2
- with:
- api-level: ${{ matrix.api-level }}
- target: ${{ matrix.target }}
- arch: ${{ matrix.arch }}
- ram-size: 2048M
- disk-size: 5120M
- force-avd-creation: false
- emulator-options: -no-snapshot-save -gpu swiftshader_indirect -noaudio -no-boot-anim -camera-back none -snapshot ${{ matrix.api-level }}-${{ matrix.arch }}+termux-${{ env.TERMUX }}
- script: |
- util/android-commands.sh sync
- util/android-commands.sh build
- util/android-commands.sh tests
-
- test_freebsd:
- name: Tests/FreeBSD test suite
- needs: [ min_version, deps ]
- runs-on: ${{ matrix.job.os }}
- timeout-minutes: 90
- strategy:
- fail-fast: false
- matrix:
- job:
- - { os: macos-12 , features: unix } ## GHA MacOS-11.0 VM won't have VirtualBox; refs: <https://github.com/actions/virtual-environments/issues/4060> , <https://github.com/actions/virtual-environments/pull/4010>
- env:
- mem: 4096
- steps:
- - uses: actions/checkout@v3
- - uses: Swatinem/rust-cache@v2
- - name: Prepare, build and test
- ## spell-checker:ignore (ToDO) sshfs usesh vmactions
- uses: vmactions/freebsd-vm@v0.3.0
- with:
- usesh: true
- # sync: sshfs
- prepare: pkg install -y curl gmake sudo
- run: |
- ## Prepare, build, and test
- # implementation modelled after ref: <https://github.com/rust-lang/rustup/pull/2783>
- # * NOTE: All steps need to be run in this block, otherwise, we are operating back on the mac host
- set -e
- #
- # We need a file-descriptor file system to test test_ls::test_ls_io_errors
- mount -t fdescfs fdesc /dev/fd
- #
- TEST_USER=tester
- REPO_NAME=${GITHUB_WORKSPACE##*/}
- WORKSPACE_PARENT="/Users/runner/work/${REPO_NAME}"
- WORKSPACE="${WORKSPACE_PARENT}/${REPO_NAME}"
- #
- pw adduser -n ${TEST_USER} -d /root/ -g wheel -c "Coreutils user to build" -w random
- # chown -R ${TEST_USER}:wheel /root/ "${WORKSPACE_PARENT}"/
- chown -R ${TEST_USER}:wheel /root/ "/Users/runner/work/${REPO_NAME}"/
- whoami
- #
- # Further work needs to be done in a sudo as we are changing users
- sudo -i -u ${TEST_USER} sh << EOF
- set -e
- whoami
- curl https://sh.rustup.rs -sSf --output rustup.sh
- sh rustup.sh -y --profile=minimal
- . $HOME/.cargo/env
- ## Info
- # environment
- echo "## environment"
- echo "CI='${CI}'"
- echo "REPO_NAME='${REPO_NAME}'"
- echo "TEST_USER='${TEST_USER}'"
- echo "WORKSPACE_PARENT='${WORKSPACE_PARENT}'"
- echo "WORKSPACE='${WORKSPACE}'"
- env | sort
- # tooling info
- echo "## tooling info"
- cargo -V
- rustc -V
- #
- # To ensure that files are cleaned up, we don't want to exit on error
- set +e
- cd "${WORKSPACE}"
- unset FAULT
- cargo build || FAULT=1
- export RUST_BACKTRACE=1
- if (test -z "\$FAULT"); then cargo test --features '${{ matrix.job.features }}' || FAULT=1 ; fi
- if (test -z "\$FAULT"); then cargo test --all-features -p uucore || FAULT=1 ; fi
- # Clean to avoid to rsync back the files
- cargo clean
- if (test -n "\$FAULT"); then exit 1 ; fi
- EOF
-
coverage:
name: Code Coverage
runs-on: ${{ matrix.job.os }}
timeout-minutes: 90
+ env:
+ SCCACHE_GHA_ENABLED: "true"
+ RUSTC_WRAPPER: "sccache"
strategy:
fail-fast: false
matrix:
job:
- - { os: ubuntu-latest , features: unix }
- - { os: macos-latest , features: macos }
- - { os: windows-latest , features: windows }
+ - { os: ubuntu-latest , features: unix, toolchain: nightly }
+ - { os: macos-latest , features: macos, toolchain: nightly }
+ - { os: windows-latest , features: windows, toolchain: nightly-x86_64-pc-windows-gnu }
steps:
- - uses: actions/checkout@v3
+ - uses: actions/checkout@v4
+ - uses: dtolnay/rust-toolchain@master
+ with:
+ toolchain: ${{ matrix.job.toolchain }}
+ components: rustfmt
+ - uses: taiki-e/install-action@nextest
+ - uses: taiki-e/install-action@grcov
+ - uses: Swatinem/rust-cache@v2
+ - name: Run sccache-cache
+ uses: mozilla-actions/sccache-action@v0.0.5
# - name: Reattach HEAD ## may be needed for accurate code coverage info
# run: git checkout ${{ github.head_ref }}
- name: Initialize workflow variables
@@ -1062,7 +956,7 @@ jobs:
shell: bash
run: |
## VARs setup
- outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
+ outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
# toolchain
TOOLCHAIN="nightly" ## default to "nightly" toolchain (required for certain required unstable compiler flags) ## !maint: refactor when stable channel has needed support
# * specify gnu-type TOOLCHAIN for windows; `grcov` requires gnu-style code coverage data files
@@ -1103,51 +997,36 @@ jobs:
echo "foo" > /home/runner/.plan
;;
esac
- - name: rust toolchain ~ install
- run: |
- rustup toolchain install ${{ steps.vars.outputs.TOOLCHAIN }} --profile minimal
- rustup default ${{ steps.vars.outputs.TOOLCHAIN }}
- - uses: Swatinem/rust-cache@v2
+ case '${{ matrix.job.os }}' in
+ # Update binutils if MinGW due to https://github.com/rust-lang/rust/issues/112368
+ windows-latest) C:/msys64/usr/bin/pacman.exe -Sy --needed mingw-w64-x86_64-gcc --noconfirm ; echo "C:\msys64\mingw64\bin" >> $GITHUB_PATH ;;
+ esac
- name: Initialize toolchain-dependent workflow variables
id: dep_vars
shell: bash
run: |
## Dependent VARs setup
- outputs() { step_id="dep_vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
+ outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
# * determine sub-crate utility list
UTILITY_LIST="$(./util/show-utils.sh ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }})"
CARGO_UTILITY_LIST_OPTIONS="$(for u in ${UTILITY_LIST}; do echo -n "-puu_${u} "; done;)"
outputs CARGO_UTILITY_LIST_OPTIONS
- - name: Test uucore
- run: cargo test --no-fail-fast -p uucore
- env:
- CARGO_INCREMENTAL: "0"
- RUSTC_WRAPPER: ""
- RUSTFLAGS: "-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
- RUSTDOCFLAGS: "-Cpanic=abort"
- RUST_BACKTRACE: "1"
- # RUSTUP_TOOLCHAIN: ${{ steps.vars.outputs.TOOLCHAIN }}
- name: Test
- run: cargo test ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} --no-fail-fast
+ run: cargo nextest run --profile ci --hide-progress-bar ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} -p uucore -p coreutils
env:
- CARGO_INCREMENTAL: "0"
RUSTC_WRAPPER: ""
RUSTFLAGS: "-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
RUSTDOCFLAGS: "-Cpanic=abort"
RUST_BACKTRACE: "1"
# RUSTUP_TOOLCHAIN: ${{ steps.vars.outputs.TOOLCHAIN }}
- name: Test individual utilities
- run: cargo test --no-fail-fast ${{ steps.dep_vars.outputs.CARGO_UTILITY_LIST_OPTIONS }}
+ run: cargo nextest run --profile ci --hide-progress-bar ${{ steps.dep_vars.outputs.CARGO_UTILITY_LIST_OPTIONS }}
env:
- CARGO_INCREMENTAL: "0"
RUSTC_WRAPPER: ""
RUSTFLAGS: "-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
RUSTDOCFLAGS: "-Cpanic=abort"
RUST_BACKTRACE: "1"
# RUSTUP_TOOLCHAIN: ${{ steps.vars.outputs.TOOLCHAIN }}
- - name: "`grcov` ~ install"
- id: build_grcov
- run: cargo install grcov
- name: Generate coverage data (via `grcov`)
id: coverage
shell: bash
@@ -1159,17 +1038,36 @@ jobs:
# GRCOV_EXCLUDE_OPTION='--excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()"' ## `grcov` ignores these params when passed as an environment variable (why?)
mkdir -p "${COVERAGE_REPORT_DIR}"
# display coverage files
- ~/.cargo/bin/grcov . --output-type files --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()" | sort --unique
+ grcov . --output-type files --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()" | sort --unique
# generate coverage report
- ~/.cargo/bin/grcov . --output-type lcov --output-path "${COVERAGE_REPORT_FILE}" --branch --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()"
+ grcov . --output-type lcov --output-path "${COVERAGE_REPORT_FILE}" --branch --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()"
echo "report=${COVERAGE_REPORT_FILE}" >> $GITHUB_OUTPUT
- name: Upload coverage results (to Codecov.io)
- uses: codecov/codecov-action@v3
- # if: steps.vars.outputs.HAS_CODECOV_TOKEN
+ uses: codecov/codecov-action@v4
with:
- # token: ${{ secrets.CODECOV_TOKEN }}
+ token: ${{ secrets.CODECOV_TOKEN }}
file: ${{ steps.coverage.outputs.report }}
## flags: IntegrationTests, UnitTests, ${{ steps.vars.outputs.CODECOV_FLAGS }}
flags: ${{ steps.vars.outputs.CODECOV_FLAGS }}
name: codecov-umbrella
fail_ci_if_error: false
+
+ test_separately:
+ name: Separate Builds
+ runs-on: ${{ matrix.os }}
+ strategy:
+ fail-fast: false
+ matrix:
+ os: [ubuntu-latest, macos-latest, windows-latest]
+ steps:
+ - uses: actions/checkout@v4
+ - uses: dtolnay/rust-toolchain@stable
+ - uses: Swatinem/rust-cache@v2
+ - name: build and test all programs individually
+ shell: bash
+ run: |
+ for f in $(util/show-utils.sh)
+ do
+ echo "Building and testing $f"
+ cargo test -p "uu_$f" || exit 1
+ done
diff --git a/.github/workflows/CheckScripts.yml b/.github/workflows/CheckScripts.yml
new file mode 100644
index 0000000000000000000000000000000000000000..c18c4733cbea8e890b4c22a429d6fdfad87be3ca
--- /dev/null
+++ b/.github/workflows/CheckScripts.yml
@@ -0,0 +1,56 @@
+name: CheckScripts
+
+# spell-checker:ignore ludeeus mfinelli
+
+env:
+ SCRIPT_DIR: 'util'
+
+on:
+ push:
+ branches:
+ - main
+ paths:
+ - 'util/**/*.sh'
+ pull_request:
+ branches:
+ - main
+ paths:
+ - 'util/**/*.sh'
+
+# End the current execution if there is a new changeset in the PR.
+concurrency:
+ group: ${{ github.workflow }}-${{ github.ref }}
+ cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+jobs:
+ shell_check:
+ name: ShellScript/Check
+ runs-on: ubuntu-latest
+ permissions:
+ contents: read
+ steps:
+ - uses: actions/checkout@v4
+ - name: Run ShellCheck
+ uses: ludeeus/action-shellcheck@master
+ env:
+ SHELLCHECK_OPTS: -s bash
+ with:
+ severity: warning
+ scandir: ${{ env.SCRIPT_DIR }}
+ format: tty
+
+ shell_fmt:
+ name: ShellScript/Format
+ runs-on: ubuntu-latest
+ permissions:
+ contents: read
+ steps:
+ - uses: actions/checkout@v4
+ - name: Setup shfmt
+ uses: mfinelli/setup-shfmt@v3
+ - name: Run shfmt
+ shell: bash
+ run: |
+ # fmt options: bash syntax, 4 spaces indent, indent for switch-case
+ echo "## show the differences between formatted and original scripts..."
+ find ${{ env.SCRIPT_DIR }} -name "*.sh" -print0 | xargs -0 shfmt -ln=bash -i 4 -ci -d || true
diff --git a/.github/workflows/FixPR.yml b/.github/workflows/FixPR.yml
index f2e9e7bb3efc0115cb4ea87b6ea6ced38fd16bda..e837b354687fb498bbebf271f83afc4116ed5fe2 100644
--- a/.github/workflows/FixPR.yml
+++ b/.github/workflows/FixPR.yml
@@ -1,6 +1,6 @@
name: FixPR
-# spell-checker:ignore Swatinem
+# spell-checker:ignore Swatinem dtolnay
# Trigger automated fixes for PRs being merged (with associated commits)
@@ -26,20 +26,17 @@ jobs:
job:
- { os: ubuntu-latest , features: feat_os_unix }
steps:
- - uses: actions/checkout@v3
+ - uses: actions/checkout@v4
- name: Initialize job variables
id: vars
shell: bash
run: |
- ## VARs setup
- outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
# surface MSRV from CICD workflow
RUST_MIN_SRV=$(grep -P "^\s+RUST_MIN_SRV:" .github/workflows/CICD.yml | grep -Po "(?<=\x22)\d+[.]\d+(?:[.]\d+)?(?=\x22)" )
- outputs RUST_MIN_SRV
- - name: Install `rust` toolchain (v${{ steps.vars.outputs.RUST_MIN_SRV }})
- run: |
- rustup toolchain install ${{ steps.vars.outputs.RUST_MIN_SRV }} --profile minimal
- rustup default ${{ steps.vars.outputs.RUST_MIN_SRV }}
+ echo "RUST_MIN_SRV=${RUST_MIN_SRV}" >> $GITHUB_OUTPUT
+ - uses: dtolnay/rust-toolchain@master
+ with:
+ toolchain: ${{ steps.vars.outputs.RUST_MIN_SRV }}
- uses: Swatinem/rust-cache@v2
- name: Ensure updated 'Cargo.lock'
shell: bash
@@ -66,11 +63,11 @@ jobs:
echo "## dependency list"
cargo fetch --locked --quiet
## * using the 'stable' toolchain is necessary to avoid "unexpected '--filter-platform'" errors
- RUSTUP_TOOLCHAIN=stable cargo tree --locked --all --no-dev-dependencies --no-indent --features ${{ matrix.job.features }} | grep -vE "$PWD" | sort --unique
+ RUSTUP_TOOLCHAIN=stable cargo tree --locked --no-dedupe -e=no-dev --prefix=none --features ${{ matrix.job.features }} | grep -vE "$PWD" | sort --unique
- name: Commit any changes (to '${{ env.BRANCH_TARGET }}')
uses: EndBug/add-and-commit@v9
with:
- branch: ${{ env.BRANCH_TARGET }}
+ new_branch: ${{ env.BRANCH_TARGET }}
default_author: github_actions
message: "maint ~ refresh 'Cargo.lock'"
add: Cargo.lock
@@ -88,23 +85,20 @@ jobs:
job:
- { os: ubuntu-latest , features: feat_os_unix }
steps:
- - uses: actions/checkout@v3
+ - uses: actions/checkout@v4
- name: Initialize job variables
id: vars
shell: bash
run: |
- ## VARs setup
- outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
# target-specific options
# * CARGO_FEATURES_OPTION
CARGO_FEATURES_OPTION='' ;
if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
- outputs CARGO_FEATURES_OPTION
- - name: Install `rust` toolchain
- run: |
- rm -f "${HOME}/.cargo/bin/"{rustfmt,cargo-fmt}
- rustup toolchain install stable -c rustfmt --profile minimal
- rustup default stable
+ echo "CARGO_FEATURES_OPTION=${CARGO_FEATURES_OPTION}" >> $GITHUB_OUTPUT
+ - uses: dtolnay/rust-toolchain@master
+ with:
+ toolchain: stable
+ components: rustfmt
- uses: Swatinem/rust-cache@v2
- name: "`cargo fmt`"
shell: bash
@@ -118,7 +112,7 @@ jobs:
- name: Commit any changes (to '${{ env.BRANCH_TARGET }}')
uses: EndBug/add-and-commit@v9
with:
- branch: ${{ env.BRANCH_TARGET }}
+ new_branch: ${{ env.BRANCH_TARGET }}
default_author: github_actions
message: "maint ~ rustfmt (`cargo fmt`)"
env:
diff --git a/.github/workflows/GnuComment.yml b/.github/workflows/GnuComment.yml
index bb64232a99ac21bc9beb57a31ba612e034d0e84f..36c54490ce90764ce57d21bdfdc528b9f48cf0dc 100644
--- a/.github/workflows/GnuComment.yml
+++ b/.github/workflows/GnuComment.yml
@@ -18,7 +18,7 @@ jobs:
github.event.workflow_run.event == 'pull_request'
steps:
- name: 'Download artifact'
- uses: actions/github-script@v6
+ uses: actions/github-script@v7
with:
script: |
// List all artifacts from GnuTests
@@ -43,7 +43,7 @@ jobs:
- run: unzip comment.zip
- name: 'Comment on PR'
- uses: actions/github-script@v6
+ uses: actions/github-script@v7
with:
github-token: ${{ secrets.GITHUB_TOKEN }}
script: |
diff --git a/.github/workflows/GnuTests.yml b/.github/workflows/GnuTests.yml
index 1000792f3d88e19caca32bd7599b3d65ba48910b..0ef8600cb4100a4feb02aa475e297eea369e23d3 100644
--- a/.github/workflows/GnuTests.yml
+++ b/.github/workflows/GnuTests.yml
@@ -1,14 +1,28 @@
name: GnuTests
-# spell-checker:ignore (names) gnulib ; (jargon) submodules ; (people) Dawid Dziurla * dawidd ; (utils) autopoint chksum gperf pyinotify shopt texinfo ; (vars) FILESET SUBDIRS XPASS
+# spell-checker:ignore (abbrev/names) CodeCov gnulib GnuTests Swatinem
+# spell-checker:ignore (jargon) submodules
+# spell-checker:ignore (libs/utils) autopoint chksum gperf lcov libexpect pyinotify shopt texinfo valgrind libattr libcap taiki-e
+# spell-checker:ignore (options) Ccodegen Coverflow Cpanic Zpanic
+# spell-checker:ignore (people) Dawid Dziurla * dawidd dtolnay
+# spell-checker:ignore (vars) FILESET SUBDIRS XPASS
# * note: to run a single test => `REPO/util/run-gnu-test.sh PATH/TO/TEST/SCRIPT`
-on: [push, pull_request]
+on:
+ pull_request:
+ push:
+ branches:
+ - main
permissions:
contents: read
+# End the current execution if there is a new changeset in the PR.
+concurrency:
+ group: ${{ github.workflow }}-${{ github.ref }}
+ cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
jobs:
gnu:
permissions:
@@ -16,14 +30,14 @@ jobs:
contents: read # for actions/checkout to fetch code
pull-requests: read # for dawidd6/action-download-artifact to query commit hash
name: Run GNU tests
- runs-on: ubuntu-20.04
+ runs-on: ubuntu-22.04
steps:
- name: Initialize workflow variables
id: vars
shell: bash
run: |
## VARs setup
- outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
+ outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
# * config
path_GNU="gnu"
path_GNU_tests="${path_GNU}/tests"
@@ -32,7 +46,7 @@ jobs:
outputs path_GNU path_GNU_tests path_reference path_UUTILS
#
repo_default_branch="${{ github.event.repository.default_branch }}"
- repo_GNU_ref="v9.1"
+ repo_GNU_ref="v9.5"
repo_reference_branch="${{ github.event.repository.default_branch }}"
outputs repo_default_branch repo_GNU_ref repo_reference_branch
#
@@ -45,18 +59,25 @@ jobs:
TEST_FULL_SUMMARY_FILE='gnu-full-result.json'
outputs SUITE_LOG_FILE ROOT_SUITE_LOG_FILE TEST_FILESET_PREFIX TEST_FILESET_SUFFIX TEST_LOGS_GLOB TEST_SUMMARY_FILE TEST_FULL_SUMMARY_FILE
- name: Checkout code (uutil)
- uses: actions/checkout@v3
+ uses: actions/checkout@v4
with:
path: '${{ steps.vars.outputs.path_UUTILS }}'
+ - uses: dtolnay/rust-toolchain@master
+ with:
+ toolchain: stable
+ components: rustfmt
+ - uses: Swatinem/rust-cache@v2
+ with:
+ workspaces: "./${{ steps.vars.outputs.path_UUTILS }} -> target"
- name: Checkout code (GNU coreutils)
- uses: actions/checkout@v3
+ uses: actions/checkout@v4
with:
repository: 'coreutils/coreutils'
path: '${{ steps.vars.outputs.path_GNU }}'
ref: ${{ steps.vars.outputs.repo_GNU_ref }}
submodules: recursive
- name: Retrieve reference artifacts
- uses: dawidd6/action-download-artifact@v2
+ uses: dawidd6/action-download-artifact@v6
# ref: <https://github.com/dawidd6/action-download-artifact>
continue-on-error: true ## don't break the build for missing reference artifacts (may be expired or just not generated yet)
with:
@@ -65,20 +86,16 @@ jobs:
# workflow_conclusion: success ## (default); * but, if commit with failed GnuTests is merged into the default branch, future commits will all show regression errors in GnuTests CI until o/w fixed
workflow_conclusion: completed ## continually recalibrates to last commit of default branch with a successful GnuTests (ie, "self-heals" from GnuTest regressions, but needs more supervision for/of regressions)
path: "${{ steps.vars.outputs.path_reference }}"
- - name: Install `rust` toolchain
- run: |
- rm -f "${HOME}/.cargo/bin/"{rustfmt,cargo-fmt}
- rustup toolchain install stable -c rustfmt --profile minimal
- rustup default stable
- name: Install dependencies
shell: bash
run: |
## Install dependencies
sudo apt-get update
- sudo apt-get install autoconf autopoint bison texinfo gperf gcc g++ gdb python3-pyinotify jq valgrind libexpect-perl
+ sudo apt-get install -y autoconf autopoint bison texinfo gperf gcc g++ gdb python3-pyinotify jq valgrind libexpect-perl libacl1-dev libattr1-dev libcap-dev
- name: Add various locales
shell: bash
run: |
+ ## Add various locales
echo "Before:"
locale -a
## Some tests fail with 'cannot change locale (en_US.ISO-8859-1): No such file or directory'
@@ -99,31 +116,35 @@ jobs:
run: |
## Build binaries
cd '${{ steps.vars.outputs.path_UUTILS }}'
- bash util/build-gnu.sh
+ bash util/build-gnu.sh --release-build
- name: Run GNU tests
shell: bash
run: |
+ ## Run GNU tests
path_GNU='${{ steps.vars.outputs.path_GNU }}'
path_UUTILS='${{ steps.vars.outputs.path_UUTILS }}'
bash "${path_UUTILS}/util/run-gnu-test.sh"
- name: Run GNU root tests
shell: bash
run: |
+ ## Run GNU root tests
path_GNU='${{ steps.vars.outputs.path_GNU }}'
path_UUTILS='${{ steps.vars.outputs.path_UUTILS }}'
bash "${path_UUTILS}/util/run-gnu-test.sh" run-root
- name: Extract testing info into JSON
shell: bash
run : |
+ ## Extract testing info into JSON
path_UUTILS='${{ steps.vars.outputs.path_UUTILS }}'
python ${path_UUTILS}/util/gnu-json-result.py ${{ steps.vars.outputs.path_GNU_tests }} > ${{ steps.vars.outputs.TEST_FULL_SUMMARY_FILE }}
- name: Extract/summarize testing info
id: summary
shell: bash
run: |
- path_UUTILS='${{ steps.vars.outputs.path_UUTILS }}'
## Extract/summarize testing info
- outputs() { step_id="summary"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
+ outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
+ #
+ path_UUTILS='${{ steps.vars.outputs.path_UUTILS }}'
#
SUITE_LOG_FILE='${{ steps.vars.outputs.SUITE_LOG_FILE }}'
ROOT_SUITE_LOG_FILE='${{ steps.vars.outputs.ROOT_SUITE_LOG_FILE }}'
@@ -158,32 +179,38 @@ jobs:
# Compress logs before upload (fails otherwise)
gzip ${{ steps.vars.outputs.TEST_LOGS_GLOB }}
- name: Reserve SHA1/ID of 'test-summary'
- uses: actions/upload-artifact@v3
+ uses: actions/upload-artifact@v4
with:
name: "${{ steps.summary.outputs.HASH }}"
path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
- name: Reserve test results summary
- uses: actions/upload-artifact@v3
+ uses: actions/upload-artifact@v4
with:
name: test-summary
path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
- name: Reserve test logs
- uses: actions/upload-artifact@v3
+ uses: actions/upload-artifact@v4
with:
name: test-logs
path: "${{ steps.vars.outputs.TEST_LOGS_GLOB }}"
- name: Upload full json results
- uses: actions/upload-artifact@v3
+ uses: actions/upload-artifact@v4
with:
name: gnu-full-result.json
path: ${{ steps.vars.outputs.TEST_FULL_SUMMARY_FILE }}
- name: Compare test failures VS reference
shell: bash
run: |
+ ## Compare test failures VS reference
have_new_failures=""
REF_LOG_FILE='${{ steps.vars.outputs.path_reference }}/test-logs/test-suite.log'
+ ROOT_REF_LOG_FILE='${{ steps.vars.outputs.path_reference }}/test-logs/test-suite-root.log'
REF_SUMMARY_FILE='${{ steps.vars.outputs.path_reference }}/test-summary/gnu-result.json'
REPO_DEFAULT_BRANCH='${{ steps.vars.outputs.repo_default_branch }}'
+ path_UUTILS='${{ steps.vars.outputs.path_UUTILS }}'
+ # https://github.com/uutils/coreutils/issues/4294
+ # https://github.com/uutils/coreutils/issues/4295
+ IGNORE_INTERMITTENT="${path_UUTILS}/.github/workflows/ignore-intermittent.txt"
mkdir -p ${{ steps.vars.outputs.path_reference }}
@@ -197,56 +224,96 @@ jobs:
rm -f ${COMMENT_LOG}
touch ${COMMENT_LOG}
- if test -f "${REF_LOG_FILE}"; then
- echo "Reference SHA1/ID: $(sha1sum -- "${REF_SUMMARY_FILE}")"
- REF_ERROR=$(sed -n "s/^ERROR: \([[:print:]]\+\).*/\1/p" "${REF_LOG_FILE}" | sort)
- NEW_ERROR=$(sed -n "s/^ERROR: \([[:print:]]\+\).*/\1/p" '${{ steps.vars.outputs.path_GNU_tests }}/test-suite.log' | sort)
- REF_FAILING=$(sed -n "s/^FAIL: \([[:print:]]\+\).*/\1/p" "${REF_LOG_FILE}" | sort)
- NEW_FAILING=$(sed -n "s/^FAIL: \([[:print:]]\+\).*/\1/p" '${{ steps.vars.outputs.path_GNU_tests }}/test-suite.log' | sort)
- for LINE in ${REF_FAILING}
- do
- if ! grep -Fxq ${LINE}<<<"${NEW_FAILING}"; then
- MSG="Congrats! The gnu test ${LINE} is no longer failing!"
- echo "::warning ::$MSG"
- echo $MSG >> ${COMMENT_LOG}
- fi
- done
- for LINE in ${NEW_FAILING}
- do
- if ! grep -Fxq ${LINE}<<<"${REF_FAILING}"
- then
- MSG="GNU test failed: ${LINE}. ${LINE} is passing on '${{ steps.vars.outputs.repo_default_branch }}'. Maybe you have to rebase?"
- echo "::error ::$MSG"
- echo $MSG >> ${COMMENT_LOG}
- have_new_failures="true"
- fi
- done
- for LINE in ${REF_ERROR}
- do
- if ! grep -Fxq ${LINE}<<<"${NEW_ERROR}"; then
- MSG="Congrats! The gnu test ${LINE} is no longer ERROR!"
- echo "::warning ::$MSG"
- echo $MSG >> ${COMMENT_LOG}
- fi
- done
- for LINE in ${NEW_ERROR}
- do
- if ! grep -Fxq ${LINE}<<<"${REF_ERROR}"
- then
- MSG="GNU test error: ${LINE}. ${LINE} is passing on '${{ steps.vars.outputs.repo_default_branch }}'. Maybe you have to rebase?"
- echo "::error ::$MSG"
- echo $MSG >> ${COMMENT_LOG}
- have_new_failures="true"
- fi
- done
+ compare_tests() {
+ local new_log_file=$1
+ local ref_log_file=$2
+ local test_type=$3 # "standard" or "root"
+
+ if test -f "${ref_log_file}"; then
+ echo "Reference ${test_type} test log SHA1/ID: $(sha1sum -- "${ref_log_file}") - ${test_type}"
+ REF_ERROR=$(sed -n "s/^ERROR: \([[:print:]]\+\).*/\1/p" "${ref_log_file}"| sort)
+ CURRENT_RUN_ERROR=$(sed -n "s/^ERROR: \([[:print:]]\+\).*/\1/p" "${new_log_file}" | sort)
+ REF_FAILING=$(sed -n "s/^FAIL: \([[:print:]]\+\).*/\1/p" "${ref_log_file}"| sort)
+ CURRENT_RUN_FAILING=$(sed -n "s/^FAIL: \([[:print:]]\+\).*/\1/p" "${new_log_file}" | sort)
+ echo "Detailled information:"
+ echo "REF_ERROR = ${REF_ERROR}"
+ echo "CURRENT_RUN_ERROR = ${CURRENT_RUN_ERROR}"
+ echo "REF_FAILING = ${REF_FAILING}"
+ echo "CURRENT_RUN_FAILING = ${CURRENT_RUN_FAILING}"
+
+ # Compare failing and error tests
+ for LINE in ${CURRENT_RUN_FAILING}
+ do
+ if ! grep -Fxq ${LINE}<<<"${REF_FAILING}"
+ then
+ if ! grep ${LINE} ${IGNORE_INTERMITTENT}
+ then
+ MSG="GNU test failed: ${LINE}. ${LINE} is passing on '${REPO_DEFAULT_BRANCH}'. Maybe you have to rebase?"
+ echo "::error ::$MSG"
+ echo $MSG >> ${COMMENT_LOG}
+ have_new_failures="true"
+ else
+ MSG="Skip an intermittent issue ${LINE} (fails in this run but passes in the 'main' branch)"
+ echo "::warning ::$MSG"
+ echo $MSG >> ${COMMENT_LOG}
+ echo ""
+ fi
+ fi
+ done
+
+ for LINE in ${REF_FAILING}
+ do
+ if ! grep -Fxq ${LINE}<<<"${CURRENT_RUN_FAILING}"
+ then
+ if ! grep ${LINE} ${IGNORE_INTERMITTENT}
+ then
+ MSG="Congrats! The gnu test ${LINE} is no longer failing!"
+ echo "::warning ::$MSG"
+ echo $MSG >> ${COMMENT_LOG}
+ else
+ MSG="Skipping an intermittent issue ${LINE} (passes in this run but fails in the 'main' branch)"
+ echo "::warning ::$MSG"
+ echo $MSG >> ${COMMENT_LOG}
+ echo ""
+ fi
+ fi
+ done
+
+ for LINE in ${CURRENT_RUN_ERROR}
+ do
+ if ! grep -Fxq ${LINE}<<<"${REF_ERROR}"
+ then
+ MSG="GNU test error: ${LINE}. ${LINE} is passing on '${REPO_DEFAULT_BRANCH}'. Maybe you have to rebase?"
+ echo "::error ::$MSG"
+ echo $MSG >> ${COMMENT_LOG}
+ have_new_failures="true"
+ fi
+ done
+
+ for LINE in ${REF_ERROR}
+ do
+ if ! grep -Fxq ${LINE}<<<"${CURRENT_RUN_ERROR}"
+ then
+ MSG="Congrats! The gnu test ${LINE} is no longer ERROR!"
+ echo "::warning ::$MSG"
+ echo $MSG >> ${COMMENT_LOG}
+ fi
+ done
+ else
+ echo "::warning ::Skipping ${test_type} test failure comparison; no prior reference test logs are available."
+ fi
+ }
+
+ # Compare standard tests
+ compare_tests '${{ steps.vars.outputs.path_GNU_tests }}/test-suite.log' "${REF_LOG_FILE}" "standard"
+
+ # Compare root tests
+ compare_tests '${{ steps.vars.outputs.path_GNU_tests }}/test-suite-root.log' "${ROOT_REF_LOG_FILE}" "root"
- else
- echo "::warning ::Skipping test failure comparison; no prior reference test logs are available."
- fi
if test -n "${have_new_failures}" ; then exit -1 ; fi
- name: Upload comparison log (for GnuComment workflow)
if: success() || failure() # run regardless of prior step success/failure
- uses: actions/upload-artifact@v3
+ uses: actions/upload-artifact@v4
with:
name: comment
path: ${{ steps.vars.outputs.path_reference }}/comment/
@@ -254,6 +321,7 @@ jobs:
if: success() || failure() # run regardless of prior step success/failure
shell: bash
run: |
+ ## Compare test summary VS reference
REF_SUMMARY_FILE='${{ steps.vars.outputs.path_reference }}/test-summary/gnu-result.json'
if test -f "${REF_SUMMARY_FILE}"; then
echo "Reference SHA1/ID: $(sha1sum -- "${REF_SUMMARY_FILE}")"
@@ -265,30 +333,35 @@ jobs:
gnu_coverage:
name: Run GNU tests with coverage
- runs-on: ubuntu-20.04
+ runs-on: ubuntu-22.04
steps:
- name: Checkout code uutil
- uses: actions/checkout@v3
+ uses: actions/checkout@v4
with:
path: 'uutils'
- name: Checkout GNU coreutils
- uses: actions/checkout@v3
+ uses: actions/checkout@v4
with:
repository: 'coreutils/coreutils'
path: 'gnu'
- ref: 'v9.1'
+ ref: 'v9.5'
submodules: recursive
- - name: Install `rust` toolchain
- run: |
- rm -f "${HOME}/.cargo/bin/"{rustfmt,cargo-fmt}
- rustup toolchain install nightly -c rustfmt --profile minimal
- rustup default nightly
+ - uses: dtolnay/rust-toolchain@master
+ with:
+ toolchain: nightly
+ components: rustfmt
+ - uses: taiki-e/install-action@grcov
+ - uses: Swatinem/rust-cache@v2
+ with:
+ workspaces: "./uutils -> target"
- name: Install dependencies
run: |
- sudo apt update
- sudo apt install autoconf autopoint bison texinfo gperf gcc g++ gdb python3-pyinotify jq valgrind libexpect-perl -y
+ ## Install dependencies
+ sudo apt-get update
+ sudo apt-get install -y autoconf autopoint bison texinfo gperf gcc g++ gdb python3-pyinotify jq valgrind libexpect-perl libacl1-dev libattr1-dev libcap-dev
- name: Add various locales
run: |
+ ## Add various locales
echo "Before:"
locale -a
## Some tests fail with 'cannot change locale (en_US.ISO-8859-1): No such file or directory'
@@ -301,16 +374,14 @@ jobs:
locale -a
- name: Build binaries
env:
- CARGO_INCREMENTAL: "0"
RUSTFLAGS: "-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
RUSTDOCFLAGS: "-Cpanic=abort"
run: |
+ ## Build binaries
cd uutils
- UU_MAKE_PROFILE=debug bash util/build-gnu.sh
+ bash util/build-gnu.sh
- name: Run GNU tests
run: bash uutils/util/run-gnu-test.sh
- - name: "`grcov` ~ install"
- run: cargo install grcov
- name: Generate coverage data (via `grcov`)
id: coverage
run: |
@@ -326,8 +397,9 @@ jobs:
grcov . --output-type lcov --output-path "${COVERAGE_REPORT_FILE}" --branch --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()"
echo "report=${COVERAGE_REPORT_FILE}" >> $GITHUB_OUTPUT
- name: Upload coverage results (to Codecov.io)
- uses: codecov/codecov-action@v3
+ uses: codecov/codecov-action@v4
with:
+ token: ${{ secrets.CODECOV_TOKEN }}
file: ${{ steps.coverage.outputs.report }}
flags: gnutests
name: gnutests
diff --git a/.github/workflows/android.yml b/.github/workflows/android.yml
new file mode 100644
index 0000000000000000000000000000000000000000..d4aff652a68cceabac8bf184e6f236be99d82bae
--- /dev/null
+++ b/.github/workflows/android.yml
@@ -0,0 +1,203 @@
+name: Android
+
+# spell-checker:ignore TERMUX reactivecircus Swatinem noaudio pkill swiftshader dtolnay juliangruber
+
+on:
+ pull_request:
+ push:
+ branches:
+ - main
+
+
+permissions:
+ contents: read # to fetch code (actions/checkout)
+
+# End the current execution if there is a new changeset in the PR.
+concurrency:
+ group: ${{ github.workflow }}-${{ github.ref }}
+ cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+env:
+ TERMUX: v0.118.0
+ KEY_POSTFIX: nextest+rustc-hash+adb+sshd+upgrade+XGB+inc18
+ COMMON_EMULATOR_OPTIONS: -no-window -noaudio -no-boot-anim -camera-back none -gpu swiftshader_indirect
+ EMULATOR_DISK_SIZE: 12GB
+ EMULATOR_HEAP_SIZE: 2048M
+ EMULATOR_BOOT_TIMEOUT: 1200 # 20min
+
+jobs:
+ test_android:
+ name: Test builds
+ timeout-minutes: 90
+ strategy:
+ fail-fast: false
+ matrix:
+ os: [ubuntu-latest] # , macos-latest
+ cores: [4] # , 6
+ ram: [4096, 8192]
+ api-level: [28]
+ target: [google_apis_playstore]
+ arch: [x86, x86_64] # , arm64-v8a
+ exclude:
+ - ram: 8192
+ arch: x86
+ - ram: 4096
+ arch: x86_64
+ runs-on: ${{ matrix.os }}
+ env:
+ EMULATOR_RAM_SIZE: ${{ matrix.ram }}
+ EMULATOR_CORES: ${{ matrix.cores }}
+ RUNNER_OS: ${{ matrix.os }}
+ AVD_CACHE_KEY: "set later due to limitations of github actions not able to concatenate env variables"
+ steps:
+ - name: Concatenate values to environment file
+ run: |
+ echo "AVD_CACHE_KEY=${{ matrix.os }}-${{ matrix.cores }}-${{ matrix.ram }}-${{ matrix.api-level }}-${{ matrix.target }}-${{ matrix.arch }}+termux-${{ env.TERMUX }}+${{ env.KEY_POSTFIX }}" >> $GITHUB_ENV
+ - name: Collect information about runner
+ if: always()
+ continue-on-error: true
+ run: |
+ hostname
+ uname -a
+ free -mh
+ df -Th
+ cat /proc/cpuinfo
+ - name: (Linux) create links from home to data partition
+ if: ${{ runner.os == 'Linux' }}
+ continue-on-error: true
+ run: |
+ ls -lah /mnt/
+ cat /mnt/DATALOSS_WARNING_README.txt
+ sudo mkdir /mnt/data
+ sudo chmod a+rwx /mnt/data
+ mkdir /mnt/data/.android && ln -s /mnt/data/.android ~/.android
+ mkdir /mnt/data/work && ln -s /mnt/data/work ~/work
+ - name: Enable KVM group perms (linux hardware acceleration)
+ if: ${{ runner.os == 'Linux' }}
+ run: |
+ echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules
+ sudo udevadm control --reload-rules
+ sudo udevadm trigger --name-match=kvm
+ - uses: actions/checkout@v4
+ - name: Collect information about runner
+ if: always()
+ continue-on-error: true
+ run: |
+ free -mh
+ df -Th
+ - name: Restore AVD cache
+ uses: actions/cache/restore@v4
+ id: avd-cache
+ continue-on-error: true
+ with:
+ path: |
+ ~/.android/avd/*
+ ~/.android/avd/*/snapshots/*
+ ~/.android/adb*
+ ~/__rustc_hash__
+ key: avd-${{ env.AVD_CACHE_KEY }}
+ - name: Collect information about runner after AVD cache
+ if: always()
+ continue-on-error: true
+ run: |
+ free -mh
+ df -Th
+ ls -lah /mnt/data
+ du -sch /mnt/data
+ - name: Delete AVD Lockfile when run from cache
+ if: steps.avd-cache.outputs.cache-hit == 'true'
+ run: |
+ rm -f \
+ ~/.android/avd/*.avd/*.lock \
+ ~/.android/avd/*/*.lock
+ - name: Create and cache emulator image
+ if: steps.avd-cache.outputs.cache-hit != 'true'
+ uses: reactivecircus/android-emulator-runner@v2.31.0
+ with:
+ api-level: ${{ matrix.api-level }}
+ target: ${{ matrix.target }}
+ arch: ${{ matrix.arch }}
+ ram-size: ${{ env.EMULATOR_RAM_SIZE }}
+ heap-size: ${{ env.EMULATOR_HEAP_SIZE }}
+ disk-size: ${{ env.EMULATOR_DISK_SIZE }}
+ cores: ${{ env.EMULATOR_CORES }}
+ force-avd-creation: true
+ emulator-options: ${{ env.COMMON_EMULATOR_OPTIONS }} -no-snapshot-load
+ emulator-boot-timeout: ${{ env.EMULATOR_BOOT_TIMEOUT }}
+ script: |
+ util/android-commands.sh init "${{ matrix.arch }}" "${{ matrix.api-level }}" "${{ env.TERMUX }}"
+ - name: Save AVD cache
+ if: steps.avd-cache.outputs.cache-hit != 'true'
+ uses: actions/cache/save@v4
+ with:
+ path: |
+ ~/.android/avd/*
+ ~/.android/avd/*/snapshots/*
+ ~/.android/adb*
+ ~/__rustc_hash__
+ key: avd-${{ env.AVD_CACHE_KEY }}
+ - uses: juliangruber/read-file-action@v1
+ id: read_rustc_hash
+ with:
+ # ~ expansion didn't work
+ path: ${{ runner.os == 'Linux' && '/home/runner/__rustc_hash__' || '/Users/runner/__rustc_hash__' }}
+ trim: true
+ - name: Restore rust cache
+ id: rust-cache
+ uses: actions/cache/restore@v4
+ with:
+ path: ~/__rust_cache__
+ # The version vX at the end of the key is just a development version to avoid conflicts in
+ # the github cache during the development of this workflow
+ key: ${{ matrix.arch }}_${{ matrix.target}}_${{ steps.read_rustc_hash.outputs.content }}_${{ hashFiles('**/Cargo.toml', '**/Cargo.lock') }}_v3
+ - name: Collect information about runner ressources
+ if: always()
+ continue-on-error: true
+ run: |
+ free -mh
+ df -Th
+ - name: Build and Test
+ uses: reactivecircus/android-emulator-runner@v2.31.0
+ with:
+ api-level: ${{ matrix.api-level }}
+ target: ${{ matrix.target }}
+ arch: ${{ matrix.arch }}
+ ram-size: ${{ env.EMULATOR_RAM_SIZE }}
+ heap-size: ${{ env.EMULATOR_HEAP_SIZE }}
+ disk-size: ${{ env.EMULATOR_DISK_SIZE }}
+ cores: ${{ env.EMULATOR_CORES }}
+ force-avd-creation: false
+ emulator-options: ${{ env.COMMON_EMULATOR_OPTIONS }} -no-snapshot-save -snapshot ${{ env.AVD_CACHE_KEY }}
+ emulator-boot-timeout: ${{ env.EMULATOR_BOOT_TIMEOUT }}
+ # This is not a usual script. Every line is executed in a separate shell with `sh -c`. If
+ # one of the lines returns with error the whole script is failed (like running a script with
+ # set -e) and in consequences the other lines (shells) are not executed.
+ script: |
+ util/android-commands.sh sync_host
+ util/android-commands.sh build
+ util/android-commands.sh tests
+ if [[ "${{ steps.rust-cache.outputs.cache-hit }}" != 'true' ]]; then util/android-commands.sh sync_image; fi; exit 0
+ - name: Collect information about runner ressources
+ if: always()
+ continue-on-error: true
+ run: |
+ free -mh
+ df -Th
+ - name: Save rust cache
+ if: steps.rust-cache.outputs.cache-hit != 'true'
+ uses: actions/cache/save@v4
+ with:
+ path: ~/__rust_cache__
+ key: ${{ matrix.arch }}_${{ matrix.target}}_${{ steps.read_rustc_hash.outputs.content }}_${{ hashFiles('**/Cargo.toml', '**/Cargo.lock') }}_v3
+ - name: archive any output (error screenshots)
+ if: always()
+ uses: actions/upload-artifact@v4
+ with:
+ name: test_output_${{ env.AVD_CACHE_KEY }}
+ path: output
+ - name: Collect information about runner ressources
+ if: always()
+ continue-on-error: true
+ run: |
+ free -mh
+ df -Th
diff --git a/.github/workflows/code-quality.yml b/.github/workflows/code-quality.yml
new file mode 100644
index 0000000000000000000000000000000000000000..a03213c7596045b019b463403a65842ed26de138
--- /dev/null
+++ b/.github/workflows/code-quality.yml
@@ -0,0 +1,161 @@
+name: Code Quality
+
+# spell-checker:ignore TERMUX reactivecircus Swatinem noaudio pkill swiftshader dtolnay juliangruber
+
+on:
+ pull_request:
+ push:
+ branches:
+ - main
+
+env:
+ # * style job configuration
+ STYLE_FAIL_ON_FAULT: true ## (bool) fail the build if a style job contains a fault (error or warning); may be overridden on a per-job basis
+
+permissions:
+ contents: read # to fetch code (actions/checkout)
+
+# End the current execution if there is a new changeset in the PR.
+concurrency:
+ group: ${{ github.workflow }}-${{ github.ref }}
+ cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+jobs:
+
+ style_format:
+ name: Style/format
+ runs-on: ${{ matrix.job.os }}
+ strategy:
+ fail-fast: false
+ matrix:
+ job:
+ - { os: ubuntu-latest , features: feat_os_unix }
+ steps:
+ - uses: actions/checkout@v4
+ - uses: dtolnay/rust-toolchain@master
+ with:
+ toolchain: stable
+ components: rustfmt
+ - uses: Swatinem/rust-cache@v2
+ - name: Initialize workflow variables
+ id: vars
+ shell: bash
+ run: |
+ ## VARs setup
+ outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
+ # failure mode
+ unset FAIL_ON_FAULT ; case '${{ env.STYLE_FAIL_ON_FAULT }}' in
+ ''|0|f|false|n|no|off) FAULT_TYPE=warning ;;
+ *) FAIL_ON_FAULT=true ; FAULT_TYPE=error ;;
+ esac;
+ outputs FAIL_ON_FAULT FAULT_TYPE
+ - name: "`cargo fmt` testing"
+ shell: bash
+ run: |
+ ## `cargo fmt` testing
+ unset fault
+ fault_type="${{ steps.vars.outputs.FAULT_TYPE }}"
+ fault_prefix=$(echo "$fault_type" | tr '[:lower:]' '[:upper:]')
+ # * convert any errors/warnings to GHA UI annotations; ref: <https://help.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-a-warning-message>
+ S=$(cargo fmt -- --check) && printf "%s\n" "$S" || { printf "%s\n" "$S" ; printf "%s\n" "$S" | sed -E -n -e "s/^Diff[[:space:]]+in[[:space:]]+${PWD//\//\\/}\/(.*)[[:space:]]+at[[:space:]]+[^0-9]+([0-9]+).*$/::${fault_type} file=\1,line=\2::${fault_prefix}: \`cargo fmt\`: style violation (file:'\1', line:\2; use \`cargo fmt -- \"\1\"\`)/p" ; fault=true ; }
+ if [ -n "${{ steps.vars.outputs.FAIL_ON_FAULT }}" ] && [ -n "$fault" ]; then exit 1 ; fi
+
+ style_lint:
+ name: Style/lint
+ runs-on: ${{ matrix.job.os }}
+ env:
+ SCCACHE_GHA_ENABLED: "true"
+ RUSTC_WRAPPER: "sccache"
+ strategy:
+ fail-fast: false
+ matrix:
+ job:
+ - { os: ubuntu-latest , features: feat_os_unix }
+ - { os: macos-latest , features: feat_os_macos }
+ - { os: windows-latest , features: feat_os_windows }
+ steps:
+ - uses: actions/checkout@v4
+ - uses: dtolnay/rust-toolchain@master
+ with:
+ toolchain: stable
+ components: clippy
+ - uses: Swatinem/rust-cache@v2
+ - name: Run sccache-cache
+ uses: mozilla-actions/sccache-action@v0.0.5
+ - name: Initialize workflow variables
+ id: vars
+ shell: bash
+ run: |
+ ## VARs setup
+ outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
+ # failure mode
+ unset FAIL_ON_FAULT ; case '${{ env.STYLE_FAIL_ON_FAULT }}' in
+ ''|0|f|false|n|no|off) FAULT_TYPE=warning ;;
+ *) FAIL_ON_FAULT=true ; FAULT_TYPE=error ;;
+ esac;
+ outputs FAIL_ON_FAULT FAULT_TYPE
+ - name: "`cargo clippy` lint testing"
+ uses: nick-fields/retry@v3
+ with:
+ max_attempts: 3
+ retry_on: error
+ timeout_minutes: 90
+ shell: bash
+ command: |
+ ## `cargo clippy` lint testing
+ unset fault
+ CLIPPY_FLAGS="-W clippy::default_trait_access -W clippy::manual_string_new -W clippy::cognitive_complexity -W clippy::implicit_clone -W clippy::range-plus-one -W clippy::redundant-clone -W clippy::match_bool"
+ fault_type="${{ steps.vars.outputs.FAULT_TYPE }}"
+ fault_prefix=$(echo "$fault_type" | tr '[:lower:]' '[:upper:]')
+ # * convert any warnings to GHA UI annotations; ref: <https://help.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-a-warning-message>
+ S=$(cargo clippy --all-targets --features ${{ matrix.job.features }} -pcoreutils -- ${CLIPPY_FLAGS} -D warnings 2>&1) && printf "%s\n" "$S" || { printf "%s\n" "$S" ; printf "%s" "$S" | sed -E -n -e '/^error:/{' -e "N; s/^error:[[:space:]]+(.*)\\n[[:space:]]+-->[[:space:]]+(.*):([0-9]+):([0-9]+).*$/::${fault_type} file=\2,line=\3,col=\4::${fault_prefix}: \`cargo clippy\`: \1 (file:'\2', line:\3)/p;" -e '}' ; fault=true ; }
+ if [ -n "${{ steps.vars.outputs.FAIL_ON_FAULT }}" ] && [ -n "$fault" ]; then exit 1 ; fi
+
+ style_spellcheck:
+ name: Style/spelling
+ runs-on: ${{ matrix.job.os }}
+ strategy:
+ matrix:
+ job:
+ - { os: ubuntu-latest , features: feat_os_unix }
+ steps:
+ - uses: actions/checkout@v4
+ - name: Initialize workflow variables
+ id: vars
+ shell: bash
+ run: |
+ ## VARs setup
+ outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
+ # failure mode
+ unset FAIL_ON_FAULT ; case '${{ env.STYLE_FAIL_ON_FAULT }}' in
+ ''|0|f|false|n|no|off) FAULT_TYPE=warning ;;
+ *) FAIL_ON_FAULT=true ; FAULT_TYPE=error ;;
+ esac;
+ outputs FAIL_ON_FAULT FAULT_TYPE
+ - name: Install/setup prerequisites
+ shell: bash
+ run: |
+ sudo apt-get -y update ; sudo apt-get -y install npm ; sudo npm install cspell -g ;
+ - name: Run `cspell`
+ shell: bash
+ run: |
+ ## Run `cspell`
+ unset fault
+ fault_type="${{ steps.vars.outputs.FAULT_TYPE }}"
+ fault_prefix=$(echo "$fault_type" | tr '[:lower:]' '[:upper:]')
+ # * find cspell configuration ; note: avoid quotes around ${cfg_file} b/c `cspell` (v4) doesn't correctly dequote the config argument (or perhaps a subshell expansion issue?)
+ cfg_files=($(shopt -s nullglob ; echo {.vscode,.}/{,.}c[sS]pell{.json,.config{.js,.cjs,.json,.yaml,.yml},.yaml,.yml} ;))
+ cfg_file=${cfg_files[0]}
+ unset CSPELL_CFG_OPTION ; if [ -n "$cfg_file" ]; then CSPELL_CFG_OPTION="--config $cfg_file" ; fi
+ S=$(cspell ${CSPELL_CFG_OPTION} --no-summary --no-progress "**/*") && printf "%s\n" "$S" || { printf "%s\n" "$S" ; printf "%s" "$S" | sed -E -n "s/${PWD//\//\\/}\/(.*):(.*):(.*) - (.*)/::${fault_type} file=\1,line=\2,col=\3::${fault_type^^}: \4 (file:'\1', line:\2)/p" ; fault=true ; true ; }
+ if [ -n "${{ steps.vars.outputs.FAIL_ON_FAULT }}" ] && [ -n "$fault" ]; then exit 1 ; fi
+
+ toml_format:
+ name: Style/toml
+ runs-on: ubuntu-latest
+ steps:
+ - name: Clone repository
+ uses: actions/checkout@v4
+
+ - name: Check
+ run: npx --yes @taplo/cli fmt --check
diff --git a/.github/workflows/freebsd.yml b/.github/workflows/freebsd.yml
new file mode 100644
index 0000000000000000000000000000000000000000..2975ece5f9ee8ee48204ae085ac98167d849967b
--- /dev/null
+++ b/.github/workflows/freebsd.yml
@@ -0,0 +1,197 @@
+name: FreeBSD
+
+# spell-checker:ignore sshfs usesh vmactions taiki Swatinem esac fdescfs fdesc
+
+env:
+ # * style job configuration
+ STYLE_FAIL_ON_FAULT: true ## (bool) fail the build if a style job contains a fault (error or warning); may be overridden on a per-job basis
+
+on:
+ pull_request:
+ push:
+ branches:
+ - main
+
+permissions:
+ contents: read # to fetch code (actions/checkout)
+
+# End the current execution if there is a new changeset in the PR.
+concurrency:
+ group: ${{ github.workflow }}-${{ github.ref }}
+ cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+jobs:
+ style:
+ name: Style and Lint
+ runs-on: ${{ matrix.job.os }}
+ timeout-minutes: 90
+ strategy:
+ fail-fast: false
+ matrix:
+ job:
+ - { os: ubuntu-22.04 , features: unix }
+ env:
+ SCCACHE_GHA_ENABLED: "true"
+ RUSTC_WRAPPER: "sccache"
+ steps:
+ - uses: actions/checkout@v4
+ - uses: Swatinem/rust-cache@v2
+ - name: Run sccache-cache
+ uses: mozilla-actions/sccache-action@v0.0.5
+ - name: Prepare, build and test
+ uses: vmactions/freebsd-vm@v1.0.7
+ with:
+ usesh: true
+ sync: rsync
+ copyback: false
+ # We need jq and GNU coreutils to run show-utils.sh and bash to use inline shell string replacement
+ prepare: pkg install -y curl sudo jq coreutils bash
+ run: |
+ ## Prepare, build, and test
+ # implementation modelled after ref: <https://github.com/rust-lang/rustup/pull/2783>
+ # * NOTE: All steps need to be run in this block, otherwise, we are operating back on the mac host
+ set -e
+ #
+ TEST_USER=tester
+ REPO_NAME=${GITHUB_WORKSPACE##*/}
+ WORKSPACE_PARENT="/home/runner/work/${REPO_NAME}"
+ WORKSPACE="${WORKSPACE_PARENT}/${REPO_NAME}"
+ #
+ pw adduser -n ${TEST_USER} -d /root/ -g wheel -c "Coreutils user to build" -w random
+ chown -R ${TEST_USER}:wheel /root/ "${WORKSPACE_PARENT}"/
+ whoami
+ #
+ # Further work needs to be done in a sudo as we are changing users
+ sudo -i -u ${TEST_USER} bash << EOF
+ set -e
+ whoami
+ curl https://sh.rustup.rs -sSf --output rustup.sh
+ sh rustup.sh -y -c rustfmt,clippy --profile=minimal -t stable
+ . ${HOME}/.cargo/env
+ ## VARs setup
+ cd "${WORKSPACE}"
+ unset FAIL_ON_FAULT ; case '${{ env.STYLE_FAIL_ON_FAULT }}' in
+ ''|0|f|false|n|no|off) FAULT_TYPE=warning ;;
+ *) FAIL_ON_FAULT=true ; FAULT_TYPE=error ;;
+ esac;
+ FAULT_PREFIX=\$(echo "\${FAULT_TYPE}" | tr '[:lower:]' '[:upper:]')
+ # * determine sub-crate utility list
+ UTILITY_LIST="\$(./util/show-utils.sh --features ${{ matrix.job.features }})"
+ CARGO_UTILITY_LIST_OPTIONS="\$(for u in \${UTILITY_LIST}; do echo -n "-puu_\${u} "; done;)"
+ ## Info
+ # environment
+ echo "## environment"
+ echo "CI='${CI}'"
+ echo "REPO_NAME='${REPO_NAME}'"
+ echo "TEST_USER='${TEST_USER}'"
+ echo "WORKSPACE_PARENT='${WORKSPACE_PARENT}'"
+ echo "WORKSPACE='${WORKSPACE}'"
+ echo "FAULT_PREFIX='\${FAULT_PREFIX}'"
+ echo "UTILITY_LIST='\${UTILITY_LIST}'"
+ env | sort
+ # tooling info
+ echo "## tooling info"
+ cargo -V
+ rustc -V
+ #
+ # To ensure that files are cleaned up, we don't want to exit on error
+ set +e
+ unset FAULT
+ ## cargo fmt testing
+ echo "## cargo fmt testing"
+ # * convert any errors/warnings to GHA UI annotations; ref: <https://help.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-a-warning-message>
+ S=\$(cargo fmt -- --check) && printf "%s\n" "\$S" || { printf "%s\n" "\$S" ; printf "%s\n" "\$S" | sed -E -n -e "s/^Diff[[:space:]]+in[[:space:]]+\${PWD//\//\\\\/}\/(.*)[[:space:]]+at[[:space:]]+[^0-9]+([0-9]+).*\$/::\${FAULT_TYPE} file=\1,line=\2::\${FAULT_PREFIX}: \\\`cargo fmt\\\`: style violation (file:'\1', line:\2; use \\\`cargo fmt -- \"\1\"\\\`)/p" ; FAULT=true ; }
+ ## cargo clippy lint testing
+ if [ -z "\${FAULT}" ]; then
+ echo "## cargo clippy lint testing"
+ # * convert any warnings to GHA UI annotations; ref: <https://help.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-a-warning-message>
+ S=\$(cargo clippy --all-targets \${CARGO_UTILITY_LIST_OPTIONS} -- -W clippy::manual_string_new -D warnings 2>&1) && printf "%s\n" "\$S" || { printf "%s\n" "\$S" ; printf "%s" "\$S" | sed -E -n -e '/^error:/{' -e "N; s/^error:[[:space:]]+(.*)\\n[[:space:]]+-->[[:space:]]+(.*):([0-9]+):([0-9]+).*\$/::\${FAULT_TYPE} file=\2,line=\3,col=\4::\${FAULT_PREFIX}: \\\`cargo clippy\\\`: \1 (file:'\2', line:\3)/p;" -e '}' ; FAULT=true ; }
+ fi
+ # Clean to avoid to rsync back the files
+ cargo clean
+ if [ -n "\${FAIL_ON_FAULT}" ] && [ -n "\${FAULT}" ]; then exit 1 ; fi
+ EOF
+
+ test:
+ name: Tests
+ runs-on: ${{ matrix.job.os }}
+ timeout-minutes: 90
+ strategy:
+ fail-fast: false
+ matrix:
+ job:
+ - { os: ubuntu-22.04 , features: unix }
+ env:
+ mem: 4096
+ SCCACHE_GHA_ENABLED: "true"
+ RUSTC_WRAPPER: "sccache"
+ steps:
+ - uses: actions/checkout@v4
+ - uses: Swatinem/rust-cache@v2
+ - name: Run sccache-cache
+ uses: mozilla-actions/sccache-action@v0.0.5
+ - name: Prepare, build and test
+ uses: vmactions/freebsd-vm@v1.0.7
+ with:
+ usesh: true
+ sync: rsync
+ copyback: false
+ prepare: pkg install -y curl gmake sudo
+ run: |
+ ## Prepare, build, and test
+ # implementation modelled after ref: <https://github.com/rust-lang/rustup/pull/2783>
+ # * NOTE: All steps need to be run in this block, otherwise, we are operating back on the mac host
+ set -e
+ #
+ # We need a file-descriptor file system to test test_ls::test_ls_io_errors
+ mount -t fdescfs fdesc /dev/fd
+ #
+ TEST_USER=tester
+ REPO_NAME=${GITHUB_WORKSPACE##*/}
+ WORKSPACE_PARENT="/home/runner/work/${REPO_NAME}"
+ WORKSPACE="${WORKSPACE_PARENT}/${REPO_NAME}"
+ #
+ pw adduser -n ${TEST_USER} -d /root/ -g wheel -c "Coreutils user to build" -w random
+ # chown -R ${TEST_USER}:wheel /root/ "${WORKSPACE_PARENT}"/
+ chown -R ${TEST_USER}:wheel /root/ "${WORKSPACE_PARENT}"/
+ whoami
+ #
+ # Further work needs to be done in a sudo as we are changing users
+ sudo -i -u ${TEST_USER} sh << EOF
+ set -e
+ whoami
+ curl https://sh.rustup.rs -sSf --output rustup.sh
+ sh rustup.sh -y --profile=minimal
+ . $HOME/.cargo/env
+ # Install nextest
+ mkdir -p ~/.cargo/bin
+ curl -LsSf https://get.nexte.st/latest/freebsd | tar zxf - -C ~/.cargo/bin
+ ## Info
+ # environment
+ echo "## environment"
+ echo "CI='${CI}'"
+ echo "REPO_NAME='${REPO_NAME}'"
+ echo "TEST_USER='${TEST_USER}'"
+ echo "WORKSPACE_PARENT='${WORKSPACE_PARENT}'"
+ echo "WORKSPACE='${WORKSPACE}'"
+ env | sort
+ # tooling info
+ echo "## tooling info"
+ cargo -V
+ cargo nextest --version
+ rustc -V
+ #
+ # To ensure that files are cleaned up, we don't want to exit on error
+ set +e
+ cd "${WORKSPACE}"
+ unset FAULT
+ cargo build || FAULT=1
+ export PATH=~/.cargo/bin:${PATH}
+ export RUST_BACKTRACE=1
+ export CARGO_TERM_COLOR=always
+ if (test -z "\$FAULT"); then cargo nextest run --hide-progress-bar --profile ci --features '${{ matrix.job.features }}' || FAULT=1 ; fi
+ if (test -z "\$FAULT"); then cargo nextest run --hide-progress-bar --profile ci --all-features -p uucore || FAULT=1 ; fi
+ # Clean to avoid to rsync back the files
+ cargo clean
+ if (test -n "\$FAULT"); then exit 1 ; fi
+ EOF
diff --git a/.github/workflows/fuzzing.yml b/.github/workflows/fuzzing.yml
new file mode 100644
index 0000000000000000000000000000000000000000..df40b123679585956ba549e26ff80dc2d417197c
--- /dev/null
+++ b/.github/workflows/fuzzing.yml
@@ -0,0 +1,88 @@
+name: Fuzzing
+
+# spell-checker:ignore fuzzer
+
+on:
+ pull_request:
+ push:
+ branches:
+ - main
+
+permissions:
+ contents: read # to fetch code (actions/checkout)
+
+# End the current execution if there is a new changeset in the PR.
+concurrency:
+ group: ${{ github.workflow }}-${{ github.ref }}
+ cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+jobs:
+ fuzz-build:
+ name: Build the fuzzers
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - uses: dtolnay/rust-toolchain@nightly
+ - name: Install `cargo-fuzz`
+ run: cargo install cargo-fuzz
+ - uses: Swatinem/rust-cache@v2
+ with:
+ shared-key: "cargo-fuzz-cache-key"
+ cache-directories: "fuzz/target"
+ - name: Run `cargo-fuzz build`
+ run: cargo +nightly fuzz build
+
+ fuzz-run:
+ needs: fuzz-build
+ name: Run the fuzzers
+ runs-on: ubuntu-latest
+ timeout-minutes: 5
+ env:
+ RUN_FOR: 60
+ strategy:
+ matrix:
+ test-target:
+ - { name: fuzz_test, should_pass: true }
+ # https://github.com/uutils/coreutils/issues/5311
+ - { name: fuzz_date, should_pass: false }
+ - { name: fuzz_expr, should_pass: true }
+ - { name: fuzz_printf, should_pass: false }
+ - { name: fuzz_echo, should_pass: true }
+ - { name: fuzz_seq, should_pass: false }
+ - { name: fuzz_sort, should_pass: false }
+ - { name: fuzz_wc, should_pass: false }
+ - { name: fuzz_cut, should_pass: false }
+ - { name: fuzz_split, should_pass: false }
+ - { name: fuzz_tr, should_pass: false }
+ - { name: fuzz_env, should_pass: false }
+ - { name: fuzz_parse_glob, should_pass: true }
+ - { name: fuzz_parse_size, should_pass: true }
+ - { name: fuzz_parse_time, should_pass: true }
+ - { name: fuzz_seq_parse_number, should_pass: true }
+
+ steps:
+ - uses: actions/checkout@v4
+ - uses: dtolnay/rust-toolchain@nightly
+ - name: Install `cargo-fuzz`
+ run: cargo install cargo-fuzz
+ - uses: Swatinem/rust-cache@v2
+ with:
+ shared-key: "cargo-fuzz-cache-key"
+ cache-directories: "fuzz/target"
+ - name: Restore Cached Corpus
+ uses: actions/cache/restore@v4
+ with:
+ key: corpus-cache-${{ matrix.test-target.name }}
+ path: |
+ fuzz/corpus/${{ matrix.test-target.name }}
+ - name: Run ${{ matrix.test-target.name }} for XX seconds
+ shell: bash
+ continue-on-error: ${{ !matrix.test-target.name.should_pass }}
+ run: |
+ cargo +nightly fuzz run ${{ matrix.test-target.name }} -- -max_total_time=${{ env.RUN_FOR }} -detect_leaks=0
+ - name: Save Corpus Cache
+ uses: actions/cache/save@v4
+ with:
+ key: corpus-cache-${{ matrix.test-target.name }}
+ path: |
+ fuzz/corpus/${{ matrix.test-target.name }}
diff --git a/.github/workflows/ignore-intermittent.txt b/.github/workflows/ignore-intermittent.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e163202a2ca0a078136f3e59271d4d497630f954
--- /dev/null
+++ b/.github/workflows/ignore-intermittent.txt
@@ -0,0 +1,3 @@
+tests/tail/inotify-dir-recreate
+tests/misc/timeout
+tests/rm/rm1
diff --git a/.gitignore b/.gitignore
index 77e8f717e5ec39a6e5cd9c4b1ddae6c8ba0f6b9e..ed4e54ec5bcf456519b3cd10785720dc0a09fb34 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,6 +5,7 @@ target/
/busybox/
/.vscode/
/.vs/
+/public/
*~
.*.swp
.*.swo
diff --git a/.markdownlint.yaml b/.markdownlint.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..11b733e0b494bf6a1c50f66baca5b9c6cefbd929
--- /dev/null
+++ b/.markdownlint.yaml
@@ -0,0 +1,6 @@
+#Â Disable 'Line length'. Doesn't provide much values
+MD013: false
+# Disable 'Fenced code blocks should have a language specified'
+# Doesn't provide much in src/ to enforce it
+MD040: false
+
diff --git a/.vscode/cSpell.json b/.vscode/cSpell.json
index edac1c21e2df95a6b87741387ca637a8aea8064d..6ceb038c218df725541b76f685c04834ed0df5a4 100644
--- a/.vscode/cSpell.json
+++ b/.vscode/cSpell.json
@@ -19,6 +19,7 @@
// files to ignore (globs supported)
"ignorePaths": [
"Cargo.lock",
+ "oranda.json",
"target/**",
"tests/**/fixtures/**",
"src/uu/dd/test-resources/**",
diff --git a/.vscode/cspell.dictionaries/acronyms+names.wordlist.txt b/.vscode/cspell.dictionaries/acronyms+names.wordlist.txt
index 81bc3bc5fd2f3446d7847692c00b160b718cb841..4a59ed094bd9c58f922be1843ceba7e19c3b5357 100644
--- a/.vscode/cspell.dictionaries/acronyms+names.wordlist.txt
+++ b/.vscode/cspell.dictionaries/acronyms+names.wordlist.txt
@@ -37,6 +37,7 @@ aarch
flac
impls
lzma
+loongarch
# * names
BusyBox
@@ -50,6 +51,7 @@ Gmail
GNU
Illumos
Irix
+libfuzzer
MS-DOS
MSDOS
MacOS
@@ -57,6 +59,7 @@ MinGW
Minix
NetBSD
Novell
+Nushell
OpenBSD
POSIX
PowerPC
diff --git a/.vscode/cspell.dictionaries/jargon.wordlist.txt b/.vscode/cspell.dictionaries/jargon.wordlist.txt
index dca883dc8045997c7c8b27e318167e05da049e58..20e26990f3b231945a6e581e86eac326a006e1cc 100644
--- a/.vscode/cspell.dictionaries/jargon.wordlist.txt
+++ b/.vscode/cspell.dictionaries/jargon.wordlist.txt
@@ -42,6 +42,7 @@ fileio
filesystem
filesystems
flamegraph
+fsxattr
fullblock
getfacl
gibi
@@ -133,6 +134,7 @@ urand
whitespace
wordlist
wordlists
+xattrs
# * abbreviations
consts
diff --git a/.vscode/cspell.dictionaries/shell.wordlist.txt b/.vscode/cspell.dictionaries/shell.wordlist.txt
index 16d7b25e9977a8592f05615f3fc0724a35025292..11ce341addf6505058d4ea1f08567bd256805ad8 100644
--- a/.vscode/cspell.dictionaries/shell.wordlist.txt
+++ b/.vscode/cspell.dictionaries/shell.wordlist.txt
@@ -25,6 +25,7 @@ sudoedit
tcsh
tzselect
urandom
+VARNAME
wtmp
zsh
@@ -83,6 +84,8 @@ codespell
commitlint
dprint
dtrace
+flamegraph
+flamegraphs
gcov
gmake
grcov
@@ -90,6 +93,7 @@ grep
markdownlint
rerast
rollup
+samply
sed
selinuxenabled
sestatus
diff --git a/.vscode/cspell.dictionaries/workspace.wordlist.txt b/.vscode/cspell.dictionaries/workspace.wordlist.txt
index d6e91dca5bf09a1ffbcb7094ccc9d6ff693d7d0d..ce4822f1ec3b74ee89e8a2ba6b399f91943b826a 100644
--- a/.vscode/cspell.dictionaries/workspace.wordlist.txt
+++ b/.vscode/cspell.dictionaries/workspace.wordlist.txt
@@ -20,6 +20,7 @@ exacl
filetime
formatteriteminfo
fsext
+fundu
getopts
getrandom
globset
@@ -58,6 +59,7 @@ clippy
rustc
rustfmt
rustup
+rustdoc
#
bitor # BitOr trait function
bitxor # BitXor trait function
@@ -164,6 +166,7 @@ RTLD_NEXT
RTLD
SIGINT
SIGKILL
+SIGSTOP
SIGTERM
SYS_fdatasync
SYS_syncfs
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
index d196c6e956475067198c1e30148bffce4189e152..39474f7ab9576b37922e44e5feea496b1fc8662c 100644
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -116,7 +116,7 @@ the community.
This Code of Conduct is adapted from the [Contributor Covenant][homepage],
version 2.0, available at
-https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+<https://www.contributor-covenant.org/version/2/0/code_of_conduct.html>.
Community Impact Guidelines were inspired by [Mozilla's code of conduct
enforcement ladder](https://github.com/mozilla/diversity).
@@ -124,5 +124,5 @@ enforcement ladder](https://github.com/mozilla/diversity).
[homepage]: https://www.contributor-covenant.org
For answers to common questions about this code of conduct, see the FAQ at
-https://www.contributor-covenant.org/faq. Translations are available at
-https://www.contributor-covenant.org/translations.
+<https://www.contributor-covenant.org/faq>. Translations are available at
+<https://www.contributor-covenant.org/translations>.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 7a749ebac403d7e10a618c665489c5dbd1b565c6..dfee460029da30a34ce24c1f31040a704c5b09c1 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,118 +1,318 @@
+<!-- spell-checker:ignore reimplementing toybox RUNTEST CARGOFLAGS nextest embeddable Rustonomicon rustdoc's -->
+
# Contributing to coreutils
-Contributions are very welcome, and should target Rust's main branch until the
-standard libraries are stabilized. You may *claim* an item on the to-do list by
-following these steps:
-
-1. Open an issue named "Implement [the utility of your choice]", e.g. "Implement
- ls".
-1. State that you are working on this utility.
-1. Develop the utility.
-1. Add integration tests.
-1. Add the reference to your utility into Cargo.toml and Makefile.
-1. Remove utility from the to-do list in the README.
-1. Submit a pull request and close the issue.
-
-The steps above imply that, before starting to work on a utility, you should
-search the issues to make sure no one else is working on it.
-
-## Best practices
-
-1. Follow what GNU is doing in terms of options and behavior. It is recommended
- to look at the GNU Coreutils manual ([on the
- web](https://www.gnu.org/software/coreutils/manual/html_node/index.html), or
- locally using `info <utility>`). It is more in depth than the man pages and
- provides a good description of available features and their implementation
- details.
-1. If possible, look at the GNU test suite execution in the CI and make the test
- work if failing.
-1. Use clap for argument management.
-1. Make sure that the code coverage is covering all of the cases, including
- errors.
-1. The code must be clippy-warning-free and rustfmt-compliant.
-1. Don't hesitate to move common functions into uucore if they can be reused by
- other binaries.
-1. Unsafe code should be documented with Safety comments.
-1. uutils is original code. It cannot contain code from existing GNU or Unix-like
- utilities, nor should it link to or reference GNU libraries.
+Hi! Welcome to uutils/coreutils!
-## Platforms
+Thanks for wanting to contribute to this project! This document explains
+everything you need to know to contribute. Before you start make sure to also
+check out these documents:
-We take pride in supporting many operating systems and architectures.
+- Our community's [CODE_OF_CONDUCT.md](./CODE_OF_CONDUCT.md).
+- [DEVELOPMENT.md](./DEVELOPMENT.md) for setting up your development
+ environment.
-**Tip:**
-For Windows, Microsoft provides some images (VMWare, Hyper-V, VirtualBox and Parallels)
-for development:
-https://developer.microsoft.com/windows/downloads/virtual-machines/
+Now follows a very important warning:
+> [!WARNING]
+> uutils is original code and cannot contain any code from GNU or
+> other implementations. This means that **we cannot accept any changes based on
+> the GNU source code**. To make sure that cannot happen, **you cannot link to
+> the GNU source code** either. It is however possible to look at other implementations
+> under a BSD or MIT license like [Apple's implementation](https://opensource.apple.com/source/file_cmds/)
+> or [OpenBSD](https://github.com/openbsd/src/tree/master/bin).
-## Commit messages
+Finally, feel free to join our [Discord](https://discord.gg/wQVJbvJ)!
-To help the project maintainers review pull requests from contributors across
-numerous utilities, the team has settled on conventions for commit messages.
+## Getting Oriented
-From http://git-scm.com/book/ch5-2.html:
+uutils is a big project consisting of many parts. Here are the most important
+parts for getting started:
-```
-Short (50 chars or less) summary of changes
+- [`src/uu`](./src/uu/): The code for all utilities
+- [`src/uucore`](./src/uucore/): Crate containing all the shared code between
+ the utilities.
+- [`tests/by-util`](./tests/by-util/): The tests for all utilities.
+- [`src/bin/coreutils.rs`](./src/bin/coreutils.rs): Code for the multicall
+ binary.
+- [`docs`](./docs/src): the documentation for the website
+
+Each utility is defined as a separate crate. The structure of each of these
+crates is as follows:
+
+- `Cargo.toml`
+- `src/main.rs`: contains only a single macro call
+- `src/<util name>.rs`: the actual code for the utility
+- `<util name>.md`: the documentation for the utility
+
+We have separated repositories for crates that we maintain but also publish for
+use by others:
+
+- [uutils-term-grid](https://github.com/uutils/uutils-term-grid)
+- [parse_datetime](https://github.com/uutils/parse_datetime)
+
+## Design Goals
+
+We have the following goals with our development:
+
+- **Compatible**: The utilities should be a drop-in replacement for the GNU
+ coreutils.
+- **Cross-platform**: All utilities should run on as many of the supported
+ platforms as possible.
+- **Reliable**: The utilities should never unexpectedly fail.
+- **Performant**: Our utilities should be written in fast idiomatic Rust. We aim
+ to match or exceed the performance of the GNU utilities.
+- **Well-tested**: We should have a lot of tests to be able to guarantee
+ reliability and compatibility.
+
+## How to Help
+
+There are several ways to help and writing code is just one of them. Reporting
+issues and writing documentation are just as important as writing code.
+
+### Reporting Issues
+
+We can't fix bugs we don't know about, so good issues are super helpful! Here
+are some tips for writing good issues:
+
+- If you find a bug, make sure it's still a problem on the `main` branch.
+- Search through the existing issues to see whether it has already been
+ reported.
+- Make sure to include all relevant information, such as:
+ - Which version of uutils did you check?
+ - Which version of GNU coreutils are you comparing with?
+ - What platform are you on?
+- Provide a way to reliably reproduce the issue.
+- Be as specific as possible!
+
+### Writing Documentation
+
+There's never enough documentation. If you come across any documentation that
+could be improved, feel free to submit a PR for it!
+
+### Writing Code
+
+If you want to submit a PR, make sure that you've discussed the solution with
+the maintainers beforehand. We want to avoid situations where you put a lot of
+work into a fix that we can't merge! If there's no issue for what you're trying
+to fix yet, make one _before_ you start working on the PR.
+
+Generally, we try to follow what GNU is doing in terms of options and behavior.
+It is recommended to look at the GNU coreutils manual
+([on the web](https://www.gnu.org/software/coreutils/manual/html_node/index.html),
+or locally using `info <utility>`). It is more in depth than the man pages and
+provides a good description of available features and their implementation
+details. But remember, you cannot look at the GNU source code!
+
+Also remember that we can only merge PRs which pass our test suite, follow
+rustfmt, and do not have any warnings from clippy. See
+[DEVELOPMENT.md](./DEVELOPMENT.md) for more information. Be sure to also read
+about our [Rust style](#our-rust-style).
+
+## Our Rust Style
+
+We want uutils to be written in idiomatic Rust, so here are some guidelines to
+follow. Some of these are aspirational, meaning that we don't do them correctly
+everywhere in the code. If you find violations of the advice below, feel free to
+submit a patch!
+
+### Don't `panic!`
+
+The coreutils should be very reliable. This means that we should never `panic!`.
+Therefore, you should avoid using `.unwrap()` and `panic!`. Sometimes the use of
+`unreachable!` can be justified with a comment explaining why that code is
+unreachable.
+
+### Don't `exit`
+
+We want uutils to be embeddable in other programs. This means that no function
+in uutils should exit the program. Doing so would also lead to code with more
+confusing control flow. Avoid therefore `std::process::exit` and similar
+functions which exit the program early.
+
+### `unsafe`
+
+uutils cannot be entirely safe, because we have to call out to `libc` and do
+syscalls. However, we still want to limit our use of `unsafe`. We generally only
+accept `unsafe` for FFI, with very few exceptions. Note that performance is very
+rarely a valid argument for using `unsafe`.
-More detailed explanatory text, if necessary. Wrap it to about 72
-characters or so. In some contexts, the first line is treated as the
-subject of an email and the rest of the text as the body. The blank
-line separating the summary from the body is critical (unless you omit
-the body entirely); tools like rebase can get confused if you run the
-two together.
+If you still need to write code with `unsafe`, make sure to read the
+[Rustonomicon](https://doc.rust-lang.org/nomicon/intro.html) and annotate the
+calls with `// SAFETY:` comments explaining why the use of `unsafe` is sound.
-Further paragraphs come after blank lines.
+### Macros
- - Bullet points are okay, too
+Macros can be a great tool, but they are also usually hard to understand. They
+should be used sparingly. Make sure to explore simpler options before you reach
+for a solution involving macros.
+
+### `str`, `OsStr` & `Path`
+
+Rust has many string-like types, and sometimes it's hard to choose the right
+one. It's tempting to use `str` (and `String`) for everything, but that is not
+always the right choice for uutils, because we need to support invalid UTF-8,
+just like the GNU coreutils. For example, paths on Linux might not be valid
+UTF-8! Whenever we are dealing with paths, we should therefore stick with
+`OsStr` and `Path`. Make sure that you only convert to `str`/`String` if you
+know that something is always valid UTF-8. If you need more operations on
+`OsStr`, you can use the [`bstr`](https://docs.rs/bstr/latest/bstr/) crate.
+
+### Doc-comments
+
+We use rustdoc for our documentation, so it's best to follow
+[rustdoc's guidelines](https://doc.rust-lang.org/rustdoc/how-to-write-documentation.html#documenting-components).
+Make sure that your documentation is not just repeating the name of the
+function, but actually giving more useful information. Rustdoc recommends the
+following structure:
- - Typically a hyphen or asterisk is used for the bullet, preceded by a
- single space, with blank lines in between, but conventions vary here
```
+[short sentence explaining what it is]
-Furthermore, here are a few examples for a summary line:
+[more detailed explanation]
-* commit for a single utility
+[at least one code example that users can copy/paste to try it]
+
+[even more advanced explanations if necessary]
+```
+
+### Other comments
+
+Comments should be written to _explain_ the code, not to _describe_ the code.
+Try to focus on explaining _why_ the code is the way it is. If you feel like you
+have to describe the code, that's usually a sign that you could improve the
+naming of variables and functions.
+
+If you edit a piece of code, make sure to update any comments that need to
+change as a result. The only thing worse than having no comments is having
+outdated comments!
+
+## Git Etiquette
+
+To ensure easy collaboration, we have guidelines for using Git and GitHub.
+
+### Commits
+
+- Make small and atomic commits.
+- Keep a clean history of commits.
+- Write informative commit messages.
+- Annotate your commit message with the component you're editing. For example:
+ `cp: do not overwrite on with -i` or `uucore: add support for FreeBSD`.
+- Do not unnecessarily move items around in the code. This makes the changes
+ much harder to review. If you do need to move things around, do that in a
+ separate commit.
+
+### Commit messages
+
+You can read this section in the Git book to learn how to write good commit
+messages: https://git-scm.com/book/ch5-2.html.
+
+In addition, here are a few examples for a summary line when committing to
+uutils:
+
+- commit for a single utility
```
nohup: cleanup and refactor
```
-* commit for a utility's tests
+- commit for a utility's tests
```
tests/rm: test new feature
```
-Beyond changes to an individual utility or its tests, other summary
-lines for non-utility modules include:
+Beyond changes to an individual utility or its tests, other summary lines for
+non-utility modules include:
```
README: add help
-```
-
-```
uucore: add new modules
-```
-
-```
uutils: add new utility
-```
-
-```
gitignore: add temporary files
```
-## cargo-deny
+### PRs
+
+- Make the titles of PRs descriptive.
+ - This means describing the problem you solve. For example, do not write
+ `Fix #1234`, but `ls: fix version sort order`.
+ - You can prefix the title with the utility the PR concerns.
+- Keep PRs small and self-contained. A set of small PRs is much more likely to
+ get merged quickly than one large PR.
+- Make sure the CI passes (up to intermittently failing tests).
+- You know your code best, that's why it's best if you can solve merge conflicts
+ on your branch yourself.
+ - It's up to you whether you want to use `git merge main` or
+ `git rebase main`.
+ - Feel free to ask for help with merge conflicts.
+- You do not need to ping maintainers to request a review, but it's fine to do
+ so if you don't get a response within a few days.
-This project uses [cargo-deny](https://github.com/EmbarkStudios/cargo-deny/) to
-detect duplicate dependencies, checks licenses, etc. To run it locally, first
-install it and then run with:
+## Platforms
-```
-cargo deny --all-features check all
-```
+We take pride in supporting many operating systems and architectures. Any code
+you contribute must at least compile without warnings for all platforms in the
+CI. However, you can use `#[cfg(...)]` attributes to create platform dependent
+features.
+
+**Tip:** For Windows, Microsoft provides some images (VMWare, Hyper-V,
+VirtualBox and Parallels) for development:
+<https://developer.microsoft.com/windows/downloads/virtual-machines/>
+
+## Improving the GNU compatibility
+
+Please make sure you have installed
+[GNU utils and prerequisites](DEVELOPMENT.md#gnu-utils-and-prerequisites) and
+can execute commands described in
+[Comparing with GNU](DEVELOPMENT.md#comparing-with-gnu) section of
+[DEVELOPMENT.md](DEVELOPMENT.md)
+
+The Python script `./util/remaining-gnu-error.py` shows the list of failing
+tests in the CI.
+
+To improve the GNU compatibility, the following process is recommended:
+
+1. Identify a test (the smaller, the better) on a program that you understand or
+ is easy to understand. You can use the `./util/remaining-gnu-error.py` script
+ to help with this decision.
+1. Build both the GNU and Rust coreutils using: `bash util/build-gnu.sh`
+1. Run the test with `bash util/run-gnu-test.sh <your test>`
+1. Start to modify `<your test>` to understand what is wrong. Examples:
+ 1. Add `set -v` to have the bash verbose mode
+ 1. Add `echo $?` where needed
+ 1. When the variable `fail` is used in the test, `echo $fail` to see when the
+ test started to fail
+ 1. Bump the content of the output (ex: `cat err`)
+ 1. ...
+1. Or, if the test is simple, extract the relevant information to create a new
+ test case running both GNU & Rust implementation
+1. Start to modify the Rust implementation to match the expected behavior
+1. Add a test to make sure that we don't regress (our test suite is super quick)
+
+## Code coverage
+
+To generate code coverage report locally please follow
+[Code coverage report](DEVELOPMENT.md#code-coverage-report) section of
+[DEVELOPMENT.md](DEVELOPMENT.md)
+
+## Other implementations
+
+The Coreutils have different implementations, with different levels of
+completions:
+
+- [GNU's](https://git.savannah.gnu.org/gitweb/?p=coreutils.git)
+- [OpenBSD](https://github.com/openbsd/src/tree/master/bin)
+- [Busybox](https://github.com/mirror/busybox/tree/master/coreutils)
+- [Toybox (Android)](https://github.com/landley/toybox/tree/master/toys/posix)
+- [Mac OS](https://opensource.apple.com/source/file_cmds/)
+- [V lang](https://github.com/vlang/coreutils)
+- [SerenityOS](https://github.com/SerenityOS/serenity/tree/master/Userland/Utilities)
+- [Initial Unix](https://github.com/dspinellis/unix-history-repo)
+- [Perl Power Tools](https://metacpan.org/pod/PerlPowerTools)
+
+However, when reimplementing the tools/options in Rust, don't read their source
+codes when they are using reciprocal licenses (ex: GNU GPL, GNU LGPL, etc).
## Licensing
@@ -127,17 +327,17 @@ If you wish to add or change dependencies as part of a contribution to the
project, a tool like `cargo-license` can be used to show their license details.
The following types of license are acceptable:
-* MIT License
-* Dual- or tri-license with an MIT License option ("Apache-2.0 or MIT" is a
+- MIT License
+- Dual- or tri-license with an MIT License option ("Apache-2.0 or MIT" is a
popular combination)
-* "MIT equivalent" license (2-clause BSD, 3-clause BSD, ISC)
-* License less restrictive than the MIT License (CC0 1.0 Universal)
-* Apache License version 2.0
+- "MIT equivalent" license (2-clause BSD, 3-clause BSD, ISC)
+- License less restrictive than the MIT License (CC0 1.0 Universal)
+- Apache License version 2.0
Licenses we will not use:
-* An ambiguous license, or no license
-* Strongly reciprocal licenses (GNU GPL, GNU LGPL)
+- An ambiguous license, or no license
+- Strongly reciprocal licenses (GNU GPL, GNU LGPL)
If you wish to add a reference but it doesn't meet these requirements, please
raise an issue to describe the dependency.
diff --git a/Cargo.lock b/Cargo.lock
index 95116c2a36de4a1cbb9b5d3825cf02565dc353b0..3c175e2f3e75469c51024798b39b3ca623b3ee7e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,12 +2,6 @@
# It is not intended for manual editing.
version = 3
-[[package]]
-name = "Inflector"
-version = "0.11.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe438c63458706e03479442743baae6c88256498e6431708f6dfc520a26515d3"
-
[[package]]
name = "adler"
version = "1.0.2"
@@ -16,29 +10,36 @@ checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
[[package]]
name = "ahash"
-version = "0.7.6"
+version = "0.8.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
+checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
dependencies = [
- "getrandom",
+ "cfg-if",
"once_cell",
"version_check",
+ "zerocopy",
]
[[package]]
name = "aho-corasick"
-version = "0.7.19"
+version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4f55bd91a0978cbfd91c457a164bab8b4001c833b7f323132c0a4e1922dd44e"
+checksum = "6748e8def348ed4d14996fa801f4122cd763fff530258cdc03f64b25f89d3a5a"
dependencies = [
"memchr",
]
[[package]]
-name = "aliasable"
-version = "0.1.3"
+name = "allocator-api2"
+version = "0.2.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "250f629c0161ad8107cf89319e990051fae62832fd343083bea452d93e2205fd"
+checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f"
+
+[[package]]
+name = "android-tzdata"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
[[package]]
name = "android_system_properties"
@@ -50,28 +51,83 @@ dependencies = [
]
[[package]]
-name = "arrayref"
-version = "0.3.6"
+name = "ansi-width"
+version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544"
+checksum = "219e3ce6f2611d83b51ec2098a12702112c29e57203a6b0a0929b2cddb486608"
+dependencies = [
+ "unicode-width",
+]
[[package]]
-name = "arrayvec"
-version = "0.7.2"
+name = "anstream"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f58811cfac344940f1a400b6e6231ce35171f614f26439e80f8c1465c5cc0c"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
+checksum = "41ed9a86bf92ae6580e0a31281f65a1b1d867c0cc68d5346e2ae128dddfa6a7d"
[[package]]
-name = "atty"
-version = "0.2.14"
+name = "anstyle-parse"
+version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+checksum = "e765fd216e48e067936442276d1d57399e37bce53c264d6fefbe298080cb57ee"
dependencies = [
- "hermit-abi",
- "libc",
- "winapi",
+ "utf8parse",
]
+[[package]]
+name = "anstyle-query"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ca11d4be1bab0c8bc8734a9aa7bf4ee8316d462a08c6ac5052f888fef5b494b"
+dependencies = [
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58f54d10c6dfa51283a066ceab3ec1ab78d13fae00aa49243a45e4571fb79dfd"
+dependencies = [
+ "anstyle",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "arbitrary"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d5a26814d8dcb93b0e5a0ff3c6d80a8843bafb21b39e8e18a6f05471870e110"
+dependencies = [
+ "derive_arbitrary",
+]
+
+[[package]]
+name = "arrayref"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544"
+
+[[package]]
+name = "arrayvec"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
+
[[package]]
name = "autocfg"
version = "1.1.0"
@@ -80,10 +136,12 @@ checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
[[package]]
name = "bigdecimal"
-version = "0.3.0"
+version = "0.4.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6aaf33151a6429fe9211d1b276eafdf70cdff28b071e76c0b0e1503221ea3744"
+checksum = "51d712318a27c7150326677b321a5fa91b55f6d9034ffd67f20319e147d40cee"
dependencies = [
+ "autocfg",
+ "libm",
"num-bigint",
"num-integer",
"num-traits",
@@ -98,25 +156,35 @@ dependencies = [
"compare",
]
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
[[package]]
name = "bindgen"
-version = "0.62.0"
+version = "0.69.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6720a8b7b2d39dd533285ed438d458f65b31b5c257e6ac7bb3d7e82844dd722"
+checksum = "a00dc851838a2120612785d195287475a3ac45514741da670b735818822129a0"
dependencies = [
- "bitflags",
+ "bitflags 2.5.0",
"cexpr",
"clang-sys",
+ "itertools 0.12.1",
"lazy_static",
"lazycell",
"log",
- "peeking_take_while",
+ "prettyplease",
"proc-macro2",
"quote",
"regex",
"rustc-hash",
"shlex",
- "syn",
+ "syn 2.0.60",
"which",
]
@@ -126,29 +194,46 @@ version = "1.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+[[package]]
+name = "bitflags"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
+
+[[package]]
+name = "bitvec"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
[[package]]
name = "blake2b_simd"
-version = "1.0.0"
+version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72936ee4afc7f8f736d1c38383b56480b5497b4617b4a77bdbf1d2ababc76127"
+checksum = "23285ad32269793932e830392f2fe2f83e26488fd3ec778883a93c8323735780"
dependencies = [
"arrayref",
"arrayvec",
- "constant_time_eq 0.1.5",
+ "constant_time_eq",
]
[[package]]
name = "blake3"
-version = "1.3.2"
+version = "1.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "895adc16c8b3273fbbc32685a7d55227705eda08c01e77704020f3491924b44b"
+checksum = "30cca6d3674597c30ddf2c587bf8d9d65c9a84d2326d941cc79c9842dfe0ef52"
dependencies = [
"arrayref",
"arrayvec",
"cc",
"cfg-if",
- "constant_time_eq 0.2.4",
- "digest",
+ "constant_time_eq",
]
[[package]]
@@ -162,12 +247,11 @@ dependencies = [
[[package]]
name = "bstr"
-version = "1.0.1"
+version = "1.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fca0852af221f458706eb0725c03e4ed6c46af9ac98e6a689d5e634215d594dd"
+checksum = "05efc5cfd9110c8416e471df0e96702d58690178e206e61b7173706673c93706"
dependencies = [
"memchr",
- "once_cell",
"regex-automata",
"serde",
]
@@ -180,21 +264,21 @@ checksum = "572f695136211188308f16ad2ca5c851a712c464060ae6974944458eb83880ba"
[[package]]
name = "bytecount"
-version = "0.6.3"
+version = "0.6.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c676a478f63e9fa2dd5368a42f28bba0d6c560b775f38583c8bbaa7fcd67c9c"
+checksum = "5ce89b21cab1437276d2650d57e971f9d548a2d9037cc231abdc0562b97498ce"
[[package]]
name = "byteorder"
-version = "1.4.3"
+version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
[[package]]
name = "cc"
-version = "1.0.77"
+version = "1.0.79"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9f73505338f7d905b19d18738976aae232eb46b8efc15554ffc56deb5d9ebe4"
+checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
[[package]]
name = "cexpr"
@@ -211,16 +295,22 @@ version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+[[package]]
+name = "cfg_aliases"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"
+
[[package]]
name = "chrono"
-version = "0.4.23"
+version = "0.4.38"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16b0a3d9ed01224b22057780a37bb8c5dbfe1be8ba48678e7bf57ec4b385411f"
+checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
dependencies = [
+ "android-tzdata",
"iana-time-zone",
- "num-integer",
"num-traits",
- "winapi",
+ "windows-targets 0.52.0",
]
[[package]]
@@ -236,47 +326,57 @@ dependencies = [
[[package]]
name = "clap"
-version = "4.0.26"
+version = "4.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a13b88d2c62ff462f88e4a121f17a82c1af05693a2f192b5c38d14de73c19f6"
+dependencies = [
+ "clap_builder",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2148adefda54e14492fb9bddcc600b4344c5d1a3123bd666dcb939c6f0e0e57e"
+checksum = "2bb9faaa7c2ef94b2743a21f5a29e6f0010dff4caa69ac8e9d6cf8b6fa74da08"
dependencies = [
- "atty",
- "bitflags",
+ "anstream",
+ "anstyle",
"clap_lex",
- "once_cell",
"strsim",
- "termcolor",
- "terminal_size 0.2.2",
+ "terminal_size 0.2.6",
]
[[package]]
name = "clap_complete"
-version = "4.0.6"
+version = "4.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7b3c9eae0de7bf8e3f904a5e40612b21fb2e2e566456d177809a48b892d24da"
+checksum = "586a385f7ef2f8b4d86bddaa0c094794e7ccbfe5ffef1f434fe928143fc783a5"
dependencies = [
"clap",
]
[[package]]
name = "clap_lex"
-version = "0.3.0"
+version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d4198f73e42b4936b35b5bb248d81d2b595ecb170da0bac7655c54eedfa8da8"
-dependencies = [
- "os_str_bytes",
-]
+checksum = "2da6da31387c7e4ef160ffab6d5e7f00c42626fe39aea70a7b0f1773f7dd6c1b"
[[package]]
-name = "codespan-reporting"
-version = "0.11.1"
+name = "clap_mangen"
+version = "0.2.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
+checksum = "bb0f09a0ca8f0dd8ac92c546b426f466ef19828185c6d504c80c48c9c2768ed9"
dependencies = [
- "termcolor",
- "unicode-width",
+ "clap",
+ "roff",
]
+[[package]]
+name = "colorchoice"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
+
[[package]]
name = "compare"
version = "0.1.0"
@@ -285,38 +385,42 @@ checksum = "120133d4db2ec47efe2e26502ee984747630c67f51974fca0b6c1340cf2368d3"
[[package]]
name = "console"
-version = "0.15.2"
+version = "0.15.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c050367d967ced717c04b65d8c619d863ef9292ce0c5760028655a2fb298718c"
+checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb"
dependencies = [
"encode_unicode",
"lazy_static",
"libc",
- "terminal_size 0.1.17",
"unicode-width",
- "winapi",
+ "windows-sys 0.52.0",
]
[[package]]
-name = "constant_time_eq"
-version = "0.1.5"
+name = "const-random"
+version = "0.1.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"
+checksum = "11df32a13d7892ec42d51d3d175faba5211ffe13ed25d4fb348ac9e9ce835593"
+dependencies = [
+ "const-random-macro",
+]
[[package]]
-name = "constant_time_eq"
-version = "0.2.4"
+name = "const-random-macro"
+version = "0.1.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3ad85c1f65dc7b37604eb0e89748faf0b9653065f2a8ef69f96a687ec1e9279"
+checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e"
+dependencies = [
+ "getrandom",
+ "once_cell",
+ "tiny-keccak",
+]
[[package]]
-name = "conv"
-version = "0.3.3"
+name = "constant_time_eq"
+version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78ff10625fd0ac447827aa30ea8b861fead473bb60aeb73af6c1c58caf0d1299"
-dependencies = [
- "custom_derive",
-]
+checksum = "f7144d30dcf0fafbce74250a3963025d8d52177934239851c917d29f1df280c2"
[[package]]
name = "core-foundation-sys"
@@ -326,18 +430,19 @@ checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
[[package]]
name = "coreutils"
-version = "0.0.17"
+version = "0.0.27"
dependencies = [
- "atty",
+ "bincode",
"chrono",
"clap",
"clap_complete",
- "conv",
+ "clap_mangen",
"filetime",
"glob",
"hex-literal",
"libc",
"nix",
+ "num-prime",
"once_cell",
"phf",
"phf_codegen",
@@ -349,12 +454,13 @@ dependencies = [
"rlimit",
"rstest",
"selinux",
+ "serde",
+ "serde-big-array",
"sha1",
"tempfile",
"textwrap",
"time",
"unindent",
- "users",
"uu_arch",
"uu_base32",
"uu_base64",
@@ -421,7 +527,6 @@ dependencies = [
"uu_pwd",
"uu_readlink",
"uu_realpath",
- "uu_relpath",
"uu_rm",
"uu_rmdir",
"uu_runcon",
@@ -459,50 +564,52 @@ dependencies = [
"uu_whoami",
"uu_yes",
"uucore",
+ "uuhelp_parser",
"walkdir",
+ "xattr",
"zip",
]
[[package]]
name = "cpp"
-version = "0.5.7"
+version = "0.5.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dec5e86d4f6547f0218ad923d9508244a71ef83b763196e6698b4f70f3595185"
+checksum = "bfa65869ef853e45c60e9828aa08cdd1398cb6e13f3911d9cb2a079b144fcd64"
dependencies = [
"cpp_macros",
]
[[package]]
name = "cpp_build"
-version = "0.5.7"
+version = "0.5.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16f4d303b8ec35fb3afd7e963e2c898117f1e49930becb703e4a7ac528ad2dd0"
+checksum = "0e361fae2caf9758164b24da3eedd7f7d7451be30d90d8e7b5d2be29a2f0cf5b"
dependencies = [
"cc",
"cpp_common",
"lazy_static",
"proc-macro2",
"regex",
- "syn",
+ "syn 2.0.60",
"unicode-xid",
]
[[package]]
name = "cpp_common"
-version = "0.5.7"
+version = "0.5.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76071bb9c8c4dd2b5eb209907deab7b031323cf1be3dfdc6ec5d37f4f187d8a1"
+checksum = "3e1a2532e4ed4ea13031c13bc7bc0dbca4aae32df48e9d77f0d1e743179f2ea1"
dependencies = [
"lazy_static",
"proc-macro2",
- "syn",
+ "syn 2.0.60",
]
[[package]]
name = "cpp_macros"
-version = "0.5.7"
+version = "0.5.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fdaa01904c12a8989dbfa110b41ef27efc432ac9934f691b9732f01cb64dc01"
+checksum = "47ec9cc90633446f779ef481a9ce5a0077107dd5b87016440448d908625a83fd"
dependencies = [
"aho-corasick",
"byteorder",
@@ -510,7 +617,7 @@ dependencies = [
"lazy_static",
"proc-macro2",
"quote",
- "syn",
+ "syn 2.0.60",
]
[[package]]
@@ -524,18 +631,18 @@ dependencies = [
[[package]]
name = "crc32fast"
-version = "1.3.2"
+version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
+checksum = "b3855a8a784b474f333699ef2bbca9db2c4a1f6d9088a90a2d25b1eb53111eaa"
dependencies = [
"cfg-if",
]
[[package]]
name = "crossbeam-channel"
-version = "0.5.6"
+version = "0.5.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2dd04ddaf88237dc3b8d8f9a3c1004b506b54b3313403944054d23c0870c521"
+checksum = "82a9b73a36529d9c47029b9fb3a6f0ea3cc916a261195352ba19e770fc1748b2"
dependencies = [
"cfg-if",
"crossbeam-utils",
@@ -543,9 +650,9 @@ dependencies = [
[[package]]
name = "crossbeam-deque"
-version = "0.8.2"
+version = "0.8.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "715e8152b692bba2d374b53d4875445368fdf21a94751410af607a5ac677d1fc"
+checksum = "fca89a0e215bab21874660c67903c5f143333cab1da83d041c7ded6053774751"
dependencies = [
"cfg-if",
"crossbeam-epoch",
@@ -554,34 +661,30 @@ dependencies = [
[[package]]
name = "crossbeam-epoch"
-version = "0.9.12"
+version = "0.9.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96bf8df95e795db1a4aca2957ad884a2df35413b24bbeb3114422f3cc21498e8"
+checksum = "0e3681d554572a651dda4186cd47240627c3d0114d45a95f6ad27f2f22e7548d"
dependencies = [
"autocfg",
"cfg-if",
"crossbeam-utils",
- "memoffset 0.7.1",
- "scopeguard",
]
[[package]]
name = "crossbeam-utils"
-version = "0.8.13"
+version = "0.8.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "422f23e724af1240ec469ea1e834d87a4b59ce2efe2c6a96256b0c47e2fd86aa"
-dependencies = [
- "cfg-if",
-]
+checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345"
[[package]]
name = "crossterm"
-version = "0.25.0"
+version = "0.27.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e64e6c0fbe2c17357405f7c758c1ef960fce08bdfb2c03d88d2a18d7e09c4b67"
+checksum = "f476fe445d41c9e991fd07515a6f463074b782242ccf4a5b7b1d1012e70824df"
dependencies = [
- "bitflags",
+ "bitflags 2.5.0",
"crossterm_winapi",
+ "filedescriptor",
"libc",
"mio",
"parking_lot",
@@ -592,9 +695,9 @@ dependencies = [
[[package]]
name = "crossterm_winapi"
-version = "0.9.0"
+version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ae1b35a484aa10e07fe0638d02301c5ad24de82d310ccbd2f3693da5f09bf1c"
+checksum = "acdd7c62a3665c7f6830a51635d9ac9b23ed385797f70a83bb8bafe9c572ab2b"
dependencies = [
"winapi",
]
@@ -615,100 +718,60 @@ dependencies = [
"typenum",
]
-[[package]]
-name = "ctor"
-version = "0.1.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d2301688392eb071b0bf1a37be05c469d3cc4dbbd95df672fe28ab021e6a096"
-dependencies = [
- "quote",
- "syn",
-]
-
[[package]]
name = "ctrlc"
-version = "3.2.3"
+version = "3.4.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d91974fbbe88ec1df0c24a4f00f99583667a7e2e6272b2b92d294d81e462173"
+checksum = "672465ae37dc1bc6380a6547a8883d5dd397b0f1faaad4f265726cc7042a5345"
dependencies = [
"nix",
- "winapi",
+ "windows-sys 0.52.0",
]
[[package]]
-name = "custom_derive"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef8ae57c4978a2acd8b869ce6b9ca1dfe817bff704c220209fdef2c0b75a01b9"
-
-[[package]]
-name = "cxx"
-version = "1.0.82"
+name = "data-encoding"
+version = "2.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4a41a86530d0fe7f5d9ea779916b7cadd2d4f9add748b99c2c029cbbdfaf453"
-dependencies = [
- "cc",
- "cxxbridge-flags",
- "cxxbridge-macro",
- "link-cplusplus",
-]
+checksum = "e8566979429cf69b49a5c740c60791108e86440e8be149bbea4fe54d2c32d6e2"
[[package]]
-name = "cxx-build"
-version = "1.0.82"
+name = "data-encoding-macro"
+version = "0.1.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06416d667ff3e3ad2df1cd8cd8afae5da26cf9cec4d0825040f88b5ca659a2f0"
+checksum = "f1559b6cba622276d6d63706db152618eeb15b89b3e4041446b05876e352e639"
dependencies = [
- "cc",
- "codespan-reporting",
- "once_cell",
- "proc-macro2",
- "quote",
- "scratch",
- "syn",
+ "data-encoding",
+ "data-encoding-macro-internal",
]
[[package]]
-name = "cxxbridge-flags"
-version = "1.0.82"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "820a9a2af1669deeef27cb271f476ffd196a2c4b6731336011e0ba63e2c7cf71"
-
-[[package]]
-name = "cxxbridge-macro"
-version = "1.0.82"
+name = "data-encoding-macro-internal"
+version = "0.1.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a08a6e2fcc370a089ad3b4aaf54db3b1b4cee38ddabce5896b33eb693275f470"
+checksum = "332d754c0af53bc87c108fed664d121ecf59207ec4196041f04d6ab9002ad33f"
dependencies = [
- "proc-macro2",
- "quote",
- "syn",
+ "data-encoding",
+ "syn 1.0.109",
]
[[package]]
-name = "data-encoding"
-version = "2.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ee2393c4a91429dffb4bedf19f4d6abf27d8a732c8ce4980305d782e5426d57"
-
-[[package]]
-name = "data-encoding-macro"
-version = "0.1.12"
+name = "deranged"
+version = "0.3.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86927b7cd2fe88fa698b87404b287ab98d1a0063a34071d92e575b72d3029aca"
+checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
dependencies = [
- "data-encoding",
- "data-encoding-macro-internal",
+ "powerfmt",
]
[[package]]
-name = "data-encoding-macro-internal"
-version = "0.1.10"
+name = "derive_arbitrary"
+version = "1.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5bbed42daaa95e780b60a50546aa345b8413a1e46f9a40a12907d3598f038db"
+checksum = "67e77553c4162a157adbf834ebae5b415acbecbeafc7a74b0e886657506a7611"
dependencies = [
- "data-encoding",
- "syn",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
]
[[package]]
@@ -719,38 +782,51 @@ checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
[[package]]
name = "digest"
-version = "0.10.6"
+version = "0.10.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8168378f4e5023e7218c89c891c0fd8ecdb5e5e4f18cb78f38cf245dd021e76f"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
dependencies = [
"block-buffer",
"crypto-common",
- "subtle",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "487585f4d0c6655fe74905e2504d8ad6908e4db67f744eb140876906c2f3175d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
]
[[package]]
name = "dlv-list"
-version = "0.3.0"
+version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0688c2a7f92e427f44895cd63841bff7b29f8d7a1648b9e7e07a4a365b2e1257"
+checksum = "d529fd73d344663edfd598ccb3f344e46034db51ebd103518eae34338248ad73"
+dependencies = [
+ "const-random",
+]
[[package]]
name = "dns-lookup"
-version = "1.0.8"
+version = "2.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53ecafc952c4528d9b51a458d1a8904b81783feff9fde08ab6ed2545ff396872"
+checksum = "e5766087c2235fec47fafa4cfecc81e494ee679d0fd4a59887ea0919bfb0e4fc"
dependencies = [
"cfg-if",
"libc",
"socket2",
- "winapi",
+ "windows-sys 0.48.0",
]
[[package]]
name = "dunce"
-version = "1.0.3"
+version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bd4b30a6560bbd9b4620f4de34c3f14f60848e58a9b7216801afcb4c7b31c3c"
+checksum = "56ce8c6da7551ec6c462cbaf3bfbc75131ebbfa1c944aeaa9dab51ca1c5f0c3b"
[[package]]
name = "either"
@@ -765,33 +841,28 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f"
[[package]]
-name = "errno"
-version = "0.2.8"
+name = "equivalent"
+version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f639046355ee4f37944e44f60642c6f3a7efa3cf6b78c78a0d989a8ce6c396a1"
-dependencies = [
- "errno-dragonfly",
- "libc",
- "winapi",
-]
+checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
[[package]]
-name = "errno-dragonfly"
-version = "0.1.2"
+name = "errno"
+version = "0.3.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
+checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245"
dependencies = [
- "cc",
"libc",
+ "windows-sys 0.52.0",
]
[[package]]
name = "exacl"
-version = "0.9.0"
+version = "0.12.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "129c7b60e19ea8393c47b2110f8e3cea800530fd962380ef110d1fef6591faee"
+checksum = "22be12de19decddab85d09f251ec8363f060ccb22ec9c81bc157c0c8433946d8"
dependencies = [
- "bitflags",
+ "bitflags 2.5.0",
"log",
"scopeguard",
"uuid",
@@ -799,12 +870,9 @@ dependencies = [
[[package]]
name = "fastrand"
-version = "1.8.0"
+version = "2.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7a407cfaa3385c4ae6b23e84623d48c2798d06e3e6a1878f7f59f17b3f86499"
-dependencies = [
- "instant",
-]
+checksum = "25cbce373ec4653f1a01a31e8a5e5ec0c622dc27ff9c4e6606eefef5cbbed4a5"
[[package]]
name = "file_diff"
@@ -812,23 +880,34 @@ version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "31a7a908b8f32538a2143e59a6e4e2508988832d5d4d6f7c156b3cbc762643a5"
+[[package]]
+name = "filedescriptor"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7199d965852c3bac31f779ef99cbb4537f80e952e2d6aa0ffeb30cce00f4f46e"
+dependencies = [
+ "libc",
+ "thiserror",
+ "winapi",
+]
+
[[package]]
name = "filetime"
-version = "0.2.18"
+version = "0.2.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b9663d381d07ae25dc88dbdf27df458faa83a9b25336bcac83d5e452b5fc9d3"
+checksum = "1ee447700ac8aa0b2f2bd7bc4462ad686ba06baa6727ac149a2d6277f0d240fd"
dependencies = [
"cfg-if",
"libc",
- "redox_syscall",
- "windows-sys",
+ "redox_syscall 0.4.1",
+ "windows-sys 0.52.0",
]
[[package]]
name = "flate2"
-version = "1.0.24"
+version = "1.0.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f82b0f4c27ad9f8bfd1f3208d882da2b09c301bc1c828fd3a00d0216d2fbbff6"
+checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e"
dependencies = [
"crc32fast",
"miniz_oxide",
@@ -842,9 +921,9 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
[[package]]
name = "fs_extra"
-version = "1.2.0"
+version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2022715d62ab30faffd124d40b76f4134a550a87792276512b18d63272333394"
+checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
[[package]]
name = "fsevent-sys"
@@ -857,19 +936,40 @@ dependencies = [
[[package]]
name = "fts-sys"
-version = "0.2.3"
+version = "0.2.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32bd98333d10742c0b048272ebf4cb05336d415423b853961c92ccb398966a03"
+checksum = "4e184d5f593d19793f26afb6f9a58d25f0bc755c4e48890ffcba6db416153ebb"
dependencies = [
"bindgen",
"libc",
]
+[[package]]
+name = "fundu"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c04cb831a8dccadfe3774b07cba4574a1ec24974d761510e65d8a543c2d7cb4"
+dependencies = [
+ "fundu-core",
+]
+
+[[package]]
+name = "fundu-core"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76a889e633afd839fb5b04fe53adfd588cefe518e71ec8d3c929698c6daf2acd"
+
+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
[[package]]
name = "futures"
-version = "0.3.25"
+version = "0.3.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38390104763dc37a5145a53c29c63c1290b5d316d6086ec32c293f6736051bb0"
+checksum = "23342abe12aba583913b2e62f22225ff9c950774065e4bfb61a19cd9770fec40"
dependencies = [
"futures-channel",
"futures-core",
@@ -882,9 +982,9 @@ dependencies = [
[[package]]
name = "futures-channel"
-version = "0.3.25"
+version = "0.3.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52ba265a92256105f45b719605a571ffe2d1f0fea3807304b522c1d778f79eed"
+checksum = "955518d47e09b25bbebc7a18df10b81f0c766eaf4c4f1cccef2fca5f2a4fb5f2"
dependencies = [
"futures-core",
"futures-sink",
@@ -892,15 +992,15 @@ dependencies = [
[[package]]
name = "futures-core"
-version = "0.3.25"
+version = "0.3.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04909a7a7e4633ae6c4a9ab280aeb86da1236243a77b694a49eacd659a4bd3ac"
+checksum = "4bca583b7e26f571124fe5b7561d49cb2868d79116cfa0eefce955557c6fee8c"
[[package]]
name = "futures-executor"
-version = "0.3.25"
+version = "0.3.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7acc85df6714c176ab5edf386123fafe217be88c0840ec11f199441134a074e2"
+checksum = "ccecee823288125bd88b4d7f565c9e58e41858e47ab72e8ea2d64e93624386e0"
dependencies = [
"futures-core",
"futures-task",
@@ -909,32 +1009,32 @@ dependencies = [
[[package]]
name = "futures-io"
-version = "0.3.25"
+version = "0.3.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00f5fb52a06bdcadeb54e8d3671f8888a39697dcb0b81b23b55174030427f4eb"
+checksum = "4fff74096e71ed47f8e023204cfd0aa1289cd54ae5430a9523be060cdb849964"
[[package]]
name = "futures-macro"
-version = "0.3.25"
+version = "0.3.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdfb8ce053d86b91919aad980c220b1fb8401a9394410e1c289ed7e66b61835d"
+checksum = "89ca545a94061b6365f2c7355b4b32bd20df3ff95f02da9329b34ccc3bd6ee72"
dependencies = [
"proc-macro2",
"quote",
- "syn",
+ "syn 2.0.60",
]
[[package]]
name = "futures-sink"
-version = "0.3.25"
+version = "0.3.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39c15cf1a4aa79df40f1bb462fb39676d0ad9e366c2a33b590d7c66f4f81fcf9"
+checksum = "f43be4fe21a13b9781a69afa4985b0f6ee0e1afab2c6f454a8cf30e2b2237b6e"
[[package]]
name = "futures-task"
-version = "0.3.25"
+version = "0.3.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ffb393ac5d9a6eaa9d3fdf37ae2776656b706e200c8e16b1bdb227f5198e6ea"
+checksum = "76d3d132be6c0e6aa1534069c705a74a5997a356c0dc2f86a47765e5617c5b65"
[[package]]
name = "futures-timer"
@@ -944,9 +1044,9 @@ checksum = "e64b03909df88034c26dc1547e8970b91f98bdb65165d6a4e9110d94263dbb2c"
[[package]]
name = "futures-util"
-version = "0.3.25"
+version = "0.3.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "197676987abd2f9cadff84926f410af1c183608d36641465df73ae8211dc65d6"
+checksum = "26b01e40b772d54cf6c6d721c1d1abd0647a0106a12ecaa1c186273392a69533"
dependencies = [
"futures-channel",
"futures-core",
@@ -962,12 +1062,9 @@ dependencies = [
[[package]]
name = "gcd"
-version = "2.1.0"
+version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f37978dab2ca789938a83b2f8bc1ef32db6633af9051a6cd409eff72cbaaa79a"
-dependencies = [
- "paste",
-]
+checksum = "1d758ba1b47b00caf47f24925c0074ecb20d6dfcffe7f6d53395c0465674841a"
[[package]]
name = "generic-array"
@@ -981,9 +1078,9 @@ dependencies = [
[[package]]
name = "getrandom"
-version = "0.2.8"
+version = "0.2.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
+checksum = "c85e1d9ab2eadba7e5040d4e09cbd6d072b76a557ad64e797c2cb9d4da21d7e4"
dependencies = [
"cfg-if",
"libc",
@@ -992,42 +1089,35 @@ dependencies = [
[[package]]
name = "glob"
-version = "0.3.0"
+version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"
+checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
[[package]]
name = "half"
-version = "2.1.0"
+version = "2.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad6a9459c9c30b177b925162351f97e7d967c7ea8bab3b8352805327daf45554"
+checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888"
dependencies = [
+ "cfg-if",
"crunchy",
]
[[package]]
name = "hashbrown"
-version = "0.12.3"
+version = "0.14.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
dependencies = [
"ahash",
+ "allocator-api2",
]
-[[package]]
-name = "heck"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
-
[[package]]
name = "hermit-abi"
-version = "0.1.19"
+version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
-dependencies = [
- "libc",
-]
+checksum = "443144c8cdadd93ebf52ddb4056d257f5b52c04d3c804e657d19eb73fc33668b"
[[package]]
name = "hex"
@@ -1037,19 +1127,19 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
[[package]]
name = "hex-literal"
-version = "0.3.4"
+version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ebdb29d2ea9ed0083cd8cece49bbd968021bd99b0849edb4a9a7ee0fdf6a4e0"
+checksum = "6fe2267d4ed49bc07b63801559be28c718ea06c4738b7a03c94df7386d2cde46"
[[package]]
name = "hostname"
-version = "0.3.1"
+version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c731c3e10504cc8ed35cfe2f1db4c9274c3d35fa486e3b31df46f068ef3e867"
+checksum = "f9c7c7c8ac16c798734b8a24560c1362120597c40d5e1459f09498f8f6c8f2ba"
dependencies = [
+ "cfg-if",
"libc",
- "match_cfg",
- "winapi",
+ "windows",
]
[[package]]
@@ -1068,21 +1158,31 @@ dependencies = [
[[package]]
name = "iana-time-zone-haiku"
-version = "0.1.1"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0703ae284fc167426161c2e3f1da3ea71d94b21bedbcc9494e92b28e334e3dca"
+checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
dependencies = [
- "cxx",
- "cxx-build",
+ "equivalent",
+ "hashbrown",
]
[[package]]
name = "indicatif"
-version = "0.17.2"
+version = "0.17.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4295cbb7573c16d310e99e713cf9e75101eb190ab31fccd35f2d2691b4352b19"
+checksum = "763a5a8f45087d6bcea4222e7b72c291a054edf80e4ef6efd2a4979878c7bea3"
dependencies = [
"console",
+ "instant",
"number_prefix",
"portable-atomic",
"unicode-width",
@@ -1094,7 +1194,7 @@ version = "0.9.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f8069d3ec154eb856955c1c0fbffefbf5f3c40a104ec912d4797314c1801abff"
dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
"inotify-sys",
"libc",
]
@@ -1119,15 +1219,29 @@ dependencies = [
[[package]]
name = "io-lifetimes"
-version = "0.7.5"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eae7b9aee968036d54dce06cebaefd919e4472e753296daccd6d344e3e2df0c2"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "itertools"
+version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59ce5ef949d49ee85593fc4d3f3f95ad61657076395cbbce23e2121fc5542074"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+dependencies = [
+ "either",
+]
[[package]]
name = "itertools"
-version = "0.10.5"
+version = "0.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
dependencies = [
"either",
]
@@ -1140,18 +1254,18 @@ checksum = "4217ad341ebadf8d8e724e264f13e593e0648f5b3e94b3896a5df283be015ecc"
[[package]]
name = "js-sys"
-version = "0.3.60"
+version = "0.3.64"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47"
+checksum = "c5f195fe497f702db0f318b07fdd68edb16955aed830df8363d837542f8f935a"
dependencies = [
"wasm-bindgen",
]
[[package]]
name = "keccak"
-version = "0.1.3"
+version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3afef3b6eff9ce9d8ff9b3601125eec7f0c8cbac7abd14f355d053fa56c98768"
+checksum = "8f6d5ed8676d904364de097082f4e7d240b571b67989ced0240f08b7f966f940"
dependencies = [
"cpufeatures",
]
@@ -1172,7 +1286,7 @@ version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8367585489f01bc55dd27404dcf56b95e6da061a256a666ab23be9ba96a2e587"
dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
"libc",
]
@@ -1190,9 +1304,9 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
[[package]]
name = "libc"
-version = "0.2.137"
+version = "0.2.155"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc7fcc620a3bff7cdd7a365be3376c97191aeaccc2a603e600951e452615bf89"
+checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
[[package]]
name = "libloading"
@@ -1205,19 +1319,22 @@ dependencies = [
]
[[package]]
-name = "link-cplusplus"
-version = "1.0.7"
+name = "libm"
+version = "0.2.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9272ab7b96c9046fbc5bc56c06c117cb639fe2d509df0c421cad82d2915cf369"
-dependencies = [
- "cc",
-]
+checksum = "f7012b1bbb0719e1097c47611d3898568c546d597c2e74d66f6087edd5233ff4"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef53942eb7bf7ff43a617b3e2c1c4a5ecf5944a7c1bc12d7ee39bbb15e5c1519"
[[package]]
name = "linux-raw-sys"
-version = "0.0.46"
+version = "0.4.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4d2456c373231a208ad294c33dc5bff30051eafd954cd4caae83a712b12854d"
+checksum = "c4cd1a83af159aa67994778be9070f0ae1bd732942279cabb14f86f986a21456"
[[package]]
name = "lock_api"
@@ -1231,70 +1348,53 @@ dependencies = [
[[package]]
name = "log"
-version = "0.4.17"
+version = "0.4.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
+
+[[package]]
+name = "lru"
+version = "0.12.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
+checksum = "d3262e75e648fce39813cb56ac41f3c3e3f65217ebf3844d818d1f9398cfb0dc"
dependencies = [
- "cfg-if",
+ "hashbrown",
]
[[package]]
name = "lscolors"
-version = "0.13.0"
+version = "0.16.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2dedc85d67baf5327114fad78ab9418f8893b1121c17d5538dd11005ad1ddf2"
+checksum = "ab0b209ec3976527806024406fe765474b9a1750a0ed4b8f0372364741f50e7b"
dependencies = [
"nu-ansi-term",
]
-[[package]]
-name = "match_cfg"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffbee8634e0d45d258acb448e7eaab3fce7a0a467395d4d9f228e3c1f01fb2e4"
-
[[package]]
name = "md-5"
-version = "0.10.5"
+version = "0.10.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6365506850d44bff6e2fbcb5176cf63650e48bd45ef2fe2665ae1570e0f4b9ca"
+checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
dependencies = [
+ "cfg-if",
"digest",
]
[[package]]
name = "memchr"
-version = "2.5.0"
+version = "2.7.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
[[package]]
name = "memmap2"
-version = "0.5.8"
+version = "0.9.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b182332558b18d807c4ce1ca8ca983b34c3ee32765e47b3f0f69b90355cc1dc"
+checksum = "fe751422e4a8caa417e13c3ea66452215d7d63e19e604f4980461212f3ae1322"
dependencies = [
"libc",
]
-[[package]]
-name = "memoffset"
-version = "0.6.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
-dependencies = [
- "autocfg",
-]
-
-[[package]]
-name = "memoffset"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5de893c32cde5f383baa4c04c5d6dbdd735cfd4a794b0debdb2bb1b421da5ff4"
-dependencies = [
- "autocfg",
-]
-
[[package]]
name = "minimal-lexical"
version = "0.2.1"
@@ -1303,44 +1403,42 @@ checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
[[package]]
name = "miniz_oxide"
-version = "0.5.4"
+version = "0.7.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96590ba8f175222643a85693f33d26e9c8a015f599c216509b1a6894af675d34"
+checksum = "9d811f3e15f28568be3407c8e7fdb6514c1cda3cb30683f15b6a1a1dc4ea14a7"
dependencies = [
"adler",
]
[[package]]
name = "mio"
-version = "0.8.5"
+version = "0.8.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5d732bc30207a6423068df043e3d02e0735b155ad7ce1a6f76fe2baa5b158de"
+checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c"
dependencies = [
"libc",
"log",
"wasi",
- "windows-sys",
+ "windows-sys 0.48.0",
]
[[package]]
name = "nix"
-version = "0.25.0"
+version = "0.28.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e322c04a9e3440c327fca7b6c8a63e6890a32fa2ad689db972425f07e0d22abb"
+checksum = "ab2156c4fce2f8df6c499cc1c763e4394b7482525bf2a9701c9d79d215f519e4"
dependencies = [
- "autocfg",
- "bitflags",
+ "bitflags 2.5.0",
"cfg-if",
+ "cfg_aliases",
"libc",
- "memoffset 0.6.5",
- "pin-utils",
]
[[package]]
name = "nom"
-version = "7.1.1"
+version = "7.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8903e5a29a317527874d0402f867152a3d21c908bb0b933e416c65e301d4c36"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
dependencies = [
"memchr",
"minimal-lexical",
@@ -1348,11 +1446,11 @@ dependencies = [
[[package]]
name = "notify"
-version = "5.0.0"
+version = "6.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed2c66da08abae1c024c01d635253e402341b4060a12e99b31c7594063bf490a"
+checksum = "5738a2795d57ea20abec2d6d76c6081186709c0024187cd5977265eda6598b51"
dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
"crossbeam-channel",
"filetime",
"fsevent-sys",
@@ -1361,57 +1459,78 @@ dependencies = [
"libc",
"mio",
"walkdir",
- "winapi",
+ "windows-sys 0.45.0",
]
[[package]]
name = "nu-ansi-term"
-version = "0.46.0"
+version = "0.49.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
+checksum = "c073d3c1930d0751774acf49e66653acecb416c3a54c6ec095a9b11caddb5a68"
dependencies = [
- "overload",
- "winapi",
+ "windows-sys 0.48.0",
]
[[package]]
name = "num-bigint"
-version = "0.4.3"
+version = "0.4.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f93ab6289c7b344a8a9f60f88d80aa20032336fe78da341afc91c8a2341fc75f"
+checksum = "c165a9ab64cf766f73521c0dd2cfdff64f488b8f0b3e621face3462d3db536d7"
dependencies = [
- "autocfg",
"num-integer",
"num-traits",
+ "rand",
]
+[[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
[[package]]
name = "num-integer"
-version = "0.1.45"
+version = "0.1.46"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
dependencies = [
- "autocfg",
"num-traits",
]
[[package]]
-name = "num-traits"
-version = "0.2.15"
+name = "num-modular"
+version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+checksum = "64a5fe11d4135c3bcdf3a95b18b194afa9608a5f6ff034f5d857bc9a27fb0119"
dependencies = [
- "autocfg",
+ "num-bigint",
+ "num-integer",
+ "num-traits",
]
[[package]]
-name = "num_cpus"
-version = "1.14.0"
+name = "num-prime"
+version = "0.4.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6058e64324c71e02bc2b150e4f3bc8286db6c83092132ffa3f6b1eab0f9def5"
+checksum = "e238432a7881ec7164503ccc516c014bf009be7984cde1ba56837862543bdec3"
dependencies = [
- "hermit-abi",
- "libc",
+ "bitvec",
+ "either",
+ "lru",
+ "num-bigint",
+ "num-integer",
+ "num-modular",
+ "num-traits",
+ "rand",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
]
[[package]]
@@ -1431,9 +1550,9 @@ checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3"
[[package]]
name = "once_cell"
-version = "1.16.0"
+version = "1.19.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86f0b0d4bf799edbc74508c1e8bf170ff5f41238e5f8225603ca7caaae2b7860"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
[[package]]
name = "onig"
@@ -1441,7 +1560,7 @@ version = "6.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8c4b31c8722ad9171c6d77d3557db078cab2bd50afcc9d09c8b315c59df8ca4f"
dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
"libc",
"once_cell",
"onig_sys",
@@ -1459,9 +1578,9 @@ dependencies = [
[[package]]
name = "ordered-multimap"
-version = "0.4.3"
+version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccd746e37177e1711c20dd619a1620f34f5c8b569c53590a72dedd5344d8924a"
+checksum = "49203cdcae0030493bad186b28da2fa25645fa276a51b6fec8010d281e02ef79"
dependencies = [
"dlv-list",
"hashbrown",
@@ -1476,50 +1595,6 @@ dependencies = [
"unicode-width",
]
-[[package]]
-name = "os_str_bytes"
-version = "6.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b7820b9daea5457c9f21c69448905d723fbd21136ccf521748f23fd49e723ee"
-
-[[package]]
-name = "ouroboros"
-version = "0.15.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfbb50b356159620db6ac971c6d5c9ab788c9cc38a6f49619fca2a27acb062ca"
-dependencies = [
- "aliasable",
- "ouroboros_macro",
-]
-
-[[package]]
-name = "ouroboros_macro"
-version = "0.15.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a0d9d1a6191c4f391f87219d1ea42b23f09ee84d64763cd05ee6ea88d9f384d"
-dependencies = [
- "Inflector",
- "proc-macro-error",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "output_vt100"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "628223faebab4e3e40667ee0b2336d34a5b960ff60ea743ddfdbcf7770bcfb66"
-dependencies = [
- "winapi",
-]
-
-[[package]]
-name = "overload"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
-
[[package]]
name = "parking_lot"
version = "0.12.1"
@@ -1532,43 +1607,42 @@ dependencies = [
[[package]]
name = "parking_lot_core"
-version = "0.9.4"
+version = "0.9.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4dc9e0dc2adc1c69d09143aff38d3d30c5c3f0df0dad82e6d25547af174ebec0"
+checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e"
dependencies = [
"cfg-if",
"libc",
- "redox_syscall",
+ "redox_syscall 0.4.1",
"smallvec",
- "windows-sys",
+ "windows-targets 0.48.0",
]
[[package]]
-name = "paste"
-version = "1.0.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1de2e551fb905ac83f73f7aedf2f0cb4a0da7e35efa24a202a936269f1f18e1"
-
-[[package]]
-name = "peeking_take_while"
-version = "0.1.2"
+name = "parse_datetime"
+version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099"
+checksum = "a8720474e3dd4af20cea8716703498b9f3b690f318fa9d9d9e2e38eaf44b96d0"
+dependencies = [
+ "chrono",
+ "nom",
+ "regex",
+]
[[package]]
name = "phf"
-version = "0.11.1"
+version = "0.11.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "928c6535de93548188ef63bb7c4036bd415cd8f36ad25af44b9789b2ee72a48c"
+checksum = "ade2d8b8f33c7333b51bcf0428d37e217e9f32192ae4772156f65063b8ce03dc"
dependencies = [
"phf_shared",
]
[[package]]
name = "phf_codegen"
-version = "0.11.1"
+version = "0.11.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a56ac890c5e3ca598bbdeaa99964edb5b0258a583a9eb6ef4e89fc85d9224770"
+checksum = "e8d39688d359e6b34654d328e262234662d16cc0f60ec8dcbe5e718709342a5a"
dependencies = [
"phf_generator",
"phf_shared",
@@ -1586,9 +1660,9 @@ dependencies = [
[[package]]
name = "phf_shared"
-version = "0.11.1"
+version = "0.11.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1fb5f6f826b772a8d4c0394209441e7d37cbbb967ae9c7e0e8134365c9ee676"
+checksum = "90fcb95eef784c2ac79119d1dd819e162b5da872ce6f3c3abe1e8ca1c082f72b"
dependencies = [
"siphasher",
]
@@ -1613,9 +1687,9 @@ checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"
[[package]]
name = "platform-info"
-version = "1.0.2"
+version = "2.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e7c23cfae725ae06d9e43010153fa77bdfa8c827bf08fe4beeb2a3514e6be12"
+checksum = "d5ff316b9c4642feda973c18f0decd6c8b0919d4722566f6e4337cce0dd88217"
dependencies = [
"libc",
"winapi",
@@ -1623,9 +1697,15 @@ dependencies = [
[[package]]
name = "portable-atomic"
-version = "0.3.15"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7170ef9988bc169ba16dd36a7fa041e5c4cbeb6a35b76d4c03daded371eae7c0"
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15eb2c6e362923af47e13c23ca5afb859e83d54452c55b0b9ac763b8f7c1ac16"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
[[package]]
name = "ppv-lite86"
@@ -1635,60 +1715,63 @@ checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
[[package]]
name = "pretty_assertions"
-version = "1.3.0"
+version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a25e9bcb20aa780fd0bb16b72403a9064d6b3f22f026946029acb941a50af755"
+checksum = "af7cee1a6c8a5b9208b3cb1061f10c0cb689087b3d8ce85fb9d2dd7a29b6ba66"
dependencies = [
- "ctor",
"diff",
- "output_vt100",
"yansi",
]
[[package]]
-name = "proc-macro-error"
-version = "1.0.4"
+name = "prettyplease"
+version = "0.2.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+checksum = "5ac2cf0f2e4f42b49f5ffd07dae8d746508ef7526c13940e5f524012ae6c6550"
dependencies = [
- "proc-macro-error-attr",
"proc-macro2",
- "quote",
- "syn",
- "version_check",
+ "syn 2.0.60",
]
[[package]]
-name = "proc-macro-error-attr"
-version = "1.0.4"
+name = "proc-macro-crate"
+version = "3.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+checksum = "6d37c51ca738a55da99dc0c4a34860fd675453b8b36209178c2249bb13651284"
dependencies = [
- "proc-macro2",
- "quote",
- "version_check",
+ "toml_edit",
]
[[package]]
name = "proc-macro2"
-version = "1.0.47"
+version = "1.0.86"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ea3d908b0e36316caf9e9e2c4625cdde190a7e6f440d794667ed17a1855e725"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
dependencies = [
"unicode-ident",
]
[[package]]
name = "procfs"
-version = "0.14.1"
+version = "0.16.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dfb6451c91904606a1abe93e83a8ec851f45827fa84273f256ade45dc095818"
+checksum = "731e0d9356b0c25f16f33b5be79b1c57b562f141ebfcdb0ad8ac2c13a24293b4"
dependencies = [
- "bitflags",
- "byteorder",
+ "bitflags 2.5.0",
"hex",
"lazy_static",
- "rustix",
+ "procfs-core",
+ "rustix 0.38.31",
+]
+
+[[package]]
+name = "procfs-core"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d3554923a69f4ce04c4a754260c338f505ce22642d3830e049a399fc2059a29"
+dependencies = [
+ "bitflags 2.5.0",
+ "hex",
]
[[package]]
@@ -1699,13 +1782,19 @@ checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
[[package]]
name = "quote"
-version = "1.0.21"
+version = "1.0.36"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
+checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
dependencies = [
"proc-macro2",
]
+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
[[package]]
name = "rand"
version = "0.8.5"
@@ -1747,34 +1836,40 @@ dependencies = [
[[package]]
name = "rayon"
-version = "1.6.0"
+version = "1.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e060280438193c554f654141c9ea9417886713b7acd75974c85b18a69a88e0b"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
dependencies = [
- "crossbeam-deque",
"either",
"rayon-core",
]
[[package]]
name = "rayon-core"
-version = "1.10.1"
+version = "1.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cac410af5d00ab6884528b4ab69d1e8e146e8d471201800fa1b4524126de6ad3"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
dependencies = [
- "crossbeam-channel",
"crossbeam-deque",
"crossbeam-utils",
- "num_cpus",
]
[[package]]
name = "redox_syscall"
-version = "0.2.16"
+version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
+checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c82cf8cff14456045f55ec4241383baeff27af886adb72ffb2162f99911de0fd"
+dependencies = [
+ "bitflags 2.5.0",
]
[[package]]
@@ -1785,69 +1880,59 @@ checksum = "f1bfbf25d7eb88ddcbb1ec3d755d0634da8f7657b2cb8b74089121409ab8228f"
[[package]]
name = "regex"
-version = "1.7.0"
+version = "1.10.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e076559ef8e241f2ae3479e36f97bd5741c0330689e217ad51ce2c76808b868a"
+checksum = "b91213439dad192326a0d7c6ee3955910425f441d7038e0d6933b0aec5c4517f"
dependencies = [
"aho-corasick",
"memchr",
+ "regex-automata",
"regex-syntax",
]
[[package]]
name = "regex-automata"
-version = "0.1.10"
+version = "0.4.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
+checksum = "3b7fa1134405e2ec9353fd416b17f8dacd46c473d7d3fd1cf202706a14eb792a"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
[[package]]
name = "regex-syntax"
-version = "0.6.28"
+version = "0.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
+checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
[[package]]
-name = "remove_dir_all"
-version = "0.5.3"
+name = "relative-path"
+version = "1.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
-dependencies = [
- "winapi",
-]
+checksum = "4bf2521270932c3c7bed1a59151222bd7643c79310f2916f01925e1e16255698"
[[package]]
-name = "remove_dir_all"
-version = "0.7.0"
+name = "rlimit"
+version = "0.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "882f368737489ea543bc5c340e6f3d34a28c39980bd9a979e47322b26f60ac40"
+checksum = "3560f70f30a0f16d11d01ed078a07740fe6b489667abc7c7b029155d9f21c3d8"
dependencies = [
"libc",
- "log",
- "num_cpus",
- "rayon",
- "winapi",
]
[[package]]
-name = "retain_mut"
-version = "0.1.7"
+name = "roff"
+version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c31b5c4033f8fdde8700e4657be2c497e7288f01515be52168c631e2e4d4086"
-
-[[package]]
-name = "rlimit"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7278a1ec8bfd4a4e07515c589f5ff7b309a373f987393aef44813d9dcf87aa3"
-dependencies = [
- "libc",
-]
+checksum = "b833d8d034ea094b1ea68aa6d5c740e0d04bad9d16568d08ba6f76823a114316"
[[package]]
name = "rstest"
-version = "0.16.0"
+version = "0.21.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b07f2d176c472198ec1e6551dc7da28f1c089652f66a7b722676c2238ebc0edf"
+checksum = "9afd55a67069d6e434a95161415f5beeada95a01c7b815508a82dcb0e1593682"
dependencies = [
"futures",
"futures-timer",
@@ -1857,26 +1942,31 @@ dependencies = [
[[package]]
name = "rstest_macros"
-version = "0.16.0"
+version = "0.21.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7229b505ae0706e64f37ffc54a9c163e11022a6636d58fe1f3f52018257ff9f7"
+checksum = "4165dfae59a39dd41d8dec720d3cbfbc71f69744efb480a3920f5d4e0cc6798d"
dependencies = [
"cfg-if",
+ "glob",
+ "proc-macro-crate",
"proc-macro2",
"quote",
+ "regex",
+ "relative-path",
"rustc_version",
- "syn",
+ "syn 2.0.60",
"unicode-ident",
]
[[package]]
name = "rust-ini"
-version = "0.18.0"
+version = "0.21.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6d5f2436026b4f6e79dc829837d467cc7e9a55ee40e750d716713540715a2df"
+checksum = "0d625ed57d8f49af6cfa514c42e1a71fadcff60eb0b1c517ff82fe41aa025b41"
dependencies = [
"cfg-if",
"ordered-multimap",
+ "trim-in-place",
]
[[package]]
@@ -1896,23 +1986,30 @@ dependencies = [
[[package]]
name = "rustix"
-version = "0.35.13"
+version = "0.37.26"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "727a1a6d65f786ec22df8a81ca3121107f235970dc1705ed681d3e6e8b9cd5f9"
+checksum = "84f3f8f960ed3b5a59055428714943298bf3fa2d4a1d53135084e0544829d995"
dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
"errno",
"io-lifetimes",
"libc",
- "linux-raw-sys",
- "windows-sys",
+ "linux-raw-sys 0.3.8",
+ "windows-sys 0.48.0",
]
[[package]]
-name = "rustversion"
-version = "1.0.9"
+name = "rustix"
+version = "0.38.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97477e48b4cf8603ad5f7aaf897467cf42ab4218a38ef76fb14c2d6773a6d6a8"
+checksum = "6ea3e1a662af26cd7a3ba09c0297a31af215563ecf42817c98df621387f4e949"
+dependencies = [
+ "bitflags 2.5.0",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.4.12",
+ "windows-sys 0.52.0",
+]
[[package]]
name = "same-file"
@@ -1925,23 +2022,23 @@ dependencies = [
[[package]]
name = "scopeguard"
-version = "1.1.0"
+version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
[[package]]
-name = "scratch"
-version = "1.0.2"
+name = "self_cell"
+version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8132065adcfd6e02db789d9285a0deb2f3fcb04002865ab67d5fb103533898"
+checksum = "d369a96f978623eb3dc28807c4852d6cc617fed53da5d3c400feff1ef34a714a"
[[package]]
name = "selinux"
-version = "0.3.1"
+version = "0.4.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "966a861c0b329c3078d82b404f7086009487123fd0cc905a9caac55d8b13bee1"
+checksum = "53371b1e9bbbfffd65e5ac3c895c786ec35b7695bdc4a67a8b08c29c8d057e0b"
dependencies = [
- "bitflags",
+ "bitflags 2.5.0",
"libc",
"once_cell",
"reference-counted-singleton",
@@ -1951,9 +2048,9 @@ dependencies = [
[[package]]
name = "selinux-sys"
-version = "0.6.1"
+version = "0.6.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4c02c5c6e2db8a78b3ffffc666f75fcda5bbd7068ba3c0f560e5504f4d88443"
+checksum = "89d45498373dc17ec8ebb72e1fd320c015647b0157fc81dddf678e2e00205fec"
dependencies = [
"bindgen",
"cc",
@@ -1969,15 +2066,38 @@ checksum = "e25dfac463d778e353db5be2449d1cce89bd6fd23c9f1ea21310ce6e5a1b29c4"
[[package]]
name = "serde"
-version = "1.0.147"
+version = "1.0.203"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7253ab4de971e72fb7be983802300c30b5a7f0c2e56fab8abfc6a214307c0094"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde-big-array"
+version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d193d69bae983fc11a79df82342761dfbf28a99fc8d203dca4c3c1b590948965"
+checksum = "11fc7cc2c76d73e0f27ee52abbd64eec84d46f370c88371120433196934e4b7f"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.203"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
[[package]]
name = "sha1"
-version = "0.10.5"
+version = "0.10.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f04293dc80c3993519f2d7f6f511707ee7094fe0c6d3406feb330cdb3540eba3"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
dependencies = [
"cfg-if",
"cpufeatures",
@@ -1986,9 +2106,9 @@ dependencies = [
[[package]]
name = "sha2"
-version = "0.10.6"
+version = "0.10.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82e6b795fe2e3b1e845bafcb27aa35405c4d47cdfc92af5fc8d3002f76cebdc0"
+checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
dependencies = [
"cfg-if",
"cpufeatures",
@@ -1997,9 +2117,9 @@ dependencies = [
[[package]]
name = "sha3"
-version = "0.10.6"
+version = "0.10.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdf0c33fae925bdc080598b84bc15c55e7b9a4a43b3c704da051f977469691c9"
+checksum = "75872d278a8f37ef87fa0ddbda7802605cb18344497949862c0d4dcb291eba60"
dependencies = [
"digest",
"keccak",
@@ -2007,15 +2127,15 @@ dependencies = [
[[package]]
name = "shlex"
-version = "1.1.0"
+version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43b2853a4d09f215c24cc5489c992ce46052d359b5109343cbafbf26bc62f8a3"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
[[package]]
name = "signal-hook"
-version = "0.3.14"
+version = "0.3.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a253b5e89e2698464fc26b545c9edceb338e18a89effeeecfea192c3025be29d"
+checksum = "8621587d4798caf8eb44879d42e56b9a93ea5dcd315a6487c357130095b62801"
dependencies = [
"libc",
"signal-hook-registry",
@@ -2034,9 +2154,9 @@ dependencies = [
[[package]]
name = "signal-hook-registry"
-version = "1.4.0"
+version = "1.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e51e73328dc4ac0c7ccbda3a494dfa03df1de2f46018127f60c693f2648455b0"
+checksum = "d8229b473baa5980ac72ef434c4415e70c4b5e71b423043adb4ba059f89c99a1"
dependencies = [
"libc",
]
@@ -2056,11 +2176,20 @@ dependencies = [
"autocfg",
]
+[[package]]
+name = "sm3"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebb9a3b702d0a7e33bc4d85a14456633d2b165c2ad839c5fd9a8417c1ab15860"
+dependencies = [
+ "digest",
+]
+
[[package]]
name = "smallvec"
-version = "1.10.0"
+version = "1.13.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
[[package]]
name = "smawk"
@@ -2070,12 +2199,12 @@ checksum = "f67ad224767faa3c7d8b6d91985b78e70a1324408abcb1cfcc2be4c06bc06043"
[[package]]
name = "socket2"
-version = "0.4.7"
+version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02e2d2db9033d13a1567121ddd7a095ee144db4e1ca1b1bda3419bc0da294ebd"
+checksum = "2538b18701741680e0322a2302176d3253a35388e2e62f172f64f4f16605f877"
dependencies = [
"libc",
- "winapi",
+ "windows-sys 0.48.0",
]
[[package]]
@@ -2085,35 +2214,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
[[package]]
-name = "strum"
-version = "0.24.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "063e6045c0e62079840579a7e47a355ae92f60eb74daaf156fb1e84ba164e63f"
-
-[[package]]
-name = "strum_macros"
-version = "0.24.3"
+name = "syn"
+version = "1.0.109"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e385be0d24f186b4ce2f9982191e7101bb737312ad61c1f2f984f34bcf85d59"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
dependencies = [
- "heck",
"proc-macro2",
"quote",
- "rustversion",
- "syn",
+ "unicode-ident",
]
-[[package]]
-name = "subtle"
-version = "2.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601"
-
[[package]]
name = "syn"
-version = "1.0.103"
+version = "2.0.60"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a864042229133ada95abf3b54fdc62ef5ccabe9515b64717bcb9a1919e59445d"
+checksum = "909518bc7b1c9b779f1bbf07f2929d35af9f0f37e47c6e9ef7f9dddc1e1821f3"
dependencies = [
"proc-macro2",
"quote",
@@ -2121,98 +2236,87 @@ dependencies = [
]
[[package]]
-name = "tempfile"
-version = "3.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
-dependencies = [
- "cfg-if",
- "fastrand",
- "libc",
- "redox_syscall",
- "remove_dir_all 0.5.3",
- "winapi",
-]
-
-[[package]]
-name = "term_grid"
-version = "0.1.7"
+name = "tap"
+version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "230d3e804faaed5a39b08319efb797783df2fd9671b39b7596490cb486d702cf"
-dependencies = [
- "unicode-width",
-]
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
[[package]]
-name = "termcolor"
-version = "1.1.3"
+name = "tempfile"
+version = "3.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
+checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
dependencies = [
- "winapi-util",
+ "cfg-if",
+ "fastrand",
+ "rustix 0.38.31",
+ "windows-sys 0.52.0",
]
[[package]]
name = "terminal_size"
-version = "0.1.17"
+version = "0.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "633c1a546cee861a1a6d0dc69ebeca693bf4296661ba7852b9d21d159e0506df"
+checksum = "8e6bf6f19e9f8ed8d4048dc22981458ebcf406d67e94cd422e5ecd73d63b3237"
dependencies = [
- "libc",
- "winapi",
+ "rustix 0.37.26",
+ "windows-sys 0.48.0",
]
[[package]]
name = "terminal_size"
-version = "0.2.2"
+version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40ca90c434fd12083d1a6bdcbe9f92a14f96c8a1ba600ba451734ac334521f7a"
+checksum = "21bebf2b7c9e0a515f6e0f8c51dc0f8e4696391e6f1ff30379559f8365fb0df7"
dependencies = [
- "rustix",
- "windows-sys",
+ "rustix 0.38.31",
+ "windows-sys 0.48.0",
]
[[package]]
name = "textwrap"
-version = "0.16.0"
+version = "0.16.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d"
+checksum = "23d434d3f8967a09480fb04132ebe0a3e088c173e6d0ee7897abbdf4eab0f8b9"
dependencies = [
"smawk",
- "terminal_size 0.2.2",
+ "terminal_size 0.2.6",
"unicode-linebreak",
"unicode-width",
]
[[package]]
name = "thiserror"
-version = "1.0.37"
+version = "1.0.61"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10deb33631e3c9018b9baf9dcbbc4f737320d2b576bac10f6aefa048fa407e3e"
+checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709"
dependencies = [
"thiserror-impl",
]
[[package]]
name = "thiserror-impl"
-version = "1.0.37"
+version = "1.0.61"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "982d17546b47146b28f7c22e3d08465f6b8903d0ea13c1660d9d84a6e7adcdbb"
+checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
dependencies = [
"proc-macro2",
"quote",
- "syn",
+ "syn 2.0.60",
]
[[package]]
name = "time"
-version = "0.3.17"
+version = "0.3.36"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a561bf4617eebd33bca6434b988f39ed798e527f51a1e797d0ee4f61c0a38376"
+checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885"
dependencies = [
+ "deranged",
"itoa",
"libc",
+ "num-conv",
"num_threads",
+ "powerfmt",
"serde",
"time-core",
"time-macros",
@@ -2220,19 +2324,52 @@ dependencies = [
[[package]]
name = "time-core"
-version = "0.1.0"
+version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e153e1f1acaef8acc537e68b44906d2db6436e2b35ac2c6b42640fff91f00fd"
+checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
[[package]]
name = "time-macros"
-version = "0.2.6"
+version = "0.2.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d967f99f534ca7e495c575c62638eebc2898a8c84c119b89e250477bc4ba16b2"
+checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf"
dependencies = [
+ "num-conv",
"time-core",
]
+[[package]]
+name = "tiny-keccak"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
+dependencies = [
+ "crunchy",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.6.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4badfd56924ae69bcc9039335b2e017639ce3f9b001c393c1b2d1ef846ce2cbf"
+
+[[package]]
+name = "toml_edit"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a8534fd7f78b5405e860340ad6575217ce99f38d4d5c8f2442cb5ecb50090e1"
+dependencies = [
+ "indexmap",
+ "toml_datetime",
+ "winnow",
+]
+
+[[package]]
+name = "trim-in-place"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "343e926fc669bc8cde4fa3129ab681c63671bae288b1f1081ceee6d9d37904fc"
+
[[package]]
name = "typenum"
version = "1.15.0"
@@ -2247,25 +2384,21 @@ checksum = "6ceab39d59e4c9499d4e5a8ee0e2735b891bb7308ac83dfb4e80cad195c9f6f3"
[[package]]
name = "unicode-linebreak"
-version = "0.1.4"
+version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5faade31a542b8b35855fff6e8def199853b2da8da256da52f52f1316ee3137"
-dependencies = [
- "hashbrown",
- "regex",
-]
+checksum = "3b09c83c3c29d37506a3e260c08c03743a6bb66a9cd432c6934ab501a190571f"
[[package]]
name = "unicode-segmentation"
-version = "1.10.0"
+version = "1.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fdbf052a0783de01e944a6ce7a8cb939e295b1e7be835a1112c3b9a7f047a5a"
+checksum = "d4c87d22b6e3f4a18d4d40ef354e97c90fcb14dd91d7dc0aa9d8a1172ebf7202"
[[package]]
name = "unicode-width"
-version = "0.1.10"
+version = "0.1.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
+checksum = "68f5e5f3158ecfd4b8ff6fe086db7c8467a2dfdac97fe420f2b7c4aa97af66d6"
[[package]]
name = "unicode-xid"
@@ -2275,31 +2408,21 @@ checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
[[package]]
name = "unindent"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58ee9362deb4a96cef4d437d1ad49cffc9b9e92d202b6995674e928ce684f112"
-
-[[package]]
-name = "users"
-version = "0.11.0"
+version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24cc0f6d6f267b73e5a2cadf007ba8f9bc39c6a6f9666f8cf25ea809a153b032"
-dependencies = [
- "libc",
- "log",
-]
+checksum = "c7de7d73e1754487cb58364ee906a499937a0dfabd86bcb980fa99ec8c8fa2ce"
[[package]]
-name = "utf-8"
-version = "0.7.6"
+name = "utf8parse"
+version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
+checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
[[package]]
name = "uu_arch"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "179aabf094ea209a3493e265f3274de6ffd542ef2554133b6c8196b0412a0690"
+checksum = "21667335f40e64278cae74311b16acc7e98fc70694d6eb1549cca74085981c83"
dependencies = [
"clap",
"platform-info",
@@ -2308,9 +2431,9 @@ dependencies = [
[[package]]
name = "uu_base32"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ae278a562c8ceadefc5f48a9336de1b600c1adca0958f09d1f3fa134f1143a3"
+checksum = "bd3fc0f54e62c058988658202695a10562a07a03ec0f9eb1d3ee3e08892c7b6a"
dependencies = [
"clap",
"uucore",
@@ -2318,9 +2441,9 @@ dependencies = [
[[package]]
name = "uu_base64"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7262ae2eda86166e023659763e8530a23e3f39b48b1c6d7a348950e9208ae06"
+checksum = "11c2a972bbfaba85d65e67de96ca4a6be8d541bba6f5e38e5f49ebd86160f78b"
dependencies = [
"uu_base32",
"uucore",
@@ -2328,9 +2451,9 @@ dependencies = [
[[package]]
name = "uu_basename"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b9269556172f4e5172f0848bcbfd5bf789485a07005d5da9d3c6b5abd4e68a8"
+checksum = "e06635cdc5f856703c52e8aab103ae054b5913f3bb227be39bd2f4f7332cf05f"
dependencies = [
"clap",
"uucore",
@@ -2338,9 +2461,9 @@ dependencies = [
[[package]]
name = "uu_basenc"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9f52a41ef2e46b3e923b4a8804ed0599ff1c5d8147148523a32ed99f9951c3d"
+checksum = "f507687f38abb84e8f89360f31364b72009f46236788f8e4ca91e147be1a7c9c"
dependencies = [
"clap",
"uu_base32",
@@ -2349,11 +2472,10 @@ dependencies = [
[[package]]
name = "uu_cat"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65757c042fd1e2065cced1fc82215bb55a75716e6060b99a4f4084e4177a90d9"
+checksum = "2fe37bc873f783bf0f888764827b4891d8c35527d90efcc8ec1b795792202c3d"
dependencies = [
- "atty",
"clap",
"nix",
"thiserror",
@@ -2362,9 +2484,9 @@ dependencies = [
[[package]]
name = "uu_chcon"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8ead7a4027505bb412c11256a584363ff0f67015435f2c22d3acb7afbd55d62"
+checksum = "5bd374c390db0061809de1a8c26111728d87529cf1e0ce3b72bd4c1fc0e2eeab"
dependencies = [
"clap",
"fts-sys",
@@ -2376,9 +2498,9 @@ dependencies = [
[[package]]
name = "uu_chgrp"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d70312a1c7075ea4fdde062e5bd7e422a14d5e8a0be0595b9ec4b9bb67e3f6c7"
+checksum = "c36a7f178f25d638748d165e396d46f05b4b512d73f31f69161f46ce9849a760"
dependencies = [
"clap",
"uucore",
@@ -2386,9 +2508,9 @@ dependencies = [
[[package]]
name = "uu_chmod"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0125b6b1c542626e3d280f2a677ee355cdb13b62ae3ac420773f467bf1a1217"
+checksum = "6e72a0b7d619b16d807a8c506de172ca26811f5cc156cb28e490eb2711d91766"
dependencies = [
"clap",
"libc",
@@ -2397,9 +2519,9 @@ dependencies = [
[[package]]
name = "uu_chown"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f46dd77c7a81531d535bb09a3f9b2511e76c9f9f3a56f34409c5c267cd1122c5"
+checksum = "a8d1c8cea7b63c4bcb475ff4fa09383e1aa8e563a6d1dd4ea213e6321262fedc"
dependencies = [
"clap",
"uucore",
@@ -2407,9 +2529,9 @@ dependencies = [
[[package]]
name = "uu_chroot"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0aa68e014e51ea6134cd1e114f1a2e4c9096ec2526fc7c39fffddefd04f8162c"
+checksum = "28da5d4b1d8de4370bc6c2a645df2751b977a8c6a6dcda54ac4b78d3bc8ffff5"
dependencies = [
"clap",
"uucore",
@@ -2417,19 +2539,21 @@ dependencies = [
[[package]]
name = "uu_cksum"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18638e8e13265f7ac9cfee990c471f813ecc2693f6eacd5d201766eac61c5930"
+checksum = "81833ef8d07245da6c963654c6541b1da08837cc5ec025a026e3b0dafd20b5c0"
dependencies = [
"clap",
+ "hex",
+ "regex",
"uucore",
]
[[package]]
name = "uu_comm"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2798eba155792e9334149c8f33f3729206400b6be383c153d6a443d4cf171cf"
+checksum = "d89c6b8f5e5bbd0cb2ce4cefa6737f7378c1ba6e8a060405e39b196ad79a5b31"
dependencies = [
"clap",
"uucore",
@@ -2437,9 +2561,9 @@ dependencies = [
[[package]]
name = "uu_cp"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d82ec1a61600703f5400e96270bfd3818d71eca3f9bde905a77b28a9f19debbb"
+checksum = "6fb99d355ccb02e8c514e4a1d93e4aa4eedea9837de24635dfd24c165971444e"
dependencies = [
"clap",
"exacl",
@@ -2455,9 +2579,9 @@ dependencies = [
[[package]]
name = "uu_csplit"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c1819de5bd5b5de1eeb4dc417791c481e35594882a9052982282a951bb4997a"
+checksum = "0f412683a4df2526d04184a6f17aff4a4900f88dedbe2a9d867b88927d1ee656"
dependencies = [
"clap",
"regex",
@@ -2467,11 +2591,10 @@ dependencies = [
[[package]]
name = "uu_cut"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f1685fad0fee59290c6d0ef5b6a0ea341d494c2d75d08ae43c80e29c1bdcbab"
+checksum = "492dc82df5ff644fb6f06da5be2f86abbf82606855cc5f38e0dca56087ab1639"
dependencies = [
- "atty",
"bstr",
"clap",
"memchr",
@@ -2480,35 +2603,37 @@ dependencies = [
[[package]]
name = "uu_date"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f74aa3a8d7a9db905fddf96bfe20c63dd8608658413b7d54d709dd6354c94f93"
+checksum = "09b64040b532d67a399c8670da5c5ba12bf38ee8b9d845330580f3ba7b1eabc7"
dependencies = [
"chrono",
"clap",
"libc",
+ "parse_datetime",
"uucore",
- "windows-sys",
+ "windows-sys 0.48.0",
]
[[package]]
name = "uu_dd"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0afc1ff615cac8d8ee43c2497cc38d1029203280f0c34aa252a296d3c05225db"
+checksum = "aa7f4c92b6f880888ecd4b147f5b248805105481985b4e2402ebe0d547dea48e"
dependencies = [
"clap",
"gcd",
"libc",
+ "nix",
"signal-hook",
"uucore",
]
[[package]]
name = "uu_df"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d1e82db1317d656ed95e38a194ecf2fb0b6f02b56151caaddf21dcc87e60f69"
+checksum = "3650b508da8c1dc0a77b647cfda6b48262c0b72c77aaa7f6b51904c774d7cee7"
dependencies = [
"clap",
"unicode-width",
@@ -2517,9 +2642,9 @@ dependencies = [
[[package]]
name = "uu_dir"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9534171cd90fb50a34e33e11fd1efb1ca3ce177ab72715ba652171d5a5dc24ac"
+checksum = "aa7b9a1e094ab86e53c2faaa42f09a5b8b6b29cf8072a06123ff7da0f41a0b4c"
dependencies = [
"clap",
"uu_ls",
@@ -2528,9 +2653,9 @@ dependencies = [
[[package]]
name = "uu_dircolors"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ff812f98063d8d8bafecdf682832a6332134822a35cafce50d3a6dfbb1704a8"
+checksum = "5bca465718e1512e97ad9e368f68bc03d10d21893c1c19bd44707cf520fe736f"
dependencies = [
"clap",
"uucore",
@@ -2538,9 +2663,9 @@ dependencies = [
[[package]]
name = "uu_dirname"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7976f9d5d87228303991ac1d6164d1ac79b55c215df62e461e812b2cc5f59e8e"
+checksum = "7588cebd2184bd13984417fe1467c7da536990ad7eb182a35bb6c0dd26fe1a06"
dependencies = [
"clap",
"uucore",
@@ -2548,22 +2673,22 @@ dependencies = [
[[package]]
name = "uu_du"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a3d4ca7d175ac159bace4f79694eed7a253e1897bd9bb67f05c98af8fec7207"
+checksum = "db72cd084461efc52502c66451272d3bef757aba55aecefa324c34989c1d8833"
dependencies = [
"chrono",
"clap",
"glob",
"uucore",
- "windows-sys",
+ "windows-sys 0.48.0",
]
[[package]]
name = "uu_echo"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4b5fc459fa2ac5f2e02fccc6c7f9eb212e59684c4a34b8b1ea1d4289e422ddb"
+checksum = "b17052722e4dced138680cda13ae330237c1109afc156a6e40fdccdb0ed2574d"
dependencies = [
"clap",
"uucore",
@@ -2571,9 +2696,9 @@ dependencies = [
[[package]]
name = "uu_env"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cecd980650c5722e77f4a5b751176de6538930773f182101f1fd8c6fd7a36ce"
+checksum = "55e8fcce73919063622918ac32821a86e7b59f5e3788ea78fb4974d09bafc23b"
dependencies = [
"clap",
"nix",
@@ -2583,9 +2708,9 @@ dependencies = [
[[package]]
name = "uu_expand"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c071e95f177dee8c812072a4d6552c705ef8125923da3de03b4072e2542e6acb"
+checksum = "a2fce1bd32ee57dfd09bd3e307f8e279a2d234788e1811ce2c68ef10c5ab6fa9"
dependencies = [
"clap",
"unicode-width",
@@ -2594,9 +2719,9 @@ dependencies = [
[[package]]
name = "uu_expr"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39bda267c8ca07102f64f62af8c8f11cc56a91fee60396a30401cf528c4ec4d3"
+checksum = "a7c9db74f537036db87b8f81e60b6f35dedbd5272e9ac8e1bcac0dbfc40776fb"
dependencies = [
"clap",
"num-bigint",
@@ -2607,11 +2732,13 @@ dependencies = [
[[package]]
name = "uu_factor"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06aa50e78fba6998f83c2d2eb950ed8acc1d365c0ce105098e00273caa585e3f"
+checksum = "2ede9b6fa4db7ea96b5cec45b468aa7efecd8c62dc0b92f31c8a8486450eae1a"
dependencies = [
"clap",
+ "num-bigint",
+ "num-prime",
"num-traits",
"rand",
"smallvec",
@@ -2620,9 +2747,9 @@ dependencies = [
[[package]]
name = "uu_false"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2659b37563dc7274f5fe437c89d341c3180d0dce266d3f810e89efe26f4201ae"
+checksum = "07d54e1461d5bacf272ebbf9a19e8948091874c5f0ca3109914563e18d463ec4"
dependencies = [
"clap",
"uucore",
@@ -2630,9 +2757,9 @@ dependencies = [
[[package]]
name = "uu_fmt"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f987c79b239baa87acdbb07cba33e7848d0b0a46c3de27731e34dde6d45f8d5"
+checksum = "e68fd27a340cfb9535888528567ef0f4e7ffbf1e02483f873a04dc0253f35ebc"
dependencies = [
"clap",
"unicode-width",
@@ -2641,9 +2768,9 @@ dependencies = [
[[package]]
name = "uu_fold"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31570abb73e64ccd21a17d838d236b39c8acfd6914aabaee73f1c0b4c44842c8"
+checksum = "3d358fda61f526df01bfea61a45ec8059f026a2b94117eaea946441701739db3"
dependencies = [
"clap",
"uucore",
@@ -2651,9 +2778,9 @@ dependencies = [
[[package]]
name = "uu_groups"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56986b4f41e1ecbce5d7e562aaa8b0f2179d56cbbfbff26ccddef3eefa3a94a9"
+checksum = "4ca72ac4565b35258e617b12d5bbfd16ac75196c32581ab0138c330ac57f8e8a"
dependencies = [
"clap",
"uucore",
@@ -2661,29 +2788,22 @@ dependencies = [
[[package]]
name = "uu_hashsum"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "205ee9c6d6f98e2be8e290e46d560985cbaa058df01639954cd1eddaa3b13da6"
+checksum = "9d2c79470ee3deb45eacbbda4d57b4b409663d247fc1ab99cb19d66cd9a0bf52"
dependencies = [
- "blake2b_simd",
- "blake3",
"clap",
- "digest",
"hex",
- "md-5",
"memchr",
"regex",
- "sha1",
- "sha2",
- "sha3",
"uucore",
]
[[package]]
name = "uu_head"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18a7c4277aa7d2d54aa7be13dfb1ff271296231d44ba5e7731c8bcc50417bc6b"
+checksum = "bf1e746c55b7dd576abbcc9b738895067dde284f08a338a02b2d99a8d45d91b6"
dependencies = [
"clap",
"memchr",
@@ -2692,9 +2812,9 @@ dependencies = [
[[package]]
name = "uu_hostid"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d16fb2dbb72864f0ee4412f0407b0bce1fe02431e61743ece64773370320110e"
+checksum = "75d774d5f08f7d5bbf724c2363c4ed3f97aba579897f71f516cfbdc1ecb63682"
dependencies = [
"clap",
"libc",
@@ -2703,21 +2823,21 @@ dependencies = [
[[package]]
name = "uu_hostname"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "043edf80853bb4f40fcf57090eeb482ee4375b60e023e84a25cea24b826ab2c5"
+checksum = "dcfc89a0937dfa3fa69c0c3c4374599188f9e83d72942701a9506a88e17be7c3"
dependencies = [
"clap",
"hostname",
"uucore",
- "windows-sys",
+ "windows-sys 0.48.0",
]
[[package]]
name = "uu_id"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52c7066128ca358b39c6e97662afb5f37f33270b7aa94d4a2310d9406f6d04cb"
+checksum = "cb6c479da702b045dda665385fbec0d3f4e2ea58fc71c035b411c2e2789a942d"
dependencies = [
"clap",
"selinux",
@@ -2726,9 +2846,9 @@ dependencies = [
[[package]]
name = "uu_install"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb887269b4e5f6c457822cbbb09848c03e65e5e6278997058de6be91c5f31fc6"
+checksum = "eaa74467508046a942eee421c23d6b6a1f31a5e8b6dbd04534405f533f6e47dc"
dependencies = [
"clap",
"file_diff",
@@ -2739,9 +2859,9 @@ dependencies = [
[[package]]
name = "uu_join"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ecd17b37580349040be29c5cf6bb120f2cf14ec10ccb0c4df67c85fd4a7a302"
+checksum = "eb3ebc7368b27505e3bc4c5672e30823316ced64e657882b39a580e49cdad397"
dependencies = [
"clap",
"memchr",
@@ -2750,9 +2870,9 @@ dependencies = [
[[package]]
name = "uu_kill"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bad9180c2d40a1ea81aeb72d21b0230c016c6723bf89bc81a9a5ed6222237c8f"
+checksum = "85202d46205423468145c6b4fbb8381344d44e70305af10b445f780c41b1bd40"
dependencies = [
"clap",
"nix",
@@ -2761,9 +2881,9 @@ dependencies = [
[[package]]
name = "uu_link"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34f4d6058601f990d17ea06a7fba1443dec490cece643686f6e70d2a5ce5a03c"
+checksum = "f442eaaae74d44c33b45adef268302bfc272ce960e170a1cd68c149db1bbc205"
dependencies = [
"clap",
"uucore",
@@ -2771,9 +2891,9 @@ dependencies = [
[[package]]
name = "uu_ln"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67b833c7917dc323bc329926d2ca2af5e8da32534bb82884b1cb246928471eff"
+checksum = "74cc0fb0abb0491392a41b02364d8b0301d20ef4ba9c00ac64c44b4dfdc0806a"
dependencies = [
"clap",
"uucore",
@@ -2781,9 +2901,9 @@ dependencies = [
[[package]]
name = "uu_logname"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f4010a15260061cdc31acd0858b60a6c435bda382b9161403f384c1eb88f34c"
+checksum = "d9098a04560daca2a62b4b6527ba36255ed34e50370e1f909e8577904061b784"
dependencies = [
"clap",
"libc",
@@ -2792,29 +2912,29 @@ dependencies = [
[[package]]
name = "uu_ls"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22ee4dbdc3a85bb848a0b1e0b532288ca363d82be3974f2d7c4dc5c3e9b8058e"
+checksum = "d3bdb75d15f6f2dfa0a6a642664acfc6fa375ac141120077820ecdc8898ecbc6"
dependencies = [
- "atty",
+ "ansi-width",
"chrono",
"clap",
"glob",
+ "hostname",
"lscolors",
"number_prefix",
"once_cell",
"selinux",
- "term_grid",
- "terminal_size 0.2.2",
- "unicode-width",
+ "terminal_size 0.3.0",
"uucore",
+ "uutils_term_grid",
]
[[package]]
name = "uu_mkdir"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19eaa06e03168ba7b4746dfc9174a15c34dc0caba14cf60d9e17d0fe87c729fd"
+checksum = "219588fbc146f18188781208ac4034616c51cf151677b4e1f9caf63ca8a7f2cf"
dependencies = [
"clap",
"uucore",
@@ -2822,9 +2942,9 @@ dependencies = [
[[package]]
name = "uu_mkfifo"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b70c4e0b922f96dbd6a3bad9d816d36e27af35de5057efc1091f992bed1d4082"
+checksum = "4dc2f53a01924d6b8347c28d47f022e74f6c116685e368eac561c780517f8046"
dependencies = [
"clap",
"libc",
@@ -2833,9 +2953,9 @@ dependencies = [
[[package]]
name = "uu_mknod"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27f2952dd3153e67986794fb742370301cdde895fbbfa4a4fd2aa4d88c0d0b21"
+checksum = "c8a1f784ca9fc80daae02b5ab90bcd7d20c88fd079fc6517db354899cde0457c"
dependencies = [
"clap",
"libc",
@@ -2844,9 +2964,9 @@ dependencies = [
[[package]]
name = "uu_mktemp"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1a702bc48c66e194f9528c53458f57b6d5224149db290a650b348793572c071"
+checksum = "b1e79ad2c5911908fce23a6069c52ca82e1997e2ed4bf6abf2d867c79c3dc73f"
dependencies = [
"clap",
"rand",
@@ -2856,11 +2976,10 @@ dependencies = [
[[package]]
name = "uu_more"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c043ba13a1db8cf186a7f18057321607f7bfb40b380b578ba352939a36f987a"
+checksum = "042f476a19431c63e6c3388e8c9113047adf2aab205259a41b4711870cecb172"
dependencies = [
- "atty",
"clap",
"crossterm",
"nix",
@@ -2871,9 +2990,9 @@ dependencies = [
[[package]]
name = "uu_mv"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb78dbee43cae6cee71f58160f0eac32608d87f8252c3bfecfb1b70bffe7b3a5"
+checksum = "cd57c8d02f8a99ed56ed9f6fddab403ee0e2bf9e8f3a5ca8f0f9e4d6e3e392a0"
dependencies = [
"clap",
"fs_extra",
@@ -2883,9 +3002,9 @@ dependencies = [
[[package]]
name = "uu_nice"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1507eb803598b1eb1316a85b1ab45a428b956e847fadd1c8cb81adb759000bd0"
+checksum = "3dd2287e6f5321018b8754d83825d816b950ad9a1181bfea116dbbdc6a407566"
dependencies = [
"clap",
"libc",
@@ -2895,9 +3014,9 @@ dependencies = [
[[package]]
name = "uu_nl"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5b17fba4d9b83b90a71b995f04f168b98b6c779f21077571dd5cade3982e1ec"
+checksum = "ee03c891c4ef16964c17c82d57fe9b038e433058865700de72e6859b68e9ab93"
dependencies = [
"clap",
"regex",
@@ -2906,11 +3025,10 @@ dependencies = [
[[package]]
name = "uu_nohup"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4e732ee486c9197a452039eba8ea22ceb4548c793352392a980f3356767a7ae"
+checksum = "61f0c3a470b11ebb6fcfca432895104d2c1a6e9e489285003b48a42b16cb3444"
dependencies = [
- "atty",
"clap",
"libc",
"uucore",
@@ -2918,21 +3036,20 @@ dependencies = [
[[package]]
name = "uu_nproc"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "051b9d3cc7d7181ce82e02626baa54de5236d4097bb67fd4e8a400e427fe3baa"
+checksum = "48894754c49b1cca73f17d7fd09348340e8ca51db3191d3408c4c6a83aa86ba9"
dependencies = [
"clap",
"libc",
- "num_cpus",
"uucore",
]
[[package]]
name = "uu_numfmt"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6a7c7e8271bbacb59e2aed6a664526429e02db3447f3b909d183b7a96b89f7b"
+checksum = "a6dc06d4b7e2613d67e259258957d87432c46f057ed528752396b35033a4b694"
dependencies = [
"clap",
"uucore",
@@ -2940,9 +3057,9 @@ dependencies = [
[[package]]
name = "uu_od"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8b44ed6c042d178cb67d919d48bda4dec5d987dd5636bc77d799f97edd54e94"
+checksum = "35753af35a19092ce91a236bc86b52b315863e8e9f58b2f7d97c675e6f1ad92d"
dependencies = [
"byteorder",
"clap",
@@ -2952,9 +3069,9 @@ dependencies = [
[[package]]
name = "uu_paste"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5078fb20d241e168524ec49dd80e7fff7153ef03a119b114b614eca0582e8400"
+checksum = "c54608d2d0322782a10a55f5e3501e0bab8ccb7e8f50a8c463862420effea6c2"
dependencies = [
"clap",
"uucore",
@@ -2962,9 +3079,9 @@ dependencies = [
[[package]]
name = "uu_pathchk"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6f31f21f9f49b411b767d9cb035f9ebcf6ce6bad740d284051fde5099653478"
+checksum = "16dca85de8a4932c1556a0bfc397b64059a30da368c813c90341de381e571cd6"
dependencies = [
"clap",
"libc",
@@ -2973,9 +3090,9 @@ dependencies = [
[[package]]
name = "uu_pinky"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df354a1e04c85503fd93180bb8117480f6c6c37d540a74124de139091afc73fe"
+checksum = "c62062ca221382e266a731d8a6ec6eb14643eab48c6036d0029b454ef795c50c"
dependencies = [
"clap",
"uucore",
@@ -2983,23 +3100,23 @@ dependencies = [
[[package]]
name = "uu_pr"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3907be6cd70661cd9b5d06d610b92a840884dab9eb95d2fb1d2f75152da8c78e"
+checksum = "b2a0d7a372bd3ef9f5eb060fa30143a28cac7c98dcd642945d566ee87269c8dc"
dependencies = [
+ "chrono",
"clap",
- "itertools",
+ "itertools 0.13.0",
"quick-error",
"regex",
- "time",
"uucore",
]
[[package]]
name = "uu_printenv"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4de3ce60115b70934bc462a8ad6d3219ab66499a1b3c451a7d7be4f0ce557543"
+checksum = "831df37b57770ae62aa4b2394300b933168b449d8053c4616543c62783fc9c8e"
dependencies = [
"clap",
"uucore",
@@ -3007,9 +3124,9 @@ dependencies = [
[[package]]
name = "uu_printf"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cda27750f7a4cf2ffde57f8c57d6b318da804cca9f6eafb0187e2ca0df9960b"
+checksum = "b58ff3a10f46d7728bdd8e3a1531061308870783835b3ef141cccc7cd2e85585"
dependencies = [
"clap",
"uucore",
@@ -3017,9 +3134,9 @@ dependencies = [
[[package]]
name = "uu_ptx"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c922dabd913b5f6bbe60e84b759a09cbca1f041d1dd17d8af4eae86582dd2fcc"
+checksum = "9abcf4af8bc3db797d5ca6b879491bf2b149e82be20d3040eda143402edafb53"
dependencies = [
"clap",
"regex",
@@ -3028,9 +3145,9 @@ dependencies = [
[[package]]
name = "uu_pwd"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75f25639d8d387a4ccd9e5def7a11ced804fd64342eab2c82b6bc5deb1e4a5cc"
+checksum = "8bbdb50817742592afe297fdafa34aed0fede54d6fca7dbf2ca797951fc21e7b"
dependencies = [
"clap",
"uucore",
@@ -3038,9 +3155,9 @@ dependencies = [
[[package]]
name = "uu_readlink"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d60016e49f47493e5ce3f4b0522105aa76a9e70ed202bc459de6a4818a0fa3db"
+checksum = "4f1a7ba0631fcab644dd17f926ac8064e9e4494580a9d00f9e213156fbdbc3ef"
dependencies = [
"clap",
"uucore",
@@ -3048,19 +3165,9 @@ dependencies = [
[[package]]
name = "uu_realpath"
-version = "0.0.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "954649d94ceba4d18c052d464378686a571e72f9a72874dd0963ead263908beb"
-dependencies = [
- "clap",
- "uucore",
-]
-
-[[package]]
-name = "uu_relpath"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "320b27b0199e78799ed6730dcab424cb2108551d612645b4d2651b8e566b25fd"
+checksum = "b5246bf0923035fffd9eab23026dd041c95714543a06e3153df71de7244c40fe"
dependencies = [
"clap",
"uucore",
@@ -3068,23 +3175,22 @@ dependencies = [
[[package]]
name = "uu_rm"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5dc9bf1f53562816e59108507afda821d8634bb2e5b439c7a9e15f27880c8bd4"
+checksum = "b4c4ba5cde9275c8f60ad53a527e8260adf4118016fe435e1ad344f34a56ea2c"
dependencies = [
"clap",
"libc",
- "remove_dir_all 0.7.0",
"uucore",
"walkdir",
- "windows-sys",
+ "windows-sys 0.48.0",
]
[[package]]
name = "uu_rmdir"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9edf2356be9b83122bc8659002a5728fe8cc947e617dbf41a7a47cf195b94ddb"
+checksum = "f29e9a13ae737b664a9562889bc2a800b6dc1a993c67d7570d7adbca14f02625"
dependencies = [
"clap",
"libc",
@@ -3093,9 +3199,9 @@ dependencies = [
[[package]]
name = "uu_runcon"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dac3ecfbe2ccee52c2403edd2d40a28e90de6b14d305b6d3bd78afaf0936f3fa"
+checksum = "052dd7ea379705388ccb2d3a28074d8a500dd06d310d245e9ddf67c2a3430ff1"
dependencies = [
"clap",
"libc",
@@ -3106,9 +3212,9 @@ dependencies = [
[[package]]
name = "uu_seq"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9139099d0f13751124869b4d7415573292d3ef6b23a6f04bbcacb92d3e1ce4ed"
+checksum = "24166dbe03c1916e0f0ba1b1f52f8052b24440971d0bc6a14809c8ac07401e2d"
dependencies = [
"bigdecimal",
"clap",
@@ -3119,20 +3225,21 @@ dependencies = [
[[package]]
name = "uu_shred"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9961e3a2f026390ffa5315b42b0be9af8db6ff9a592bc5d3f58f538310734cc"
+checksum = "70e6a742d89d0244486e539d4084df656b7689705a4ef5dbb4c78f132df12698"
dependencies = [
"clap",
+ "libc",
"rand",
"uucore",
]
[[package]]
name = "uu_shuf"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "006bcb7d7dc2979f9d51bf3ba774a7242a26ae277e597609247856272212b40b"
+checksum = "447f4a753669de345df3c2aba161cdd400d3be2fbab5f61060778a2da4529188"
dependencies = [
"clap",
"memchr",
@@ -3143,30 +3250,31 @@ dependencies = [
[[package]]
name = "uu_sleep"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49355e057216e406fd2f1bb8e4650b19c8e1c9ee93d6b410ba298299e0ff5c3a"
+checksum = "76242213ef977ab3ca90fa6dcc04ba8c1c045846fa07c3a9f3e4ad12cc661929"
dependencies = [
"clap",
+ "fundu",
"uucore",
]
[[package]]
name = "uu_sort"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5285069e89a4620eaf55071ed86750179e45b8d45486f93bb1fe5f1e7512479"
+checksum = "b14dc76910b1d35dcb1f6ba9406ab6c6da13c9abdfd38cbb2be6375dd1100c49"
dependencies = [
"binary-heap-plus",
"clap",
"compare",
"ctrlc",
"fnv",
- "itertools",
+ "itertools 0.13.0",
"memchr",
- "ouroboros",
"rand",
"rayon",
+ "self_cell",
"tempfile",
"unicode-width",
"uucore",
@@ -3174,9 +3282,9 @@ dependencies = [
[[package]]
name = "uu_split"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e94b35a17d7fb5abf81a5ebd38bcaf1195cd6969633ce9fb2a7c5068a5723e6"
+checksum = "d160589b68f4c4fd96d5403ee710c02ee803f058f5f1cdd6e503136dbdaf29f8"
dependencies = [
"clap",
"memchr",
@@ -3185,19 +3293,20 @@ dependencies = [
[[package]]
name = "uu_stat"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ad0e0b9c0a6050244090172f9077c426218cb30d9b9f9a1609b1c1201b2bc9f"
+checksum = "bade33eae8ad64704df255783d33da2348d87e878013447cffc2fc1acb6405c5"
dependencies = [
+ "chrono",
"clap",
"uucore",
]
[[package]]
name = "uu_stdbuf"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "363924180dafab7a63cc7730401f4237df4f9567443ef8bf0a20bb97efe42a24"
+checksum = "fc8cdb8030c30f34ff74e0a193b9eadec0777e492b20338ad5b4820741767fe0"
dependencies = [
"clap",
"tempfile",
@@ -3207,21 +3316,20 @@ dependencies = [
[[package]]
name = "uu_stdbuf_libstdbuf"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "428a862fa2545461e87e738b5c7b4dfeaa0f21faac2fc4e1c2af3bf251145941"
+checksum = "a349ccbd94b783840d6eda341f05c010cec799e5b9b94952baa453c2e4f7a4a2"
dependencies = [
"cpp",
"cpp_build",
"libc",
- "uucore",
]
[[package]]
name = "uu_stty"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c2ee8fcdcf276c83eaded7325f3ecb9b6b5fc5f879b043fa6f1eec3af27df85"
+checksum = "56cf57fc3edf8a259f1d790cb0729b028ee1658d63a850260f11918d8482d3d0"
dependencies = [
"clap",
"nix",
@@ -3230,9 +3338,9 @@ dependencies = [
[[package]]
name = "uu_sum"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c09ca88cf8ea482911c5ea7fb42439afc83c845aa3c56480973ccba9024e40d1"
+checksum = "51b9a9ded589bea166954926571759b6ad5c7d8ed5ee0528ef9bd3e9d64b0f78"
dependencies = [
"clap",
"uucore",
@@ -3240,22 +3348,22 @@ dependencies = [
[[package]]
name = "uu_sync"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b597875abef34bca6dcda653eff5bb19bfe0d9aca819dbe4aca1a2c49ba4c5af"
+checksum = "dd81016dea58891378deb7986bfd1e8aa064281e5c21227a5c04a7cc10d94e5b"
dependencies = [
"clap",
"libc",
"nix",
"uucore",
- "windows-sys",
+ "windows-sys 0.48.0",
]
[[package]]
name = "uu_tac"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93f7ec370681c0f96289a7fab788e7516393a12bf87dfd5543a6fb5942ba65fa"
+checksum = "bf0c2eea954dfe8c8e7b4e77090cffe0b77421844ba6ece772f18ed19e1a2a00"
dependencies = [
"clap",
"memchr",
@@ -3266,51 +3374,49 @@ dependencies = [
[[package]]
name = "uu_tail"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd8026d829f6ee2c853706fbe2edb4bef65f664ba16fdccabd136938c9b0e48a"
+checksum = "8df84e298af6e1274a4395f46ed94d48e8ff6b019c1b3b68c25d0fb65210eae7"
dependencies = [
- "atty",
"clap",
+ "fundu",
"libc",
"memchr",
- "nix",
"notify",
"same-file",
"uucore",
"winapi-util",
- "windows-sys",
+ "windows-sys 0.48.0",
]
[[package]]
name = "uu_tee"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ff6837eeb34465af60b56751bfb7a8be6b1e68b937c9da33bbfd041bfb6b3bd"
+checksum = "3e1382662a030bfffb1c0d29b794b2d2f905dd1e8bf1fffe6306db6aa5f57152"
dependencies = [
"clap",
"libc",
- "retain_mut",
"uucore",
]
[[package]]
name = "uu_test"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbf946c0ad6049a563c629dc6a76ebcfe1799216e37023964fa8b55de3f0ef6c"
+checksum = "5e1a8350fee271e3f34972356db837204ad4d6eb5114ce3db9dbcea6b126c92f"
dependencies = [
"clap",
"libc",
- "redox_syscall",
+ "redox_syscall 0.5.2",
"uucore",
]
[[package]]
name = "uu_timeout"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49029c5a39acec1324269c8535a260bace2e668b7f499a93b48a0126fd3f0502"
+checksum = "b438994aee0fa96343785ad1b54a3d48ecc580c7e1b167c7836fe5ff00604871"
dependencies = [
"clap",
"libc",
@@ -3320,22 +3426,23 @@ dependencies = [
[[package]]
name = "uu_touch"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b74692f6865833074e71a0644026da3c0fcf4104997569ae77d03ed6a478eb9a"
+checksum = "07698cd67da84b138369eeed24bee77c860b8b22021581a56edd31c4697dd61d"
dependencies = [
+ "chrono",
"clap",
"filetime",
- "time",
+ "parse_datetime",
"uucore",
- "windows-sys",
+ "windows-sys 0.48.0",
]
[[package]]
name = "uu_tr"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e94c3dce9cf79f1118578bddbec52242224a090ad7beaf58e19c1edca33971c"
+checksum = "b825e40258d2cd9c5664af888d847073bb6e63f5bd568901ebe598b272c509c1"
dependencies = [
"clap",
"nom",
@@ -3344,9 +3451,9 @@ dependencies = [
[[package]]
name = "uu_true"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6faca31c28c9b3d3d94b947da42d72f920f1990e35c47e8f6b417698338279bc"
+checksum = "3795e7fd2bbed0b2dcf09308884d980720acdaaa8d508d9a191b2b1b800df334"
dependencies = [
"clap",
"uucore",
@@ -3354,9 +3461,9 @@ dependencies = [
[[package]]
name = "uu_truncate"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cdb845e534f9a114fb4ee3d86283eae2000c44ef1b2c892b43b342eaecc859c"
+checksum = "5ccdc7621fbfca169ab5e2ebd38bf87e321a70fb9143b0432d84e9b20d2cfdd8"
dependencies = [
"clap",
"uucore",
@@ -3364,9 +3471,9 @@ dependencies = [
[[package]]
name = "uu_tsort"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a064c6609d3cff557f99b6d2bf80fefa0c299836274d5cbcf4a0039dfc23e2b"
+checksum = "5e7a96d369ee9e839d9974c7da4b57522eca116d1393ba9a80dd0968b8725194"
dependencies = [
"clap",
"uucore",
@@ -3374,11 +3481,10 @@ dependencies = [
[[package]]
name = "uu_tty"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2064c1fb6d7492e373c1f41bd14d66e71fff1d3623868aaed642d93abb073fbe"
+checksum = "e799d9cdd3af2c266e14cbdec38dafb2b30331cec0b6fef09b70861f9810318f"
dependencies = [
- "atty",
"clap",
"nix",
"uucore",
@@ -3386,9 +3492,9 @@ dependencies = [
[[package]]
name = "uu_uname"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fb302f5892f51beadb6a5f5c707a759d991f11828d0b40f66c51b244ee510ab"
+checksum = "ad1ca90f9b292bccaad0de70e6feccac5182c6713a5e1ca72d97bf3555b608b4"
dependencies = [
"clap",
"platform-info",
@@ -3397,9 +3503,9 @@ dependencies = [
[[package]]
name = "uu_unexpand"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5eb3b1b8eef83ca1ad928fdcaa53d4f9d9701a8015e651d0e612c2e8fc90828"
+checksum = "23dbf2d917f4662a307dc6858488105e24243a65b02043a73448e217b97672dd"
dependencies = [
"clap",
"unicode-width",
@@ -3408,21 +3514,19 @@ dependencies = [
[[package]]
name = "uu_uniq"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f78cd42fa8c0ae6c9e349562af8664b839a2f343ae36fbd48ecdd06033606ef"
+checksum = "207e5588ebbddb949a2c992f57402e77939bca9a99c7a6423fd6e6838531641c"
dependencies = [
"clap",
- "strum",
- "strum_macros",
"uucore",
]
[[package]]
name = "uu_unlink"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3368a9ba5e0b4efc9e877b349652512c70c340f29bb04b5f4156270b97788a96"
+checksum = "2e6562f2e382848b4c315b8c0b2b380724643e52c4f8cc8e1d7b95ddecfe0456"
dependencies = [
"clap",
"uucore",
@@ -3430,20 +3534,21 @@ dependencies = [
[[package]]
name = "uu_uptime"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbec5b633ac35d42cc4feb980a5f6d1c8860dae6c46e58d0034c90b24329d867"
+checksum = "25855a22c3fe8b461224a01c663eeb65fe1e3abf617058cec2a899af4ae67986"
dependencies = [
"chrono",
"clap",
+ "thiserror",
"uucore",
]
[[package]]
name = "uu_users"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6496768cd0f2658a5b817f93ab1bc0c3faefef9ae9179f12056e89485bbf367"
+checksum = "ca40a521b881daa2eea59899d0d764e54b2d1072d80dbfa61c0e8971653774fd"
dependencies = [
"clap",
"uucore",
@@ -3451,9 +3556,9 @@ dependencies = [
[[package]]
name = "uu_vdir"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64f5bed26b60988e03fd679f76bdb9820ea2b2e3a1fd513c0869fc0cb0f34ef7"
+checksum = "a98a1f11f4c93e7d6835afbd691a6b30e69d0eb201ea21696b2e8f9d4fb1cc62"
dependencies = [
"clap",
"uu_ls",
@@ -3462,24 +3567,24 @@ dependencies = [
[[package]]
name = "uu_wc"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9b0bcd49c5cbefba3500a60b0017abdbababd661a57ea2dbad8710ec9621ce9"
+checksum = "f5bae9179ce3883b58739181a01e45f7c1b8f9022c06c3e6be5aeeccc7dc39aa"
dependencies = [
"bytecount",
"clap",
"libc",
"nix",
+ "thiserror",
"unicode-width",
- "utf-8",
"uucore",
]
[[package]]
name = "uu_who"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7321bbd03aa5d4f5e185121f1f3c7e46568e41116f55940401ba2c6da84365ff"
+checksum = "8c367d0381e558c3b603dcb187556e2884047240c408546e804440d25de03aa7"
dependencies = [
"clap",
"uucore",
@@ -3487,70 +3592,99 @@ dependencies = [
[[package]]
name = "uu_whoami"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da27b6a2525fad2c7ac10a022fcb246188e5e91ecceadfb94923ee970ca2e02a"
+checksum = "bc7c52e42e0425710461700adc1063f468f2ba8a8ff83ee69ba661095ab7b77a"
dependencies = [
"clap",
"libc",
"uucore",
- "windows-sys",
+ "windows-sys 0.48.0",
]
[[package]]
name = "uu_yes"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6bd5cd30a1d279ee8bf8f61424592a7e36a0b133fcbe17c70eb50560def8068"
+checksum = "810f1da959c869571b067648d9e0696d0461928885829f79f73bebbee9d8da14"
dependencies = [
"clap",
- "libc",
+ "itertools 0.13.0",
"nix",
"uucore",
]
[[package]]
name = "uucore"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72eb519b0d45d8c782dc1a00d0b0e0e43b7974ffcfe1d3a5dec7ef300df6eafd"
+checksum = "7b54aad02cf7e96f5fafabb6b836efa73eef934783b17530095a29ffd4fdc154"
dependencies = [
+ "blake2b_simd",
+ "blake3",
"clap",
"data-encoding",
"data-encoding-macro",
+ "digest",
"dns-lookup",
"dunce",
"glob",
- "itertools",
+ "hex",
+ "itertools 0.13.0",
"libc",
+ "md-5",
+ "memchr",
"nix",
+ "number_prefix",
"once_cell",
"os_display",
+ "regex",
+ "sha1",
+ "sha2",
+ "sha3",
+ "sm3",
"thiserror",
"time",
"uucore_procs",
"walkdir",
"wild",
"winapi-util",
- "windows-sys",
+ "windows-sys 0.48.0",
+ "xattr",
"z85",
]
[[package]]
name = "uucore_procs"
-version = "0.0.17"
+version = "0.0.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53b2849b12914220af5539b71e5ae814c5101d9e88a81196337e50fc1090101e"
+checksum = "c3d588f57acb2ba416e072a6fa652f2e11cf727267c697d2e2d65175f3b10c41"
dependencies = [
"proc-macro2",
"quote",
+ "uuhelp_parser",
]
+[[package]]
+name = "uuhelp_parser"
+version = "0.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96f26868814bf1ca9deec910a08007c93eb1d8e407ce36451999d4c1c1ea6767"
+
[[package]]
name = "uuid"
-version = "1.2.2"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f00cc9702ca12d3c81455259621e676d0f7251cec66a21e98fe2e9a37db93b2a"
+
+[[package]]
+name = "uutils_term_grid"
+version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "422ee0de9031b5b948b97a8fc04e3aa35230001a722ddd27943e0be31564ce4c"
+checksum = "f89defb4adb4ba5703a57abc879f96ddd6263a444cacc446db90bf2617f141fb"
+dependencies = [
+ "ansi-width",
+]
[[package]]
name = "version_check"
@@ -3560,12 +3694,11 @@ checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
[[package]]
name = "walkdir"
-version = "2.3.2"
+version = "2.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
dependencies = [
"same-file",
- "winapi",
"winapi-util",
]
@@ -3577,9 +3710,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
[[package]]
name = "wasm-bindgen"
-version = "0.2.83"
+version = "0.2.87"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268"
+checksum = "7706a72ab36d8cb1f80ffbf0e071533974a60d0a308d01a5d0375bf60499a342"
dependencies = [
"cfg-if",
"wasm-bindgen-macro",
@@ -3587,24 +3720,24 @@ dependencies = [
[[package]]
name = "wasm-bindgen-backend"
-version = "0.2.83"
+version = "0.2.87"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142"
+checksum = "5ef2b6d3c510e9625e5fe6f509ab07d66a760f0885d858736483c32ed7809abd"
dependencies = [
"bumpalo",
"log",
"once_cell",
"proc-macro2",
"quote",
- "syn",
+ "syn 2.0.60",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-macro"
-version = "0.2.83"
+version = "0.2.87"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "052be0f94026e6cbc75cdefc9bae13fd6052cdcaf532fa6c45e7ae33a1e6c810"
+checksum = "dee495e55982a3bd48105a7b947fd2a9b4a8ae3010041b9e0faab3f9cd028f1d"
dependencies = [
"quote",
"wasm-bindgen-macro-support",
@@ -3612,22 +3745,22 @@ dependencies = [
[[package]]
name = "wasm-bindgen-macro-support"
-version = "0.2.83"
+version = "0.2.87"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07bc0c051dc5f23e307b13285f9d75df86bfdf816c5721e573dec1f9b8aa193c"
+checksum = "54681b18a46765f095758388f2d0cf16eb8d4169b639ab575a8f5693af210c7b"
dependencies = [
"proc-macro2",
"quote",
- "syn",
+ "syn 2.0.60",
"wasm-bindgen-backend",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-shared"
-version = "0.2.83"
+version = "0.2.87"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f"
+checksum = "ca6ad05a4870b2bf5fe995117d3728437bd27d7cd5f06f13c17443ef369775a1"
[[package]]
name = "which"
@@ -3642,9 +3775,9 @@ dependencies = [
[[package]]
name = "wild"
-version = "2.1.0"
+version = "2.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05b116685a6be0c52f5a103334cbff26db643826c7b3735fc0a3ba9871310a74"
+checksum = "a3131afc8c575281e1e80f36ed6a092aa502c08b18ed7524e86fbbb12bb410e1"
dependencies = [
"glob",
]
@@ -3667,11 +3800,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
[[package]]
name = "winapi-util"
-version = "0.1.5"
+version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"
dependencies = [
- "winapi",
+ "windows-sys 0.52.0",
]
[[package]]
@@ -3680,70 +3813,250 @@ version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+[[package]]
+name = "windows"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e48a53791691ab099e5e2ad123536d0fff50652600abaf43bbf952894110d0be"
+dependencies = [
+ "windows-core",
+ "windows-targets 0.52.0",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+dependencies = [
+ "windows-targets 0.52.0",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.45.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+dependencies = [
+ "windows-targets 0.42.2",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.0",
+]
+
[[package]]
name = "windows-sys"
-version = "0.42.0"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.0",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+dependencies = [
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b1eb6f0cd7c80c79759c929114ef071b87354ce476d9d94271031c0497adfd5"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.0",
+ "windows_aarch64_msvc 0.48.0",
+ "windows_i686_gnu 0.48.0",
+ "windows_i686_msvc 0.48.0",
+ "windows_x86_64_gnu 0.48.0",
+ "windows_x86_64_gnullvm 0.48.0",
+ "windows_x86_64_msvc 0.48.0",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
+checksum = "8a18201040b24831fbb9e4eb208f8892e1f50a37feb53cc7ff887feb8f50e7cd"
dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "windows_aarch64_gnullvm 0.52.0",
+ "windows_aarch64_msvc 0.52.0",
+ "windows_i686_gnu 0.52.0",
+ "windows_i686_msvc 0.52.0",
+ "windows_x86_64_gnu 0.52.0",
+ "windows_x86_64_gnullvm 0.52.0",
+ "windows_x86_64_msvc 0.52.0",
]
[[package]]
name = "windows_aarch64_gnullvm"
-version = "0.42.0"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41d2aa71f6f0cbe00ae5167d90ef3cfe66527d6f613ca78ac8024c3ccab9a19e"
+checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb7764e35d4db8a7921e09562a0304bf2f93e0a51bfccee0bd0bb0b666b015ea"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
[[package]]
name = "windows_aarch64_msvc"
-version = "0.42.0"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbaa0368d4f1d2aaefc55b6fcfee13f41544ddf36801e793edbbfd7d7df075ef"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.42.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd0f252f5a35cac83d6311b2e795981f5ee6e67eb1f9a7f64eb4500fbc4dcdb4"
+checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
[[package]]
name = "windows_i686_gnu"
-version = "0.42.0"
+version = "0.48.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbeae19f6716841636c28d695375df17562ca208b2b7d0dc47635a50ae6c5de7"
+checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a28637cb1fa3560a16915793afb20081aba2c92ee8af57b4d5f28e4b3e7df313"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
[[package]]
name = "windows_i686_msvc"
-version = "0.42.0"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffe5e8e31046ce6230cc7215707b816e339ff4d4d67c65dffa206fd0f7aa7b9a"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.42.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84c12f65daa39dd2babe6e442988fc329d6243fdce47d7d2d155b8d874862246"
+checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
[[package]]
name = "windows_x86_64_gnu"
-version = "0.42.0"
+version = "0.48.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf7b1b21b5362cbc318f686150e5bcea75ecedc74dd157d874d754a2ca44b0ed"
+checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d6fa32db2bc4a2f5abeacf2b69f7992cd09dca97498da74a151a3132c26befd"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
[[package]]
name = "windows_x86_64_gnullvm"
-version = "0.42.0"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a657e1e9d3f514745a572a6846d3c7aa7dbe1658c056ed9c3344c4109a6949e"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.42.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09d525d2ba30eeb3297665bd434a54297e4170c7f1a44cad4ef58095b4cd2028"
+checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
[[package]]
name = "windows_x86_64_msvc"
-version = "0.42.0"
+version = "0.48.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f40009d85759725a34da6d89a94e63d7bdc50a862acf0dbc7c8e488f1edcb6f5"
+checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04"
+
+[[package]]
+name = "winnow"
+version = "0.5.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
[[package]]
name = "xattr"
-version = "0.2.3"
+version = "1.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d1526bbe5aaeb5eb06885f4d987bcdfa5e23187055de9b83fe00156a821fabc"
+checksum = "8da84f1a25939b27f6820d92aed108f83ff920fdf11a7b19366c27c4cda81d4f"
dependencies = [
"libc",
+ "linux-raw-sys 0.4.12",
+ "rustix 0.38.31",
]
[[package]]
@@ -3758,14 +4071,37 @@ version = "3.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2a599daf1b507819c1121f0bf87fa37eb19daac6aff3aefefd4e6e2e0f2020fc"
+[[package]]
+name = "zerocopy"
+version = "0.7.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "087eca3c1eaf8c47b94d02790dd086cd594b912d2043d4de4bfdd466b3befb7c"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f4b6c273f496d8fd4eaf18853e6b448760225dc030ff2c485a786859aea6393"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
[[package]]
name = "zip"
-version = "0.6.3"
+version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "537ce7411d25e54e8ae21a7ce0b15840e7bfcff15b51d697ec3266cc76bdf080"
+checksum = "f1f4a27345eb6f7aa7bd015ba7eb4175fa4e1b462a29874b779e0bbcf96c6ac7"
dependencies = [
- "byteorder",
+ "arbitrary",
"crc32fast",
"crossbeam-utils",
+ "displaydoc",
"flate2",
+ "indexmap",
+ "thiserror",
]
diff --git a/Cargo.toml b/Cargo.toml
index 20953d528f21246da527d196fab3b2b4fbb5cd35..3a17ac6dd1863fbc827cf84bc113ce0dee3fbf20 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,11 +1,11 @@
# coreutils (uutils)
# * see the repository LICENSE, README, and CONTRIBUTING files for more information
-# spell-checker:ignore (libs) libselinux gethostid procfs
+# spell-checker:ignore (libs) bigdecimal datetime serde bincode fundu gethostid kqueue libselinux mangen memmap procfs uuhelp
[package]
name = "coreutils"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "coreutils ~ GNU coreutils (updated); implemented as universal (cross-platform) utils, written in Rust"
@@ -16,22 +16,22 @@ repository = "https://github.com/uutils/coreutils"
readme = "README.md"
keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
categories = ["command-line-utilities"]
-rust-version = "1.60.0"
+rust-version = "1.70.0"
edition = "2021"
build = "build.rs"
[features]
-default = [ "feat_common_core" ]
+default = ["feat_common_core"]
## OS feature shortcodes
-macos = [ "feat_os_macos" ]
-unix = [ "feat_os_unix" ]
-windows = [ "feat_os_windows" ]
+macos = ["feat_os_macos"]
+unix = ["feat_os_unix"]
+windows = ["feat_os_windows"]
## project-specific feature shortcodes
nightly = []
test_unimplemented = []
# * only build `uudoc` when `--feature uudoc` is activated
-uudoc = ["zip"]
+uudoc = ["zip", "dep:uuhelp_parser"]
## features
# "feat_acl" == enable support for ACLs (access control lists; by using`--features feat_acl`)
# NOTE:
@@ -42,342 +42,432 @@ feat_acl = ["cp/feat_acl"]
# NOTE:
# * The selinux(-sys) crate requires `libselinux` headers and shared library to be accessible in the C toolchain at compile time.
# * Running a uutils compiled with `feat_selinux` requires an SELinux enabled Kernel at run time.
-feat_selinux = ["cp/selinux", "id/selinux", "ls/selinux", "selinux", "feat_require_selinux"]
+feat_selinux = [
+ "cp/selinux",
+ "id/selinux",
+ "ls/selinux",
+ "selinux",
+ "feat_require_selinux",
+]
##
## feature sets
## (common/core and Tier1) feature sets
# "feat_common_core" == baseline core set of utilities which can be built/run on most targets
feat_common_core = [
- "base32",
- "base64",
- "basename",
- "basenc",
- "cat",
- "cksum",
- "comm",
- "cp",
- "csplit",
- "cut",
- "date",
- "df",
- "dir",
- "dircolors",
- "dirname",
- "dd",
- "du",
- "echo",
- "env",
- "expand",
- "expr",
- "factor",
- "false",
- "fmt",
- "fold",
- "hashsum",
- "head",
- "join",
- "link",
- "ln",
- "ls",
- "mkdir",
- "mktemp",
- "more",
- "mv",
- "nl",
- "numfmt",
- "od",
- "paste",
- "pr",
- "printenv",
- "printf",
- "ptx",
- "pwd",
- "readlink",
- "realpath",
- "relpath",
- "rm",
- "rmdir",
- "seq",
- "shred",
- "shuf",
- "sleep",
- "sort",
- "split",
- "sum",
- "tac",
- "tail",
- "tee",
- "test",
- "tr",
- "true",
- "truncate",
- "tsort",
- "touch",
- "unexpand",
- "uniq",
- "unlink",
- "vdir",
- "wc",
- "yes",
+ "base32",
+ "base64",
+ "basename",
+ "basenc",
+ "cat",
+ "cksum",
+ "comm",
+ "cp",
+ "csplit",
+ "cut",
+ "date",
+ "df",
+ "dir",
+ "dircolors",
+ "dirname",
+ "dd",
+ "du",
+ "echo",
+ "env",
+ "expand",
+ "expr",
+ "factor",
+ "false",
+ "fmt",
+ "fold",
+ "hashsum",
+ "head",
+ "join",
+ "link",
+ "ln",
+ "ls",
+ "mkdir",
+ "mktemp",
+ "more",
+ "mv",
+ "nl",
+ "numfmt",
+ "od",
+ "paste",
+ "pr",
+ "printenv",
+ "printf",
+ "ptx",
+ "pwd",
+ "readlink",
+ "realpath",
+ "rm",
+ "rmdir",
+ "seq",
+ "shred",
+ "shuf",
+ "sleep",
+ "sort",
+ "split",
+ "sum",
+ "tac",
+ "tail",
+ "tee",
+ "test",
+ "tr",
+ "true",
+ "truncate",
+ "tsort",
+ "touch",
+ "unexpand",
+ "uniq",
+ "unlink",
+ "vdir",
+ "wc",
+ "yes",
]
# "feat_Tier1" == expanded set of utilities which can be built/run on the usual rust "Tier 1" target platforms (ref: <https://forge.rust-lang.org/release/platform-support.html>)
feat_Tier1 = [
- "feat_common_core",
- #
- "arch",
- "hostname",
- "nproc",
- "sync",
- "touch",
- "uname",
- "whoami",
+ "feat_common_core",
+ #
+ "arch",
+ "hostname",
+ "nproc",
+ "sync",
+ "touch",
+ "uname",
+ "whoami",
]
## (primary platforms) feature sets
# "feat_os_macos" == set of utilities which can be built/run on the MacOS platform
feat_os_macos = [
- "feat_os_unix", ## == a modern/usual *nix platform
- #
- "feat_require_unix_hostid",
+ "feat_os_unix", ## == a modern/usual *nix platform
+ #
+ "feat_require_unix_hostid",
]
# "feat_os_unix" == set of utilities which can be built/run on modern/usual *nix platforms
feat_os_unix = [
- "feat_Tier1",
- #
- "feat_require_crate_cpp",
- "feat_require_unix",
- "feat_require_unix_utmpx",
+ "feat_Tier1",
+ #
+ "feat_require_crate_cpp",
+ "feat_require_unix",
+ "feat_require_unix_utmpx",
+ "feat_require_unix_hostid",
]
# "feat_os_windows" == set of utilities which can be built/run on modern/usual windows platforms
feat_os_windows = [
- "feat_Tier1", ## == "feat_os_windows_legacy" + "hostname"
+ "feat_Tier1", ## == "feat_os_windows_legacy" + "hostname"
]
## (secondary platforms) feature sets
# "feat_os_unix_gnueabihf" == set of utilities which can be built/run on the "arm-unknown-linux-gnueabihf" target (ARMv6 Linux [hardfloat])
feat_os_unix_gnueabihf = [
- "feat_Tier1",
- #
- "feat_require_unix",
- "feat_require_unix_hostid",
- "feat_require_unix_utmpx",
+ "feat_Tier1",
+ #
+ "feat_require_unix",
+ "feat_require_unix_hostid",
+ "feat_require_unix_utmpx",
]
# "feat_os_unix_musl" == set of utilities which can be built/run on targets binding to the "musl" library (ref: <https://musl.libc.org/about.html>)
feat_os_unix_musl = [
- "feat_Tier1",
- #
- "feat_require_unix",
- "feat_require_unix_hostid",
+ "feat_Tier1",
+ #
+ "feat_require_unix",
+ "feat_require_unix_hostid",
]
feat_os_unix_android = [
- "feat_Tier1",
- #
- "feat_require_unix",
+ "feat_Tier1",
+ #
+ "feat_require_unix",
]
## feature sets with requirements (restricting cross-platform availability)
#
# ** NOTE: these `feat_require_...` sets should be minimized as much as possible to encourage cross-platform availability of utilities
#
# "feat_require_crate_cpp" == set of utilities requiring the `cpp` crate (which fail to compile on several platforms; as of 2020-04-23)
-feat_require_crate_cpp = [
- "stdbuf",
-]
+feat_require_crate_cpp = ["stdbuf"]
# "feat_require_unix" == set of utilities requiring support which is only available on unix platforms (as of 2020-04-23)
feat_require_unix = [
- "chgrp",
- "chmod",
- "chown",
- "chroot",
- "groups",
- "id",
- "install",
- "kill",
- "logname",
- "mkfifo",
- "mknod",
- "nice",
- "nohup",
- "pathchk",
- "stat",
- "stty",
- "timeout",
- "tty",
+ "chgrp",
+ "chmod",
+ "chown",
+ "chroot",
+ "groups",
+ "id",
+ "install",
+ "kill",
+ "logname",
+ "mkfifo",
+ "mknod",
+ "nice",
+ "nohup",
+ "pathchk",
+ "stat",
+ "stty",
+ "timeout",
+ "tty",
]
# "feat_require_unix_utmpx" == set of utilities requiring unix utmp/utmpx support
# * ref: <https://wiki.musl-libc.org/faq.html#Q:-Why-is-the-utmp/wtmp-functionality-only-implemented-as-stubs?>
-feat_require_unix_utmpx = [
- "pinky",
- "uptime",
- "users",
- "who",
-]
+feat_require_unix_utmpx = ["pinky", "uptime", "users", "who"]
# "feat_require_unix_hostid" == set of utilities requiring gethostid in libc (only some unixes provide)
-feat_require_unix_hostid = [
- "hostid",
-]
+feat_require_unix_hostid = ["hostid"]
# "feat_require_selinux" == set of utilities depending on SELinux.
-feat_require_selinux = [
- "chcon",
- "runcon",
-]
+feat_require_selinux = ["chcon", "runcon"]
## (alternate/newer/smaller platforms) feature sets
# "feat_os_unix_fuchsia" == set of utilities which can be built/run on the "Fuchsia" OS (refs: <https://fuchsia.dev>; <https://en.wikipedia.org/wiki/Google_Fuchsia>)
feat_os_unix_fuchsia = [
- "feat_common_core",
- #
- "feat_require_crate_cpp",
- #
- "chgrp",
- "chmod",
- "chown",
- "du",
- "groups",
- "hostid",
- "install",
- "logname",
- "mkfifo",
- "mknod",
- "nice",
- "pathchk",
- "tty",
- "uname",
- "unlink",
+ "feat_common_core",
+ #
+ "feat_require_crate_cpp",
+ #
+ "chgrp",
+ "chmod",
+ "chown",
+ "du",
+ "groups",
+ "hostid",
+ "install",
+ "logname",
+ "mkfifo",
+ "mknod",
+ "nice",
+ "pathchk",
+ "tty",
+ "uname",
+ "unlink",
]
# "feat_os_unix_redox" == set of utilities which can be built/run on "Redox OS" (refs: <https://www.redox-os.org>; <https://en.wikipedia.org/wiki/Redox_(operating_system)>)
feat_os_unix_redox = [
- "feat_common_core",
- #
- "chmod",
- "uname",
+ "feat_common_core",
+ #
+ "chmod",
+ "stat",
+ "uname",
]
# "feat_os_windows_legacy" == slightly restricted set of utilities which can be built/run on early windows platforms (eg, "WinXP")
feat_os_windows_legacy = [
- "feat_common_core",
- #
- "arch",
- "nproc",
- "sync",
- "touch",
- "whoami",
+ "feat_common_core",
+ #
+ "arch",
+ "nproc",
+ "sync",
+ "touch",
+ "whoami",
]
##
# * bypass/override ~ translate 'test' feature name to avoid dependency collision with rust core 'test' crate (o/w surfaces as compiler errors during testing)
-test = [ "uu_test" ]
+test = ["uu_test"]
+
+[workspace.dependencies]
+ansi-width = "0.1.0"
+bigdecimal = "0.4"
+binary-heap-plus = "0.5.0"
+bstr = "1.9.1"
+bytecount = "0.6.8"
+byteorder = "1.5.0"
+chrono = { version = "0.4.38", default-features = false, features = [
+ "std",
+ "alloc",
+ "clock",
+] }
+clap = { version = "4.4", features = ["wrap_help", "cargo"] }
+clap_complete = "4.4"
+clap_mangen = "0.2"
+compare = "0.1.0"
+coz = { version = "0.1.3" }
+crossterm = ">=0.27.0"
+ctrlc = { version = "3.4.4", features = ["termination"] }
+exacl = "0.12.0"
+file_diff = "1.0.0"
+filetime = "0.2.23"
+fnv = "1.0.7"
+fs_extra = "1.3.0"
+fts-sys = "0.2.9"
+fundu = "2.0.0"
+gcd = "2.3"
+glob = "0.3.1"
+half = "2.4.1"
+hostname = "0.4"
+indicatif = "0.17.8"
+itertools = "0.13.0"
+libc = "0.2.153"
+lscolors = { version = "0.16.0", default-features = false, features = [
+ "gnu_legacy",
+] }
+memchr = "2.7.2"
+memmap2 = "0.9.4"
+nix = { version = "0.28", default-features = false }
+nom = "7.1.3"
+notify = { version = "=6.0.1", features = ["macos_kqueue"] }
+num-bigint = "0.4.4"
+num-prime = "0.4.3"
+num-traits = "0.2.19"
+number_prefix = "0.4"
+once_cell = "1.19.0"
+onig = { version = "~6.4", default-features = false }
+parse_datetime = "0.6.0"
+phf = "0.11.2"
+phf_codegen = "0.11.2"
+platform-info = "2.0.3"
+quick-error = "2.0.1"
+rand = { version = "0.8.5", features = ["small_rng"] }
+rand_core = "0.6.4"
+rayon = "1.10"
+redox_syscall = "0.5.1"
+regex = "1.10.4"
+rstest = "0.21.0"
+rust-ini = "0.21.0"
+same-file = "1.0.6"
+self_cell = "1.0.4"
+selinux = "0.4.4"
+signal-hook = "0.3.17"
+smallvec = { version = "1.13.2", features = ["union"] }
+tempfile = "3.10.1"
+uutils_term_grid = "0.6"
+terminal_size = "0.3.0"
+textwrap = { version = "0.16.1", features = ["terminal_size"] }
+thiserror = "1.0.59"
+time = { version = "0.3.36" }
+unicode-segmentation = "1.11.0"
+unicode-width = "0.1.12"
+utf-8 = "0.7.6"
+walkdir = "2.5"
+winapi-util = "0.1.8"
+windows-sys = { version = "0.48.0", default-features = false }
+xattr = "1.3.1"
+zip = { version = "1.1.4", default-features = false, features = ["deflate"] }
+
+hex = "0.4.3"
+md-5 = "0.10.6"
+sha1 = "0.10.6"
+sha2 = "0.10.8"
+sha3 = "0.10.8"
+blake2b_simd = "1.0.2"
+blake3 = "1.5.1"
+sm3 = "0.4.2"
+digest = "0.10.7"
-[workspace]
+uucore = { version = ">=0.0.19", package = "uucore", path = "src/uucore" }
+uucore_procs = { version = ">=0.0.19", package = "uucore_procs", path = "src/uucore_procs" }
+uu_ls = { version = ">=0.0.18", path = "src/uu/ls" }
+uu_base32 = { version = ">=0.0.18", path = "src/uu/base32" }
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-clap_complete = "4.0"
-once_cell = "1.13.1"
-phf = "0.11.1"
-selinux = { version="0.3", optional = true }
-textwrap = { version="0.16.0", features=["terminal_size"] }
-uucore = { version=">=0.0.17", package="uucore", path="src/uucore" }
-zip = { version = "0.6.3", optional=true, default_features=false, features=["deflate"] }
+clap = { workspace = true }
+once_cell = { workspace = true }
+uucore = { workspace = true }
+clap_complete = { workspace = true }
+clap_mangen = { workspace = true }
+phf = { workspace = true }
+selinux = { workspace = true, optional = true }
+textwrap = { workspace = true }
+zip = { workspace = true, optional = true }
+
+uuhelp_parser = { optional = true, version = ">=0.0.19", path = "src/uuhelp_parser" }
+
# * uutils
-uu_test = { optional=true, version="0.0.17", package="uu_test", path="src/uu/test" }
+uu_test = { optional = true, version = "0.0.27", package = "uu_test", path = "src/uu/test" }
#
-arch = { optional=true, version="0.0.17", package="uu_arch", path="src/uu/arch" }
-base32 = { optional=true, version="0.0.17", package="uu_base32", path="src/uu/base32" }
-base64 = { optional=true, version="0.0.17", package="uu_base64", path="src/uu/base64" }
-basename = { optional=true, version="0.0.17", package="uu_basename", path="src/uu/basename" }
-basenc = { optional=true, version="0.0.17", package="uu_basenc", path="src/uu/basenc" }
-cat = { optional=true, version="0.0.17", package="uu_cat", path="src/uu/cat" }
-chcon = { optional=true, version="0.0.17", package="uu_chcon", path="src/uu/chcon" }
-chgrp = { optional=true, version="0.0.17", package="uu_chgrp", path="src/uu/chgrp" }
-chmod = { optional=true, version="0.0.17", package="uu_chmod", path="src/uu/chmod" }
-chown = { optional=true, version="0.0.17", package="uu_chown", path="src/uu/chown" }
-chroot = { optional=true, version="0.0.17", package="uu_chroot", path="src/uu/chroot" }
-cksum = { optional=true, version="0.0.17", package="uu_cksum", path="src/uu/cksum" }
-comm = { optional=true, version="0.0.17", package="uu_comm", path="src/uu/comm" }
-cp = { optional=true, version="0.0.17", package="uu_cp", path="src/uu/cp" }
-csplit = { optional=true, version="0.0.17", package="uu_csplit", path="src/uu/csplit" }
-cut = { optional=true, version="0.0.17", package="uu_cut", path="src/uu/cut" }
-date = { optional=true, version="0.0.17", package="uu_date", path="src/uu/date" }
-dd = { optional=true, version="0.0.17", package="uu_dd", path="src/uu/dd" }
-df = { optional=true, version="0.0.17", package="uu_df", path="src/uu/df" }
-dir = { optional=true, version="0.0.17", package="uu_dir", path="src/uu/dir" }
-dircolors= { optional=true, version="0.0.17", package="uu_dircolors", path="src/uu/dircolors" }
-dirname = { optional=true, version="0.0.17", package="uu_dirname", path="src/uu/dirname" }
-du = { optional=true, version="0.0.17", package="uu_du", path="src/uu/du" }
-echo = { optional=true, version="0.0.17", package="uu_echo", path="src/uu/echo" }
-env = { optional=true, version="0.0.17", package="uu_env", path="src/uu/env" }
-expand = { optional=true, version="0.0.17", package="uu_expand", path="src/uu/expand" }
-expr = { optional=true, version="0.0.17", package="uu_expr", path="src/uu/expr" }
-factor = { optional=true, version="0.0.17", package="uu_factor", path="src/uu/factor" }
-false = { optional=true, version="0.0.17", package="uu_false", path="src/uu/false" }
-fmt = { optional=true, version="0.0.17", package="uu_fmt", path="src/uu/fmt" }
-fold = { optional=true, version="0.0.17", package="uu_fold", path="src/uu/fold" }
-groups = { optional=true, version="0.0.17", package="uu_groups", path="src/uu/groups" }
-hashsum = { optional=true, version="0.0.17", package="uu_hashsum", path="src/uu/hashsum" }
-head = { optional=true, version="0.0.17", package="uu_head", path="src/uu/head" }
-hostid = { optional=true, version="0.0.17", package="uu_hostid", path="src/uu/hostid" }
-hostname = { optional=true, version="0.0.17", package="uu_hostname", path="src/uu/hostname" }
-id = { optional=true, version="0.0.17", package="uu_id", path="src/uu/id" }
-install = { optional=true, version="0.0.17", package="uu_install", path="src/uu/install" }
-join = { optional=true, version="0.0.17", package="uu_join", path="src/uu/join" }
-kill = { optional=true, version="0.0.17", package="uu_kill", path="src/uu/kill" }
-link = { optional=true, version="0.0.17", package="uu_link", path="src/uu/link" }
-ln = { optional=true, version="0.0.17", package="uu_ln", path="src/uu/ln" }
-ls = { optional=true, version="0.0.17", package="uu_ls", path="src/uu/ls" }
-logname = { optional=true, version="0.0.17", package="uu_logname", path="src/uu/logname" }
-mkdir = { optional=true, version="0.0.17", package="uu_mkdir", path="src/uu/mkdir" }
-mkfifo = { optional=true, version="0.0.17", package="uu_mkfifo", path="src/uu/mkfifo" }
-mknod = { optional=true, version="0.0.17", package="uu_mknod", path="src/uu/mknod" }
-mktemp = { optional=true, version="0.0.17", package="uu_mktemp", path="src/uu/mktemp" }
-more = { optional=true, version="0.0.17", package="uu_more", path="src/uu/more" }
-mv = { optional=true, version="0.0.17", package="uu_mv", path="src/uu/mv" }
-nice = { optional=true, version="0.0.17", package="uu_nice", path="src/uu/nice" }
-nl = { optional=true, version="0.0.17", package="uu_nl", path="src/uu/nl" }
-nohup = { optional=true, version="0.0.17", package="uu_nohup", path="src/uu/nohup" }
-nproc = { optional=true, version="0.0.17", package="uu_nproc", path="src/uu/nproc" }
-numfmt = { optional=true, version="0.0.17", package="uu_numfmt", path="src/uu/numfmt" }
-od = { optional=true, version="0.0.17", package="uu_od", path="src/uu/od" }
-paste = { optional=true, version="0.0.17", package="uu_paste", path="src/uu/paste" }
-pathchk = { optional=true, version="0.0.17", package="uu_pathchk", path="src/uu/pathchk" }
-pinky = { optional=true, version="0.0.17", package="uu_pinky", path="src/uu/pinky" }
-pr = { optional=true, version="0.0.17", package="uu_pr", path="src/uu/pr" }
-printenv = { optional=true, version="0.0.17", package="uu_printenv", path="src/uu/printenv" }
-printf = { optional=true, version="0.0.17", package="uu_printf", path="src/uu/printf" }
-ptx = { optional=true, version="0.0.17", package="uu_ptx", path="src/uu/ptx" }
-pwd = { optional=true, version="0.0.17", package="uu_pwd", path="src/uu/pwd" }
-readlink = { optional=true, version="0.0.17", package="uu_readlink", path="src/uu/readlink" }
-realpath = { optional=true, version="0.0.17", package="uu_realpath", path="src/uu/realpath" }
-relpath = { optional=true, version="0.0.17", package="uu_relpath", path="src/uu/relpath" }
-rm = { optional=true, version="0.0.17", package="uu_rm", path="src/uu/rm" }
-rmdir = { optional=true, version="0.0.17", package="uu_rmdir", path="src/uu/rmdir" }
-runcon = { optional=true, version="0.0.17", package="uu_runcon", path="src/uu/runcon" }
-seq = { optional=true, version="0.0.17", package="uu_seq", path="src/uu/seq" }
-shred = { optional=true, version="0.0.17", package="uu_shred", path="src/uu/shred" }
-shuf = { optional=true, version="0.0.17", package="uu_shuf", path="src/uu/shuf" }
-sleep = { optional=true, version="0.0.17", package="uu_sleep", path="src/uu/sleep" }
-sort = { optional=true, version="0.0.17", package="uu_sort", path="src/uu/sort" }
-split = { optional=true, version="0.0.17", package="uu_split", path="src/uu/split" }
-stat = { optional=true, version="0.0.17", package="uu_stat", path="src/uu/stat" }
-stdbuf = { optional=true, version="0.0.17", package="uu_stdbuf", path="src/uu/stdbuf" }
-stty = { optional=true, version="0.0.17", package="uu_stty", path="src/uu/stty" }
-sum = { optional=true, version="0.0.17", package="uu_sum", path="src/uu/sum" }
-sync = { optional=true, version="0.0.17", package="uu_sync", path="src/uu/sync" }
-tac = { optional=true, version="0.0.17", package="uu_tac", path="src/uu/tac" }
-tail = { optional=true, version="0.0.17", package="uu_tail", path="src/uu/tail" }
-tee = { optional=true, version="0.0.17", package="uu_tee", path="src/uu/tee" }
-timeout = { optional=true, version="0.0.17", package="uu_timeout", path="src/uu/timeout" }
-touch = { optional=true, version="0.0.17", package="uu_touch", path="src/uu/touch" }
-tr = { optional=true, version="0.0.17", package="uu_tr", path="src/uu/tr" }
-true = { optional=true, version="0.0.17", package="uu_true", path="src/uu/true" }
-truncate = { optional=true, version="0.0.17", package="uu_truncate", path="src/uu/truncate" }
-tsort = { optional=true, version="0.0.17", package="uu_tsort", path="src/uu/tsort" }
-tty = { optional=true, version="0.0.17", package="uu_tty", path="src/uu/tty" }
-uname = { optional=true, version="0.0.17", package="uu_uname", path="src/uu/uname" }
-unexpand = { optional=true, version="0.0.17", package="uu_unexpand", path="src/uu/unexpand" }
-uniq = { optional=true, version="0.0.17", package="uu_uniq", path="src/uu/uniq" }
-unlink = { optional=true, version="0.0.17", package="uu_unlink", path="src/uu/unlink" }
-uptime = { optional=true, version="0.0.17", package="uu_uptime", path="src/uu/uptime" }
-users = { optional=true, version="0.0.17", package="uu_users", path="src/uu/users" }
-vdir = { optional=true, version="0.0.17", package="uu_vdir", path="src/uu/vdir" }
-wc = { optional=true, version="0.0.17", package="uu_wc", path="src/uu/wc" }
-who = { optional=true, version="0.0.17", package="uu_who", path="src/uu/who" }
-whoami = { optional=true, version="0.0.17", package="uu_whoami", path="src/uu/whoami" }
-yes = { optional=true, version="0.0.17", package="uu_yes", path="src/uu/yes" }
+arch = { optional = true, version = "0.0.27", package = "uu_arch", path = "src/uu/arch" }
+base32 = { optional = true, version = "0.0.27", package = "uu_base32", path = "src/uu/base32" }
+base64 = { optional = true, version = "0.0.27", package = "uu_base64", path = "src/uu/base64" }
+basename = { optional = true, version = "0.0.27", package = "uu_basename", path = "src/uu/basename" }
+basenc = { optional = true, version = "0.0.27", package = "uu_basenc", path = "src/uu/basenc" }
+cat = { optional = true, version = "0.0.27", package = "uu_cat", path = "src/uu/cat" }
+chcon = { optional = true, version = "0.0.27", package = "uu_chcon", path = "src/uu/chcon" }
+chgrp = { optional = true, version = "0.0.27", package = "uu_chgrp", path = "src/uu/chgrp" }
+chmod = { optional = true, version = "0.0.27", package = "uu_chmod", path = "src/uu/chmod" }
+chown = { optional = true, version = "0.0.27", package = "uu_chown", path = "src/uu/chown" }
+chroot = { optional = true, version = "0.0.27", package = "uu_chroot", path = "src/uu/chroot" }
+cksum = { optional = true, version = "0.0.27", package = "uu_cksum", path = "src/uu/cksum" }
+comm = { optional = true, version = "0.0.27", package = "uu_comm", path = "src/uu/comm" }
+cp = { optional = true, version = "0.0.27", package = "uu_cp", path = "src/uu/cp" }
+csplit = { optional = true, version = "0.0.27", package = "uu_csplit", path = "src/uu/csplit" }
+cut = { optional = true, version = "0.0.27", package = "uu_cut", path = "src/uu/cut" }
+date = { optional = true, version = "0.0.27", package = "uu_date", path = "src/uu/date" }
+dd = { optional = true, version = "0.0.27", package = "uu_dd", path = "src/uu/dd" }
+df = { optional = true, version = "0.0.27", package = "uu_df", path = "src/uu/df" }
+dir = { optional = true, version = "0.0.27", package = "uu_dir", path = "src/uu/dir" }
+dircolors = { optional = true, version = "0.0.27", package = "uu_dircolors", path = "src/uu/dircolors" }
+dirname = { optional = true, version = "0.0.27", package = "uu_dirname", path = "src/uu/dirname" }
+du = { optional = true, version = "0.0.27", package = "uu_du", path = "src/uu/du" }
+echo = { optional = true, version = "0.0.27", package = "uu_echo", path = "src/uu/echo" }
+env = { optional = true, version = "0.0.27", package = "uu_env", path = "src/uu/env" }
+expand = { optional = true, version = "0.0.27", package = "uu_expand", path = "src/uu/expand" }
+expr = { optional = true, version = "0.0.27", package = "uu_expr", path = "src/uu/expr" }
+factor = { optional = true, version = "0.0.27", package = "uu_factor", path = "src/uu/factor" }
+false = { optional = true, version = "0.0.27", package = "uu_false", path = "src/uu/false" }
+fmt = { optional = true, version = "0.0.27", package = "uu_fmt", path = "src/uu/fmt" }
+fold = { optional = true, version = "0.0.27", package = "uu_fold", path = "src/uu/fold" }
+groups = { optional = true, version = "0.0.27", package = "uu_groups", path = "src/uu/groups" }
+hashsum = { optional = true, version = "0.0.27", package = "uu_hashsum", path = "src/uu/hashsum" }
+head = { optional = true, version = "0.0.27", package = "uu_head", path = "src/uu/head" }
+hostid = { optional = true, version = "0.0.27", package = "uu_hostid", path = "src/uu/hostid" }
+hostname = { optional = true, version = "0.0.27", package = "uu_hostname", path = "src/uu/hostname" }
+id = { optional = true, version = "0.0.27", package = "uu_id", path = "src/uu/id" }
+install = { optional = true, version = "0.0.27", package = "uu_install", path = "src/uu/install" }
+join = { optional = true, version = "0.0.27", package = "uu_join", path = "src/uu/join" }
+kill = { optional = true, version = "0.0.27", package = "uu_kill", path = "src/uu/kill" }
+link = { optional = true, version = "0.0.27", package = "uu_link", path = "src/uu/link" }
+ln = { optional = true, version = "0.0.27", package = "uu_ln", path = "src/uu/ln" }
+ls = { optional = true, version = "0.0.27", package = "uu_ls", path = "src/uu/ls" }
+logname = { optional = true, version = "0.0.27", package = "uu_logname", path = "src/uu/logname" }
+mkdir = { optional = true, version = "0.0.27", package = "uu_mkdir", path = "src/uu/mkdir" }
+mkfifo = { optional = true, version = "0.0.27", package = "uu_mkfifo", path = "src/uu/mkfifo" }
+mknod = { optional = true, version = "0.0.27", package = "uu_mknod", path = "src/uu/mknod" }
+mktemp = { optional = true, version = "0.0.27", package = "uu_mktemp", path = "src/uu/mktemp" }
+more = { optional = true, version = "0.0.27", package = "uu_more", path = "src/uu/more" }
+mv = { optional = true, version = "0.0.27", package = "uu_mv", path = "src/uu/mv" }
+nice = { optional = true, version = "0.0.27", package = "uu_nice", path = "src/uu/nice" }
+nl = { optional = true, version = "0.0.27", package = "uu_nl", path = "src/uu/nl" }
+nohup = { optional = true, version = "0.0.27", package = "uu_nohup", path = "src/uu/nohup" }
+nproc = { optional = true, version = "0.0.27", package = "uu_nproc", path = "src/uu/nproc" }
+numfmt = { optional = true, version = "0.0.27", package = "uu_numfmt", path = "src/uu/numfmt" }
+od = { optional = true, version = "0.0.27", package = "uu_od", path = "src/uu/od" }
+paste = { optional = true, version = "0.0.27", package = "uu_paste", path = "src/uu/paste" }
+pathchk = { optional = true, version = "0.0.27", package = "uu_pathchk", path = "src/uu/pathchk" }
+pinky = { optional = true, version = "0.0.27", package = "uu_pinky", path = "src/uu/pinky" }
+pr = { optional = true, version = "0.0.27", package = "uu_pr", path = "src/uu/pr" }
+printenv = { optional = true, version = "0.0.27", package = "uu_printenv", path = "src/uu/printenv" }
+printf = { optional = true, version = "0.0.27", package = "uu_printf", path = "src/uu/printf" }
+ptx = { optional = true, version = "0.0.27", package = "uu_ptx", path = "src/uu/ptx" }
+pwd = { optional = true, version = "0.0.27", package = "uu_pwd", path = "src/uu/pwd" }
+readlink = { optional = true, version = "0.0.27", package = "uu_readlink", path = "src/uu/readlink" }
+realpath = { optional = true, version = "0.0.27", package = "uu_realpath", path = "src/uu/realpath" }
+rm = { optional = true, version = "0.0.27", package = "uu_rm", path = "src/uu/rm" }
+rmdir = { optional = true, version = "0.0.27", package = "uu_rmdir", path = "src/uu/rmdir" }
+runcon = { optional = true, version = "0.0.27", package = "uu_runcon", path = "src/uu/runcon" }
+seq = { optional = true, version = "0.0.27", package = "uu_seq", path = "src/uu/seq" }
+shred = { optional = true, version = "0.0.27", package = "uu_shred", path = "src/uu/shred" }
+shuf = { optional = true, version = "0.0.27", package = "uu_shuf", path = "src/uu/shuf" }
+sleep = { optional = true, version = "0.0.27", package = "uu_sleep", path = "src/uu/sleep" }
+sort = { optional = true, version = "0.0.27", package = "uu_sort", path = "src/uu/sort" }
+split = { optional = true, version = "0.0.27", package = "uu_split", path = "src/uu/split" }
+stat = { optional = true, version = "0.0.27", package = "uu_stat", path = "src/uu/stat" }
+stdbuf = { optional = true, version = "0.0.27", package = "uu_stdbuf", path = "src/uu/stdbuf" }
+stty = { optional = true, version = "0.0.27", package = "uu_stty", path = "src/uu/stty" }
+sum = { optional = true, version = "0.0.27", package = "uu_sum", path = "src/uu/sum" }
+sync = { optional = true, version = "0.0.27", package = "uu_sync", path = "src/uu/sync" }
+tac = { optional = true, version = "0.0.27", package = "uu_tac", path = "src/uu/tac" }
+tail = { optional = true, version = "0.0.27", package = "uu_tail", path = "src/uu/tail" }
+tee = { optional = true, version = "0.0.27", package = "uu_tee", path = "src/uu/tee" }
+timeout = { optional = true, version = "0.0.27", package = "uu_timeout", path = "src/uu/timeout" }
+touch = { optional = true, version = "0.0.27", package = "uu_touch", path = "src/uu/touch" }
+tr = { optional = true, version = "0.0.27", package = "uu_tr", path = "src/uu/tr" }
+true = { optional = true, version = "0.0.27", package = "uu_true", path = "src/uu/true" }
+truncate = { optional = true, version = "0.0.27", package = "uu_truncate", path = "src/uu/truncate" }
+tsort = { optional = true, version = "0.0.27", package = "uu_tsort", path = "src/uu/tsort" }
+tty = { optional = true, version = "0.0.27", package = "uu_tty", path = "src/uu/tty" }
+uname = { optional = true, version = "0.0.27", package = "uu_uname", path = "src/uu/uname" }
+unexpand = { optional = true, version = "0.0.27", package = "uu_unexpand", path = "src/uu/unexpand" }
+uniq = { optional = true, version = "0.0.27", package = "uu_uniq", path = "src/uu/uniq" }
+unlink = { optional = true, version = "0.0.27", package = "uu_unlink", path = "src/uu/unlink" }
+uptime = { optional = true, version = "0.0.27", package = "uu_uptime", path = "src/uu/uptime" }
+users = { optional = true, version = "0.0.27", package = "uu_users", path = "src/uu/users" }
+vdir = { optional = true, version = "0.0.27", package = "uu_vdir", path = "src/uu/vdir" }
+wc = { optional = true, version = "0.0.27", package = "uu_wc", path = "src/uu/wc" }
+who = { optional = true, version = "0.0.27", package = "uu_who", path = "src/uu/who" }
+whoami = { optional = true, version = "0.0.27", package = "uu_whoami", path = "src/uu/whoami" }
+yes = { optional = true, version = "0.0.27", package = "uu_yes", path = "src/uu/yes" }
# this breaks clippy linting with: "tests/by-util/test_factor_benches.rs: No such file or directory (os error 2)"
# factor_benches = { optional = true, version = "0.0.0", package = "uu_factor_benches", path = "tests/benches/factor" }
@@ -388,35 +478,48 @@ yes = { optional=true, version="0.0.17", package="uu_yes", path="src/uu/yes
#pin_cc = { version="1.0.61, < 1.0.62", package="cc" } ## cc v1.0.62 has compiler errors for MinRustV v1.32.0, requires 1.34 (for `std::str::split_ascii_whitespace()`)
[dev-dependencies]
-chrono = { version="^0.4.23", default-features=false, features=["std", "alloc", "clock"]}
-conv = "0.3"
-filetime = "0.2"
-glob = "0.3.0"
-libc = "0.2"
-pretty_assertions = "1"
-rand = "0.8"
-regex = "1.7"
-sha1 = { version="0.10", features=["std"] }
-tempfile = "3"
-time = {version="0.3", features=["local-offset"]}
-unindent = "0.1"
-uucore = { version=">=0.0.17", package="uucore", path="src/uucore", features=["entries", "process"] }
-walkdir = "2.2"
-atty = "0.2"
-hex-literal = "0.3.1"
-rstest = "0.16.0"
+chrono = { workspace = true }
+filetime = { workspace = true }
+glob = { workspace = true }
+libc = { workspace = true }
+num-prime = { workspace = true }
+pretty_assertions = "1.4.0"
+rand = { workspace = true }
+regex = { workspace = true }
+sha1 = { version = "0.10.6", features = ["std"] }
+tempfile = { workspace = true }
+time = { workspace = true, features = ["local-offset"] }
+unindent = "0.2.3"
+uucore = { workspace = true, features = [
+ "mode",
+ "entries",
+ "process",
+ "signals",
+ "utmpx",
+] }
+walkdir = { workspace = true }
+hex-literal = "0.4.1"
+rstest = { workspace = true }
[target.'cfg(any(target_os = "linux", target_os = "android"))'.dev-dependencies]
-procfs = { version = "0.14", default-features = false }
-rlimit = "0.8.3"
+procfs = { version = "0.16", default-features = false }
[target.'cfg(unix)'.dev-dependencies]
-nix = { version = "0.25", default-features = false, features = ["process", "signal", "user"] }
-rust-users = { version="0.11", package="users" }
-rand_pcg = "0.3"
+nix = { workspace = true, features = ["process", "signal", "user", "term"] }
+rlimit = "0.10.1"
+rand_pcg = "0.3.1"
+xattr = { workspace = true }
+
+# Specifically used in test_uptime::test_uptime_with_file_containing_valid_boot_time_utmpx_record
+# to deserialize a utmpx struct into a binary file
+[target.'cfg(all(target_family= "unix",not(target_os = "macos")))'.dev-dependencies]
+serde = { version = "1.0.202", features = ["derive"] }
+bincode = { version = "1.3.3" }
+serde-big-array = "0.5.1"
+
[build-dependencies]
-phf_codegen = "0.11.1"
+phf_codegen = { workspace = true }
[[bin]]
name = "coreutils"
@@ -426,3 +529,22 @@ path = "src/bin/coreutils.rs"
name = "uudoc"
path = "src/bin/uudoc.rs"
required-features = ["uudoc"]
+
+# The default release profile. It contains all optimizations, without
+# sacrificing debug info. With this profile (like in the standard
+# release profile), the debug info and the stack traces will still be available.
+[profile.release]
+lto = true
+
+# A release-like profile that is tuned to be fast, even when being fast
+# compromises on binary size. This includes aborting on panic.
+[profile.release-fast]
+inherits = "release"
+panic = "abort"
+
+# A release-like profile that is as small as possible.
+[profile.release-small]
+inherits = "release"
+opt-level = "z"
+panic = "abort"
+strip = true
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
index 20953d528f21246da527d196fab3b2b4fbb5cd35..3a17ac6dd1863fbc827cf84bc113ce0dee3fbf20 100644
--- a/Cargo.toml.orig
+++ b/Cargo.toml.orig
@@ -1,11 +1,11 @@
# coreutils (uutils)
# * see the repository LICENSE, README, and CONTRIBUTING files for more information
-# spell-checker:ignore (libs) libselinux gethostid procfs
+# spell-checker:ignore (libs) bigdecimal datetime serde bincode fundu gethostid kqueue libselinux mangen memmap procfs uuhelp
[package]
name = "coreutils"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "coreutils ~ GNU coreutils (updated); implemented as universal (cross-platform) utils, written in Rust"
@@ -16,22 +16,22 @@ repository = "https://github.com/uutils/coreutils"
readme = "README.md"
keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
categories = ["command-line-utilities"]
-rust-version = "1.60.0"
+rust-version = "1.70.0"
edition = "2021"
build = "build.rs"
[features]
-default = [ "feat_common_core" ]
+default = ["feat_common_core"]
## OS feature shortcodes
-macos = [ "feat_os_macos" ]
-unix = [ "feat_os_unix" ]
-windows = [ "feat_os_windows" ]
+macos = ["feat_os_macos"]
+unix = ["feat_os_unix"]
+windows = ["feat_os_windows"]
## project-specific feature shortcodes
nightly = []
test_unimplemented = []
# * only build `uudoc` when `--feature uudoc` is activated
-uudoc = ["zip"]
+uudoc = ["zip", "dep:uuhelp_parser"]
## features
# "feat_acl" == enable support for ACLs (access control lists; by using`--features feat_acl`)
# NOTE:
@@ -42,342 +42,432 @@ feat_acl = ["cp/feat_acl"]
# NOTE:
# * The selinux(-sys) crate requires `libselinux` headers and shared library to be accessible in the C toolchain at compile time.
# * Running a uutils compiled with `feat_selinux` requires an SELinux enabled Kernel at run time.
-feat_selinux = ["cp/selinux", "id/selinux", "ls/selinux", "selinux", "feat_require_selinux"]
+feat_selinux = [
+ "cp/selinux",
+ "id/selinux",
+ "ls/selinux",
+ "selinux",
+ "feat_require_selinux",
+]
##
## feature sets
## (common/core and Tier1) feature sets
# "feat_common_core" == baseline core set of utilities which can be built/run on most targets
feat_common_core = [
- "base32",
- "base64",
- "basename",
- "basenc",
- "cat",
- "cksum",
- "comm",
- "cp",
- "csplit",
- "cut",
- "date",
- "df",
- "dir",
- "dircolors",
- "dirname",
- "dd",
- "du",
- "echo",
- "env",
- "expand",
- "expr",
- "factor",
- "false",
- "fmt",
- "fold",
- "hashsum",
- "head",
- "join",
- "link",
- "ln",
- "ls",
- "mkdir",
- "mktemp",
- "more",
- "mv",
- "nl",
- "numfmt",
- "od",
- "paste",
- "pr",
- "printenv",
- "printf",
- "ptx",
- "pwd",
- "readlink",
- "realpath",
- "relpath",
- "rm",
- "rmdir",
- "seq",
- "shred",
- "shuf",
- "sleep",
- "sort",
- "split",
- "sum",
- "tac",
- "tail",
- "tee",
- "test",
- "tr",
- "true",
- "truncate",
- "tsort",
- "touch",
- "unexpand",
- "uniq",
- "unlink",
- "vdir",
- "wc",
- "yes",
+ "base32",
+ "base64",
+ "basename",
+ "basenc",
+ "cat",
+ "cksum",
+ "comm",
+ "cp",
+ "csplit",
+ "cut",
+ "date",
+ "df",
+ "dir",
+ "dircolors",
+ "dirname",
+ "dd",
+ "du",
+ "echo",
+ "env",
+ "expand",
+ "expr",
+ "factor",
+ "false",
+ "fmt",
+ "fold",
+ "hashsum",
+ "head",
+ "join",
+ "link",
+ "ln",
+ "ls",
+ "mkdir",
+ "mktemp",
+ "more",
+ "mv",
+ "nl",
+ "numfmt",
+ "od",
+ "paste",
+ "pr",
+ "printenv",
+ "printf",
+ "ptx",
+ "pwd",
+ "readlink",
+ "realpath",
+ "rm",
+ "rmdir",
+ "seq",
+ "shred",
+ "shuf",
+ "sleep",
+ "sort",
+ "split",
+ "sum",
+ "tac",
+ "tail",
+ "tee",
+ "test",
+ "tr",
+ "true",
+ "truncate",
+ "tsort",
+ "touch",
+ "unexpand",
+ "uniq",
+ "unlink",
+ "vdir",
+ "wc",
+ "yes",
]
# "feat_Tier1" == expanded set of utilities which can be built/run on the usual rust "Tier 1" target platforms (ref: <https://forge.rust-lang.org/release/platform-support.html>)
feat_Tier1 = [
- "feat_common_core",
- #
- "arch",
- "hostname",
- "nproc",
- "sync",
- "touch",
- "uname",
- "whoami",
+ "feat_common_core",
+ #
+ "arch",
+ "hostname",
+ "nproc",
+ "sync",
+ "touch",
+ "uname",
+ "whoami",
]
## (primary platforms) feature sets
# "feat_os_macos" == set of utilities which can be built/run on the MacOS platform
feat_os_macos = [
- "feat_os_unix", ## == a modern/usual *nix platform
- #
- "feat_require_unix_hostid",
+ "feat_os_unix", ## == a modern/usual *nix platform
+ #
+ "feat_require_unix_hostid",
]
# "feat_os_unix" == set of utilities which can be built/run on modern/usual *nix platforms
feat_os_unix = [
- "feat_Tier1",
- #
- "feat_require_crate_cpp",
- "feat_require_unix",
- "feat_require_unix_utmpx",
+ "feat_Tier1",
+ #
+ "feat_require_crate_cpp",
+ "feat_require_unix",
+ "feat_require_unix_utmpx",
+ "feat_require_unix_hostid",
]
# "feat_os_windows" == set of utilities which can be built/run on modern/usual windows platforms
feat_os_windows = [
- "feat_Tier1", ## == "feat_os_windows_legacy" + "hostname"
+ "feat_Tier1", ## == "feat_os_windows_legacy" + "hostname"
]
## (secondary platforms) feature sets
# "feat_os_unix_gnueabihf" == set of utilities which can be built/run on the "arm-unknown-linux-gnueabihf" target (ARMv6 Linux [hardfloat])
feat_os_unix_gnueabihf = [
- "feat_Tier1",
- #
- "feat_require_unix",
- "feat_require_unix_hostid",
- "feat_require_unix_utmpx",
+ "feat_Tier1",
+ #
+ "feat_require_unix",
+ "feat_require_unix_hostid",
+ "feat_require_unix_utmpx",
]
# "feat_os_unix_musl" == set of utilities which can be built/run on targets binding to the "musl" library (ref: <https://musl.libc.org/about.html>)
feat_os_unix_musl = [
- "feat_Tier1",
- #
- "feat_require_unix",
- "feat_require_unix_hostid",
+ "feat_Tier1",
+ #
+ "feat_require_unix",
+ "feat_require_unix_hostid",
]
feat_os_unix_android = [
- "feat_Tier1",
- #
- "feat_require_unix",
+ "feat_Tier1",
+ #
+ "feat_require_unix",
]
## feature sets with requirements (restricting cross-platform availability)
#
# ** NOTE: these `feat_require_...` sets should be minimized as much as possible to encourage cross-platform availability of utilities
#
# "feat_require_crate_cpp" == set of utilities requiring the `cpp` crate (which fail to compile on several platforms; as of 2020-04-23)
-feat_require_crate_cpp = [
- "stdbuf",
-]
+feat_require_crate_cpp = ["stdbuf"]
# "feat_require_unix" == set of utilities requiring support which is only available on unix platforms (as of 2020-04-23)
feat_require_unix = [
- "chgrp",
- "chmod",
- "chown",
- "chroot",
- "groups",
- "id",
- "install",
- "kill",
- "logname",
- "mkfifo",
- "mknod",
- "nice",
- "nohup",
- "pathchk",
- "stat",
- "stty",
- "timeout",
- "tty",
+ "chgrp",
+ "chmod",
+ "chown",
+ "chroot",
+ "groups",
+ "id",
+ "install",
+ "kill",
+ "logname",
+ "mkfifo",
+ "mknod",
+ "nice",
+ "nohup",
+ "pathchk",
+ "stat",
+ "stty",
+ "timeout",
+ "tty",
]
# "feat_require_unix_utmpx" == set of utilities requiring unix utmp/utmpx support
# * ref: <https://wiki.musl-libc.org/faq.html#Q:-Why-is-the-utmp/wtmp-functionality-only-implemented-as-stubs?>
-feat_require_unix_utmpx = [
- "pinky",
- "uptime",
- "users",
- "who",
-]
+feat_require_unix_utmpx = ["pinky", "uptime", "users", "who"]
# "feat_require_unix_hostid" == set of utilities requiring gethostid in libc (only some unixes provide)
-feat_require_unix_hostid = [
- "hostid",
-]
+feat_require_unix_hostid = ["hostid"]
# "feat_require_selinux" == set of utilities depending on SELinux.
-feat_require_selinux = [
- "chcon",
- "runcon",
-]
+feat_require_selinux = ["chcon", "runcon"]
## (alternate/newer/smaller platforms) feature sets
# "feat_os_unix_fuchsia" == set of utilities which can be built/run on the "Fuchsia" OS (refs: <https://fuchsia.dev>; <https://en.wikipedia.org/wiki/Google_Fuchsia>)
feat_os_unix_fuchsia = [
- "feat_common_core",
- #
- "feat_require_crate_cpp",
- #
- "chgrp",
- "chmod",
- "chown",
- "du",
- "groups",
- "hostid",
- "install",
- "logname",
- "mkfifo",
- "mknod",
- "nice",
- "pathchk",
- "tty",
- "uname",
- "unlink",
+ "feat_common_core",
+ #
+ "feat_require_crate_cpp",
+ #
+ "chgrp",
+ "chmod",
+ "chown",
+ "du",
+ "groups",
+ "hostid",
+ "install",
+ "logname",
+ "mkfifo",
+ "mknod",
+ "nice",
+ "pathchk",
+ "tty",
+ "uname",
+ "unlink",
]
# "feat_os_unix_redox" == set of utilities which can be built/run on "Redox OS" (refs: <https://www.redox-os.org>; <https://en.wikipedia.org/wiki/Redox_(operating_system)>)
feat_os_unix_redox = [
- "feat_common_core",
- #
- "chmod",
- "uname",
+ "feat_common_core",
+ #
+ "chmod",
+ "stat",
+ "uname",
]
# "feat_os_windows_legacy" == slightly restricted set of utilities which can be built/run on early windows platforms (eg, "WinXP")
feat_os_windows_legacy = [
- "feat_common_core",
- #
- "arch",
- "nproc",
- "sync",
- "touch",
- "whoami",
+ "feat_common_core",
+ #
+ "arch",
+ "nproc",
+ "sync",
+ "touch",
+ "whoami",
]
##
# * bypass/override ~ translate 'test' feature name to avoid dependency collision with rust core 'test' crate (o/w surfaces as compiler errors during testing)
-test = [ "uu_test" ]
+test = ["uu_test"]
+
+[workspace.dependencies]
+ansi-width = "0.1.0"
+bigdecimal = "0.4"
+binary-heap-plus = "0.5.0"
+bstr = "1.9.1"
+bytecount = "0.6.8"
+byteorder = "1.5.0"
+chrono = { version = "0.4.38", default-features = false, features = [
+ "std",
+ "alloc",
+ "clock",
+] }
+clap = { version = "4.4", features = ["wrap_help", "cargo"] }
+clap_complete = "4.4"
+clap_mangen = "0.2"
+compare = "0.1.0"
+coz = { version = "0.1.3" }
+crossterm = ">=0.27.0"
+ctrlc = { version = "3.4.4", features = ["termination"] }
+exacl = "0.12.0"
+file_diff = "1.0.0"
+filetime = "0.2.23"
+fnv = "1.0.7"
+fs_extra = "1.3.0"
+fts-sys = "0.2.9"
+fundu = "2.0.0"
+gcd = "2.3"
+glob = "0.3.1"
+half = "2.4.1"
+hostname = "0.4"
+indicatif = "0.17.8"
+itertools = "0.13.0"
+libc = "0.2.153"
+lscolors = { version = "0.16.0", default-features = false, features = [
+ "gnu_legacy",
+] }
+memchr = "2.7.2"
+memmap2 = "0.9.4"
+nix = { version = "0.28", default-features = false }
+nom = "7.1.3"
+notify = { version = "=6.0.1", features = ["macos_kqueue"] }
+num-bigint = "0.4.4"
+num-prime = "0.4.3"
+num-traits = "0.2.19"
+number_prefix = "0.4"
+once_cell = "1.19.0"
+onig = { version = "~6.4", default-features = false }
+parse_datetime = "0.6.0"
+phf = "0.11.2"
+phf_codegen = "0.11.2"
+platform-info = "2.0.3"
+quick-error = "2.0.1"
+rand = { version = "0.8.5", features = ["small_rng"] }
+rand_core = "0.6.4"
+rayon = "1.10"
+redox_syscall = "0.5.1"
+regex = "1.10.4"
+rstest = "0.21.0"
+rust-ini = "0.21.0"
+same-file = "1.0.6"
+self_cell = "1.0.4"
+selinux = "0.4.4"
+signal-hook = "0.3.17"
+smallvec = { version = "1.13.2", features = ["union"] }
+tempfile = "3.10.1"
+uutils_term_grid = "0.6"
+terminal_size = "0.3.0"
+textwrap = { version = "0.16.1", features = ["terminal_size"] }
+thiserror = "1.0.59"
+time = { version = "0.3.36" }
+unicode-segmentation = "1.11.0"
+unicode-width = "0.1.12"
+utf-8 = "0.7.6"
+walkdir = "2.5"
+winapi-util = "0.1.8"
+windows-sys = { version = "0.48.0", default-features = false }
+xattr = "1.3.1"
+zip = { version = "1.1.4", default-features = false, features = ["deflate"] }
+
+hex = "0.4.3"
+md-5 = "0.10.6"
+sha1 = "0.10.6"
+sha2 = "0.10.8"
+sha3 = "0.10.8"
+blake2b_simd = "1.0.2"
+blake3 = "1.5.1"
+sm3 = "0.4.2"
+digest = "0.10.7"
-[workspace]
+uucore = { version = ">=0.0.19", package = "uucore", path = "src/uucore" }
+uucore_procs = { version = ">=0.0.19", package = "uucore_procs", path = "src/uucore_procs" }
+uu_ls = { version = ">=0.0.18", path = "src/uu/ls" }
+uu_base32 = { version = ">=0.0.18", path = "src/uu/base32" }
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-clap_complete = "4.0"
-once_cell = "1.13.1"
-phf = "0.11.1"
-selinux = { version="0.3", optional = true }
-textwrap = { version="0.16.0", features=["terminal_size"] }
-uucore = { version=">=0.0.17", package="uucore", path="src/uucore" }
-zip = { version = "0.6.3", optional=true, default_features=false, features=["deflate"] }
+clap = { workspace = true }
+once_cell = { workspace = true }
+uucore = { workspace = true }
+clap_complete = { workspace = true }
+clap_mangen = { workspace = true }
+phf = { workspace = true }
+selinux = { workspace = true, optional = true }
+textwrap = { workspace = true }
+zip = { workspace = true, optional = true }
+
+uuhelp_parser = { optional = true, version = ">=0.0.19", path = "src/uuhelp_parser" }
+
# * uutils
-uu_test = { optional=true, version="0.0.17", package="uu_test", path="src/uu/test" }
+uu_test = { optional = true, version = "0.0.27", package = "uu_test", path = "src/uu/test" }
#
-arch = { optional=true, version="0.0.17", package="uu_arch", path="src/uu/arch" }
-base32 = { optional=true, version="0.0.17", package="uu_base32", path="src/uu/base32" }
-base64 = { optional=true, version="0.0.17", package="uu_base64", path="src/uu/base64" }
-basename = { optional=true, version="0.0.17", package="uu_basename", path="src/uu/basename" }
-basenc = { optional=true, version="0.0.17", package="uu_basenc", path="src/uu/basenc" }
-cat = { optional=true, version="0.0.17", package="uu_cat", path="src/uu/cat" }
-chcon = { optional=true, version="0.0.17", package="uu_chcon", path="src/uu/chcon" }
-chgrp = { optional=true, version="0.0.17", package="uu_chgrp", path="src/uu/chgrp" }
-chmod = { optional=true, version="0.0.17", package="uu_chmod", path="src/uu/chmod" }
-chown = { optional=true, version="0.0.17", package="uu_chown", path="src/uu/chown" }
-chroot = { optional=true, version="0.0.17", package="uu_chroot", path="src/uu/chroot" }
-cksum = { optional=true, version="0.0.17", package="uu_cksum", path="src/uu/cksum" }
-comm = { optional=true, version="0.0.17", package="uu_comm", path="src/uu/comm" }
-cp = { optional=true, version="0.0.17", package="uu_cp", path="src/uu/cp" }
-csplit = { optional=true, version="0.0.17", package="uu_csplit", path="src/uu/csplit" }
-cut = { optional=true, version="0.0.17", package="uu_cut", path="src/uu/cut" }
-date = { optional=true, version="0.0.17", package="uu_date", path="src/uu/date" }
-dd = { optional=true, version="0.0.17", package="uu_dd", path="src/uu/dd" }
-df = { optional=true, version="0.0.17", package="uu_df", path="src/uu/df" }
-dir = { optional=true, version="0.0.17", package="uu_dir", path="src/uu/dir" }
-dircolors= { optional=true, version="0.0.17", package="uu_dircolors", path="src/uu/dircolors" }
-dirname = { optional=true, version="0.0.17", package="uu_dirname", path="src/uu/dirname" }
-du = { optional=true, version="0.0.17", package="uu_du", path="src/uu/du" }
-echo = { optional=true, version="0.0.17", package="uu_echo", path="src/uu/echo" }
-env = { optional=true, version="0.0.17", package="uu_env", path="src/uu/env" }
-expand = { optional=true, version="0.0.17", package="uu_expand", path="src/uu/expand" }
-expr = { optional=true, version="0.0.17", package="uu_expr", path="src/uu/expr" }
-factor = { optional=true, version="0.0.17", package="uu_factor", path="src/uu/factor" }
-false = { optional=true, version="0.0.17", package="uu_false", path="src/uu/false" }
-fmt = { optional=true, version="0.0.17", package="uu_fmt", path="src/uu/fmt" }
-fold = { optional=true, version="0.0.17", package="uu_fold", path="src/uu/fold" }
-groups = { optional=true, version="0.0.17", package="uu_groups", path="src/uu/groups" }
-hashsum = { optional=true, version="0.0.17", package="uu_hashsum", path="src/uu/hashsum" }
-head = { optional=true, version="0.0.17", package="uu_head", path="src/uu/head" }
-hostid = { optional=true, version="0.0.17", package="uu_hostid", path="src/uu/hostid" }
-hostname = { optional=true, version="0.0.17", package="uu_hostname", path="src/uu/hostname" }
-id = { optional=true, version="0.0.17", package="uu_id", path="src/uu/id" }
-install = { optional=true, version="0.0.17", package="uu_install", path="src/uu/install" }
-join = { optional=true, version="0.0.17", package="uu_join", path="src/uu/join" }
-kill = { optional=true, version="0.0.17", package="uu_kill", path="src/uu/kill" }
-link = { optional=true, version="0.0.17", package="uu_link", path="src/uu/link" }
-ln = { optional=true, version="0.0.17", package="uu_ln", path="src/uu/ln" }
-ls = { optional=true, version="0.0.17", package="uu_ls", path="src/uu/ls" }
-logname = { optional=true, version="0.0.17", package="uu_logname", path="src/uu/logname" }
-mkdir = { optional=true, version="0.0.17", package="uu_mkdir", path="src/uu/mkdir" }
-mkfifo = { optional=true, version="0.0.17", package="uu_mkfifo", path="src/uu/mkfifo" }
-mknod = { optional=true, version="0.0.17", package="uu_mknod", path="src/uu/mknod" }
-mktemp = { optional=true, version="0.0.17", package="uu_mktemp", path="src/uu/mktemp" }
-more = { optional=true, version="0.0.17", package="uu_more", path="src/uu/more" }
-mv = { optional=true, version="0.0.17", package="uu_mv", path="src/uu/mv" }
-nice = { optional=true, version="0.0.17", package="uu_nice", path="src/uu/nice" }
-nl = { optional=true, version="0.0.17", package="uu_nl", path="src/uu/nl" }
-nohup = { optional=true, version="0.0.17", package="uu_nohup", path="src/uu/nohup" }
-nproc = { optional=true, version="0.0.17", package="uu_nproc", path="src/uu/nproc" }
-numfmt = { optional=true, version="0.0.17", package="uu_numfmt", path="src/uu/numfmt" }
-od = { optional=true, version="0.0.17", package="uu_od", path="src/uu/od" }
-paste = { optional=true, version="0.0.17", package="uu_paste", path="src/uu/paste" }
-pathchk = { optional=true, version="0.0.17", package="uu_pathchk", path="src/uu/pathchk" }
-pinky = { optional=true, version="0.0.17", package="uu_pinky", path="src/uu/pinky" }
-pr = { optional=true, version="0.0.17", package="uu_pr", path="src/uu/pr" }
-printenv = { optional=true, version="0.0.17", package="uu_printenv", path="src/uu/printenv" }
-printf = { optional=true, version="0.0.17", package="uu_printf", path="src/uu/printf" }
-ptx = { optional=true, version="0.0.17", package="uu_ptx", path="src/uu/ptx" }
-pwd = { optional=true, version="0.0.17", package="uu_pwd", path="src/uu/pwd" }
-readlink = { optional=true, version="0.0.17", package="uu_readlink", path="src/uu/readlink" }
-realpath = { optional=true, version="0.0.17", package="uu_realpath", path="src/uu/realpath" }
-relpath = { optional=true, version="0.0.17", package="uu_relpath", path="src/uu/relpath" }
-rm = { optional=true, version="0.0.17", package="uu_rm", path="src/uu/rm" }
-rmdir = { optional=true, version="0.0.17", package="uu_rmdir", path="src/uu/rmdir" }
-runcon = { optional=true, version="0.0.17", package="uu_runcon", path="src/uu/runcon" }
-seq = { optional=true, version="0.0.17", package="uu_seq", path="src/uu/seq" }
-shred = { optional=true, version="0.0.17", package="uu_shred", path="src/uu/shred" }
-shuf = { optional=true, version="0.0.17", package="uu_shuf", path="src/uu/shuf" }
-sleep = { optional=true, version="0.0.17", package="uu_sleep", path="src/uu/sleep" }
-sort = { optional=true, version="0.0.17", package="uu_sort", path="src/uu/sort" }
-split = { optional=true, version="0.0.17", package="uu_split", path="src/uu/split" }
-stat = { optional=true, version="0.0.17", package="uu_stat", path="src/uu/stat" }
-stdbuf = { optional=true, version="0.0.17", package="uu_stdbuf", path="src/uu/stdbuf" }
-stty = { optional=true, version="0.0.17", package="uu_stty", path="src/uu/stty" }
-sum = { optional=true, version="0.0.17", package="uu_sum", path="src/uu/sum" }
-sync = { optional=true, version="0.0.17", package="uu_sync", path="src/uu/sync" }
-tac = { optional=true, version="0.0.17", package="uu_tac", path="src/uu/tac" }
-tail = { optional=true, version="0.0.17", package="uu_tail", path="src/uu/tail" }
-tee = { optional=true, version="0.0.17", package="uu_tee", path="src/uu/tee" }
-timeout = { optional=true, version="0.0.17", package="uu_timeout", path="src/uu/timeout" }
-touch = { optional=true, version="0.0.17", package="uu_touch", path="src/uu/touch" }
-tr = { optional=true, version="0.0.17", package="uu_tr", path="src/uu/tr" }
-true = { optional=true, version="0.0.17", package="uu_true", path="src/uu/true" }
-truncate = { optional=true, version="0.0.17", package="uu_truncate", path="src/uu/truncate" }
-tsort = { optional=true, version="0.0.17", package="uu_tsort", path="src/uu/tsort" }
-tty = { optional=true, version="0.0.17", package="uu_tty", path="src/uu/tty" }
-uname = { optional=true, version="0.0.17", package="uu_uname", path="src/uu/uname" }
-unexpand = { optional=true, version="0.0.17", package="uu_unexpand", path="src/uu/unexpand" }
-uniq = { optional=true, version="0.0.17", package="uu_uniq", path="src/uu/uniq" }
-unlink = { optional=true, version="0.0.17", package="uu_unlink", path="src/uu/unlink" }
-uptime = { optional=true, version="0.0.17", package="uu_uptime", path="src/uu/uptime" }
-users = { optional=true, version="0.0.17", package="uu_users", path="src/uu/users" }
-vdir = { optional=true, version="0.0.17", package="uu_vdir", path="src/uu/vdir" }
-wc = { optional=true, version="0.0.17", package="uu_wc", path="src/uu/wc" }
-who = { optional=true, version="0.0.17", package="uu_who", path="src/uu/who" }
-whoami = { optional=true, version="0.0.17", package="uu_whoami", path="src/uu/whoami" }
-yes = { optional=true, version="0.0.17", package="uu_yes", path="src/uu/yes" }
+arch = { optional = true, version = "0.0.27", package = "uu_arch", path = "src/uu/arch" }
+base32 = { optional = true, version = "0.0.27", package = "uu_base32", path = "src/uu/base32" }
+base64 = { optional = true, version = "0.0.27", package = "uu_base64", path = "src/uu/base64" }
+basename = { optional = true, version = "0.0.27", package = "uu_basename", path = "src/uu/basename" }
+basenc = { optional = true, version = "0.0.27", package = "uu_basenc", path = "src/uu/basenc" }
+cat = { optional = true, version = "0.0.27", package = "uu_cat", path = "src/uu/cat" }
+chcon = { optional = true, version = "0.0.27", package = "uu_chcon", path = "src/uu/chcon" }
+chgrp = { optional = true, version = "0.0.27", package = "uu_chgrp", path = "src/uu/chgrp" }
+chmod = { optional = true, version = "0.0.27", package = "uu_chmod", path = "src/uu/chmod" }
+chown = { optional = true, version = "0.0.27", package = "uu_chown", path = "src/uu/chown" }
+chroot = { optional = true, version = "0.0.27", package = "uu_chroot", path = "src/uu/chroot" }
+cksum = { optional = true, version = "0.0.27", package = "uu_cksum", path = "src/uu/cksum" }
+comm = { optional = true, version = "0.0.27", package = "uu_comm", path = "src/uu/comm" }
+cp = { optional = true, version = "0.0.27", package = "uu_cp", path = "src/uu/cp" }
+csplit = { optional = true, version = "0.0.27", package = "uu_csplit", path = "src/uu/csplit" }
+cut = { optional = true, version = "0.0.27", package = "uu_cut", path = "src/uu/cut" }
+date = { optional = true, version = "0.0.27", package = "uu_date", path = "src/uu/date" }
+dd = { optional = true, version = "0.0.27", package = "uu_dd", path = "src/uu/dd" }
+df = { optional = true, version = "0.0.27", package = "uu_df", path = "src/uu/df" }
+dir = { optional = true, version = "0.0.27", package = "uu_dir", path = "src/uu/dir" }
+dircolors = { optional = true, version = "0.0.27", package = "uu_dircolors", path = "src/uu/dircolors" }
+dirname = { optional = true, version = "0.0.27", package = "uu_dirname", path = "src/uu/dirname" }
+du = { optional = true, version = "0.0.27", package = "uu_du", path = "src/uu/du" }
+echo = { optional = true, version = "0.0.27", package = "uu_echo", path = "src/uu/echo" }
+env = { optional = true, version = "0.0.27", package = "uu_env", path = "src/uu/env" }
+expand = { optional = true, version = "0.0.27", package = "uu_expand", path = "src/uu/expand" }
+expr = { optional = true, version = "0.0.27", package = "uu_expr", path = "src/uu/expr" }
+factor = { optional = true, version = "0.0.27", package = "uu_factor", path = "src/uu/factor" }
+false = { optional = true, version = "0.0.27", package = "uu_false", path = "src/uu/false" }
+fmt = { optional = true, version = "0.0.27", package = "uu_fmt", path = "src/uu/fmt" }
+fold = { optional = true, version = "0.0.27", package = "uu_fold", path = "src/uu/fold" }
+groups = { optional = true, version = "0.0.27", package = "uu_groups", path = "src/uu/groups" }
+hashsum = { optional = true, version = "0.0.27", package = "uu_hashsum", path = "src/uu/hashsum" }
+head = { optional = true, version = "0.0.27", package = "uu_head", path = "src/uu/head" }
+hostid = { optional = true, version = "0.0.27", package = "uu_hostid", path = "src/uu/hostid" }
+hostname = { optional = true, version = "0.0.27", package = "uu_hostname", path = "src/uu/hostname" }
+id = { optional = true, version = "0.0.27", package = "uu_id", path = "src/uu/id" }
+install = { optional = true, version = "0.0.27", package = "uu_install", path = "src/uu/install" }
+join = { optional = true, version = "0.0.27", package = "uu_join", path = "src/uu/join" }
+kill = { optional = true, version = "0.0.27", package = "uu_kill", path = "src/uu/kill" }
+link = { optional = true, version = "0.0.27", package = "uu_link", path = "src/uu/link" }
+ln = { optional = true, version = "0.0.27", package = "uu_ln", path = "src/uu/ln" }
+ls = { optional = true, version = "0.0.27", package = "uu_ls", path = "src/uu/ls" }
+logname = { optional = true, version = "0.0.27", package = "uu_logname", path = "src/uu/logname" }
+mkdir = { optional = true, version = "0.0.27", package = "uu_mkdir", path = "src/uu/mkdir" }
+mkfifo = { optional = true, version = "0.0.27", package = "uu_mkfifo", path = "src/uu/mkfifo" }
+mknod = { optional = true, version = "0.0.27", package = "uu_mknod", path = "src/uu/mknod" }
+mktemp = { optional = true, version = "0.0.27", package = "uu_mktemp", path = "src/uu/mktemp" }
+more = { optional = true, version = "0.0.27", package = "uu_more", path = "src/uu/more" }
+mv = { optional = true, version = "0.0.27", package = "uu_mv", path = "src/uu/mv" }
+nice = { optional = true, version = "0.0.27", package = "uu_nice", path = "src/uu/nice" }
+nl = { optional = true, version = "0.0.27", package = "uu_nl", path = "src/uu/nl" }
+nohup = { optional = true, version = "0.0.27", package = "uu_nohup", path = "src/uu/nohup" }
+nproc = { optional = true, version = "0.0.27", package = "uu_nproc", path = "src/uu/nproc" }
+numfmt = { optional = true, version = "0.0.27", package = "uu_numfmt", path = "src/uu/numfmt" }
+od = { optional = true, version = "0.0.27", package = "uu_od", path = "src/uu/od" }
+paste = { optional = true, version = "0.0.27", package = "uu_paste", path = "src/uu/paste" }
+pathchk = { optional = true, version = "0.0.27", package = "uu_pathchk", path = "src/uu/pathchk" }
+pinky = { optional = true, version = "0.0.27", package = "uu_pinky", path = "src/uu/pinky" }
+pr = { optional = true, version = "0.0.27", package = "uu_pr", path = "src/uu/pr" }
+printenv = { optional = true, version = "0.0.27", package = "uu_printenv", path = "src/uu/printenv" }
+printf = { optional = true, version = "0.0.27", package = "uu_printf", path = "src/uu/printf" }
+ptx = { optional = true, version = "0.0.27", package = "uu_ptx", path = "src/uu/ptx" }
+pwd = { optional = true, version = "0.0.27", package = "uu_pwd", path = "src/uu/pwd" }
+readlink = { optional = true, version = "0.0.27", package = "uu_readlink", path = "src/uu/readlink" }
+realpath = { optional = true, version = "0.0.27", package = "uu_realpath", path = "src/uu/realpath" }
+rm = { optional = true, version = "0.0.27", package = "uu_rm", path = "src/uu/rm" }
+rmdir = { optional = true, version = "0.0.27", package = "uu_rmdir", path = "src/uu/rmdir" }
+runcon = { optional = true, version = "0.0.27", package = "uu_runcon", path = "src/uu/runcon" }
+seq = { optional = true, version = "0.0.27", package = "uu_seq", path = "src/uu/seq" }
+shred = { optional = true, version = "0.0.27", package = "uu_shred", path = "src/uu/shred" }
+shuf = { optional = true, version = "0.0.27", package = "uu_shuf", path = "src/uu/shuf" }
+sleep = { optional = true, version = "0.0.27", package = "uu_sleep", path = "src/uu/sleep" }
+sort = { optional = true, version = "0.0.27", package = "uu_sort", path = "src/uu/sort" }
+split = { optional = true, version = "0.0.27", package = "uu_split", path = "src/uu/split" }
+stat = { optional = true, version = "0.0.27", package = "uu_stat", path = "src/uu/stat" }
+stdbuf = { optional = true, version = "0.0.27", package = "uu_stdbuf", path = "src/uu/stdbuf" }
+stty = { optional = true, version = "0.0.27", package = "uu_stty", path = "src/uu/stty" }
+sum = { optional = true, version = "0.0.27", package = "uu_sum", path = "src/uu/sum" }
+sync = { optional = true, version = "0.0.27", package = "uu_sync", path = "src/uu/sync" }
+tac = { optional = true, version = "0.0.27", package = "uu_tac", path = "src/uu/tac" }
+tail = { optional = true, version = "0.0.27", package = "uu_tail", path = "src/uu/tail" }
+tee = { optional = true, version = "0.0.27", package = "uu_tee", path = "src/uu/tee" }
+timeout = { optional = true, version = "0.0.27", package = "uu_timeout", path = "src/uu/timeout" }
+touch = { optional = true, version = "0.0.27", package = "uu_touch", path = "src/uu/touch" }
+tr = { optional = true, version = "0.0.27", package = "uu_tr", path = "src/uu/tr" }
+true = { optional = true, version = "0.0.27", package = "uu_true", path = "src/uu/true" }
+truncate = { optional = true, version = "0.0.27", package = "uu_truncate", path = "src/uu/truncate" }
+tsort = { optional = true, version = "0.0.27", package = "uu_tsort", path = "src/uu/tsort" }
+tty = { optional = true, version = "0.0.27", package = "uu_tty", path = "src/uu/tty" }
+uname = { optional = true, version = "0.0.27", package = "uu_uname", path = "src/uu/uname" }
+unexpand = { optional = true, version = "0.0.27", package = "uu_unexpand", path = "src/uu/unexpand" }
+uniq = { optional = true, version = "0.0.27", package = "uu_uniq", path = "src/uu/uniq" }
+unlink = { optional = true, version = "0.0.27", package = "uu_unlink", path = "src/uu/unlink" }
+uptime = { optional = true, version = "0.0.27", package = "uu_uptime", path = "src/uu/uptime" }
+users = { optional = true, version = "0.0.27", package = "uu_users", path = "src/uu/users" }
+vdir = { optional = true, version = "0.0.27", package = "uu_vdir", path = "src/uu/vdir" }
+wc = { optional = true, version = "0.0.27", package = "uu_wc", path = "src/uu/wc" }
+who = { optional = true, version = "0.0.27", package = "uu_who", path = "src/uu/who" }
+whoami = { optional = true, version = "0.0.27", package = "uu_whoami", path = "src/uu/whoami" }
+yes = { optional = true, version = "0.0.27", package = "uu_yes", path = "src/uu/yes" }
# this breaks clippy linting with: "tests/by-util/test_factor_benches.rs: No such file or directory (os error 2)"
# factor_benches = { optional = true, version = "0.0.0", package = "uu_factor_benches", path = "tests/benches/factor" }
@@ -388,35 +478,48 @@ yes = { optional=true, version="0.0.17", package="uu_yes", path="src/uu/yes
#pin_cc = { version="1.0.61, < 1.0.62", package="cc" } ## cc v1.0.62 has compiler errors for MinRustV v1.32.0, requires 1.34 (for `std::str::split_ascii_whitespace()`)
[dev-dependencies]
-chrono = { version="^0.4.23", default-features=false, features=["std", "alloc", "clock"]}
-conv = "0.3"
-filetime = "0.2"
-glob = "0.3.0"
-libc = "0.2"
-pretty_assertions = "1"
-rand = "0.8"
-regex = "1.7"
-sha1 = { version="0.10", features=["std"] }
-tempfile = "3"
-time = {version="0.3", features=["local-offset"]}
-unindent = "0.1"
-uucore = { version=">=0.0.17", package="uucore", path="src/uucore", features=["entries", "process"] }
-walkdir = "2.2"
-atty = "0.2"
-hex-literal = "0.3.1"
-rstest = "0.16.0"
+chrono = { workspace = true }
+filetime = { workspace = true }
+glob = { workspace = true }
+libc = { workspace = true }
+num-prime = { workspace = true }
+pretty_assertions = "1.4.0"
+rand = { workspace = true }
+regex = { workspace = true }
+sha1 = { version = "0.10.6", features = ["std"] }
+tempfile = { workspace = true }
+time = { workspace = true, features = ["local-offset"] }
+unindent = "0.2.3"
+uucore = { workspace = true, features = [
+ "mode",
+ "entries",
+ "process",
+ "signals",
+ "utmpx",
+] }
+walkdir = { workspace = true }
+hex-literal = "0.4.1"
+rstest = { workspace = true }
[target.'cfg(any(target_os = "linux", target_os = "android"))'.dev-dependencies]
-procfs = { version = "0.14", default-features = false }
-rlimit = "0.8.3"
+procfs = { version = "0.16", default-features = false }
[target.'cfg(unix)'.dev-dependencies]
-nix = { version = "0.25", default-features = false, features = ["process", "signal", "user"] }
-rust-users = { version="0.11", package="users" }
-rand_pcg = "0.3"
+nix = { workspace = true, features = ["process", "signal", "user", "term"] }
+rlimit = "0.10.1"
+rand_pcg = "0.3.1"
+xattr = { workspace = true }
+
+# Specifically used in test_uptime::test_uptime_with_file_containing_valid_boot_time_utmpx_record
+# to deserialize a utmpx struct into a binary file
+[target.'cfg(all(target_family= "unix",not(target_os = "macos")))'.dev-dependencies]
+serde = { version = "1.0.202", features = ["derive"] }
+bincode = { version = "1.3.3" }
+serde-big-array = "0.5.1"
+
[build-dependencies]
-phf_codegen = "0.11.1"
+phf_codegen = { workspace = true }
[[bin]]
name = "coreutils"
@@ -426,3 +529,22 @@ path = "src/bin/coreutils.rs"
name = "uudoc"
path = "src/bin/uudoc.rs"
required-features = ["uudoc"]
+
+# The default release profile. It contains all optimizations, without
+# sacrificing debug info. With this profile (like in the standard
+# release profile), the debug info and the stack traces will still be available.
+[profile.release]
+lto = true
+
+# A release-like profile that is tuned to be fast, even when being fast
+# compromises on binary size. This includes aborting on panic.
+[profile.release-fast]
+inherits = "release"
+panic = "abort"
+
+# A release-like profile that is as small as possible.
+[profile.release-small]
+inherits = "release"
+opt-level = "z"
+panic = "abort"
+strip = true
diff --git a/DEVELOPER_INSTRUCTIONS.md b/DEVELOPER_INSTRUCTIONS.md
deleted file mode 100644
index 28deb2677775a9b47de81715790f426e9565d1d2..0000000000000000000000000000000000000000
--- a/DEVELOPER_INSTRUCTIONS.md
+++ /dev/null
@@ -1,70 +0,0 @@
-Documentation
--------------
-
-The source of the documentation is available on:
-
-https://uutils.github.io/dev/coreutils/
-
-The documentation is updated everyday on this repository:
-
-https://github.com/uutils/uutils.github.io/
-
-Running GNU tests
------------------
-
-<!-- spell-checker:ignore gnulib -->
-
-- Check out https://github.com/coreutils/coreutils next to your fork as gnu
-- Check out https://github.com/coreutils/gnulib next to your fork as gnulib
-- Rename the checkout of your fork to uutils
-
-At the end you should have uutils, gnu and gnulib checked out next to each other.
-
-- Run `cd uutils && ./util/build-gnu.sh && cd ..` to get everything ready (this may take a while)
-- Finally, you can run tests with `bash uutils/util/run-gnu-test.sh <tests>`. Instead of `<tests>` insert the tests you want to run, e.g. `tests/misc/wc-proc.sh`.
-
-
-Code Coverage Report Generation
----------------------------------
-
-<!-- spell-checker:ignore (flags) Ccodegen Coverflow Cpanic Zinstrument Zpanic -->
-
-Code coverage report can be generated using [grcov](https://github.com/mozilla/grcov).
-
-### Using Nightly Rust
-
-To generate [gcov-based](https://github.com/mozilla/grcov#example-how-to-generate-gcda-files-for-a-rust-project) coverage report
-
-```bash
-$ export CARGO_INCREMENTAL=0
-$ export RUSTFLAGS="-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
-$ export RUSTDOCFLAGS="-Cpanic=abort"
-$ cargo build <options...> # e.g., --features feat_os_unix
-$ cargo test <options...> # e.g., --features feat_os_unix test_pathchk
-$ grcov . -s . --binary-path ./target/debug/ -t html --branch --ignore-not-existing --ignore build.rs --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?\#\[derive\()" -o ./target/debug/coverage/
-$ # open target/debug/coverage/index.html in browser
-```
-
-if changes are not reflected in the report then run `cargo clean` and run the above commands.
-
-### Using Stable Rust
-
-If you are using stable version of Rust that doesn't enable code coverage instrumentation by default
-then add `-Z-Zinstrument-coverage` flag to `RUSTFLAGS` env variable specified above.
-
-
-pre-commit hooks
-----------------
-
-A configuration for `pre-commit` is provided in the repository. It allows automatically checking every git commit you make to ensure it compiles, and passes `clippy` and `rustfmt` without warnings.
-
-To use the provided hook:
-
-1. [Install `pre-commit`](https://pre-commit.com/#install)
-2. Run `pre-commit install` while in the repository directory
-
-Your git commits will then automatically be checked. If a check fails, an error message will explain why, and your commit will be canceled. You can then make the suggested changes, and run `git commit ...` again.
-
-### Using Clippy
-
-The `msrv` key in the clippy configuration file `clippy.toml` is used to disable lints pertaining to newer features by specifying the minimum supported Rust version (MSRV). However, this key is only supported on `nightly`. To invoke clippy without errors, use `cargo +nightly clippy`. In order to also check tests and non-default crate features, use `cargo +nightly clippy --all-targets --all-features`.
diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md
new file mode 100644
index 0000000000000000000000000000000000000000..6f1de3b54761d0c43db0c5ea3a9159e696a6f5aa
--- /dev/null
+++ b/DEVELOPMENT.md
@@ -0,0 +1,337 @@
+<!-- spell-checker:ignore (flags) Ccodegen Coverflow Cpanic Zinstrument Zpanic reimplementing toybox RUNTEST CARGOFLAGS nextest prereq autopoint gettext texinfo automake findutils shellenv libexec gnubin toolchains gsed -->
+
+# Setting up your local development environment
+
+For contributing rules and best practices please refer to [CONTRIBUTING.md](CONTRIBUTING.md)
+
+## Before you start
+
+For this guide we assume that you already have a GitHub account and have `git` and your favorite code editor or IDE installed and configured.
+Before you start working on coreutils, please follow these steps:
+
+1. Fork the [coreutils repository](https://github.com/uutils/coreutils) to your GitHub account.
+***Tip:*** See [this GitHub guide](https://docs.github.com/en/get-started/quickstart/fork-a-repo) for more information on this step.
+2. Clone that fork to your local development environment:
+
+```shell
+git clone https://github.com/YOUR-GITHUB-ACCOUNT/coreutils
+cd coreutils
+```
+
+## Tools
+
+You will need the tools mentioned in this section to build and test your code changes locally.
+This section will explain how to install and configure these tools.
+We also have an extensive CI that uses these tools and will check your code before it can be merged.
+The next section [Testing](#testing) will explain how to run those checks locally to avoid waiting for the CI.
+
+### Rust toolchain
+
+[Install Rust](https://www.rust-lang.org/tools/install)
+
+If you're using rustup to install and manage your Rust toolchains, `clippy` and `rustfmt` are usually already installed. If you are using one of the alternative methods, please make sure to install them manually. See following sub-sections for their usage: [clippy](#clippy) [rustfmt](#rustfmt).
+
+***Tip*** You might also need to add 'llvm-tools' component if you are going to [generate code coverage reports locally](#code-coverage-report):
+
+```shell
+rustup component add llvm-tools-preview
+```
+
+### GNU utils and prerequisites
+
+If you are developing on Linux, most likely you already have all/most GNU utilities and prerequisites installed.
+
+To make sure, please check GNU coreutils [README-prereq](https://github.com/coreutils/coreutils/blob/master/README-prereq).
+
+You will need these to [run uutils against the GNU test suite locally](#comparing-with-gnu).
+
+For MacOS and Windows platform specific setup please check [MacOS GNU utils](#macos-gnu-utils) and [Windows GNU utils](#windows-gnu-utils) sections respectfully.
+
+### pre-commit hooks
+
+A configuration for `pre-commit` is provided in the repository. It allows
+automatically checking every git commit you make to ensure it compiles, and
+passes `clippy` and `rustfmt` without warnings.
+
+To use the provided hook:
+
+1. [Install `pre-commit`](https://pre-commit.com/#install)
+1. Run `pre-commit install` while in the repository directory
+
+Your git commits will then automatically be checked. If a check fails, an error
+message will explain why, and your commit will be canceled. You can then make
+the suggested changes, and run `git commit ...` again.
+
+**NOTE: On MacOS** the pre-commit hooks are currently broken. There are workarounds involving switching to unstable nightly Rust and components.
+
+### clippy
+
+```shell
+cargo clippy --all-targets --all-features
+```
+
+The `msrv` key in the clippy configuration file `clippy.toml` is used to disable
+lints pertaining to newer features by specifying the minimum supported Rust
+version (MSRV).
+
+### rustfmt
+
+```shell
+cargo fmt --all
+```
+
+### cargo-deny
+
+This project uses [cargo-deny](https://github.com/EmbarkStudios/cargo-deny/) to
+detect duplicate dependencies, checks licenses, etc. To run it locally, first
+install it and then run with:
+
+```shell
+cargo deny --all-features check all
+```
+
+### Markdown linter
+
+We use [markdownlint](https://github.com/DavidAnson/markdownlint) to lint the
+Markdown files in the repository.
+
+### Spell checker
+
+We use `cspell` as spell checker for all files in the project. If you are using
+VS Code, you can install the
+[code spell checker](https://marketplace.visualstudio.com/items?itemName=streetsidesoftware.code-spell-checker)
+extension to enable spell checking within your editor. Otherwise, you can
+install [cspell](https://cspell.org/) separately.
+
+If you want to make the spell checker ignore a word, you can add
+
+```rust
+// spell-checker:ignore word_to_ignore
+```
+
+at the top of the file.
+
+## Testing
+
+This section explains how to run our CI checks locally.
+Testing can be done using either Cargo or `make`.
+
+### Testing with Cargo
+
+Just like with building, we follow the standard procedure for testing using
+Cargo:
+
+```shell
+cargo test
+```
+
+By default, `cargo test` only runs the common programs. To run also platform
+specific tests, run:
+
+```shell
+cargo test --features unix
+```
+
+If you would prefer to test a select few utilities:
+
+```shell
+cargo test --features "chmod mv tail" --no-default-features
+```
+
+If you also want to test the core utilities:
+
+```shell
+cargo test -p uucore -p coreutils
+# or
+cargo test --all-features -p uucore
+```
+
+Running the complete test suite might take a while. We use [nextest](https://nexte.st/index.html) in
+the CI and you might want to try it out locally. It can speed up the execution time of the whole
+test run significantly if the cpu has multiple cores.
+
+```shell
+cargo nextest run --features unix --no-fail-fast
+```
+
+To debug:
+
+```shell
+rust-gdb --args target/debug/coreutils ls
+(gdb) b ls.rs:79
+(gdb) run
+```
+
+### Testing with GNU Make
+
+To simply test all available utilities:
+
+```shell
+make test
+```
+
+To test all but a few of the available utilities:
+
+```shell
+make SKIP_UTILS='UTILITY_1 UTILITY_2' test
+```
+
+To test only a few of the available utilities:
+
+```shell
+make UTILS='UTILITY_1 UTILITY_2' test
+```
+
+To include tests for unimplemented behavior:
+
+```shell
+make UTILS='UTILITY_1 UTILITY_2' SPEC=y test
+```
+
+To run tests with `nextest` just use the nextest target. Note you'll need to
+[install](https://nexte.st/book/installation.html) `nextest` first. The `nextest` target accepts the
+same arguments like the default `test` target, so it's possible to pass arguments to `nextest run`
+via `CARGOFLAGS`:
+
+```shell
+make CARGOFLAGS='--no-fail-fast' UTILS='UTILITY_1 UTILITY_2' nextest
+```
+
+### Run Busybox Tests
+
+This testing functionality is only available on *nix operating systems and
+requires `make`.
+
+To run busybox tests for all utilities for which busybox has tests
+
+```shell
+make busytest
+```
+
+To run busybox tests for a few of the available utilities
+
+```shell
+make UTILS='UTILITY_1 UTILITY_2' busytest
+```
+
+To pass an argument like "-v" to the busybox test runtime
+
+```shell
+make UTILS='UTILITY_1 UTILITY_2' RUNTEST_ARGS='-v' busytest
+```
+
+### Comparing with GNU
+
+To run uutils against the GNU test suite locally, run the following commands:
+
+```shell
+bash util/build-gnu.sh
+# Build uutils with release optimizations
+bash util/build-gnu.sh --release-build
+bash util/run-gnu-test.sh
+# To run a single test:
+bash util/run-gnu-test.sh tests/touch/not-owner.sh # for example
+# To run several tests:
+bash util/run-gnu-test.sh tests/touch/not-owner.sh tests/rm/no-give-up.sh # for example
+# If this is a perl (.pl) test, to run in debug:
+DEBUG=1 bash util/run-gnu-test.sh tests/misc/sm3sum.pl
+```
+
+***Tip:*** First time you run `bash util/build-gnu.sh` command, it will provide instructions on how to checkout GNU coreutils repository at the correct release tag. Please follow those instructions and when done, run `bash util/build-gnu.sh` command again.
+
+Note that GNU test suite relies on individual utilities (not the multicall binary).
+
+On FreeBSD, you need to install packages for GNU coreutils and sed (used in shell scripts instead of system commands):
+
+```shell
+pkg install coreutils gsed
+```
+
+## Code coverage report
+
+Code coverage report can be generated using [grcov](https://github.com/mozilla/grcov).
+
+### Using Nightly Rust
+
+To generate [gcov-based](https://github.com/mozilla/grcov#example-how-to-generate-gcda-files-for-a-rust-project) coverage report
+
+```shell
+export CARGO_INCREMENTAL=0
+export RUSTFLAGS="-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
+export RUSTDOCFLAGS="-Cpanic=abort"
+cargo build <options...> # e.g., --features feat_os_unix
+cargo test <options...> # e.g., --features feat_os_unix test_pathchk
+grcov . -s . --binary-path ./target/debug/ -t html --branch --ignore-not-existing --ignore build.rs --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?\#\[derive\()" -o ./target/debug/coverage/
+# open target/debug/coverage/index.html in browser
+```
+
+if changes are not reflected in the report then run `cargo clean` and run the above commands.
+
+### Using Stable Rust
+
+If you are using stable version of Rust that doesn't enable code coverage instrumentation by default
+then add `-Z-Zinstrument-coverage` flag to `RUSTFLAGS` env variable specified above.
+
+## Tips for setting up on Mac
+
+### C Compiler and linker
+
+On MacOS you'll need to install C compiler & linker:
+
+```shell
+xcode-select --install
+```
+
+### MacOS GNU utils
+
+On MacOS you will need to install [Homebrew](https://docs.brew.sh/Installation) and use it to install the following Homebrew formulas:
+
+```shell
+brew install \
+ coreutils \
+ autoconf \
+ gettext \
+ wget \
+ texinfo \
+ xz \
+ automake \
+ gnu-sed \
+ m4 \
+ bison \
+ pre-commit \
+ findutils
+```
+
+After installing these Homebrew formulas, please make sure to add the following lines to your `zsh` or `bash` rc file, i.e. `~/.profile` or `~/.zshrc` or `~/.bashrc` ...
+(assuming Homebrew is installed at default location `/opt/homebrew`):
+
+```shell
+eval "$(/opt/homebrew/bin/brew shellenv)"
+export PATH="/opt/homebrew/opt/coreutils/libexec/gnubin:$PATH"
+export PATH="/opt/homebrew/opt/bison/bin:$PATH"
+export PATH="/opt/homebrew/opt/findutils/libexec/gnubin:$PATH"
+```
+
+Last step is to link Homebrew coreutils version of `timeout` to `/usr/local/bin` (as admin user):
+
+```shell
+sudo ln -s /opt/homebrew/bin/timeout /usr/local/bin/timeout
+```
+
+Do not forget to either source updated rc file or restart you terminal session to update environment variables.
+
+## Tips for setting up on Windows
+
+### MSVC build tools
+
+On Windows you'll need the MSVC build tools for Visual Studio 2013 or later.
+
+If you are using `rustup-init.exe` to install Rust toolchain, it will guide you through the process of downloading and installing these prerequisites.
+
+Otherwise please follow [this guide](https://learn.microsoft.com/en-us/windows/dev-environment/rust/setup).
+
+### Windows GNU utils
+
+If you have used [Git for Windows](https://gitforwindows.org) to install `git` on you Windows system you might already have some GNU core utilities installed as part of "GNU Bash" included in Git for Windows package, but it is not a complete package. [This article](https://gist.github.com/evanwill/0207876c3243bbb6863e65ec5dc3f058) provides instruction on how to add more to it.
+
+Alternatively you can install [Cygwin](https://www.cygwin.com) and/or use [WSL2](https://learn.microsoft.com/en-us/windows/wsl/compare-versions#whats-new-in-wsl-2) to get access to all GNU core utilities on Windows.
diff --git a/GNUmakefile b/GNUmakefile
index b242bc8ceaaa10333cd15f8f4539469dd09944e7..0b4f2d04ce7d2a29fabc92731d3731dae49fe628 100644
--- a/GNUmakefile
+++ b/GNUmakefile
@@ -1,4 +1,4 @@
-# spell-checker:ignore (misc) testsuite runtest findstring (targets) busytest toybox distclean pkgs ; (vars/env) BINDIR BUILDDIR CARGOFLAGS DESTDIR DOCSDIR INSTALLDIR INSTALLEES MULTICALL DATAROOTDIR TESTDIR
+# spell-checker:ignore (misc) testsuite runtest findstring (targets) busytest toybox distclean pkgs nextest ; (vars/env) BINDIR BUILDDIR CARGOFLAGS DESTDIR DOCSDIR INSTALLDIR INSTALLEES MULTICALL DATAROOTDIR TESTDIR manpages
# Config options
PROFILE ?= debug
@@ -102,7 +102,6 @@ PROGS := \
pwd \
readlink \
realpath \
- relpath \
rm \
rmdir \
seq \
@@ -148,6 +147,7 @@ UNIX_PROGS := \
nohup \
pathchk \
pinky \
+ sleep \
stat \
stdbuf \
timeout \
@@ -222,6 +222,7 @@ TEST_PROGS := \
rmdir \
runcon \
seq \
+ sleep \
sort \
split \
stat \
@@ -289,6 +290,9 @@ $(foreach test,$(filter-out $(SKIP_UTILS),$(PROGS)),$(eval $(call TEST_BUSYBOX,$
test:
${CARGO} test ${CARGOFLAGS} --features "$(TESTS) $(TEST_SPEC_FEATURE)" --no-default-features $(TEST_NO_FAIL_FAST)
+nextest:
+ ${CARGO} nextest run ${CARGOFLAGS} --features "$(TESTS) $(TEST_SPEC_FEATURE)" --no-default-features $(TEST_NO_FAIL_FAST)
+
test_toybox:
-(cd $(TOYBOX_SRC)/ && make tests)
@@ -334,7 +338,21 @@ clean:
distclean: clean
$(CARGO) clean $(CARGOFLAGS) && $(CARGO) update $(CARGOFLAGS)
-install: build
+manpages: build-coreutils
+ mkdir -p $(BUILDDIR)/man/
+ $(foreach prog, $(INSTALLEES), \
+ $(BUILDDIR)/coreutils manpage $(prog) > $(BUILDDIR)/man/$(PROG_PREFIX)$(prog).1; \
+ )
+
+completions: build-coreutils
+ mkdir -p $(BUILDDIR)/completions/zsh $(BUILDDIR)/completions/bash $(BUILDDIR)/completions/fish
+ $(foreach prog, $(INSTALLEES), \
+ $(BUILDDIR)/coreutils completion $(prog) zsh > $(BUILDDIR)/completions/zsh/_$(PROG_PREFIX)$(prog); \
+ $(BUILDDIR)/coreutils completion $(prog) bash > $(BUILDDIR)/completions/bash/$(PROG_PREFIX)$(prog); \
+ $(BUILDDIR)/coreutils completion $(prog) fish > $(BUILDDIR)/completions/fish/$(PROG_PREFIX)$(prog).fish; \
+ )
+
+install: build manpages completions
mkdir -p $(INSTALLDIR_BIN)
ifeq (${MULTICALL}, y)
$(INSTALL) $(BUILDDIR)/coreutils $(INSTALLDIR_BIN)/$(PROG_PREFIX)coreutils
@@ -346,13 +364,18 @@ else
$(INSTALL) $(BUILDDIR)/$(prog) $(INSTALLDIR_BIN)/$(PROG_PREFIX)$(prog);)
$(if $(findstring test,$(INSTALLEES)), $(INSTALL) $(BUILDDIR)/test $(INSTALLDIR_BIN)/$(PROG_PREFIX)[)
endif
+ mkdir -p $(DESTDIR)$(DATAROOTDIR)/man/man1
+ $(foreach prog, $(INSTALLEES), \
+ $(INSTALL) $(BUILDDIR)/man/$(PROG_PREFIX)$(prog).1 $(DESTDIR)$(DATAROOTDIR)/man/man1/; \
+ )
+
mkdir -p $(DESTDIR)$(DATAROOTDIR)/zsh/site-functions
mkdir -p $(DESTDIR)$(DATAROOTDIR)/bash-completion/completions
mkdir -p $(DESTDIR)$(DATAROOTDIR)/fish/vendor_completions.d
$(foreach prog, $(INSTALLEES), \
- $(BUILDDIR)/coreutils completion $(prog) zsh > $(DESTDIR)$(DATAROOTDIR)/zsh/site-functions/_$(PROG_PREFIX)$(prog); \
- $(BUILDDIR)/coreutils completion $(prog) bash > $(DESTDIR)$(DATAROOTDIR)/bash-completion/completions/$(PROG_PREFIX)$(prog); \
- $(BUILDDIR)/coreutils completion $(prog) fish > $(DESTDIR)$(DATAROOTDIR)/fish/vendor_completions.d/$(PROG_PREFIX)$(prog).fish; \
+ $(INSTALL) $(BUILDDIR)/completions/zsh/_$(PROG_PREFIX)$(prog) $(DESTDIR)$(DATAROOTDIR)/zsh/site-functions/; \
+ $(INSTALL) $(BUILDDIR)/completions/bash/$(PROG_PREFIX)$(prog) $(DESTDIR)$(DATAROOTDIR)/bash-completion/completions/; \
+ $(INSTALL) $(BUILDDIR)/completions/fish/$(PROG_PREFIX)$(prog).fish $(DESTDIR)$(DATAROOTDIR)/fish/vendor_completions.d/; \
)
uninstall:
@@ -364,5 +387,6 @@ endif
rm -f $(addprefix $(DESTDIR)$(DATAROOTDIR)/zsh/site-functions/_$(PROG_PREFIX),$(PROGS))
rm -f $(addprefix $(DESTDIR)$(DATAROOTDIR)/bash-completion/completions/$(PROG_PREFIX),$(PROGS))
rm -f $(addprefix $(DESTDIR)$(DATAROOTDIR)/fish/vendor_completions.d/$(PROG_PREFIX),$(addsuffix .fish,$(PROGS)))
+ rm -f $(addprefix $(DESTDIR)$(DATAROOTDIR)/man/man1/$(PROG_PREFIX),$(addsuffix .1,$(PROGS)))
.PHONY: all build build-coreutils build-pkgs test distclean clean busytest install uninstall
diff --git a/LICENSE b/LICENSE
index 49fdbd4cf5f39825e8b4044664cbb25efe4ea04b..21bd44404e32a494415122c935801b01d7330685 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) Jordi Boggiano and many others
+Copyright (c) uutils developers
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
diff --git a/Makefile.toml b/Makefile.toml
index ded2cd55b833906a8c240289810e6d9f21fd654f..84698df5f98427c8783cef513aac09fa83584702 100644
--- a/Makefile.toml
+++ b/Makefile.toml
@@ -20,15 +20,12 @@ run_task = "_init"
[tasks._init]
private = true
-dependencies = [
- "_init-vars",
-]
+dependencies = ["_init-vars"]
[tasks._init-vars]
private = true
script_runner = "@duckscript"
-script = [
-'''
+script = ['''
# reset build/test flags
set_env CARGO_MAKE_CARGO_BUILD_TEST_FLAGS ""
# determine features
@@ -90,54 +87,36 @@ for arg in "${args_utils_list}"
end
args_utils = trim "${args_utils}"
set_env CARGO_MAKE_TASK_BUILD_UTILS_ARGS "${args_utils}"
-'''
-]
+''']
### tasks
[tasks.default]
description = "## *DEFAULT* Build (debug-mode) and test project"
category = "[project]"
-dependencies = [
- "action-build-debug",
- "test-terse",
-]
+dependencies = ["action-build-debug", "test-terse"]
##
[tasks.build]
description = "## Build (release-mode) project"
category = "[project]"
-dependencies = [
- "core::pre-build",
- "action-build-release",
- "core::post-build",
-]
+dependencies = ["core::pre-build", "action-build-release", "core::post-build"]
[tasks.build-debug]
description = "## Build (debug-mode) project"
category = "[project]"
-dependencies = [
- "action-build-debug",
-]
+dependencies = ["action-build-debug"]
[tasks.build-examples]
description = "## Build (release-mode) project example(s); usage: `cargo make (build-examples | examples) [EXAMPLE]...`"
category = "[project]"
-dependencies = [
- "core::pre-build",
- "action-build-examples",
- "core::post-build",
-]
+dependencies = ["core::pre-build", "action-build-examples", "core::post-build"]
[tasks.build-features]
description = "## Build (with features; release-mode) project; usage: `cargo make (build-features | features) FEATURE...`"
category = "[project]"
-dependencies = [
- "core::pre-build",
- "action-build-features",
- "core::post-build",
-]
+dependencies = ["core::pre-build", "action-build-features", "core::post-build"]
[tasks.build-release]
alias = "build"
@@ -148,9 +127,7 @@ alias = "build-debug"
[tasks.example]
description = "hidden singular-form alias for 'examples'"
category = "[project]"
-dependencies = [
- "examples",
-]
+dependencies = ["examples"]
[tasks.examples]
alias = "build-examples"
@@ -161,17 +138,12 @@ alias = "build-features"
[tasks.format]
description = "## Format code files (with `cargo fmt`; includes tests)"
category = "[project]"
-dependencies = [
- "action-format",
- "action-format-tests",
-]
+dependencies = ["action-format", "action-format-tests"]
[tasks.help]
description = "## Display help"
category = "[project]"
-dependencies = [
- "action-display-help",
-]
+dependencies = ["action-display-help"]
[tasks.install]
description = "## Install project binary (to $HOME/.cargo/bin)"
@@ -182,10 +154,7 @@ args = ["install", "--path", "."]
[tasks.lint]
description = "## Display lint report"
category = "[project]"
-dependencies = [
- "action-clippy",
- "action-fmt_report",
-]
+dependencies = ["action-clippy", "action-fmt_report"]
[tasks.release]
alias = "build"
@@ -193,48 +162,32 @@ alias = "build"
[tasks.test]
description = "## Run project tests"
category = "[project]"
-dependencies = [
- "core::pre-test",
- "core::test",
- "core::post-test",
-]
+dependencies = ["core::pre-test", "core::test", "core::post-test"]
[tasks.test-terse]
description = "## Run project tests (with terse/summary output)"
category = "[project]"
-dependencies = [
- "core::pre-test",
- "action-test_quiet",
- "core::post-test",
-]
+dependencies = ["core::pre-test", "action-test_quiet", "core::post-test"]
[tasks.test-util]
description = "## Test (individual) utilities; usage: `cargo make (test-util | test-uutil) [UTIL_NAME...]`"
category = "[project]"
-dependencies = [
- "action-test-utils",
-]
+dependencies = ["action-test-utils"]
[tasks.test-utils]
description = "hidden plural-form alias for 'test-util'"
category = "[project]"
-dependencies = [
- "test-util",
-]
+dependencies = ["test-util"]
[tasks.test-uutil]
description = "hidden alias for 'test-util'"
category = "[project]"
-dependencies = [
- "test-util",
-]
+dependencies = ["test-util"]
[tasks.test-uutils]
description = "hidden alias for 'test-util'"
category = "[project]"
-dependencies = [
- "test-util",
-]
+dependencies = ["test-util"]
[tasks.uninstall]
description = "## Remove project binary (from $HOME/.cargo/bin)"
@@ -246,63 +199,66 @@ args = ["uninstall"]
description = "## Build (individual; release-mode) utilities; usage: `cargo make (util | uutil) [UTIL_NAME...]`"
category = "[project]"
dependencies = [
- "core::pre-build",
- "action-determine-utils",
- "action-build-utils",
- "core::post-build",
+ "core::pre-build",
+ "action-determine-utils",
+ "action-build-utils",
+ "core::post-build",
]
[tasks.utils]
description = "hidden plural-form alias for 'util'"
category = "[project]"
-dependencies = [
- "util",
-]
+dependencies = ["util"]
[tasks.uutil]
description = "hidden alias for 'util'"
category = "[project]"
-dependencies = [
- "util",
-]
+dependencies = ["util"]
[tasks.uutils]
description = "hidden plural-form alias for 'util'"
category = "[project]"
-dependencies = [
- "util",
-]
+dependencies = ["util"]
### actions
[tasks.action-build-release]
description = "`cargo build --release`"
command = "cargo"
-args = ["build", "--release", "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )" ]
+args = ["build", "--release", "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )"]
[tasks.action-build-debug]
description = "`cargo build`"
command = "cargo"
-args = ["build", "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )" ]
+args = ["build", "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )"]
[tasks.action-build-examples]
description = "`cargo build (--examples|(--example EXAMPLE)...)`"
command = "cargo"
-args = ["build", "--release", "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )", "${CARGO_MAKE_TASK_BUILD_EXAMPLES_ARGS}" ]
+args = [
+ "build",
+ "--release",
+ "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )",
+ "${CARGO_MAKE_TASK_BUILD_EXAMPLES_ARGS}",
+]
[tasks.action-build-features]
description = "`cargo build --release --features FEATURES`"
command = "cargo"
-args = ["build", "--release", "--no-default-features", "--features", "${CARGO_MAKE_TASK_BUILD_FEATURES_ARGS}" ]
+args = [
+ "build",
+ "--release",
+ "--no-default-features",
+ "--features",
+ "${CARGO_MAKE_TASK_BUILD_FEATURES_ARGS}",
+]
[tasks.action-build-utils]
description = "Build individual utilities"
-dependencies = [
- "action-determine-utils",
-]
+dependencies = ["action-determine-utils"]
command = "cargo"
# args = ["build", "@@remove-empty(CARGO_MAKE_TASK_BUILD_UTILS_ARGS)" ]
-args = ["build", "--release", "@@split(CARGO_MAKE_TASK_BUILD_UTILS_ARGS, )" ]
+args = ["build", "--release", "@@split(CARGO_MAKE_TASK_BUILD_UTILS_ARGS, )"]
[tasks.action-clippy]
description = "`cargo clippy` lint report"
@@ -311,8 +267,7 @@ args = ["clippy", "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )"]
[tasks.action-determine-utils]
script_runner = "@duckscript"
-script = [
-'''
+script = ['''
package_options = get_env CARGO_MAKE_TASK_BUILD_UTILS_ARGS
if is_empty "${package_options}"
show_utils = get_env CARGO_MAKE_VAR_SHOW_UTILS
@@ -335,13 +290,11 @@ if is_empty "${package_options}"
package_options = trim "${package_options}"
end_if
set_env CARGO_MAKE_TASK_BUILD_UTILS_ARGS "${package_options}"
-'''
-]
+''']
[tasks.action-determine-tests]
script_runner = "@duckscript"
-script = [
-'''
+script = ['''
test_files = glob_array tests/**/*.rs
for file in ${test_files}
file = replace "${file}" "\\" "/"
@@ -354,8 +307,7 @@ for file in ${test_files}
end_if
end
set_env CARGO_MAKE_VAR_TESTS "${tests}"
-'''
-]
+''']
[tasks.action-format]
description = "`cargo fmt`"
@@ -364,9 +316,7 @@ args = ["fmt"]
[tasks.action-format-tests]
description = "`cargo fmt` tests"
-dependencies = [
- "action-determine-tests",
-]
+dependencies = ["action-determine-tests"]
command = "cargo"
args = ["fmt", "--", "@@split(CARGO_MAKE_VAR_TESTS, )"]
@@ -381,16 +331,18 @@ args = ["fmt", "--", "--check"]
[tasks.action-spellcheck-codespell]
description = "`codespell` spellcheck repository"
command = "codespell" # (from `pip install codespell`)
-args = [".", "--skip=*/.git,./target,./tests/fixtures", "--ignore-words-list=mut,od"]
+args = [
+ ".",
+ "--skip=*/.git,./target,./tests/fixtures",
+ "--ignore-words-list=mut,od",
+]
[tasks.action-test-utils]
description = "Build individual utilities"
-dependencies = [
- "action-determine-utils",
-]
+dependencies = ["action-determine-utils"]
command = "cargo"
# args = ["build", "@@remove-empty(CARGO_MAKE_TASK_BUILD_UTILS_ARGS)" ]
-args = ["test", "@@split(CARGO_MAKE_TASK_BUILD_UTILS_ARGS, )" ]
+args = ["test", "@@split(CARGO_MAKE_TASK_BUILD_UTILS_ARGS, )"]
[tasks.action-test_quiet]
description = "Test (in `--quiet` mode)"
@@ -399,8 +351,7 @@ args = ["test", "--quiet", "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )"]
[tasks.action-display-help]
script_runner = "@duckscript"
-script = [
-'''
+script = ['''
echo ""
echo "usage: `cargo make TARGET [ARGS...]`"
echo ""
@@ -432,5 +383,4 @@ script = [
end_if
end
echo ""
-'''
-]
+''']
diff --git a/README.md b/README.md
index 6c75db838887b4b128e58c95024a36fd1d68f70a..895e3c9a908d9413ddb7daf9708a7615f9c1a648 100644
--- a/README.md
+++ b/README.md
@@ -1,114 +1,132 @@
+<!-- markdownlint-disable MD033 MD041 MD002 -->
+<!-- markdownlint-disable commands-show-output no-duplicate-heading -->
+<!-- spell-checker:ignore markdownlint ; (options) DESTDIR UTILNAME manpages reimplementation oranda -->
+<div class="oranda-hide">
+<div align="center">
+
+
+
# uutils coreutils
[](https://crates.io/crates/coreutils)
[](https://discord.gg/wQVJbvJ)
[](https://github.com/uutils/coreutils/blob/main/LICENSE)
-[](https://github.com/Aaronepower/tokei)
[](https://deps.rs/repo/github/uutils/coreutils)
[](https://codecov.io/gh/uutils/coreutils)
-
+
------------------------------------------------
+</div>
-<!-- markdownlint-disable commands-show-output no-duplicate-heading -->
-<!-- spell-checker:ignore markdownlint ; (options) DESTDIR RUNTEST UTILNAME -->
+---
-uutils is an attempt at writing universal (as in cross-platform) CLI
-utilities in [Rust](http://www.rust-lang.org).
-While all programs have been implemented, some options might be missing
-or different behavior might be experienced.
+</div>
+
+uutils coreutils is a cross-platform reimplementation of the GNU coreutils in
+[Rust](http://www.rust-lang.org). While all programs have been implemented, some
+options might be missing or different behavior might be experienced.
+
+<div class="oranda-hide">
To install it:
+```shell
+cargo install coreutils
+~/.cargo/bin/coreutils
```
-$ cargo install coreutils
-$ ~/.cargo/bin/coreutils
-```
-## Why?
+</div>
+
+<!-- markdownlint-disable-next-line MD026 -->
-uutils aims to work on as many platforms as possible, to be able to use the
-same utils on Linux, Mac, Windows and other platforms. This ensures, for
-example, that scripts can be easily transferred between platforms. Rust was
-chosen not only because it is fast and safe, but is also excellent for
-writing cross-platform code.
+## Goals
+
+uutils aims to be a drop-in replacement for the GNU utils. Differences with GNU
+are treated as bugs.
+
+uutils aims to work on as many platforms as possible, to be able to use the same
+utils on Linux, Mac, Windows and other platforms. This ensures, for example,
+that scripts can be easily transferred between platforms.
+
+<div class="oranda-hide">
## Documentation
uutils has both user and developer documentation available:
-- [User Manual](https://uutils.github.io/user/)
-- [Developer Documentation](https://uutils.github.io/dev/coreutils/)
+- [User Manual](https://uutils.github.io/coreutils/docs/)
+- [Developer Documentation](https://docs.rs/crate/coreutils/)
+
+Both can also be generated locally, the instructions for that can be found in
+the [coreutils docs](https://github.com/uutils/uutils.github.io) repository.
-Both can also be generated locally, the instructions for that can be found in the
-[coreutils docs](https://github.com/uutils/uutils.github.io) repository.
<!-- ANCHOR: build (this mark is needed for mdbook) -->
+
## Requirements
-* Rust (`cargo`, `rustc`)
-* GNU Make (optional)
+- Rust (`cargo`, `rustc`)
+- GNU Make (optional)
### Rust Version
-uutils follows Rust's release channels and is tested against stable, beta and nightly.
-The current Minimum Supported Rust Version (MSRV) is `1.60.0`.
+uutils follows Rust's release channels and is tested against stable, beta and
+nightly. The current Minimum Supported Rust Version (MSRV) is `1.70.0`.
## Building
-There are currently two methods to build the uutils binaries: either Cargo
-or GNU Make.
+There are currently two methods to build the uutils binaries: either Cargo or
+GNU Make.
> Building the full package, including all documentation, requires both Cargo
> and Gnu Make on a Unix platform.
For either method, we first need to fetch the repository:
-```bash
-$ git clone https://github.com/uutils/coreutils
-$ cd coreutils
+```shell
+git clone https://github.com/uutils/coreutils
+cd coreutils
```
### Cargo
-Building uutils using Cargo is easy because the process is the same as for
-every other Rust program:
+Building uutils using Cargo is easy because the process is the same as for every
+other Rust program:
-```bash
-$ cargo build --release
+```shell
+cargo build --release
```
This command builds the most portable common core set of uutils into a multicall
(BusyBox-type) binary, named 'coreutils', on most Rust-supported platforms.
-Additional platform-specific uutils are often available. Building these
-expanded sets of uutils for a platform (on that platform) is as simple as
-specifying it as a feature:
+Additional platform-specific uutils are often available. Building these expanded
+sets of uutils for a platform (on that platform) is as simple as specifying it
+as a feature:
-```bash
-$ cargo build --release --features macos
+```shell
+cargo build --release --features macos
# or ...
-$ cargo build --release --features windows
+cargo build --release --features windows
# or ...
-$ cargo build --release --features unix
+cargo build --release --features unix
```
If you don't want to build every utility available on your platform into the
-final binary, you can also specify which ones you want to build manually.
-For example:
+final binary, you can also specify which ones you want to build manually. For
+example:
-```bash
-$ cargo build --features "base32 cat echo rm" --no-default-features
+```shell
+cargo build --features "base32 cat echo rm" --no-default-features
```
-If you don't want to build the multicall binary and would prefer to build
-the utilities as individual binaries, that is also possible. Each utility
-is contained in its own package within the main repository, named
-"uu_UTILNAME". To build individual utilities, use cargo to build just the
-specific packages (using the `--package` [aka `-p`] option). For example:
+If you don't want to build the multicall binary and would prefer to build the
+utilities as individual binaries, that is also possible. Each utility is
+contained in its own package within the main repository, named "uu_UTILNAME". To
+build individual utilities, use cargo to build just the specific packages (using
+the `--package` [aka `-p`] option). For example:
-```bash
-$ cargo build -p uu_base32 -p uu_cat -p uu_echo -p uu_rm
+```shell
+cargo build -p uu_base32 -p uu_cat -p uu_echo -p uu_rm
```
### GNU Make
@@ -117,80 +135,88 @@ Building using `make` is a simple process as well.
To simply build all available utilities:
-```bash
-$ make
+```shell
+make
+```
+
+In release mode:
+
+```shell
+make PROFILE=release
```
To build all but a few of the available utilities:
-```bash
-$ make SKIP_UTILS='UTILITY_1 UTILITY_2'
+```shell
+make SKIP_UTILS='UTILITY_1 UTILITY_2'
```
To build only a few of the available utilities:
-```bash
-$ make UTILS='UTILITY_1 UTILITY_2'
+```shell
+make UTILS='UTILITY_1 UTILITY_2'
```
## Installation
-### Cargo
+### Install with Cargo
Likewise, installing can simply be done using:
-```bash
-$ cargo install --path .
+```shell
+cargo install --path . --locked
```
-This command will install uutils into Cargo's *bin* folder (*e.g.* `$HOME/.cargo/bin`).
+This command will install uutils into Cargo's _bin_ folder (_e.g._
+`$HOME/.cargo/bin`).
-This does not install files necessary for shell completion. For shell completion to work,
-use `GNU Make` or see `Manually install shell completions`.
+This does not install files necessary for shell completion or manpages. For
+manpages or shell completion to work, use `GNU Make` or see
+`Manually install shell completions`/`Manually install manpages`.
-### GNU Make
+### Install with GNU Make
To install all available utilities:
-```bash
-$ make install
+```shell
+make install
```
To install using `sudo` switch `-E` must be used:
-```bash
-$ sudo -E make install
+```shell
+sudo -E make install
```
To install all but a few of the available utilities:
-```bash
-$ make SKIP_UTILS='UTILITY_1 UTILITY_2' install
+```shell
+make SKIP_UTILS='UTILITY_1 UTILITY_2' install
```
To install only a few of the available utilities:
-```bash
-$ make UTILS='UTILITY_1 UTILITY_2' install
+```shell
+make UTILS='UTILITY_1 UTILITY_2' install
```
To install every program with a prefix (e.g. uu-echo uu-cat):
-```bash
-$ make PROG_PREFIX=PREFIX_GOES_HERE install
+```shell
+make PROG_PREFIX=PREFIX_GOES_HERE install
```
To install the multicall binary:
-```bash
-$ make MULTICALL=y install
+```shell
+make MULTICALL=y install
```
Set install parent directory (default value is /usr/local):
-```bash
+```shell
# DESTDIR is also supported
-$ make PREFIX=/my/path install
+make PREFIX=/my/path install
```
Installing with `make` installs shell completions for all installed utilities
@@ -199,302 +225,96 @@ be generated; See `Manually install shell completions`.
### Manually install shell completions
-The `coreutils` binary can generate completions for the `bash`, `elvish`, `fish`, `powershell`
-and `zsh` shells. It prints the result to stdout.
+The `coreutils` binary can generate completions for the `bash`, `elvish`,
+`fish`, `powershell` and `zsh` shells. It prints the result to stdout.
The syntax is:
-```bash
+
+```shell
cargo run completion <utility> <shell>
```
-So, to install completions for `ls` on `bash` to `/usr/local/share/bash-completion/completions/ls`,
-run:
+So, to install completions for `ls` on `bash` to
+`/usr/local/share/bash-completion/completions/ls`, run:
-```bash
+```shell
cargo run completion ls bash > /usr/local/share/bash-completion/completions/ls
```
-## Un-installation
-
-Un-installation differs depending on how you have installed uutils. If you used
-Cargo to install, use Cargo to uninstall. If you used GNU Make to install, use
-Make to uninstall.
-
-### Cargo
-
-To uninstall uutils:
-
-```bash
-$ cargo uninstall uutils
-```
-
-### GNU Make
-
-To uninstall all utilities:
-
-```bash
-$ make uninstall
-```
-
-To uninstall every program with a set prefix:
-
-```bash
-$ make PROG_PREFIX=PREFIX_GOES_HERE uninstall
-```
-
-To uninstall the multicall binary:
-
-```bash
-$ make MULTICALL=y uninstall
-```
-
-To uninstall from a custom parent directory:
-
-```bash
-# DESTDIR is also supported
-$ make PREFIX=/my/path uninstall
-```
-<!-- ANCHOR_END: build (this mark is needed for mdbook) -->
-
-## Testing
-
-Testing can be done using either Cargo or `make`.
-
-### Cargo
+### Manually install manpages
-Just like with building, we follow the standard procedure for testing using
-Cargo:
+To generate manpages, the syntax is:
```bash
-$ cargo test
+cargo run manpage <utility>
```
-By default, `cargo test` only runs the common programs. To run also platform
-specific tests, run:
+So, to install the manpage for `ls` to `/usr/local/share/man/man1/ls.1` run:
```bash
-$ cargo test --features unix
+cargo run manpage ls > /usr/local/share/man/man1/ls.1
```
-If you would prefer to test a select few utilities:
-
-```bash
-$ cargo test --features "chmod mv tail" --no-default-features
-```
-
-If you also want to test the core utilities:
-
-```bash
-$ cargo test -p uucore -p coreutils
-```
-
-To debug:
+## Un-installation
-```bash
-$ gdb --args target/debug/coreutils ls
-(gdb) b ls.rs:79
-(gdb) run
-```
+Un-installation differs depending on how you have installed uutils. If you used
+Cargo to install, use Cargo to uninstall. If you used GNU Make to install, use
+Make to uninstall.
-### GNU Make
+### Uninstall with Cargo
-To simply test all available utilities:
+To uninstall uutils:
-```bash
-$ make test
+```shell
+cargo uninstall uutils
```
-To test all but a few of the available utilities:
-
-```bash
-$ make SKIP_UTILS='UTILITY_1 UTILITY_2' test
-```
+### Uninstall with GNU Make
-To test only a few of the available utilities:
+To uninstall all utilities:
-```bash
-$ make UTILS='UTILITY_1 UTILITY_2' test
+```shell
+make uninstall
```
-To include tests for unimplemented behavior:
+To uninstall every program with a set prefix:
-```bash
-$ make UTILS='UTILITY_1 UTILITY_2' SPEC=y test
+```shell
+make PROG_PREFIX=PREFIX_GOES_HERE uninstall
```
-### Run Busybox Tests
-
-This testing functionality is only available on *nix operating systems and
-requires `make`.
-
-To run busybox tests for all utilities for which busybox has tests
+To uninstall the multicall binary:
-```bash
-$ make busytest
+```shell
+make MULTICALL=y uninstall
```
-To run busybox tests for a few of the available utilities
+To uninstall from a custom parent directory:
-```bash
-$ make UTILS='UTILITY_1 UTILITY_2' busytest
+```shell
+# DESTDIR is also supported
+make PREFIX=/my/path uninstall
```
-To pass an argument like "-v" to the busybox test runtime
-
-```bash
-$ make UTILS='UTILITY_1 UTILITY_2' RUNTEST_ARGS='-v' busytest
-```
+<!-- ANCHOR_END: build (this mark is needed for mdbook) -->
-### Comparing with GNU
+## GNU test suite compatibility
Below is the evolution of how many GNU tests uutils passes. A more detailed
breakdown of the GNU test results of the main branch can be found
-[in the user manual](https://uutils.github.io/user/test_coverage.html).
+[in the user manual](https://uutils.github.io/coreutils/docs/test_coverage.html).
-
-
-To run locally:
-
-```bash
-$ bash util/build-gnu.sh
-$ bash util/run-gnu-test.sh
-# To run a single test:
-$ bash util/run-gnu-test.sh tests/touch/not-owner.sh # for example
-# To run several tests:
-$ bash util/run-gnu-test.sh tests/touch/not-owner.sh tests/rm/no-give-up.sh # for example
-# If this is a perl (.pl) test, to run in debug:
-$ DEBUG=1 bash util/run-gnu-test.sh tests/misc/sm3sum.pl
-```
-
-Note that it relies on individual utilities (not the multicall binary).
-
-### Improving the GNU compatibility
-
-The Python script `./util/remaining-gnu-error.py` shows the list of failing tests in the CI.
-
-To improve the GNU compatibility, the following process is recommended:
+See <https://github.com/orgs/uutils/projects/1> for the main meta bugs
+(many are missing).
-1. Identify a test (the smaller, the better) on a program that you understand or is easy to understand. You can use the `./util/remaining-gnu-error.py` script to help with this decision.
-1. Build both the GNU and Rust coreutils using: `bash util/build-gnu.sh`
-1. Run the test with `bash util/run-gnu-test.sh <your test>`
-1. Start to modify `<your test>` to understand what is wrong. Examples:
- 1. Add `set -v` to have the bash verbose mode
- 1. Add `echo $?` where needed
- 1. When the variable `fail` is used in the test, `echo $fail` to see when the test started to fail
- 1. Bump the content of the output (ex: `cat err`)
- 1. ...
-1. Or, if the test is simple, extract the relevant information to create a new test case running both GNU & Rust implementation
-1. Start to modify the Rust implementation to match the expected behavior
-1. Add a test to make sure that we don't regress (our test suite is super quick)
+
+</div> <!-- close oranda-hide div -->
## Contributing
To contribute to uutils, please see [CONTRIBUTING](CONTRIBUTING.md).
-## Utilities
-
-Please note that this is not fully accurate:
-* Some new options can be added / removed in the GNU implementation;
-* Some error management might be missing;
-* Some behaviors might be different.
-
-See https://github.com/uutils/coreutils/issues/3336 for the main meta bugs
-(many are missing).
-
-| Done | WIP |
-|-----------|-----------|
-| arch | cp |
-| base32 | date |
-| base64 | dd |
-| basename | df |
-| basenc | expr |
-| cat | install |
-| chcon | ls |
-| chgrp | more |
-| chmod | numfmt |
-| chown | od (`--strings` and 128-bit data types missing) |
-| chroot | pr |
-| cksum | printf |
-| comm | sort |
-| csplit | split |
-| cut | tac |
-| dircolors | test |
-| dirname | dir |
-| du | vdir |
-| echo | stty |
-| env | |
-| expand | |
-| factor | |
-| false | |
-| fmt | |
-| fold | |
-| groups | |
-| hashsum | |
-| head | |
-| hostid | |
-| hostname | |
-| id | |
-| join | |
-| kill | |
-| link | |
-| ln | |
-| logname | |
-| ~~md5sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/main/src/uu/hashsum/src/hashsum.rs)) | |
-| ~~sha1sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/main/src/uu/hashsum/src/hashsum.rs)) | |
-| ~~sha224sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/main/src/uu/hashsum/src/hashsum.rs)) | |
-| ~~sha256sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/main/src/uu/hashsum/src/hashsum.rs)) | |
-| ~~sha384sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/main/src/uu/hashsum/src/hashsum.rs)) | |
-| ~~sha512sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/main/src/uu/hashsum/src/hashsum.rs)) | |
-| mkdir | |
-| mkfifo | |
-| mknod | |
-| mktemp | |
-| mv | |
-| nice | |
-| nl | |
-| nohup | |
-| nproc | |
-| paste | |
-| pathchk | |
-| pinky | |
-| printenv | |
-| ptx | |
-| pwd | |
-| readlink | |
-| realpath | |
-| relpath | |
-| rm | |
-| rmdir | |
-| runcon | |
-| seq | |
-| shred | |
-| shuf | |
-| sleep | |
-| stat | |
-| stdbuf | |
-| sum | |
-| sync | |
-| tail | |
-| tee | |
-| timeout | |
-| touch | |
-| tr | |
-| true | |
-| truncate | |
-| tsort | |
-| tty | |
-| uname | |
-| unexpand | |
-| uniq | |
-| unlink | |
-| uptime | |
-| users | |
-| wc | |
-| who | |
-| whoami | |
-| yes | |
-
## License
uutils is licensed under the MIT License - see the `LICENSE` file for details
diff --git a/README.target.md b/README.target.md
deleted file mode 100644
index b8190ce3edba89d27e23a89429b5a9d72447772d..0000000000000000000000000000000000000000
--- a/README.target.md
+++ /dev/null
@@ -1,28 +0,0 @@
-# Targets that compile
-
-**Note: this list isn't up to date.**
-
-This is an auto-generated table showing which binaries compile for each target-triple. Note that this **does not** indicate that they are fully implemented, or that the tests pass.
-
-|######OS######|###ARCH####|arch|base32|base64|basename|cat|chgrp|chmod|chown|chroot|cksum|comm|cp|csplit|cut|date|df|dircolors|dirname|du|echo|env|expand|expr|factor|false|fmt|fold|groups|hashsum|head|hostid|hostname|id|install|join|kill|link|ln|logname|ls|mkdir|mkfifo|mknod|mktemp|more|mv|nice|nl|nohup|nproc|numfmt|od|paste|pathchk|pinky|printenv|printf|ptx|pwd|readlink|realpath|relpath|rm|rmdir|seq|shred|shuf|sleep|sort|split|stat|stdbuf|sum|sync|tac|tail|tee|test|timeout|touch|tr|true|truncate|tsort|tty|uname|unexpand|uniq|unlink|uptime|users|wc|who|whoami|yes|chcon|pr|dir|vdir|dd|basenc|runcon|
-|--------------|-----------|----|------|------|--------|---|-----|-----|-----|------|-----|----|--|------|---|----|--|---------|-------|--|----|---|------|----|------|-----|---|----|------|-------|----|------|--------|--|-------|----|----|----|--|-------|--|-----|------|-----|------|----|--|----|--|-----|-----|------|--|-----|-------|-----|--------|------|---|---|--------|--------|-------|--|-----|---|-----|----|-----|----|-----|----|------|---|----|---|----|---|----|-------|-----|--|----|--------|-----|---|-----|--------|----|------|------|-----|--|---|------|---|-----|--|---|----|--|------|------|
-|linux-gnu|aarch64|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y| |y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|
-|linux-gnu|i686|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|
-|linux-gnu|powerpc64|y|y|y|y|y|y|y|y|y|y|y| |y|y|y|y|y|y|y|y|y|y| |y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|
-|linux-gnu|riscv64gc| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
-|linux-gnu|x86_64|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y| |y|y|y|y|y| |y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|
-|windows-msvc|aarch64|y|y|y|y|y| | | | |y|y|y|y|y|y|y|y|y| |y|y|y| |y|y|y|y| |y|y|y|y| | |y| |y|y|y| |y| | |y|y|y| |y| |y|y|y|y| | |y|y|y|y|y|y|y|y|y|y|y|y|y|y|y| | |y|y|y|y|y|y| |y|y|y|y|y| |y|y|y| |y| |y| | |y|y|y|y|y|y|y|y|
-|windows-gnu|i686|y|y|y|y|y| | | | |y|y|y|y|y|y|y|y|y| |y|y|y| |y|y|y|y| |y|y|y|y| | |y| |y|y|y|y|y| | |y|y|y| |y| |y|y|y|y| | |y|y|y|y|y|y|y|y|y|y|y|y|y|y|y| | |y|y|y|y|y|y| |y|y|y|y|y|y|y|y|y| |y| |y| |y|y|y|y|y|y|y|y|y|
-|windows-msvc|i686|y|y|y|y|y| | | | |y|y|y|y|y|y|y|y|y| |y|y|y| |y|y|y|y| |y|y|y|y| | |y| |y|y|y|y|y| | |y|y|y| |y| |y|y|y|y| | |y|y|y|y|y|y|y|y|y|y|y|y|y|y|y| | |y|y|y|y|y|y| |y|y|y|y|y| |y|y|y| |y| |y| |y|y|y|y|y|y|y|y|y|
-|windows-gnu|x86_64|y|y|y|y|y| | | | |y|y|y|y|y|y|y|y|y| |y|y|y| |y|y|y|y| |y|y|y|y| | |y| |y|y|y|y|y| | |y|y|y| |y| |y|y|y|y| | |y|y|y|y|y|y|y|y|y|y|y|y|y|y|y| | |y|y|y|y|y|y| |y|y|y|y|y|y|y|y|y| |y| |y| |y|y|y|y|y|y|y|y|y|
-|windows-msvc|x86_64|y|y|y|y|y| | | | |y|y|y|y|y|y|y|y|y| |y|y|y| |y|y|y|y| |y|y|y|y| | |y| |y|y|y|y|y| | |y|y|y| |y| |y|y|y|y| | |y|y|y|y|y|y|y|y|y|y|y|y|y|y|y| | |y|y|y|y|y|y| |y|y|y|y|y| |y|y|y| |y| |y| |y|y|y|y|y|y|y|y|y|
-|apple MacOS|x86_64|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y| |y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|
-|freebsd|x86_64|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|
-|netbsd|x86_64|y|y|y|y|y|y|y|y| |y|y|y|y|y|y| |y|y|y|y|y|y| |y|y|y|y|y|y|y|y|y| |y|y| |y|y|y|y|y|y|y|y|y|y|y|y| |y|y|y|y|y| |y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y|y| |y|y|y|y|y|y| |y|y|y| | |y| |y|y|y|y|y|y|y|y|y|
-|android|aarch64|y|y|y|y|y|y|y|y| |y|y|y|y|y|y| |y|y|y|y|y|y| |y|y|y|y|y|y|y|y|y| |y|y| |y|y|y|y|y|y|y|y|y|y|y|y| |y|y|y|y|y| |y|y|y|y|y|y|y|y|y|y|y|y|y|y|y| |y|y| |y|y|y|y| |y|y|y|y|y|y| |y|y|y| | |y| |y|y|y|y|y|y|y|y|y|
-|android|x86_64|y|y|y|y|y|y|y|y| |y|y|y|y|y|y| |y|y|y|y|y|y| |y|y|y|y|y|y|y|y|y| |y|y| |y|y|y|y|y|y|y|y|y|y|y|y| |y|y|y|y|y| |y|y|y|y|y|y|y|y|y|y|y|y|y|y|y| |y|y| |y|y|y|y| |y|y|y|y|y|y| |y|y|y| | |y| |y|y|y|y|y|y|y|y|y|
-|solaris|x86_64| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
-|wasi|wasm32| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
-|redox|x86_64| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
-|fuchsia|aarch64| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
-|fuchsia|x86_64| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
diff --git a/build.rs b/build.rs
index 5201b91697f3868362cbb99c554d6fa29a1636f8..bb4e2b53609b136e58692d58e5d6b5e1394feed3 100644
--- a/build.rs
+++ b/build.rs
@@ -1,3 +1,8 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
// spell-checker:ignore (vars) krate
use std::env;
@@ -20,6 +25,8 @@ pub fn main() {
for (key, val) in env::vars() {
if val == "1" && key.starts_with(ENV_FEATURE_PREFIX) {
let krate = key[ENV_FEATURE_PREFIX.len()..].to_lowercase();
+ // Allow this as we have a bunch of info in the comments
+ #[allow(clippy::match_same_arms)]
match krate.as_ref() {
"default" | "macos" | "unix" | "windows" | "selinux" | "zip" => continue, // common/standard feature names
"nightly" | "test_unimplemented" => continue, // crate-local custom features
@@ -36,14 +43,15 @@ pub fn main() {
let mut mf = File::create(Path::new(&out_dir).join("uutils_map.rs")).unwrap();
mf.write_all(
- "type UtilityMap<T> = phf::Map<&'static str, (fn(T) -> i32, fn() -> Command)>;\n\
+ "type UtilityMap<T> = phf::OrderedMap<&'static str, (fn(T) -> i32, fn() -> Command)>;\n\
\n\
+ #[allow(clippy::too_many_lines)]
fn util_map<T: uucore::Args>() -> UtilityMap<T> {\n"
.as_bytes(),
)
.unwrap();
- let mut phf_map = phf_codegen::Map::<&str>::new();
+ let mut phf_map = phf_codegen::OrderedMap::<&str>::new();
for krate in &crates {
let map_value = format!("({krate}::uumain, {krate}::uu_app)");
match krate.as_ref() {
diff --git a/debian/README.Debian b/debian/README.Debian
index c313046b955857a4216fade7b3f88c8b53c19a09..e2abb42bfb19177cea792d7bbb4876455f011397 100644
--- a/debian/README.Debian
+++ b/debian/README.Debian
@@ -53,22 +53,29 @@ Repack
======
cd $TARGET
+# Update the version
+$EDITOR src/coreutils/debian/changelog
rm -rf build/coreutils
./update.sh coreutils # will fail
-git clone git@github.com:uutils/coreutils.git -b 0.0.17 coreutils
+git clone git@github.com:uutils/coreutils.git -b 0.0.27 coreutils
cd <tagged-source-of-coreutils>
cp -R $TARGET/src/coreutils/debian $TARGET/build/coreutils/
cp Cargo.toml $TARGET/build/coreutils/
cp -R src/* $TARGET/build/coreutils/src/
cd $TARGET/build
rm -rf coreutils.orig coreutils/.pc/
-tar Jcvf rust-coreutils_0.0.17.orig.tar.xz coreutils/
+tar Jcvf rust-coreutils_0.0.27.orig.tar.xz coreutils/
dpkg-source -b -i coreutils
+If the patches do not apply, you will have to do
+cd coreutils
+quilt push -f
+and do the rebase dance.
+
For now, we are following upstream version.
If one day, we want to replace GNU/coreutils package with this one,
we will have to follow the version of the GNU version as we have some packages
having an explicit minimal dep (ex: initramfs-tools-core, xinit, initscripts)
- -- Sylvestre Ledru <sylvestre@debian.org>, Tue, 7 Jun 2022 21:11:21 +0200
+ -- Sylvestre Ledru <sylvestre@debian.org>, Sun, 31 Mar 2024 11:03:36 +0200
diff --git a/debian/patches/lower-zip.diff b/debian/RFS
similarity index 100%
rename from debian/patches/lower-zip.diff
rename to debian/RFS
diff --git a/debian/TODO b/debian/TODO
deleted file mode 100644
index a5ec6bceb5768c0469fb2b8b59f55b8c18365c68..0000000000000000000000000000000000000000
--- a/debian/TODO
+++ /dev/null
@@ -1,15 +0,0 @@
-
-textwrap:
-textwrap is too old in debian
-the new version depends on:
-librust-smawk-0.3+default-dev (>= 0.3.1-~~) librust-unicode-linebreak-0.1+default-dev (>= 0.1.2-~~) librust-unicode-width-0.1+default-dev (>= 0.1.9-~~)
-they are in new
-
-time:
-fails to build for now :
-https://github.com/uutils/coreutils/issues/2884
-
-NEW:
-conv, exacl, paste, rlimit and fts-sys
-
-Will need clap 3
diff --git a/debian/apertis/copyright b/debian/apertis/copyright
index 2d7891c0b59405618cdb03bbc6a1a74b6106db39..f01f85d7550a8cd3d82d0963eca3fff6a2c6b2b4 100644
--- a/debian/apertis/copyright
+++ b/debian/apertis/copyright
@@ -2,47 +2,472 @@ Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
Files: *
Copyright: uutils developers
- Jordi Boggiano and many others
-License: Expat or Expat and/or GPL-3+
-
-Files: src/* src/bin/* src/uu/arch/* src/uu/base32/* src/uu/base64/* src/uu/basename/* src/uu/basenc/* src/uu/cat/* src/uu/chgrp/* src/uu/chown/* src/uu/chroot/* src/uu/cksum/* src/uu/comm/* src/uu/cp/* src/uu/cut/* src/uu/date/* src/uu/dd/* src/uu/df/* src/uu/dir/* src/uu/dircolors/* src/uu/dirname/* src/uu/du/* src/uu/echo/* src/uu/env/* src/uu/expand/* src/uu/expr/* src/uu/factor/* src/uu/factor/src/* src/uu/factor/src/numeric/* src/uu/false/* src/uu/fmt/* src/uu/groups/* src/uu/hashsum/* src/uu/hostid/* src/uu/hostname/* src/uu/id/* src/uu/install/* src/uu/join/* src/uu/kill/* src/uu/link/* src/uu/ln/* src/uu/logname/* src/uu/ls/* src/uu/mkdir/* src/uu/mkfifo/* src/uu/mknod/* src/uu/mktemp/* src/uu/more/* src/uu/mv/* src/uu/nl/* src/uu/nohup/* src/uu/nproc/* src/uu/numfmt/* src/uu/od/* src/uu/pathchk/* src/uu/pinky/* src/uu/printenv/* src/uu/ptx/* src/uu/pwd/* src/uu/readlink/* src/uu/realpath/* src/uu/relpath/* src/uu/shred/* src/uu/sort/* src/uu/split/* src/uu/stat/* src/uu/stdbuf/* src/uu/sum/* src/uu/sync/* src/uu/tail/* src/uu/tee/* src/uu/test/* src/uu/touch/* src/uu/true/* src/uu/tsort/* src/uu/tty/* src/uu/uname/* src/uu/unexpand/* src/uu/uniq/* src/uu/unlink/* src/uu/uptime/* src/uu/users/* src/uu/vdir/* src/uu/wc/* src/uu/who/* src/uu/whoami/* src/uu/yes/* src/uucore/src/lib/features/* src/uucore/src/lib/mods/* tests/* tests/fixtures/* tests/fixtures/dd/* tests/fixtures/install/*
-Copyright: 2018-2021 uutils developers
-License: MIT
+License: Expat or GPL-3+
Files: CONTRIBUTING.md
Copyright: assignment is required to contribute.
License: Expat
-Files: README.md
-Copyright: no-info-found
-License: Expat and/or GPL-3+
+Files: Cargo.toml
+ LICENSE
+Copyright: uutils developers
+License: Expat
Files: debian/*
-Copyright: 2020 Debian Rust Maintainers <pkg-rust-maintainers@alioth-lists.debian.net>
- 2020 Sylvestre Ledru <sylvestre@debian.org>
-License: MIT
+Copyright: 2020, Sylvestre Ledru <sylvestre@debian.org>
+ 2020, Debian Rust Maintainers <pkg-rust-maintainers@alioth-lists.debian.net>
+License: Expat
-Files: debian/patches/apertis/Switch-release-builds-back-to-thin-LTO.patch
+Files: debian/patches/apertis/Tweak-release-build-profile.patch
Copyright: generation.
-License: MIT
+License: Expat
-Files: docs/*
+Files: docs/src/index.md
+ docs/src/packaging.md
Copyright: no-info-found
License: Expat
+Files: src/uu/arch/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/base32/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/base64/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/basename/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/basenc/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/cat/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/chcon/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/chgrp/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/chmod/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/chown/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/chroot/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/cksum/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/comm/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/cp/*
+Copyright: uutils developers
+ Joshua S. Miller <jsmiller@uchicago.edu>
+ Jordy Dickinson <jordy.dickinson@gmail.com>
+License: Expat
+
+Files: src/uu/csplit/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/cut/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/date/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/dd/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/df/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/dir/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/dircolors/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/dirname/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/du/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/echo/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/env/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/env/src/split_iterator.rs
+Copyright: no-info-found
+License: Apache-2.0 or Expat~unspecified
+
+Files: src/uu/expand/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/expr/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/factor/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/false/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/fmt/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/fold/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/groups/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/hashsum/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/head/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/hostid/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/hostname/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/id/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/install/*
+Copyright: uutils developers
+ Ben Eills <ben@beneills.com>
+License: Expat
+
+Files: src/uu/join/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/kill/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/link/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/ln/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/logname/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/ls/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/mkdir/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/mkfifo/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/mknod/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/mktemp/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/more/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/mv/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/nice/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/nl/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/nohup/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/nproc/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/numfmt/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/od/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/paste/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/pathchk/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/pinky/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/pr/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/printenv/*
+Copyright: uutils developers
+License: Expat
+
Files: src/uu/printf/*
-Copyright: 2015, uutils project.
+Copyright: uutils developers
+ Nathan Ross
+License: Expat
+
+Files: src/uu/ptx/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/pwd/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/readlink/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/realpath/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/rm/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/rmdir/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/runcon/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/seq/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/shred/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/shuf/*
+Copyright: uutils developers
License: Expat
Files: src/uu/shuf/src/rand_read_adapter.rs
Copyright: 2018, Developers of the Rand project.
2013, The Rust Project Developers.
-License: Apache-2.0 or MIT~unspecified
+License: Apache-2.0 or Expat~unspecified
+
+Files: src/uu/sleep/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/sort/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/split/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/stat/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/stdbuf/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/stty/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/sum/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/sync/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/tac/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/tail/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/tee/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/test/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/timeout/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/touch/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/tr/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/true/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/truncate/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/tsort/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/tty/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/uname/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/unexpand/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/uniq/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/unlink/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/uptime/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/users/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/vdir/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/wc/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/wc/src/utf8/*
+Copyright: Simon Sapin and many others
+License: Expat
+
+Files: src/uu/who/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/whoami/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uu/yes/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uucore/*
+Copyright: uutils developers
+License: Expat
+
+Files: src/uucore_procs/*
+Copyright: Roy Ivy III <rivy.dev@gmail.com>
+License: Expat
+
+Files: src/uuhelp_parser/*
+Copyright: no-info-found
+License: Expat
-Files: util/*
+Files: util/test-repo-whitespace.BAT
Copyright: 2016-2022
License: Expat
-Files: src/uu/base32/src/base_common.rs src/uu/dircolors/src/dircolors.rs src/uu/factor/src/cli.rs src/uu/factor/src/numeric/mod.rs src/uu/factor/src/numeric/montgomery.rs src/uu/factor/src/numeric/traits.rs src/uu/factor/src/rho.rs src/uu/factor/src/table.rs src/uu/sort/src/sort.rs src/uu/tail/src/platform/windows.rs src/uu/tail/src/tail.rs src/uu/test/src/test.rs src/uu/whoami/src/platform/unix.rs src/uucore/src/lib/features/fs.rs src/uucore/src/lib/features/fsext.rs src/uucore/src/lib/features/mode.rs src/uucore/src/lib/features/process.rs src/uucore/src/lib/features/signals.rs src/uucore/src/lib/features/wide.rs tests/by-util/test_factor.rs tests/by-util/test_test.rs tests/fixtures/install/helloworld_linux tests/fixtures/install/helloworld_macos
+Files: tests/fixtures/cksum/raw/sha384_single_file.expected tests/fixtures/dd/gnudd-conv-sync-ibs-1031-obs-521-random.spec tests/fixtures/dd/gnudd-conv-sync-ibs-521-obs-1031-random.spec tests/fixtures/dd/gnudd-random-first-32k.spec tests/fixtures/dd/random-5828891cb1230748e146f34223bbd3b5.test tests/fixtures/install/helloworld_android tests/fixtures/install/helloworld_macos
Copyright: 2018-2021 uutils developers
License: MIT
diff --git a/debian/cargo-checksum.json.debcargo.hint b/debian/cargo-checksum.json.debcargo.hint
index 67689c35e596f0eb96975fdf71f1519d35c8c91c..058da8c28659f5b9cb8a60d430d1f8e29e96cdea 100644
--- a/debian/cargo-checksum.json.debcargo.hint
+++ b/debian/cargo-checksum.json.debcargo.hint
@@ -1 +1 @@
-{"package":"27008aca098d9da9f9c5ac5c0cfb5f18be560195a130abc155456e9df44add5e","files":{}}
+{"package":"413b6ba35a97fd3bb82947f8a9d984a0a5552e09794638201d3c3559e63baebe","files":{}}
diff --git a/debian/changelog b/debian/changelog
index 8430c2b280f37e7cabd830da16c3a9aba717b709..11e1e35de6e0f3a8191f232214ed03e54e5d84d0 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,181 @@
+rust-coreutils (0.0.27-3+apertis1) apertis; urgency=medium
+
+ * Sync from debian/trixie.
+ * Remaining Apertis specific changes:
+ - Add symlinks in /usr/bin/ instead of /usr/lib/cargo/bin/coreutils/
+ - debian/control:
+ + Priority: required
+ + Essential: yes
+ + Provides: coreutils (= 8.24-1), mktemp
+ + Conflicts: coreutils, coreutils-gplv2, mktemp (<< 1.6-4co5)
+ + Replaces: mktemp
+ - debian/rules:
+ + CARGO_PROFILE_RELEASE_DEBUG=true
+ + SKIP_UTILS=stdbuf
+ - Tweak the release build profile for the right balance between the
+ smallest binary size and enough debug info to generate Apertis SBOM.
+
+ -- Dylan Aïssi <dylan.aissi@collabora.com> Mon, 24 Feb 2025 16:51:07 +0100
+
+rust-coreutils (0.0.27-3) unstable; urgency=medium
+
+ [ NoisyCoil ]
+ * Team upload.
+ * Package coreutils 0.0.27 from crates.io using debcargo 2.7.5
+ * Remove unused librust-users-dev build-dependency
+ (Closes: #1089872)
+
+ [ Sylvestre Ledru ]
+ * Update of the description. Thanks to Dylan Aissi
+ * Fix the executable-not-elf-or-script warning
+ * Remove old patches
+
+ -- Sylvestre Ledru <sylvestre@debian.org> Sat, 14 Dec 2024 12:02:20 +0100
+
+rust-coreutils (0.0.27-2) unstable; urgency=medium
+
+ * Team upload.
+ * Update for nix 0.28 (Closes: #1085563)
+ + Drop relax-nix.patch and nix-0.27.patch
+ + Add new patch for nix 0.29
+ * Add patch to support rust-ini 0.18, since newer version is blocked on
+ rust-trim-in-place clearing NEW.
+ * Reduce context in patches to avoid problems applying them after changes
+ in other patches.
+
+ -- Peter Michael Green <plugwash@debian.org> Sun, 03 Nov 2024 17:56:48 +0000
+
+rust-coreutils (0.0.27-1) unstable; urgency=medium
+
+ * New upstream release
+ * Disable factor as num-prime isn't working in Debian yet
+
+ -- Sylvestre Ledru <sylvestre@debian.org> Sun, 03 Nov 2024 00:31:47 +0100
+
+rust-coreutils (0.0.26-5) unstable; urgency=medium
+
+ * Only apply the debug sed if the file exists (Closes: #1082938)
+ * Fix the half dependency (Closes: #1083058) - was fixed in the previous
+ upload but not closed
+
+ -- Sylvestre Ledru <sylvestre@debian.org> Sun, 06 Oct 2024 10:58:56 +0200
+
+rust-coreutils (0.0.26-4) unstable; urgency=medium
+
+ * Team upload.
+ * Stop patching cargo dependenies on half and glob. Update Debian build
+ dependencies accordingly.
+ * Reduce context in relax-itertools.diff, relax-gcd.diff, relax-fundu.diff
+ and relax-hostname.diff to avoid fuzz.
+
+ -- Peter Michael Green <plugwash@debian.org> Thu, 19 Sep 2024 14:50:41 +0000
+
+rust-coreutils (0.0.26-3) unstable; urgency=medium
+
+ * Relax notify dependency to support 6.x
+
+ -- James McCoy <jamessan@debian.org> Tue, 11 Jun 2024 16:29:09 -0400
+
+rust-coreutils (0.0.26-2) unstable; urgency=medium
+
+ * Team upload
+
+ [ Sylvestre Ledru ]
+ * As nix & chrono have been updated, remove the upstream cherry-picked
+ patches
+
+ [ Peter Michael Green ]
+ * Fix build on 32-bit architectures with time64 (Closes: #1071048)
+ + Use mem::zeroed to create timespec structs as they contain padding on
+ time64 architectures.
+ + Build-depend on librust-selinux-sys-dev (>= 0.6.7-2) to pick up time64
+ fix.
+ * Add patch to support nix 0.27 (upstream uses 0.28).
+ * Tighten nix dependency in debian/control, the nix 0.27 patch will need
+ to be removed when debian upgrades to nix 0.28.
+
+ -- Peter Michael Green <plugwash@debian.org> Wed, 15 May 2024 00:16:03 +0000
+
+rust-coreutils (0.0.26-1) unstable; urgency=medium
+
+ * New upstream release
+ (Closes: #1067897, #1069413)
+ Adds support for loongarch (Closes: #1059268)
+ * remove librust-failure-dev, librust-failure-derive-dev unused deps
+ * remove help2man from the build deps (not used)
+
+ -- Sylvestre Ledru <sylvestre@debian.org> Wed, 01 May 2024 14:03:13 +0200
+
+rust-coreutils (0.0.23-3) unstable; urgency=medium
+
+ * Team upload.
+ * Fix Debian dependency for "half" crate.
+
+ -- Peter Michael Green <plugwash@debian.org> Thu, 25 Jan 2024 08:27:35 +0000
+
+rust-coreutils (0.0.23-2) unstable; urgency=medium
+
+ * Team upload.
+ * Relax crossterm dependency.
+
+ -- Peter Michael Green <plugwash@debian.org> Wed, 22 Nov 2023 17:02:31 +0000
+
+rust-coreutils (0.0.23-1) unstable; urgency=medium
+
+ * New upstream release
+ * Fix "Fails to build source after successful build"
+ (closes: #1046006)
+
+ -- Sylvestre Ledru <sylvestre@debian.org> Sat, 18 Nov 2023 12:38:26 +0100
+
+rust-coreutils (0.0.22-1) unstable; urgency=medium
+
+ * New upstream release
+
+ -- Sylvestre Ledru <sylvestre@debian.org> Sun, 15 Oct 2023 22:04:25 +0200
+
+rust-coreutils (0.0.21-1) unstable; urgency=medium
+
+ * New upstream release
+
+ -- Sylvestre Ledru <sylvestre@debian.org> Sun, 03 Sep 2023 18:58:30 +0200
+
+rust-coreutils (0.0.20-1) unstable; urgency=medium
+
+ * New upstream release
+ * librust-self-cell-dev is a new dep
+ * Standards-Version updated 4.6.2
+
+ -- Sylvestre Ledru <sylvestre@debian.org> Sun, 16 Jul 2023 18:34:00 +0200
+
+rust-coreutils (0.0.19-3) unstable; urgency=medium
+
+ * Team upload.
+ * On 32-bit architectures, reduce debuginfo level and use thin lto rather
+ than full lto to avoid issues with running out of address space.
+
+ -- Peter Michael Green <plugwash@debian.org> Sun, 16 Jul 2023 00:20:58 +0000
+
+rust-coreutils (0.0.19-2) unstable; urgency=medium
+
+ * Add missing build dep
+ librust-clap-mangen-dev
+
+ -- Sylvestre Ledru <sylvestre@debian.org> Fri, 14 Jul 2023 17:17:12 +0200
+
+rust-coreutils (0.0.19-1) unstable; urgency=medium
+
+ [ Peter Michael Green ]
+ * Drop empty patch lower-zip.diff
+ * Drop relax-bstr.diff
+ * Build-depend explicitly on version 4 of clap and clap-complete.
+
+ [ Sylvestre Ledru ]
+ * New upstream release
+ * Add override_dh_dwz
+
+ -- Sylvestre Ledru <sylvestre@debian.org> Sat, 10 Jun 2023 14:04:16 +0200
+
rust-coreutils (0.0.17-2+apertis12) apertis; urgency=medium
* Refresh the automatically detected licensing information
@@ -167,7 +345,7 @@ rust-coreutils (0.0.14-4~exp1) experimental; urgency=medium
* Use symlink instead of multiple binaries.
Works the same way but decrease the footprint
- Use changes from apertus:
+ Use changes from apertis:
https://gitlab.apertis.org/pkg/rust-coreutils/-/tree/apertis/v2023dev1/debian
* Be more explicit for some dependencies
* Build selinux binaries
diff --git a/debian/control b/debian/control
index f9b258fd5acea90b5dd9bdcd1da039c46dda3452..f54899dbd374bdaef81a83c2d498d1e97bd49f27 100644
--- a/debian/control
+++ b/debian/control
@@ -7,48 +7,54 @@ Build-Depends: debhelper (>= 12),
cargo:native,
rustc:native,
libstd-rust-dev,
- librust-clap-dev (>= 3.2), librust-clap-complete-dev,
+ librust-clap-4-dev, librust-clap-complete-4-dev,
+ librust-clap-mangen-dev,
librust-backtrace-dev,
- librust-half-1.6+default-dev | librust-half-1.3+default-dev | librust-half-1.2+default-dev | librust-half-1.1+default-dev,
+ librust-half-2+default-dev (>= 2.4),
librust-lazy-static-1+default-dev (>= 1.3-~~),
librust-same-file-1.0.6+default-dev | librust-same-file-1.0.5+default-dev | librust-same-file-1.0.4+default-dev,
librust-textwrap-dev (>= 0.16.0), librust-cc-dev,
librust-quick-error-dev (>= 2.0), librust-unix-socket-dev, librust-getopts-dev,
librust-filetime-dev (>= 0.2.17),
- librust-walkdir-dev (>= 2.3.2), librust-xattr-dev, librust-number-prefix-dev,
- librust-rust-ini-dev (>= 0.18.0), librust-failure-dev, librust-failure-derive-dev,
- librust-glob-dev, librust-chrono-dev, librust-onig-dev (>= 6.3),
+ librust-walkdir-dev (>= 2.3.2), librust-xattr-dev (>= 1.0.0), librust-number-prefix-dev,
+ librust-ansi-width-dev,
+# librust-num-prime-dev,
+ librust-bincode-dev, librust-serde-big-array-dev,
+ librust-rust-ini-dev (>= 0.18.0),
+ librust-glob-dev (>= 0.3.1), librust-chrono-dev (>= 0.4.31), librust-onig-dev (>= 6.3),
librust-blake2-rfc-dev, librust-digest-dev (>= 0.10.5), librust-hex-dev, librust-md5-dev,
librust-sha1-dev (>= 0.10.1), librust-sha2-dev, librust-sha3-dev,
- librust-atty-dev, librust-term-grid-dev, librust-termsize-dev,
- librust-tempfile-dev, librust-nix-dev (>= 0.25.0), librust-fs-extra-dev,
- librust-itertools-dev, librust-bit-set-dev, librust-dunce-dev (>= 1.0.3),
+ librust-atty-dev, librust-uutils-term-grid-dev (>= 0.6.0), librust-termsize-dev,
+ librust-tempfile-dev, librust-nix-0.29-dev, librust-fs-extra-dev,
+ librust-itertools-dev (>= 0.10.5), librust-bit-set-dev, librust-dunce-dev (>= 1.0.3),
librust-data-encoding-dev, librust-platform-info-dev (>= 1.0.2),
librust-num-traits-dev (>= 0.2.14), librust-smallvec-dev (>= 1.9.0),
librust-rand-pcg-dev, librust-thiserror-dev, librust-lazy-static-dev,
librust-byteorder-dev, librust-hostname-dev (>= 0.3.1), librust-cpp-build-dev,
librust-fnv-dev, librust-wild-dev, librust-cpp-dev, librust-thread-local-dev,
- librust-selinux-dev (>= 0.3.0), librust-conv-dev, librust-pretty-assertions-dev (>= 1),
- librust-time-dev (>= 0.3.9), librust-unindent-dev, librust-rlimit-dev (>= 0.8.3),
+ librust-selinux-dev (>= 0.3.0), librust-selinux-sys-dev (>= 0.6.7-2), librust-conv-dev, librust-pretty-assertions-dev (>= 1),
+ librust-time-dev (>= 0.3.9), librust-unindent-dev (>= 0.2.1), librust-rlimit-dev (>= 0.8.3),
librust-data-encoding-macro-dev, librust-dns-lookup-dev, librust-os-display-dev,
librust-z85-dev, librust-fts-sys-dev, librust-exacl-dev, librust-byte-unit-dev,
- librust-gcd-dev, librust-signal-hook-dev, librust-paste-dev, librust-quickcheck-dev,
+ librust-gcd-dev, librust-signal-hook-dev (>= 0.3.15), librust-paste-dev, librust-quickcheck-dev,
librust-crossterm-dev (>= 0.25.0), librust-bigdecimal-dev, librust-binary-heap-plus-dev,
librust-ouroboros-dev, librust-memmap2-dev (>= 0.5), librust-retain-mut-dev (>= 0.1.7),
librust-strum-dev, librust-utf-8-dev, librust-phf-dev, librust-phf-codegen-dev,
- librust-zip-dev, librust-users-dev, librust-blake2b-simd-dev,
- librust-hex-literal-dev, librust-lscolors-0.13-dev, librust-blake3-dev,
- librust-file-diff-dev, librust-ctrlc-dev, librust-flate2-dev,
- librust-bstr-dev, librust-md-5-dev, librust-bytecount-dev (>= 0.6.3),
+ librust-zip-dev, librust-blake2b-simd-dev,
+ librust-hex-literal-dev, librust-lscolors-dev (>= 0.14.0-4), librust-blake3-dev,
+ librust-file-diff-dev, librust-ctrlc-dev (>= 3.4.0), librust-flate2-dev,
+ librust-bstr-dev (>= 1.5.0), librust-md-5-dev, librust-bytecount-dev (>= 0.6.3),
librust-regex-automata-dev, librust-notify-dev,
librust-procfs-dev, librust-terminal-size-dev (>= 0.2.1),
librust-indicatif-dev (>= 0.17.3),
- librust-backtrace-sys-dev, python3-sphinx, help2man
-Build-Conflicts: cargo-web, rustc-web
+ librust-fundu-dev, librust-parse-datetime-dev,
+ librust-is-terminal-dev, librust-sm3-dev, librust-self-cell-dev,
+ librust-uutils-term-grid-dev, librust-rstest-dev,
+ librust-backtrace-sys-dev, python3-sphinx
Maintainer: Debian Rust Maintainers <pkg-rust-maintainers@alioth-lists.debian.net>
Uploaders:
Sylvestre Ledru <sylvestre@debian.org>
-Standards-Version: 4.5.1
+Standards-Version: 4.6.2
Vcs-Git: https://salsa.debian.org/rust-team/debcargo-conf.git [src/coreutils]
Vcs-Browser: https://salsa.debian.org/rust-team/debcargo-conf/tree/master/src/coreutils
Homepage: https://github.com/uutils/coreutils
@@ -85,8 +91,3 @@ Description: Universal coreutils utils, written in Rust
* Might have important bugs,
* Might be slower,
* Output of the binaries might be slightly different.
- .
- It might break your system.
- .
- This is an EXPERIMENTAL package. It should not be used in
- production.
diff --git a/debian/control.debcargo.hint b/debian/control.debcargo.hint
index dd5c7dde667d23ba4aaa58e0d58d939537855b7f..74a533720b76fc5d94b15a71d2abcf71e7a23d77 100644
--- a/debian/control.debcargo.hint
+++ b/debian/control.debcargo.hint
@@ -1,99 +1,100 @@
Source: rust-coreutils
Section: utils
Priority: optional
-Build-Depends: debhelper (>= 12),
- dh-cargo (>= 25),
+Build-Depends: debhelper-compat (= 13),
+ dh-sequence-cargo,
cargo:native,
- rustc:native,
+ rustc:native (>= 1.70.0),
libstd-rust-dev,
- librust-clap-3+cargo-dev (>= 3.1-~~),
- librust-clap-3+default-dev (>= 3.1-~~),
- librust-clap-3+wrap-help-dev (>= 3.1-~~),
- librust-clap-complete-3+default-dev (>= 3.1-~~),
- librust-lazy-static-1+default-dev (>= 1.3-~~),
- librust-phf-0.10+default-dev (>= 0.10.1-~~),
- librust-phf-codegen-0.10+default-dev,
- librust-textwrap-0.15+default-dev,
- librust-textwrap-0.15+terminal-size-dev,
- librust-uu-base32-0.0.14+default-dev,
- librust-uu-base64-0.0.14+default-dev,
- librust-uu-basename-0.0.14+default-dev,
- librust-uu-basenc-0.0.14+default-dev,
- librust-uu-cat-0.0.14+default-dev,
- librust-uu-cksum-0.0.14+default-dev,
- librust-uu-comm-0.0.14+default-dev,
- librust-uu-cp-0.0.14+default-dev,
- librust-uu-csplit-0.0.14+default-dev,
- librust-uu-cut-0.0.14+default-dev,
- librust-uu-date-0.0.14+default-dev,
- librust-uu-dd-0.0.14+default-dev,
- librust-uu-df-0.0.14+default-dev,
- librust-uu-dir-0.0.14+default-dev,
- librust-uu-dircolors-0.0.14+default-dev,
- librust-uu-dirname-0.0.14+default-dev,
- librust-uu-du-0.0.14+default-dev,
- librust-uu-echo-0.0.14+default-dev,
- librust-uu-env-0.0.14+default-dev,
- librust-uu-expand-0.0.14+default-dev,
- librust-uu-expr-0.0.14+default-dev,
- librust-uu-factor-0.0.14+default-dev,
- librust-uu-false-0.0.14+default-dev,
- librust-uu-fmt-0.0.14+default-dev,
- librust-uu-fold-0.0.14+default-dev,
- librust-uu-hashsum-0.0.14+default-dev,
- librust-uu-head-0.0.14+default-dev,
- librust-uu-join-0.0.14+default-dev,
- librust-uu-link-0.0.14+default-dev,
- librust-uu-ln-0.0.14+default-dev,
- librust-uu-ls-0.0.14+default-dev,
- librust-uu-mkdir-0.0.14+default-dev,
- librust-uu-mktemp-0.0.14+default-dev,
- librust-uu-more-0.0.14+default-dev,
- librust-uu-mv-0.0.14+default-dev,
- librust-uu-nl-0.0.14+default-dev,
- librust-uu-numfmt-0.0.14+default-dev,
- librust-uu-od-0.0.14+default-dev,
- librust-uu-paste-0.0.14+default-dev,
- librust-uu-pr-0.0.14+default-dev,
- librust-uu-printenv-0.0.14+default-dev,
- librust-uu-printf-0.0.14+default-dev,
- librust-uu-ptx-0.0.14+default-dev,
- librust-uu-pwd-0.0.14+default-dev,
- librust-uu-readlink-0.0.14+default-dev,
- librust-uu-realpath-0.0.14+default-dev,
- librust-uu-relpath-0.0.14+default-dev,
- librust-uu-rm-0.0.14+default-dev,
- librust-uu-rmdir-0.0.14+default-dev,
- librust-uu-seq-0.0.14+default-dev,
- librust-uu-shred-0.0.14+default-dev,
- librust-uu-shuf-0.0.14+default-dev,
- librust-uu-sleep-0.0.14+default-dev,
- librust-uu-sort-0.0.14+default-dev,
- librust-uu-split-0.0.14+default-dev,
- librust-uu-sum-0.0.14+default-dev,
- librust-uu-tac-0.0.14+default-dev,
- librust-uu-tail-0.0.14+default-dev,
- librust-uu-tee-0.0.14+default-dev,
- librust-uu-test-0.0.14+default-dev,
- librust-uu-touch-0.0.14+default-dev,
- librust-uu-tr-0.0.14+default-dev,
- librust-uu-true-0.0.14+default-dev,
- librust-uu-truncate-0.0.14+default-dev,
- librust-uu-tsort-0.0.14+default-dev,
- librust-uu-unexpand-0.0.14+default-dev,
- librust-uu-uniq-0.0.14+default-dev,
- librust-uu-unlink-0.0.14+default-dev,
- librust-uu-vdir-0.0.14+default-dev,
- librust-uu-wc-0.0.14+default-dev,
- librust-uu-yes-0.0.14+default-dev,
- librust-uucore+default-dev (>= 0.0.11-~~)
+ librust-clap-4+cargo-dev (>= 4.4-~~),
+ librust-clap-4+default-dev (>= 4.4-~~),
+ librust-clap-4+wrap-help-dev (>= 4.4-~~),
+ librust-clap-complete-4+default-dev (>= 4.4-~~),
+ librust-clap-mangen-0.2+default-dev,
+ librust-once-cell-1+default-dev (>= 1.19.0-~~),
+ librust-phf-0.11+default-dev (>= 0.11.2-~~),
+ librust-phf-codegen-0.11+default-dev (>= 0.11.2-~~),
+ librust-textwrap-0.16+default-dev (>= 0.16.1-~~),
+ librust-textwrap-0.16+terminal-size-dev (>= 0.16.1-~~),
+ librust-uu-base32-0.0.27+default-dev,
+ librust-uu-base64-0.0.27+default-dev,
+ librust-uu-basename-0.0.27+default-dev,
+ librust-uu-basenc-0.0.27+default-dev,
+ librust-uu-cat-0.0.27+default-dev,
+ librust-uu-cksum-0.0.27+default-dev,
+ librust-uu-comm-0.0.27+default-dev,
+ librust-uu-cp-0.0.27+default-dev,
+ librust-uu-csplit-0.0.27+default-dev,
+ librust-uu-cut-0.0.27+default-dev,
+ librust-uu-date-0.0.27+default-dev,
+ librust-uu-dd-0.0.27+default-dev,
+ librust-uu-df-0.0.27+default-dev,
+ librust-uu-dir-0.0.27+default-dev,
+ librust-uu-dircolors-0.0.27+default-dev,
+ librust-uu-dirname-0.0.27+default-dev,
+ librust-uu-du-0.0.27+default-dev,
+ librust-uu-echo-0.0.27+default-dev,
+ librust-uu-env-0.0.27+default-dev,
+ librust-uu-expand-0.0.27+default-dev,
+ librust-uu-expr-0.0.27+default-dev,
+ librust-uu-factor-0.0.27+default-dev,
+ librust-uu-false-0.0.27+default-dev,
+ librust-uu-fmt-0.0.27+default-dev,
+ librust-uu-fold-0.0.27+default-dev,
+ librust-uu-hashsum-0.0.27+default-dev,
+ librust-uu-head-0.0.27+default-dev,
+ librust-uu-join-0.0.27+default-dev,
+ librust-uu-link-0.0.27+default-dev,
+ librust-uu-ln-0.0.27+default-dev,
+ librust-uu-ls-0.0.27+default-dev,
+ librust-uu-mkdir-0.0.27+default-dev,
+ librust-uu-mktemp-0.0.27+default-dev,
+ librust-uu-more-0.0.27+default-dev,
+ librust-uu-mv-0.0.27+default-dev,
+ librust-uu-nl-0.0.27+default-dev,
+ librust-uu-numfmt-0.0.27+default-dev,
+ librust-uu-od-0.0.27+default-dev,
+ librust-uu-paste-0.0.27+default-dev,
+ librust-uu-pr-0.0.27+default-dev,
+ librust-uu-printenv-0.0.27+default-dev,
+ librust-uu-printf-0.0.27+default-dev,
+ librust-uu-ptx-0.0.27+default-dev,
+ librust-uu-pwd-0.0.27+default-dev,
+ librust-uu-readlink-0.0.27+default-dev,
+ librust-uu-realpath-0.0.27+default-dev,
+ librust-uu-rm-0.0.27+default-dev,
+ librust-uu-rmdir-0.0.27+default-dev,
+ librust-uu-seq-0.0.27+default-dev,
+ librust-uu-shred-0.0.27+default-dev,
+ librust-uu-shuf-0.0.27+default-dev,
+ librust-uu-sleep-0.0.27+default-dev,
+ librust-uu-sort-0.0.27+default-dev,
+ librust-uu-split-0.0.27+default-dev,
+ librust-uu-sum-0.0.27+default-dev,
+ librust-uu-tac-0.0.27+default-dev,
+ librust-uu-tail-0.0.27+default-dev,
+ librust-uu-tee-0.0.27+default-dev,
+ librust-uu-test-0.0.27+default-dev,
+ librust-uu-touch-0.0.27+default-dev,
+ librust-uu-tr-0.0.27+default-dev,
+ librust-uu-true-0.0.27+default-dev,
+ librust-uu-truncate-0.0.27+default-dev,
+ librust-uu-tsort-0.0.27+default-dev,
+ librust-uu-unexpand-0.0.27+default-dev,
+ librust-uu-uniq-0.0.27+default-dev,
+ librust-uu-unlink-0.0.27+default-dev,
+ librust-uu-vdir-0.0.27+default-dev,
+ librust-uu-wc-0.0.27+default-dev,
+ librust-uu-yes-0.0.27+default-dev,
+ librust-uucore+default-dev (>= 0.0.19-~~)
Maintainer: Debian Rust Maintainers <pkg-rust-maintainers@alioth-lists.debian.net>
Uploaders:
Sylvestre Ledru <sylvestre@debian.org>
-Standards-Version: 4.5.1
+Standards-Version: 4.7.0
Vcs-Git: https://salsa.debian.org/rust-team/debcargo-conf.git [src/coreutils]
Vcs-Browser: https://salsa.debian.org/rust-team/debcargo-conf/tree/master/src/coreutils
Homepage: https://github.com/uutils/coreutils
+X-Cargo-Crate: coreutils
Rules-Requires-Root: no
Package: coreutils
@@ -110,7 +111,7 @@ Suggests:
Provides:
${cargo:Provides}
Built-Using: ${cargo:Built-Using}
-XB-X-Cargo-Built-Using: ${cargo:X-Cargo-Built-Using}
+Static-Built-Using: ${cargo:Static-Built-Using}
Description: Coreutils ~ GNU coreutils (updated); implemented as universal (cross-platform) utils, written in Rust
This package contains the following binaries built from the Rust crate
"coreutils":
diff --git a/debian/copyright.debcargo.hint b/debian/copyright.debcargo.hint
index 351314f4fe953e3a14e5dd871ecbb063e37e1534..d328318ceaeb86e004912a607937aaff6ca0e004 100644
--- a/debian/copyright.debcargo.hint
+++ b/debian/copyright.debcargo.hint
@@ -12,14 +12,7 @@ Comment:
be correct information so you should review and fix this before uploading to
the archive.
-Files: ./tests/fixtures/dircolors/internal.expected
-Copyright: 1996-2016 Free Software Foundation, Inc.
-License: UNKNOWN-LICENSE; FIXME (overlay)
-Comment:
- FIXME (overlay): These notices are extracted from files. Please review them
- before uploading to the archive.
-
-Files: ./util/test-repo-whitespace.BAT
+Files: util/test-repo-whitespace.BAT
Copyright: 2016-2022 ~ Roy Ivy III <rivy.dev@gmail.com>
License: UNKNOWN-LICENSE; FIXME (overlay)
Comment:
@@ -28,8 +21,8 @@ Comment:
Files: debian/*
Copyright:
- 2021-2022 Debian Rust Maintainers <pkg-rust-maintainers@alioth-lists.debian.net>
- 2021-2022 Sylvestre Ledru <sylvestre@debian.org>
+ 2021-2024 Debian Rust Maintainers <pkg-rust-maintainers@alioth-lists.debian.net>
+ 2021-2024 Sylvestre Ledru <sylvestre@debian.org>
License: MIT
License: MIT
diff --git a/debian/not-installed b/debian/not-installed
deleted file mode 100644
index d2d9c160561743834aa4ad579015eaec9cb9c894..0000000000000000000000000000000000000000
--- a/debian/not-installed
+++ /dev/null
@@ -1,7 +0,0 @@
-usr/local/share/bash-completion/*
-usr/local/share/fish/*
-usr/local/share/zsh/*
-
-# Don 't install symlinks created by upstream makefile
-# That leads to issues with merged-usr and no-merged-usr env
-usr/local/bin/*
diff --git a/debian/patches/add_path.diff b/debian/patches/add_path.diff
deleted file mode 100644
index fe02133e3b510db6eb61bbff6ef307e9e0a400ed..0000000000000000000000000000000000000000
--- a/debian/patches/add_path.diff
+++ /dev/null
@@ -1,647 +0,0 @@
-Index: coreutils/Cargo.toml
-===================================================================
---- coreutils.orig/Cargo.toml
-+++ coreutils/Cargo.toml
-@@ -44,61 +44,73 @@ required-features = ["uudoc"]
- version = "0.0.17"
- optional = true
- package = "uu_arch"
-+path = "src/uu/arch"
-
- [dependencies.base32]
- version = "0.0.17"
- optional = true
- package = "uu_base32"
-+path = "src/uu/base32"
-
- [dependencies.base64]
- version = "0.0.17"
- optional = true
- package = "uu_base64"
-+path = "src/uu/base64"
-
- [dependencies.basename]
- version = "0.0.17"
- optional = true
- package = "uu_basename"
-+path = "src/uu/basename"
-
- [dependencies.basenc]
- version = "0.0.17"
- optional = true
- package = "uu_basenc"
-+path = "src/uu/basenc"
-
- [dependencies.cat]
- version = "0.0.17"
- optional = true
- package = "uu_cat"
-+path = "src/uu/cat"
-
- [dependencies.chcon]
- version = "0.0.17"
- optional = true
- package = "uu_chcon"
-+path = "src/uu/chcon"
-
- [dependencies.chgrp]
- version = "0.0.17"
- optional = true
- package = "uu_chgrp"
-+path = "src/uu/chgrp"
-
- [dependencies.chmod]
- version = "0.0.17"
- optional = true
- package = "uu_chmod"
-+path = "src/uu/chmod"
-
- [dependencies.chown]
- version = "0.0.17"
- optional = true
- package = "uu_chown"
-+path = "src/uu/chown"
-
- [dependencies.chroot]
- version = "0.0.17"
- optional = true
- package = "uu_chroot"
-+path = "src/uu/chroot"
-
- [dependencies.cksum]
- version = "0.0.17"
- optional = true
- package = "uu_cksum"
-+path = "src/uu/cksum"
-
- [dependencies.clap]
- version = "4.0"
-@@ -114,221 +126,265 @@ version = "4.0"
- version = "0.0.17"
- optional = true
- package = "uu_comm"
-+path = "src/uu/comm"
-
- [dependencies.cp]
- version = "0.0.17"
- optional = true
- package = "uu_cp"
-+path = "src/uu/cp"
-
- [dependencies.csplit]
- version = "0.0.17"
- optional = true
- package = "uu_csplit"
-+path = "src/uu/csplit"
-
- [dependencies.cut]
- version = "0.0.17"
- optional = true
- package = "uu_cut"
-+path = "src/uu/cut"
-
- [dependencies.date]
- version = "0.0.17"
- optional = true
- package = "uu_date"
-+path = "src/uu/date"
-
- [dependencies.dd]
- version = "0.0.17"
- optional = true
- package = "uu_dd"
-+path = "src/uu/dd"
-
- [dependencies.df]
- version = "0.0.17"
- optional = true
- package = "uu_df"
-+path = "src/uu/df"
-
- [dependencies.dir]
- version = "0.0.17"
- optional = true
- package = "uu_dir"
-+path = "src/uu/dir"
-
- [dependencies.dircolors]
- version = "0.0.17"
- optional = true
- package = "uu_dircolors"
-+path = "src/uu/dircolors"
-
- [dependencies.dirname]
- version = "0.0.17"
- optional = true
- package = "uu_dirname"
-+path = "src/uu/dirname"
-
- [dependencies.du]
- version = "0.0.17"
- optional = true
- package = "uu_du"
-+path = "src/uu/du"
-
- [dependencies.echo]
- version = "0.0.17"
- optional = true
- package = "uu_echo"
-+path = "src/uu/echo"
-
- [dependencies.env]
- version = "0.0.17"
- optional = true
- package = "uu_env"
-+path = "src/uu/env"
-
- [dependencies.expand]
- version = "0.0.17"
- optional = true
- package = "uu_expand"
-+path = "src/uu/expand"
-
- [dependencies.expr]
- version = "0.0.17"
- optional = true
- package = "uu_expr"
-+path = "src/uu/expr"
-
- [dependencies.factor]
- version = "0.0.17"
- optional = true
- package = "uu_factor"
-+path = "src/uu/factor"
-
- [dependencies.false]
- version = "0.0.17"
- optional = true
- package = "uu_false"
-+path = "src/uu/false"
-
- [dependencies.fmt]
- version = "0.0.17"
- optional = true
- package = "uu_fmt"
-+path = "src/uu/fmt"
-
- [dependencies.fold]
- version = "0.0.17"
- optional = true
- package = "uu_fold"
-+path = "src/uu/fold"
-
- [dependencies.groups]
- version = "0.0.17"
- optional = true
- package = "uu_groups"
-+path = "src/uu/groups"
-
- [dependencies.hashsum]
- version = "0.0.17"
- optional = true
- package = "uu_hashsum"
-+path = "src/uu/hashsum"
-
- [dependencies.head]
- version = "0.0.17"
- optional = true
- package = "uu_head"
-+path = "src/uu/head"
-
- [dependencies.hostid]
- version = "0.0.17"
- optional = true
- package = "uu_hostid"
-+path = "src/uu/hostid"
-
- [dependencies.hostname]
- version = "0.0.17"
- optional = true
- package = "uu_hostname"
-+path = "src/uu/hostname"
-
- [dependencies.id]
- version = "0.0.17"
- optional = true
- package = "uu_id"
-+path = "src/uu/id"
-
- [dependencies.install]
- version = "0.0.17"
- optional = true
- package = "uu_install"
-+path = "src/uu/install"
-
- [dependencies.join]
- version = "0.0.17"
- optional = true
- package = "uu_join"
-+path = "src/uu/join"
-
- [dependencies.kill]
- version = "0.0.17"
- optional = true
- package = "uu_kill"
-+path = "src/uu/kill"
-
- [dependencies.link]
- version = "0.0.17"
- optional = true
- package = "uu_link"
-+path = "src/uu/link"
-
- [dependencies.ln]
- version = "0.0.17"
- optional = true
- package = "uu_ln"
-+path = "src/uu/ln"
-
- [dependencies.logname]
- version = "0.0.17"
- optional = true
- package = "uu_logname"
-+path = "src/uu/logname"
-
- [dependencies.ls]
- version = "0.0.17"
- optional = true
- package = "uu_ls"
-+path = "src/uu/ls"
-
- [dependencies.mkdir]
- version = "0.0.17"
- optional = true
- package = "uu_mkdir"
-+path = "src/uu/mkdir"
-
- [dependencies.mkfifo]
- version = "0.0.17"
- optional = true
- package = "uu_mkfifo"
-+path = "src/uu/mkfifo"
-
- [dependencies.mknod]
- version = "0.0.17"
- optional = true
- package = "uu_mknod"
-+path = "src/uu/mknod"
-
- [dependencies.mktemp]
- version = "0.0.17"
- optional = true
- package = "uu_mktemp"
-+path = "src/uu/mktemp"
-
- [dependencies.more]
- version = "0.0.17"
- optional = true
- package = "uu_more"
-+path = "src/uu/more"
-
- [dependencies.mv]
- version = "0.0.17"
- optional = true
- package = "uu_mv"
-+path = "src/uu/mv"
-
- [dependencies.nice]
- version = "0.0.17"
- optional = true
- package = "uu_nice"
-+path = "src/uu/nice"
-
- [dependencies.nl]
- version = "0.0.17"
- optional = true
- package = "uu_nl"
-+path = "src/uu/nl"
-
- [dependencies.nohup]
- version = "0.0.17"
- optional = true
- package = "uu_nohup"
-+path = "src/uu/nohup"
-
- [dependencies.nproc]
- version = "0.0.17"
- optional = true
- package = "uu_nproc"
-+path = "src/uu/nproc"
-
- [dependencies.numfmt]
- version = "0.0.17"
- optional = true
- package = "uu_numfmt"
-+path = "src/uu/numfmt"
-
- [dependencies.od]
- version = "0.0.17"
- optional = true
- package = "uu_od"
-+path = "src/uu/od"
-
- [dependencies.once_cell]
- version = "1"
-@@ -337,11 +393,13 @@ version = "1"
- version = "0.0.17"
- optional = true
- package = "uu_paste"
-+path = "src/uu/paste"
-
- [dependencies.pathchk]
- version = "0.0.17"
- optional = true
- package = "uu_pathchk"
-+path = "src/uu/pathchk"
-
- [dependencies.phf]
- version = "0.11.1"
-@@ -350,61 +408,73 @@ version = "0.11.1"
- version = "0.0.17"
- optional = true
- package = "uu_pinky"
-+path = "src/uu/pinky"
-
- [dependencies.pr]
- version = "0.0.17"
- optional = true
- package = "uu_pr"
-+path = "src/uu/pr"
-
- [dependencies.printenv]
- version = "0.0.17"
- optional = true
- package = "uu_printenv"
-+path = "src/uu/printenv"
-
- [dependencies.printf]
- version = "0.0.17"
- optional = true
- package = "uu_printf"
-+path = "src/uu/printf"
-
- [dependencies.ptx]
- version = "0.0.17"
- optional = true
- package = "uu_ptx"
-+path = "src/uu/ptx"
-
- [dependencies.pwd]
- version = "0.0.17"
- optional = true
- package = "uu_pwd"
-+path = "src/uu/pwd"
-
- [dependencies.readlink]
- version = "0.0.17"
- optional = true
- package = "uu_readlink"
-+path = "src/uu/readlink"
-
- [dependencies.realpath]
- version = "0.0.17"
- optional = true
- package = "uu_realpath"
-+path = "src/uu/realpath"
-
- [dependencies.relpath]
- version = "0.0.17"
- optional = true
- package = "uu_relpath"
-+path = "src/uu/relpath"
-
- [dependencies.rm]
- version = "0.0.17"
- optional = true
- package = "uu_rm"
-+path = "src/uu/rm"
-
- [dependencies.rmdir]
- version = "0.0.17"
- optional = true
- package = "uu_rmdir"
-+path = "src/uu/rmdir"
-
- [dependencies.runcon]
- version = "0.0.17"
- optional = true
- package = "uu_runcon"
-+path = "src/uu/runcon"
-
- [dependencies.selinux]
- version = "0.3"
-@@ -414,71 +484,85 @@ optional = true
- version = "0.0.17"
- optional = true
- package = "uu_seq"
-+path = "src/uu/seq"
-
- [dependencies.shred]
- version = "0.0.17"
- optional = true
- package = "uu_shred"
-+path = "src/uu/shred"
-
- [dependencies.shuf]
- version = "0.0.17"
- optional = true
- package = "uu_shuf"
-+path = "src/uu/shuf"
-
- [dependencies.sleep]
- version = "0.0.17"
- optional = true
- package = "uu_sleep"
-+path = "src/uu/sleep"
-
- [dependencies.sort]
- version = "0.0.17"
- optional = true
- package = "uu_sort"
-+path = "src/uu/sort"
-
- [dependencies.split]
- version = "0.0.17"
- optional = true
- package = "uu_split"
-+path = "src/uu/split"
-
- [dependencies.stat]
- version = "0.0.17"
- optional = true
- package = "uu_stat"
-+path = "src/uu/stat"
-
- [dependencies.stdbuf]
- version = "0.0.17"
- optional = true
- package = "uu_stdbuf"
-+path = "src/uu/stdbuf"
-
- [dependencies.stty]
- version = "0.0.17"
- optional = true
- package = "uu_stty"
-+path = "src/uu/stty"
-
- [dependencies.sum]
- version = "0.0.17"
- optional = true
- package = "uu_sum"
-+path = "src/uu/sum"
-
- [dependencies.sync]
- version = "0.0.17"
- optional = true
- package = "uu_sync"
-+path = "src/uu/sync"
-
- [dependencies.tac]
- version = "0.0.17"
- optional = true
- package = "uu_tac"
-+path = "src/uu/tac"
-
- [dependencies.tail]
- version = "0.0.17"
- optional = true
- package = "uu_tail"
-+path = "src/uu/tail"
-
- [dependencies.tee]
- version = "0.0.17"
- optional = true
- package = "uu_tee"
-+path = "src/uu/tee"
-
- [dependencies.textwrap]
- version = "0.16.0"
-@@ -488,100 +572,120 @@ features = ["terminal_size"]
- version = "0.0.17"
- optional = true
- package = "uu_timeout"
-+path = "src/uu/timeout"
-
- [dependencies.touch]
- version = "0.0.17"
- optional = true
- package = "uu_touch"
-+path = "src/uu/touch"
-
- [dependencies.tr]
- version = "0.0.17"
- optional = true
- package = "uu_tr"
-+path = "src/uu/tr"
-
- [dependencies.true]
- version = "0.0.17"
- optional = true
- package = "uu_true"
-+path = "src/uu/true"
-
- [dependencies.truncate]
- version = "0.0.17"
- optional = true
- package = "uu_truncate"
-+path = "src/uu/truncate"
-
- [dependencies.tsort]
- version = "0.0.17"
- optional = true
- package = "uu_tsort"
-+path = "src/uu/tsort"
-
- [dependencies.tty]
- version = "0.0.17"
- optional = true
- package = "uu_tty"
-+path = "src/uu/tty"
-
- [dependencies.uname]
- version = "0.0.17"
- optional = true
- package = "uu_uname"
-+path = "src/uu/uname"
-
- [dependencies.unexpand]
- version = "0.0.17"
- optional = true
- package = "uu_unexpand"
-+path = "src/uu/unexpand"
-
- [dependencies.uniq]
- version = "0.0.17"
- optional = true
- package = "uu_uniq"
-+path = "src/uu/uniq"
-
- [dependencies.unlink]
- version = "0.0.17"
- optional = true
- package = "uu_unlink"
-+path = "src/uu/unlink"
-
- [dependencies.uptime]
- version = "0.0.17"
- optional = true
- package = "uu_uptime"
-+path = "src/uu/uptime"
-
- [dependencies.users]
- version = "0"
- optional = true
- package = "uu_users"
-+path = "src/uu/users"
-
- [dependencies.uu_test]
- version = "0.0.17"
- optional = true
- package = "uu_test"
-+path = "src/uu/test"
-
- [dependencies.uucore]
- version = ">=0.0.17"
- package = "uucore"
-+path = "src/uucore"
-
- [dependencies.vdir]
- version = "0.0.17"
- optional = true
- package = "uu_vdir"
-+path = "src/uu/vdir"
-
- [dependencies.wc]
- version = "0.0.17"
- optional = true
- package = "uu_wc"
-+path = "src/uu/wc"
-
- [dependencies.who]
- version = "0.0.17"
- optional = true
- package = "uu_who"
-+path = "src/uu/who"
-
- [dependencies.whoami]
- version = "0.0.17"
- optional = true
- package = "uu_whoami"
-+path = "src/uu/whoami"
-
- [dependencies.yes]
- version = "0.0.17"
- optional = true
- package = "uu_yes"
-+path = "src/uu/yes"
-
- [dependencies.zip]
- version = "0"
-@@ -649,6 +753,7 @@ features = [
- "process",
- ]
- package = "uucore"
-+path = "src/uucore"
-
- [dev-dependencies.walkdir]
- version = "2.2"
diff --git a/debian/patches/apertis/HACK-cp-mv-add-dummy-missing-arguments.patch b/debian/patches/apertis/HACK-Add-dummy-missing-argument-to-cp-mv.patch
similarity index 94%
rename from debian/patches/apertis/HACK-cp-mv-add-dummy-missing-arguments.patch
rename to debian/patches/apertis/HACK-Add-dummy-missing-argument-to-cp-mv.patch
index 94dd301500ac50fc19ddaa060dab6d67a287ce5c..720d240048f5cf864e9bef8e6bad1c6338abde54 100644
--- a/debian/patches/apertis/HACK-cp-mv-add-dummy-missing-arguments.patch
+++ b/debian/patches/apertis/HACK-Add-dummy-missing-argument-to-cp-mv.patch
@@ -20,7 +20,7 @@ Bug: https://github.com/uutils/coreutils/issues/2404
--- a/src/uu/cp/src/cp.rs
+++ b/src/uu/cp/src/cp.rs
-@@ -242,6 +242,7 @@
+@@ -362,6 +362,7 @@
pub const ATTRIBUTES_ONLY: &str = "attributes-only";
pub const CLI_SYMBOLIC_LINKS: &str = "cli-symbolic-links";
pub const CONTEXT: &str = "context";
@@ -28,7 +28,7 @@ Bug: https://github.com/uutils/coreutils/issues/2404
pub const COPY_CONTENTS: &str = "copy-contents";
pub const DEREFERENCE: &str = "dereference";
pub const FORCE: &str = "force";
-@@ -540,6 +541,15 @@
+@@ -658,6 +659,15 @@
.help(
"NotImplemented: set SELinux security context of destination file to \
default type",
@@ -46,15 +46,15 @@ Bug: https://github.com/uutils/coreutils/issues/2404
// END TODO
--- a/src/uu/mv/src/mv.rs
+++ b/src/uu/mv/src/mv.rs
-@@ -68,6 +68,7 @@
+@@ -107,6 +107,7 @@
+ static OPT_TARGET_DIRECTORY: &str = "target-directory";
static OPT_NO_TARGET_DIRECTORY: &str = "no-target-directory";
- static OPT_UPDATE: &str = "update";
static OPT_VERBOSE: &str = "verbose";
+static OPT_CONTEXT: &str = "context";
static OPT_PROGRESS: &str = "progress";
static ARG_FILES: &str = "files";
-@@ -221,6 +222,18 @@
+@@ -256,6 +257,18 @@
.value_parser(ValueParser::os_string())
.value_hint(clap::ValueHint::AnyPath),
)
diff --git a/debian/patches/apertis/Add-hack-for-missing-argument-to-mkdir.patch b/debian/patches/apertis/HACK-Add-dummy-missing-argument-to-mkdir.patch
similarity index 83%
rename from debian/patches/apertis/Add-hack-for-missing-argument-to-mkdir.patch
rename to debian/patches/apertis/HACK-Add-dummy-missing-argument-to-mkdir.patch
index feb3169b86101f39d56af9cf2804bdaee432ff9d..0060ddf750619b73a0436613b93e96881ac943b6 100644
--- a/debian/patches/apertis/Add-hack-for-missing-argument-to-mkdir.patch
+++ b/debian/patches/apertis/HACK-Add-dummy-missing-argument-to-mkdir.patch
@@ -6,23 +6,25 @@ Following the same approach that in cp and mv apply a patch to avoid
raising errors on the unsupported -Z option.
Signed-off-by: Walter Lozano <walter.lozano@collabora.com>
+
+Forwarded: not-needed
+Bug: https://github.com/uutils/coreutils/issues/5682
+
---
src/uu/mkdir/src/mkdir.rs | 10 ++++++++++
1 file changed, 10 insertions(+)
-diff --git a/src/uu/mkdir/src/mkdir.rs b/src/uu/mkdir/src/mkdir.rs
-index 038d688..aea3237 100644
--- a/src/uu/mkdir/src/mkdir.rs
+++ b/src/uu/mkdir/src/mkdir.rs
-@@ -30,6 +30,7 @@ mod options {
+@@ -29,6 +29,7 @@
pub const PARENTS: &str = "parents";
pub const VERBOSE: &str = "verbose";
pub const DIRS: &str = "dirs";
+ pub const CONTEXT_DEFAULT: &str = "context-default";
}
- fn get_long_usage() -> &'static str {
-@@ -141,6 +142,15 @@ pub fn uu_app() -> Command {
+ #[cfg(windows)]
+@@ -130,6 +131,15 @@
.value_parser(ValueParser::os_string())
.value_hint(clap::ValueHint::DirPath),
)
diff --git a/debian/patches/apertis/Switch-release-builds-back-to-thin-LTO.patch b/debian/patches/apertis/Switch-release-builds-back-to-thin-LTO.patch
deleted file mode 100644
index 3f660ebd5e7c161de77c1568153f35bb03d45ae0..0000000000000000000000000000000000000000
--- a/debian/patches/apertis/Switch-release-builds-back-to-thin-LTO.patch
+++ /dev/null
@@ -1,29 +0,0 @@
-From: Ryan Gonzalez <ryan.gonzalez@collabora.com>
-Date: Tue, 17 Sep 2024 16:39:27 -0500
-Subject: Switch release builds back to thin LTO
-
-Using full LTO results in the loss of individual crate compilation unit
-names in the debuginfo, which interferes with our copyright generation.
-Rust's default behavior is *already* thin LTO, which only takes up 1MiB
-of extra space but avoids this issue.
-
-(This seems to work on newer Rust releases and thus either specific to
-the Debian package or fixed in rustc/LLVM, so it might be worth re-
-evaluating the situation once the version in Debian is updated.)
-
-Signed-off-by: Ryan Gonzalez <ryan.gonzalez@collabora.com>
----
- Cargo.toml | 1 -
- 1 file changed, 1 deletion(-)
-
-diff --git a/Cargo.toml b/Cargo.toml
-index 88a712a..c99ca67 100644
---- a/Cargo.toml
-+++ b/Cargo.toml
-@@ -428,6 +428,5 @@ path = "src/bin/uudoc.rs"
- required-features = ["uudoc"]
-
- [profile.release]
--lto = true
- opt-level = "z"
- panic = "abort"
diff --git a/debian/patches/apertis/Tweak-release-build-profile.patch b/debian/patches/apertis/Tweak-release-build-profile.patch
new file mode 100644
index 0000000000000000000000000000000000000000..3a3b6fb9de807e6f6a38c6c8d524aa1bf5594c3a
--- /dev/null
+++ b/debian/patches/apertis/Tweak-release-build-profile.patch
@@ -0,0 +1,33 @@
+Description: Tweak the release build profile for the right balance between
+ the smallest binary size and enough debug info to generate Apertis SBOM.
+
+ - Use opt-level = "z": to optimize for size.
+ - Make the panic handler simply abort() rather then unwinding and
+ printing a backtrace.
+ - Using full LTO results in the loss of individual crate compilation unit
+ names in the debuginfo, which interferes with our copyright generation.
+ Rust's default behavior is *already* thin LTO, which only takes up 1MiB
+ of extra space but avoids this issue.
+ (This seems to work on newer Rust releases and thus either specific to
+ the Debian package or fixed in rustc/LLVM, so it might be worth re-
+ evaluating the situation once the version in Debian is updated.)
+
+Signed-off-by: Detlev Casanova <detlev.casanova@collabora.com>
+Signed-off-by: Ryan Gonzalez <ryan.gonzalez@collabora.com>
+Signed-off-by: Dylan Aïssi <dylan.aissi@collabora.com>
+
+Forwarded: not-needed
+
+--- a/Cargo.toml
++++ b/Cargo.toml
+@@ -536,7 +536,9 @@
+ # sacrificing debug info. With this profile (like in the standard
+ # release profile), the debug info and the stack traces will still be available.
+ [profile.release]
+-lto = true
++lto = "thin"
++opt-level = "z"
++panic = "abort"
+
+ # A release-like profile that is tuned to be fast, even when being fast
+ # compromises on binary size. This includes aborting on panic.
diff --git a/debian/patches/apertis/size-optimize.patch b/debian/patches/apertis/size-optimize.patch
deleted file mode 100644
index 500b3aa95cc5ad57df5320eb7d6d442fc54cab4a..0000000000000000000000000000000000000000
--- a/debian/patches/apertis/size-optimize.patch
+++ /dev/null
@@ -1,18 +0,0 @@
-Description: Use by default flags to optimize the binary size:
- - Add "lto": whole binary link time optimisation.
- - Use opt-level = "z": to optimize for size.
- - Make the panic handler simply abort() rather then unwinding and
- printing a backtrace.
-Origin: upstream, https://github.com/uutils/coreutils/commit/0c4f586
-
---- a/Cargo.toml
-+++ b/Cargo.toml
-@@ -426,3 +426,8 @@
- name = "uudoc"
- path = "src/bin/uudoc.rs"
- required-features = ["uudoc"]
-+
-+[profile.release]
-+lto = true
-+opt-level = "z"
-+panic = "abort"
diff --git a/debian/patches/apertis/tsort-Switch-to-BTreeHash-and-BTreeSet.patch b/debian/patches/apertis/tsort-Switch-to-BTreeHash-and-BTreeSet.patch
deleted file mode 100644
index 323a5190b63fb2f5dac46197b755f0814f677b8e..0000000000000000000000000000000000000000
--- a/debian/patches/apertis/tsort-Switch-to-BTreeHash-and-BTreeSet.patch
+++ /dev/null
@@ -1,51 +0,0 @@
-From: Detlev Casanova <detlev.casanova@collabora.com>
-Date: Fri, 2 Jun 2023 14:42:47 -0400
-Subject: tsort: Switch to BTreeHash and BTreeSet
-
-Using HashMap and HashSet give a valid topological sort, but the output
-will change randomly at each run.
-
-BTree based structures will guarantee that the output is always ordered
-in the same way.
-
-This also makes the ouptut similar to the output of the C version of the
-tools, on which some applications rely.
-
-Forwarded: https://github.com/uutils/coreutils/pull/4931
----
- src/uu/tsort/src/tsort.rs | 8 ++++----
- 1 file changed, 4 insertions(+), 4 deletions(-)
-
-diff --git a/src/uu/tsort/src/tsort.rs b/src/uu/tsort/src/tsort.rs
-index 1ef8537..a0c149f 100644
---- a/src/uu/tsort/src/tsort.rs
-+++ b/src/uu/tsort/src/tsort.rs
-@@ -6,7 +6,7 @@
- // * For the full copyright and license information, please view the LICENSE
- // * file that was distributed with this source code.
- use clap::{crate_version, Arg, Command};
--use std::collections::{HashMap, HashSet};
-+use std::collections::{BTreeMap, BTreeSet};
- use std::fs::File;
- use std::io::{stdin, BufRead, BufReader, Read};
- use std::path::Path;
-@@ -105,8 +105,8 @@ pub fn uu_app() -> Command {
- // but using integer may improve performance.
- #[derive(Default)]
- struct Graph {
-- in_edges: HashMap<String, HashSet<String>>,
-- out_edges: HashMap<String, Vec<String>>,
-+ in_edges: BTreeMap<String, BTreeSet<String>>,
-+ out_edges: BTreeMap<String, Vec<String>>,
- result: Vec<String>,
- }
-
-@@ -124,7 +124,7 @@ impl Graph {
- }
-
- fn init_node(&mut self, n: &str) {
-- self.in_edges.insert(n.to_string(), HashSet::new());
-+ self.in_edges.insert(n.to_string(), BTreeSet::new());
- self.out_edges.insert(n.to_string(), vec![]);
- }
-
diff --git a/debian/patches/bump-crossterm.diff b/debian/patches/bump-crossterm.diff
index dfca97e96000988943d3599e2655f2acede10808..55358a60323d98a05413b38421292e67b7db2732 100644
--- a/debian/patches/bump-crossterm.diff
+++ b/debian/patches/bump-crossterm.diff
@@ -1,13 +1,13 @@
-Index: coreutils/src/uu/more/Cargo.toml
+Index: coreutils/Cargo.toml
===================================================================
---- coreutils.orig/src/uu/more/Cargo.toml
-+++ coreutils/src/uu/more/Cargo.toml
-@@ -17,7 +17,7 @@ path = "src/more.rs"
- [dependencies]
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
--crossterm = ">=0.19"
-+crossterm = "0.25"
- atty = "0.2"
- unicode-width = "0.1.7"
- unicode-segmentation = "1"
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -274,7 +274,7 @@ clap_complete = "4.4"
+ clap_mangen = "0.2"
+ compare = "0.1.0"
+ coz = { version = "0.1.3" }
+-crossterm = ">=0.27.0"
++crossterm = ">=0.25"
+ ctrlc = { version = "3.4.4", features = ["termination"] }
+ exacl = "0"
+ file_diff = "1.0.0"
diff --git a/debian/patches/bump-exacl.diff b/debian/patches/bump-exacl.diff
index 3871459f6e62ede80e50acecbc49ab9a02faa33c..8fa811785025d89e88627837430e5735c51d9502 100644
--- a/debian/patches/bump-exacl.diff
+++ b/debian/patches/bump-exacl.diff
@@ -1,13 +1,13 @@
-Index: coreutils/src/uu/cp/Cargo.toml
+Index: coreutils/Cargo.toml
===================================================================
---- coreutils.orig/src/uu/cp/Cargo.toml
-+++ coreutils/src/uu/cp/Cargo.toml
-@@ -30,7 +30,7 @@ indicatif = "0.17"
-
- [target.'cfg(unix)'.dependencies]
- xattr="0.2.3"
--exacl= { version = "0.9.0", optional=true }
-+exacl= { version = "0", optional=true }
-
- [[bin]]
- name = "cp"
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -276,7 +276,7 @@ compare = "0.1.0"
+ coz = { version = "0.1.3" }
+ crossterm = ">=0.27.0"
+ ctrlc = { version = "3.4.4", features = ["termination"] }
+-exacl = "0.12.0"
++exacl = "0"
+ file_diff = "1.0.0"
+ filetime = "0.2.23"
+ fnv = "1.0.7"
diff --git a/debian/patches/delegate-ln-to-dh.diff b/debian/patches/delegate-ln-to-dh.diff
index ffeb50fdcc3aa3ac04fbcfd17ca9ad7b51c56b2c..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644
--- a/debian/patches/delegate-ln-to-dh.diff
+++ b/debian/patches/delegate-ln-to-dh.diff
@@ -1,17 +0,0 @@
-Index: coreutils/GNUmakefile
-===================================================================
---- coreutils.orig/GNUmakefile
-+++ coreutils/GNUmakefile
-@@ -338,9 +338,9 @@ install: build
- mkdir -p $(INSTALLDIR_BIN)
- ifeq (${MULTICALL}, y)
- $(INSTALL) $(BUILDDIR)/coreutils $(INSTALLDIR_BIN)/$(PROG_PREFIX)coreutils
-- cd $(INSTALLDIR_BIN) && $(foreach prog, $(filter-out coreutils, $(INSTALLEES)), \
-- ln -fs $(PROG_PREFIX)coreutils $(PROG_PREFIX)$(prog) &&) :
-- $(if $(findstring test,$(INSTALLEES)), cd $(INSTALLDIR_BIN) && ln -fs $(PROG_PREFIX)coreutils $(PROG_PREFIX)[)
-+# cd $(INSTALLDIR_BIN) && $(foreach prog, $(filter-out coreutils, $(INSTALLEES)), \
-+# ln -fs $(PROG_PREFIX)coreutils $(PROG_PREFIX)$(prog) &&) :
-+# $(if $(findstring test,$(INSTALLEES)), cd $(INSTALLDIR_BIN) && ln -fs $(PROG_PREFIX)coreutils $(PROG_PREFIX)[)
- else
- $(foreach prog, $(INSTALLEES), \
- $(INSTALL) $(BUILDDIR)/$(prog) $(INSTALLDIR_BIN)/$(PROG_PREFIX)$(prog);)
diff --git a/debian/patches/disable-coz.diff b/debian/patches/disable-coz.diff
index 45a9188e42a282e9378bc989eb54a40da5cbdfdb..f8d7660a2f01feb97d0a6898c83438f2a192ff17 100644
--- a/debian/patches/disable-coz.diff
+++ b/debian/patches/disable-coz.diff
@@ -2,12 +2,12 @@ Index: coreutils/src/uu/factor/Cargo.toml
===================================================================
--- coreutils.orig/src/uu/factor/Cargo.toml
+++ coreutils/src/uu/factor/Cargo.toml
-@@ -16,7 +16,7 @@ num-traits = "0.2.15" # used in src/nume
+@@ -16,7 +16,7 @@ num-traits = { workspace = true } # used
[dependencies]
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
--coz = { version = "0.1.3", optional = true }
-+#coz = { version = "0.1.3", optional = true }
- num-traits = "0.2.15" # Needs at least version 0.2.15 for "OverflowingAdd"
- rand = { version = "0.8", features = ["small_rng"] }
- smallvec = { version = "1.10", features = ["union"] }
+ clap = { workspace = true }
+-coz = { workspace = true, optional = true }
++#coz = { workspace = true, optional = true }
+ num-traits = { workspace = true }
+ rand = { workspace = true }
+ smallvec = { workspace = true }
diff --git a/debian/patches/disable-factor.diff b/debian/patches/disable-factor.diff
new file mode 100644
index 0000000000000000000000000000000000000000..530c67b09282d8139e655f51fc3759eb1c751b69
--- /dev/null
+++ b/debian/patches/disable-factor.diff
@@ -0,0 +1,72 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -76,7 +76,7 @@ feat_common_core = [
+ "env",
+ "expand",
+ "expr",
+- "factor",
++## "factor",
+ "false",
+ "fmt",
+ "fold",
+@@ -300,7 +300,7 @@ nix = { version = "0", default-features
+ nom = "7"
+ notify = ">= 5, < 7"
+ num-bigint = "0.4"
+-num-prime = "0.4.3"
++#num-prime = "0.4.3"
+ num-traits = "0.2"
+ number_prefix = "0.4"
+ once_cell = "1"
+@@ -396,7 +396,7 @@ echo = { optional = true, version = "0.0
+ env = { optional = true, version = "0.0.27", package = "uu_env", path = "src/uu/env" }
+ expand = { optional = true, version = "0.0.27", package = "uu_expand", path = "src/uu/expand" }
+ expr = { optional = true, version = "0.0.27", package = "uu_expr", path = "src/uu/expr" }
+-factor = { optional = true, version = "0.0.27", package = "uu_factor", path = "src/uu/factor" }
++#factor = { optional = true, version = "0.0.27", package = "uu_factor", path = "src/uu/factor" }
+ false = { optional = true, version = "0.0.27", package = "uu_false", path = "src/uu/false" }
+ fmt = { optional = true, version = "0.0.27", package = "uu_fmt", path = "src/uu/fmt" }
+ fold = { optional = true, version = "0.0.27", package = "uu_fold", path = "src/uu/fold" }
+@@ -484,7 +484,7 @@ chrono = { workspace = true }
+ filetime = { workspace = true }
+ glob = { workspace = true }
+ libc = { workspace = true }
+-num-prime = { workspace = true }
++#num-prime = { workspace = true }
+ pretty_assertions = "1.4.0"
+ rand = { workspace = true }
+ regex = { workspace = true }
+Index: coreutils/GNUmakefile
+===================================================================
+--- coreutils.orig/GNUmakefile
++++ coreutils/GNUmakefile
+@@ -76,7 +76,6 @@ PROGS := \
+ env \
+ expand \
+ expr \
+- factor \
+ false \
+ fmt \
+ fold \
+@@ -194,7 +193,6 @@ TEST_PROGS := \
+ echo \
+ env \
+ expr \
+- factor \
+ false \
+ fold \
+ hashsum \
+Index: coreutils/src/uu/ls/src/ls.rs
+===================================================================
+--- coreutils.orig/src/uu/ls/src/ls.rs
++++ coreutils/src/uu/ls/src/ls.rs
+@@ -15,7 +15,6 @@ use lscolors::{LsColors, Style};
+ use ansi_width::ansi_width;
+ use std::{cell::OnceCell, num::IntErrorKind};
+ use std::{collections::HashSet, io::IsTerminal};
+-use ansi_width::ansi_width;
+
+ #[cfg(windows)]
+ use std::os::windows::fs::MetadataExt;
diff --git a/debian/patches/disable-windows.diff b/debian/patches/disable-windows.diff
index e31d63f6c4fd149839bc7116ecbabb43c18bd069..bb5119fe0486b1a418e66307a05228e38283ad95 100644
--- a/debian/patches/disable-windows.diff
+++ b/debian/patches/disable-windows.diff
@@ -2,148 +2,191 @@ Index: coreutils/src/uu/date/Cargo.toml
===================================================================
--- coreutils.orig/src/uu/date/Cargo.toml
+++ coreutils/src/uu/date/Cargo.toml
-@@ -22,8 +22,8 @@ uucore = { version=">=0.0.17", package="
+@@ -24,12 +24,6 @@ parse_datetime = { workspace = true }
[target.'cfg(unix)'.dependencies]
- libc = "0.2"
+ libc = { workspace = true }
-[target.'cfg(windows)'.dependencies]
--windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_Foundation", "Win32_System_SystemInformation"] }
-+#[target.'cfg(windows)'.dependencies]
-+#windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_Foundation", "Win32_System_SystemInformation"] }
-
+-windows-sys = { workspace = true, features = [
+- "Win32_Foundation",
+- "Win32_System_SystemInformation",
+-] }
+-
[[bin]]
name = "date"
+ path = "src/main.rs"
Index: coreutils/src/uu/du/Cargo.toml
===================================================================
--- coreutils.orig/src/uu/du/Cargo.toml
+++ coreutils/src/uu/du/Cargo.toml
-@@ -21,8 +21,8 @@ glob = "0.3.0"
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+@@ -21,12 +21,6 @@ glob = { workspace = true }
+ clap = { workspace = true }
+ uucore = { workspace = true, features = ["format"] }
-[target.'cfg(target_os = "windows")'.dependencies]
--windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_Storage_FileSystem", "Win32_Foundation"] }
-+#[target.'cfg(target_os = "windows")'.dependencies]
-+#windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_Storage_FileSystem", "Win32_Foundation"] }
-
+-windows-sys = { workspace = true, features = [
+- "Win32_Storage_FileSystem",
+- "Win32_Foundation",
+-] }
+-
[[bin]]
name = "du"
+ path = "src/main.rs"
Index: coreutils/src/uu/hostname/Cargo.toml
===================================================================
--- coreutils.orig/src/uu/hostname/Cargo.toml
+++ coreutils/src/uu/hostname/Cargo.toml
-@@ -19,8 +19,8 @@ clap = { version = "4.0", features = ["w
- hostname = { version = "0.3", features = ["set"] }
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["wide"] }
+@@ -19,12 +19,6 @@ clap = { workspace = true }
+ hostname = { workspace = true, features = ["set"] }
+ uucore = { workspace = true, features = ["wide"] }
-[target.'cfg(target_os = "windows")'.dependencies]
--windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_Networking_WinSock", "Win32_Foundation"] }
-+#[target.'cfg(target_os = "windows")'.dependencies]
-+#windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_Networking_WinSock", "Win32_Foundation"] }
-
+-windows-sys = { workspace = true, features = [
+- "Win32_Networking_WinSock",
+- "Win32_Foundation",
+-] }
+-
[[bin]]
name = "hostname"
+ path = "src/main.rs"
Index: coreutils/src/uu/rm/Cargo.toml
===================================================================
--- coreutils.orig/src/uu/rm/Cargo.toml
+++ coreutils/src/uu/rm/Cargo.toml
-@@ -23,8 +23,8 @@ uucore = { version=">=0.0.17", package="
+@@ -22,9 +22,6 @@ uucore = { workspace = true, features =
[target.'cfg(unix)'.dependencies]
- libc = "0.2.137"
+ libc = { workspace = true }
-[target.'cfg(windows)'.dependencies]
--windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_Storage_FileSystem"] }
-+#[target.'cfg(windows)'.dependencies]
-+#windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_Storage_FileSystem"] }
-
+-windows-sys = { workspace = true, features = ["Win32_Storage_FileSystem"] }
+-
[[bin]]
name = "rm"
+ path = "src/main.rs"
Index: coreutils/src/uu/sync/Cargo.toml
===================================================================
--- coreutils.orig/src/uu/sync/Cargo.toml
+++ coreutils/src/uu/sync/Cargo.toml
-@@ -22,8 +22,8 @@ uucore = { version=">=0.0.17", package="
+@@ -22,13 +22,6 @@ uucore = { workspace = true, features =
[target.'cfg(any(target_os = "linux", target_os = "android"))'.dependencies]
- nix = "0"
+ nix = { workspace = true }
-[target.'cfg(target_os = "windows")'.dependencies]
--windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_Storage_FileSystem", "Win32_System_WindowsProgramming", "Win32_Foundation"] }
-+# [target.'cfg(target_os = "windows")'.dependencies]
-+# windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_Storage_FileSystem", "Win32_System_WindowsProgramming", "Win32_Foundation"] }
-
+-windows-sys = { workspace = true, features = [
+- "Win32_Storage_FileSystem",
+- "Win32_System_WindowsProgramming",
+- "Win32_Foundation",
+-] }
+-
[[bin]]
name = "sync"
+ path = "src/main.rs"
Index: coreutils/src/uu/tail/Cargo.toml
===================================================================
--- coreutils.orig/src/uu/tail/Cargo.toml
+++ coreutils/src/uu/tail/Cargo.toml
-@@ -24,9 +24,9 @@ uucore = { version=">=0.0.17", package="
- same-file = "1.0.6"
- atty = "0.2"
+@@ -24,12 +24,12 @@ uucore = { workspace = true }
+ same-file = { workspace = true }
+ fundu = { workspace = true }
-[target.'cfg(windows)'.dependencies]
--windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_System_Threading", "Win32_Foundation"] }
--winapi-util = { version="0.1.5" }
-+# [target.'cfg(windows)'.dependencies]
-+# windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_System_Threading", "Win32_Foundation"] }
-+# winapi-util = { version="0.1.5" }
-
- [target.'cfg(unix)'.dependencies]
- nix = { version = "0", features = ["fs"] }
+-windows-sys = { workspace = true, features = [
+- "Win32_System_Threading",
+- "Win32_Foundation",
+-] }
+-winapi-util = { workspace = true }
++#[target.'cfg(windows)'.dependencies]
++#windows-sys = { workspace = true, features = [
++# "Win32_System_Threading",
++# "Win32_Foundation",
++#] }
++#winapi-util = { workspace = true }
+
+ [dev-dependencies]
+ rstest = { workspace = true }
Index: coreutils/src/uu/touch/Cargo.toml
===================================================================
--- coreutils.orig/src/uu/touch/Cargo.toml
+++ coreutils/src/uu/touch/Cargo.toml
-@@ -20,8 +20,8 @@ clap = { version = "4.0", features = ["w
- time = { version = "0.3", features = ["parsing", "formatting", "local-offset", "macros"] }
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["libc"] }
+@@ -22,12 +22,6 @@ chrono = { workspace = true }
+ parse_datetime = { workspace = true }
+ uucore = { workspace = true, features = ["libc"] }
-[target.'cfg(target_os = "windows")'.dependencies]
--windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_Storage_FileSystem", "Win32_Foundation"] }
-+# [target.'cfg(target_os = "windows")'.dependencies]
-+# windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_Storage_FileSystem", "Win32_Foundation"] }
-
+-windows-sys = { workspace = true, features = [
+- "Win32_Storage_FileSystem",
+- "Win32_Foundation",
+-] }
+-
[[bin]]
name = "touch"
+ path = "src/main.rs"
Index: coreutils/src/uu/whoami/Cargo.toml
===================================================================
--- coreutils.orig/src/uu/whoami/Cargo.toml
+++ coreutils/src/uu/whoami/Cargo.toml
-@@ -18,8 +18,8 @@ path = "src/whoami.rs"
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["entries"] }
+@@ -18,13 +18,6 @@ path = "src/whoami.rs"
+ clap = { workspace = true }
+ uucore = { workspace = true, features = ["entries", "process"] }
-[target.'cfg(target_os = "windows")'.dependencies]
--windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_NetworkManagement_NetManagement", "Win32_System_WindowsProgramming", "Win32_Foundation"] }
-+# [target.'cfg(target_os = "windows")'.dependencies]
-+# windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_NetworkManagement_NetManagement", "Win32_System_WindowsProgramming", "Win32_Foundation"] }
-
+-windows-sys = { workspace = true, features = [
+- "Win32_NetworkManagement_NetManagement",
+- "Win32_System_WindowsProgramming",
+- "Win32_Foundation",
+-] }
+-
[target.'cfg(unix)'.dependencies]
- libc = "0.2.137"
+ libc = { workspace = true }
+
Index: coreutils/src/uucore/Cargo.toml
===================================================================
--- coreutils.orig/src/uucore/Cargo.toml
+++ coreutils/src/uucore/Cargo.toml
-@@ -44,17 +44,17 @@ nix = { version = "0", default-features
- clap = "4.0"
- once_cell = "1"
+@@ -63,13 +63,13 @@ clap = { workspace = true }
+ once_cell = { workspace = true }
+ tempfile = { workspace = true }
-[target.'cfg(target_os = "windows")'.dependencies]
--winapi-util = { version= "0.1.5", optional=true }
--windows-sys = { version = "0.42.0", optional = true, default-features = false, features = ["Win32_Storage_FileSystem", "Win32_Foundation", "Win32_System_WindowsProgramming"] }
+-winapi-util = { workspace = true, optional = true }
+-windows-sys = { workspace = true, optional = true, default-features = false, features = [
+- "Win32_Storage_FileSystem",
+- "Win32_Foundation",
+- "Win32_System_WindowsProgramming",
+-] }
+# [target.'cfg(target_os = "windows")'.dependencies]
-+# winapi-util = { version= "0.1.5", optional=true }
-+# windows-sys = { version = "0.42.0", optional = true, default-features = false, features = ["Win32_Storage_FileSystem", "Win32_Foundation", "Win32_System_WindowsProgramming"] }
++# winapi-util = { workspace = true, optional = true }
++# windows-sys = { workspace = true, optional = true, default-features = false, features = [
++# "Win32_Storage_FileSystem",
++# "Win32_Foundation",
++# "Win32_System_WindowsProgramming",
++# ] }
[features]
default = []
- # * non-default features
+@@ -79,8 +79,8 @@ colors = []
+ checksum = ["regex", "sum"]
encoding = ["data-encoding", "data-encoding-macro", "z85", "thiserror"]
entries = ["libc"]
--fs = ["libc", "winapi-util", "windows-sys"]
--fsext = ["libc", "time", "windows-sys"]
-+fs = ["libc"]
-+fsext = ["libc", "time"]
+-fs = ["dunce", "libc", "winapi-util", "windows-sys"]
+-fsext = ["libc", "windows-sys"]
++fs = ["dunce", "libc"]#, "winapi-util", "windows-sys"]
++fsext = ["libc"]#, "windows-sys"]
+ fsxattr = ["xattr"]
lines = []
- memo = ["itertools"]
- mode = ["libc"]
+ format = ["itertools", "quoting-style"]
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -331,8 +331,8 @@ unicode-segmentation = "1"
+ unicode-width = "0.1.12"
+ utf-8 = "0.7.6"
+ walkdir = "2.5"
+-winapi-util = "0.1.8"
+-windows-sys = { version = "0.48.0", default-features = false }
++#winapi-util = "0.1.8"
++#windows-sys = { version = "0.48.0", default-features = false }
+ xattr = "1.3.1"
+ zip = { version = "1.1.4", default-features = false, features = ["deflate"] }
+
diff --git a/debian/patches/fix-completion-path.diff b/debian/patches/fix-completion-path.diff
index 9dd222f944905ddd784759103d4fb707e9abda5f..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644
--- a/debian/patches/fix-completion-path.diff
+++ b/debian/patches/fix-completion-path.diff
@@ -1,31 +0,0 @@
-Index: coreutils/GNUmakefile
-===================================================================
---- coreutils.orig/GNUmakefile
-+++ coreutils/GNUmakefile
-@@ -346,13 +346,13 @@ else
- $(INSTALL) $(BUILDDIR)/$(prog) $(INSTALLDIR_BIN)/$(PROG_PREFIX)$(prog);)
- $(if $(findstring test,$(INSTALLEES)), $(INSTALL) $(BUILDDIR)/test $(INSTALLDIR_BIN)/$(PROG_PREFIX)[)
- endif
-- mkdir -p $(DESTDIR)$(DATAROOTDIR)/zsh/site-functions
-+ mkdir -p $(DESTDIR)$(DATAROOTDIR)/zsh/site-functions/rust-coreutils/
- mkdir -p $(DESTDIR)$(DATAROOTDIR)/bash-completion/completions
-- mkdir -p $(DESTDIR)$(DATAROOTDIR)/fish/vendor_completions.d
-+ mkdir -p $(DESTDIR)$(DATAROOTDIR)/fish/completions/
- $(foreach prog, $(INSTALLEES), \
-- $(BUILDDIR)/coreutils completion $(prog) zsh > $(DESTDIR)$(DATAROOTDIR)/zsh/site-functions/_$(PROG_PREFIX)$(prog); \
-- $(BUILDDIR)/coreutils completion $(prog) bash > $(DESTDIR)$(DATAROOTDIR)/bash-completion/completions/$(PROG_PREFIX)$(prog); \
-- $(BUILDDIR)/coreutils completion $(prog) fish > $(DESTDIR)$(DATAROOTDIR)/fish/vendor_completions.d/$(PROG_PREFIX)$(prog).fish; \
-+ $(BUILDDIR)/coreutils completion $(prog) zsh > $(DESTDIR)$(DATAROOTDIR)/zsh/site-functions/rust-coreutils/$(PROG_PREFIX)$(prog); \
-+ $(BUILDDIR)/coreutils completion $(prog) bash > $(DESTDIR)$(DATAROOTDIR)/bash-completion/completions/rust-$(PROG_PREFIX)$(prog); \
-+ $(BUILDDIR)/coreutils completion $(prog) fish > $(DESTDIR)$(DATAROOTDIR)/fish/completions/rust-$(PROG_PREFIX)$(prog).fish; \
- )
-
- uninstall:
-@@ -363,6 +363,6 @@ endif
- rm -f $(INSTALLDIR_BIN)/$(PROG_PREFIX)[
- rm -f $(addprefix $(DESTDIR)$(DATAROOTDIR)/zsh/site-functions/_$(PROG_PREFIX),$(PROGS))
- rm -f $(addprefix $(DESTDIR)$(DATAROOTDIR)/bash-completion/completions/$(PROG_PREFIX),$(PROGS))
-- rm -f $(addprefix $(DESTDIR)$(DATAROOTDIR)/fish/vendor_completions.d/$(PROG_PREFIX),$(addsuffix .fish,$(PROGS)))
-+ rm -f $(addprefix $(DESTDIR)$(DATAROOTDIR)/fish/completions/$(PROG_PREFIX),$(addsuffix .fish,$(PROGS)))
-
- .PHONY: all build build-coreutils build-pkgs test distclean clean busytest install uninstall
diff --git a/debian/patches/fix-hashsum.diff b/debian/patches/fix-hashsum.diff
index 1b5bac611bb96f1642d937e12817b3b2149e5d81..9cd686ce1914be6d30f0c6e17e4302aa8a03c853 100644
--- a/debian/patches/fix-hashsum.diff
+++ b/debian/patches/fix-hashsum.diff
@@ -1,24 +1,17 @@
-Index: coreutils/src/uu/hashsum/Cargo.toml
+Index: coreutils/Cargo.toml
===================================================================
---- coreutils.orig/src/uu/hashsum/Cargo.toml
-+++ coreutils/src/uu/hashsum/Cargo.toml
-@@ -15,15 +15,15 @@ edition = "2021"
- path = "src/hashsum.rs"
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -338,9 +338,9 @@ zip = { version = "1.1.4", default-featu
- [dependencies]
--digest = "0.10.6"
-+digest = "0.10"
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
hex = "0.4.3"
- memchr = "2"
md-5 = "0.10"
- regex = "1"
--sha1 = "0.10.1"
--sha2 = "0.10.2"
--sha3 = "0.10.6"
+-sha1 = "0.10.6"
+-sha2 = "0.10.8"
+-sha3 = "0.10.8"
+sha1 = "0.10"
+sha2 = "0.10"
+sha3 = "0.10"
- blake2b_simd = "1.0.0"
- blake3 = "1.3.1"
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+ blake2b_simd = "1.0.2"
+ blake3 = "1.5.1"
+ sm3 = "0.4.2"
diff --git a/debian/patches/fix-install-path.diff b/debian/patches/fix-install-path.diff
index 9f25308a27ba058a402c6e5f4aab57ae72055017..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644
--- a/debian/patches/fix-install-path.diff
+++ b/debian/patches/fix-install-path.diff
@@ -1,13 +0,0 @@
-Index: coreutils/GNUmakefile
-===================================================================
---- coreutils.orig/GNUmakefile
-+++ coreutils/GNUmakefile
-@@ -20,7 +20,7 @@ CARGO ?= cargo
- CARGOFLAGS ?=
-
- # Install directories
--PREFIX ?= /usr/local
-+PREFIX ?= /usr/
- DESTDIR ?=
- BINDIR ?= $(PREFIX)/bin
- DATAROOTDIR ?= $(PREFIX)/share
diff --git a/debian/patches/fix-prefix.diff b/debian/patches/fix-prefix.diff
new file mode 100644
index 0000000000000000000000000000000000000000..63c165e265abf21d4cf777261eecde8c530f9e49
--- /dev/null
+++ b/debian/patches/fix-prefix.diff
@@ -0,0 +1,22 @@
+Index: coreutils/GNUmakefile
+===================================================================
+--- coreutils.orig/GNUmakefile
++++ coreutils/GNUmakefile
+@@ -20,7 +20,7 @@ CARGO ?= cargo
+ CARGOFLAGS ?=
+
+ # Install directories
+-PREFIX ?= /usr/local
++PREFIX ?= /usr
+ DESTDIR ?=
+ BINDIR ?= $(PREFIX)/bin
+ DATAROOTDIR ?= $(PREFIX)/share
+@@ -28,7 +28,7 @@ DATAROOTDIR ?= $(PREFIX)/share
+ INSTALLDIR_BIN=$(DESTDIR)$(BINDIR)
+
+ #prefix to apply to coreutils binary and all tool binaries
+-PROG_PREFIX ?=
++PROG_PREFIX ?= rust-
+
+ # This won't support any directory with spaces in its name, but you can just
+ # make a symlink without spaces that points to the directory.
diff --git a/debian/patches/lower-half.diff b/debian/patches/lower-half.diff
deleted file mode 100644
index 1a6f23d9f5dad6ee23a9882b580be7e25db343f2..0000000000000000000000000000000000000000
--- a/debian/patches/lower-half.diff
+++ /dev/null
@@ -1,13 +0,0 @@
-Index: coreutils/src/uu/od/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/od/Cargo.toml
-+++ coreutils/src/uu/od/Cargo.toml
-@@ -17,7 +17,7 @@ path = "src/od.rs"
- [dependencies]
- byteorder = "1.3.2"
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
--half = "2.1"
-+half = "1.6"
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
-
- [[bin]]
diff --git a/debian/patches/lower-memmap2.diff b/debian/patches/lower-memmap2.diff
new file mode 100644
index 0000000000000000000000000000000000000000..7a8f4533c53133c75900b28da9dd01abcc8c2374
--- /dev/null
+++ b/debian/patches/lower-memmap2.diff
@@ -0,0 +1,7 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -297,1 +297,1 @@
+-memmap2 = "0.9.4"
++memmap2 = "0"
diff --git a/debian/patches/lower-onig.diff b/debian/patches/lower-onig.diff
index 967e587337b4282da0edc4d8d4d4d38d07301df4..ae0381e8e344169ca0fa2c21a7644342280999d1 100644
--- a/debian/patches/lower-onig.diff
+++ b/debian/patches/lower-onig.diff
@@ -1,13 +1,13 @@
-Index: coreutils/src/uu/expr/Cargo.toml
+Index: coreutils/Cargo.toml
===================================================================
---- coreutils.orig/src/uu/expr/Cargo.toml
-+++ coreutils/src/uu/expr/Cargo.toml
-@@ -18,7 +18,7 @@ path = "src/expr.rs"
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
- num-bigint = "0.4.0"
- num-traits = "0.2.15"
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -303,7 +303,7 @@ num-prime = "0.4.3"
+ num-traits = "0.2.19"
+ number_prefix = "0.4"
+ once_cell = "1.19.0"
-onig = { version = "~6.4", default-features = false }
-+onig = { version = "6", default-features = false }
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
-
- [[bin]]
++onig = { version = "~6", default-features = false }
+ parse_datetime = "0.6.0"
+ phf = "0.11.2"
+ phf_codegen = "0.11.2"
diff --git a/debian/patches/lower-phf.diff b/debian/patches/lower-phf.diff
index c7355e23f6e4aef5939597ce2f744bc0578990e8..da2ed1f0f5132c8b66357816b1f6394093478333 100644
--- a/debian/patches/lower-phf.diff
+++ b/debian/patches/lower-phf.diff
@@ -2,21 +2,14 @@ Index: coreutils/Cargo.toml
===================================================================
--- coreutils.orig/Cargo.toml
+++ coreutils/Cargo.toml
-@@ -268,7 +268,7 @@ test = [ "uu_test" ]
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
- clap_complete = "4.0"
- once_cell = "1"
--phf = "0.11.1"
+@@ -305,8 +305,8 @@ number_prefix = "0.4"
+ once_cell = "1.19.0"
+ onig = { version = "~6", default-features = false }
+ parse_datetime = "0.6.0"
+-phf = "0.11.2"
+-phf_codegen = "0.11.2"
+phf = "0"
- selinux = { version="0.3", optional = true }
- textwrap = { version="0.16.0", features=["terminal_size"] }
- uucore = { version=">=0.0.17", package="uucore", path="src/uucore" }
-@@ -416,7 +416,7 @@ rust-users = { version="0", package="use
- rand_pcg = "0.3"
-
- [build-dependencies]
--phf_codegen = "0.11.1"
+phf_codegen = "0"
-
- [[bin]]
- name = "coreutils"
+ platform-info = "2.0.3"
+ quick-error = "2.0.1"
+ rand = { version = "0.8.5", features = ["small_rng"] }
diff --git a/debian/patches/lower-rayon.diff b/debian/patches/lower-rayon.diff
index 0c5dbb5a60f81e1329131669b51599e74a487f8d..dcecad4d90990f207665acab2836f1b853c7a2a8 100644
--- a/debian/patches/lower-rayon.diff
+++ b/debian/patches/lower-rayon.diff
@@ -1,13 +1,13 @@
-Index: coreutils/src/uu/sort/Cargo.toml
+Index: coreutils/Cargo.toml
===================================================================
---- coreutils.orig/src/uu/sort/Cargo.toml
-+++ coreutils/src/uu/sort/Cargo.toml
-@@ -24,7 +24,7 @@ itertools = "0.10.0"
- memchr = "2.5.0"
- ouroboros = "0.15.5"
- rand = "0.8"
--rayon = "1.5"
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -311,7 +311,7 @@ platform-info = "2.0.3"
+ quick-error = "2.0.1"
+ rand = { version = "0.8.5", features = ["small_rng"] }
+ rand_core = "0.6.4"
+-rayon = "1.10"
+rayon = "1"
- tempfile = "3"
- unicode-width = "0.1.8"
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["fs"] }
+ redox_syscall = "0.5.1"
+ regex = "1.10.4"
+ rstest = "0.21.0"
diff --git a/debian/patches/nix-0.29.diff b/debian/patches/nix-0.29.diff
new file mode 100644
index 0000000000000000000000000000000000000000..5551625cd08947feda5c57ec4b2b86d07d90680f
--- /dev/null
+++ b/debian/patches/nix-0.29.diff
@@ -0,0 +1,46 @@
+Index: rust-coreutils-0.0.27/Cargo.toml
+===================================================================
+--- rust-coreutils-0.0.27.orig/Cargo.toml
++++ rust-coreutils-0.0.27/Cargo.toml
+@@ -296,7 +296,7 @@ lscolors = { version = "0", default-feat
+ ] }
+ memchr = "2.7"
+ memmap2 = "0"
+-nix = { version = "0.28", default-features = false }
++nix = { version = "0.29", default-features = false }
+ nom = "7"
+ notify = ">= 5, < 7"
+ num-bigint = "0.4"
+Index: rust-coreutils-0.0.27/src/uucore/src/lib/features/pipes.rs
+===================================================================
+--- rust-coreutils-0.0.27.orig/src/uucore/src/lib/features/pipes.rs
++++ rust-coreutils-0.0.27/src/uucore/src/lib/features/pipes.rs
+@@ -11,6 +11,7 @@ use std::os::unix::io::AsRawFd;
+
+ #[cfg(any(target_os = "linux", target_os = "android"))]
+ use nix::fcntl::SpliceFFlags;
++use std::os::fd::BorrowedFd;
+
+ pub use nix::{Error, Result};
+
+@@ -35,9 +36,9 @@ pub fn pipe() -> Result<(File, File)> {
+ #[cfg(any(target_os = "linux", target_os = "android"))]
+ pub fn splice(source: &impl AsRawFd, target: &impl AsRawFd, len: usize) -> Result<usize> {
+ nix::fcntl::splice(
+- source.as_raw_fd(),
++ unsafe { BorrowedFd::borrow_raw(source.as_raw_fd()) },
+ None,
+- target.as_raw_fd(),
++ unsafe { BorrowedFd::borrow_raw(target.as_raw_fd()) },
+ None,
+ len,
+ SpliceFFlags::empty(),
+@@ -66,7 +67,7 @@ pub fn splice_exact(source: &impl AsRawF
+ #[cfg(any(target_os = "linux", target_os = "android"))]
+ pub fn vmsplice(target: &impl AsRawFd, bytes: &[u8]) -> Result<usize> {
+ nix::fcntl::vmsplice(
+- target.as_raw_fd(),
++ unsafe { BorrowedFd::borrow_raw(target.as_raw_fd()) },
+ &[IoSlice::new(bytes)],
+ SpliceFFlags::empty(),
+ )
diff --git a/debian/patches/relax-bigdecimal.diff b/debian/patches/relax-bigdecimal.diff
new file mode 100644
index 0000000000000000000000000000000000000000..81b628ddb2c7fde7310074798f909824b40aa49f
--- /dev/null
+++ b/debian/patches/relax-bigdecimal.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -259,7 +259,7 @@ test = ["uu_test"]
+
+ [workspace.dependencies]
+ ansi-width = "0.1.0"
+-bigdecimal = "0.4"
++bigdecimal = "0"
+ binary-heap-plus = "0"
+ bstr = "1"
+ bytecount = "0.6.8"
diff --git a/debian/patches/relax-bigint.diff b/debian/patches/relax-bigint.diff
new file mode 100644
index 0000000000000000000000000000000000000000..0ec21ea214623e9727c83ec6fdf95b9060115a5a
--- /dev/null
+++ b/debian/patches/relax-bigint.diff
@@ -0,0 +1,7 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -232,1 +232,1 @@
+-num-bigint = "0.4.4"
++num-bigint = "0.4"
diff --git a/debian/patches/relax-binary-heap-plus.diff b/debian/patches/relax-binary-heap-plus.diff
index e54e71b7e93e5a878ef7e4fda504a152c63121e2..451c86b59a748bb81e563fbb73c78cb2adff6c9e 100644
--- a/debian/patches/relax-binary-heap-plus.diff
+++ b/debian/patches/relax-binary-heap-plus.diff
@@ -1,13 +1,13 @@
-Index: coreutils/src/uu/sort/Cargo.toml
+Index: coreutils/Cargo.toml
===================================================================
---- coreutils.orig/src/uu/sort/Cargo.toml
-+++ coreutils/src/uu/sort/Cargo.toml
-@@ -15,7 +15,7 @@ edition = "2021"
- path = "src/sort.rs"
-
- [dependencies]
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -260,7 +260,7 @@ test = ["uu_test"]
+ [workspace.dependencies]
+ ansi-width = "0.1.0"
+ bigdecimal = "0.4"
-binary-heap-plus = "0.5.0"
+binary-heap-plus = "0"
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
- compare = "0.1.0"
- ctrlc = { version = "3.0", features = ["termination"] }
+ bstr = "1.9.1"
+ bytecount = "0.6.8"
+ byteorder = "1.5.0"
diff --git a/debian/patches/relax-blake2.diff b/debian/patches/relax-blake2.diff
new file mode 100644
index 0000000000000000000000000000000000000000..bccdde527e149276ac4661efef9deb834704d08d
--- /dev/null
+++ b/debian/patches/relax-blake2.diff
@@ -0,0 +1,15 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -341,8 +341,8 @@ md-5 = "0.10"
+ sha1 = "0.10"
+ sha2 = "0.10"
+ sha3 = "0.10"
+-blake2b_simd = "1.0.2"
+-blake3 = "1.5.1"
++blake2b_simd = "1"
++blake3 = "1"
+ sm3 = "0.4.2"
+ digest = "0.10.7"
+
diff --git a/debian/patches/relax-bstr.diff b/debian/patches/relax-bstr.diff
index 7c5061eeaa3b993af4c8297d18c12b799e866c98..0cb1b96238014f43d0044972b1881b2766d3e944 100644
--- a/debian/patches/relax-bstr.diff
+++ b/debian/patches/relax-bstr.diff
@@ -1,13 +1,13 @@
-Index: coreutils/src/uu/cut/Cargo.toml
+Index: coreutils/Cargo.toml
===================================================================
---- coreutils.orig/src/uu/cut/Cargo.toml
-+++ coreutils/src/uu/cut/Cargo.toml
-@@ -18,7 +18,7 @@ path = "src/cut.rs"
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
- memchr = "2"
--bstr = "1.0"
-+bstr = "0"
- atty = "0.2"
-
- [[bin]]
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -261,7 +261,7 @@ test = ["uu_test"]
+ ansi-width = "0.1.0"
+ bigdecimal = "0.4"
+ binary-heap-plus = "0"
+-bstr = "1.9.1"
++bstr = "1"
+ bytecount = "0.6.8"
+ byteorder = "1.5.0"
+ chrono = { version = "0.4", default-features = false, features = [
diff --git a/debian/patches/relax-bytecount.diff b/debian/patches/relax-bytecount.diff
new file mode 100644
index 0000000000000000000000000000000000000000..0e37e9c41e7e15d11d8e67ec04424ef1e949f634
--- /dev/null
+++ b/debian/patches/relax-bytecount.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -263,7 +263,7 @@ ansi-width = "0.1.0"
+ bigdecimal = "0"
+ binary-heap-plus = "0"
+ bstr = "1"
+-bytecount = "0.6.8"
++bytecount = "0.6"
+ byteorder = "1"
+ chrono = { version = "0.4", default-features = false, features = [
+ "std",
diff --git a/debian/patches/relax-byteorder.diff b/debian/patches/relax-byteorder.diff
new file mode 100644
index 0000000000000000000000000000000000000000..b4e9e4b1c000aea797a7d244da433a5dc38aa154
--- /dev/null
+++ b/debian/patches/relax-byteorder.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -264,7 +264,7 @@ bigdecimal = "0"
+ binary-heap-plus = "0"
+ bstr = "1"
+ bytecount = "0.6.8"
+-byteorder = "1.5.0"
++byteorder = "1"
+ chrono = { version = "0.4", default-features = false, features = [
+ "std",
+ "alloc",
diff --git a/debian/patches/relax-chrono.diff b/debian/patches/relax-chrono.diff
new file mode 100644
index 0000000000000000000000000000000000000000..c728bf99fc314773a1b4abeaa76583defba98f5f
--- /dev/null
+++ b/debian/patches/relax-chrono.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -264,7 +264,7 @@ binary-heap-plus = "0"
+ bstr = "1.9.1"
+ bytecount = "0.6.8"
+ byteorder = "1.5.0"
+-chrono = { version = "0.4.38", default-features = false, features = [
++chrono = { version = "0.4", default-features = false, features = [
+ "std",
+ "alloc",
+ "clock",
diff --git a/debian/patches/relax-clap.diff b/debian/patches/relax-clap.diff
new file mode 100644
index 0000000000000000000000000000000000000000..c5a04172c40959fa893845f725266468ae4f82de
--- /dev/null
+++ b/debian/patches/relax-clap.diff
@@ -0,0 +1,15 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -269,8 +269,8 @@ chrono = { version = "0.4.38", default-f
+ "alloc",
+ "clock",
+ ] }
+-clap = { version = "4.4", features = ["wrap_help", "cargo"] }
+-clap_complete = "4.4"
++clap = { version = "4", features = ["wrap_help", "cargo"] }
++clap_complete = "4"
+ clap_mangen = "0.2"
+ compare = "0.1.0"
+ coz = { version = "0.1.3" }
diff --git a/debian/patches/relax-cpp-build.diff b/debian/patches/relax-cpp-build.diff
deleted file mode 100644
index d43c262ebd8681e5db1ffee3b759e19709f92e7b..0000000000000000000000000000000000000000
--- a/debian/patches/relax-cpp-build.diff
+++ /dev/null
@@ -1,10 +0,0 @@
-Index: coreutils/src/uu/stdbuf/src/libstdbuf/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/stdbuf/src/libstdbuf/Cargo.toml
-+++ coreutils/src/uu/stdbuf/src/libstdbuf/Cargo.toml
-@@ -22,4 +22,4 @@ libc = "0.2"
- uucore = { version=">=0.0.17", package="uucore", path="../../../../uucore" }
-
- [build-dependencies]
--cpp_build = "0.5"
-+cpp_build = "0"
diff --git a/debian/patches/relax-data-encoding.diff b/debian/patches/relax-data-encoding.diff
new file mode 100644
index 0000000000000000000000000000000000000000..af4e4d047ac19649a9b453e850999be29673e66d
--- /dev/null
+++ b/debian/patches/relax-data-encoding.diff
@@ -0,0 +1,15 @@
+Index: coreutils/src/uucore/Cargo.toml
+===================================================================
+--- coreutils.orig/src/uucore/Cargo.toml
++++ coreutils/src/uucore/Cargo.toml
+@@ -34,8 +34,8 @@ time = { workspace = true, optional = tr
+ "macros",
+ ] }
+ # * "problem" dependencies (pinned)
+-data-encoding = { version = "2.6", optional = true }
+-data-encoding-macro = { version = "0.1.15", optional = true }
++data-encoding = { version = "2", optional = true }
++data-encoding-macro = { version = "0", optional = true }
+ z85 = { version = "3", optional = true }
+ libc = { workspace = true, optional = true }
+ once_cell = { workspace = true }
diff --git a/debian/patches/relax-digest.diff b/debian/patches/relax-digest.diff
new file mode 100644
index 0000000000000000000000000000000000000000..c651183ab305d15414dd5a9b9fb9ffab23af6216
--- /dev/null
+++ b/debian/patches/relax-digest.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -344,7 +344,7 @@ sha3 = "0.10"
+ blake2b_simd = "1"
+ blake3 = "1"
+ sm3 = "0.4.2"
+-digest = "0.10.7"
++digest = "0.10"
+
+ uucore = { version = ">=0.0.19", package = "uucore", path = "src/uucore" }
+ uucore_procs = { version = ">=0.0.19", package = "uucore_procs", path = "src/uucore_procs" }
diff --git a/debian/patches/relax-dns-lookup.diff b/debian/patches/relax-dns-lookup.diff
new file mode 100644
index 0000000000000000000000000000000000000000..576e07a12d1caeb42e30e56bd054081779e9a501
--- /dev/null
+++ b/debian/patches/relax-dns-lookup.diff
@@ -0,0 +1,13 @@
+Index: coreutils/src/uucore/Cargo.toml
+===================================================================
+--- coreutils.orig/src/uucore/Cargo.toml
++++ coreutils/src/uucore/Cargo.toml
+@@ -21,7 +21,7 @@ path = "src/lib/lib.rs"
+ clap = { workspace = true }
+ uucore_procs = { workspace = true }
+ number_prefix = { workspace = true }
+-dns-lookup = { version = "2.0.4", optional = true }
++dns-lookup = { version = "1", optional = true }
+ dunce = { version = "1.0.4", optional = true }
+ wild = "2.2.1"
+ glob = { workspace = true }
diff --git a/debian/patches/relax-dunce.diff b/debian/patches/relax-dunce.diff
new file mode 100644
index 0000000000000000000000000000000000000000..a44c05402d547050969730d6bca67775bf3da5bd
--- /dev/null
+++ b/debian/patches/relax-dunce.diff
@@ -0,0 +1,13 @@
+Index: coreutils/src/uucore/Cargo.toml
+===================================================================
+--- coreutils.orig/src/uucore/Cargo.toml
++++ coreutils/src/uucore/Cargo.toml
+@@ -22,7 +22,7 @@ clap = { workspace = true }
+ uucore_procs = { workspace = true }
+ number_prefix = { workspace = true }
+ dns-lookup = { version = "1", optional = true }
+-dunce = { version = "1.0.4", optional = true }
++dunce = { version = "1", optional = true }
+ wild = "2.2.1"
+ glob = { workspace = true }
+ # * optional
diff --git a/debian/patches/relax-fs-extra.diff b/debian/patches/relax-fs-extra.diff
new file mode 100644
index 0000000000000000000000000000000000000000..dc745c2e6ca3d3c8401518154f8e5112bd507e33
--- /dev/null
+++ b/debian/patches/relax-fs-extra.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -280,7 +280,7 @@ exacl = "0"
+ file_diff = "1.0.0"
+ filetime = "0.2.23"
+ fnv = "1.0.7"
+-fs_extra = "1.3.0"
++fs_extra = "1"
+ fts-sys = "0.2.9"
+ fundu = "2.0.0"
+ gcd = "2"
diff --git a/debian/patches/relax-fts.diff b/debian/patches/relax-fts.diff
new file mode 100644
index 0000000000000000000000000000000000000000..6b2c840b77359bbdd8020d04b6e0e8444f790c98
--- /dev/null
+++ b/debian/patches/relax-fts.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -282,7 +282,7 @@ file_diff = "1.0.0"
+ filetime = "0.2.23"
+ fnv = "1.0.7"
+ fs_extra = "1"
+-fts-sys = "0.2.9"
++fts-sys = "0.2"
+ fundu = "1"
+ gcd = "2"
+ glob = "0.3.1"
diff --git a/debian/patches/relax-fundu.diff b/debian/patches/relax-fundu.diff
new file mode 100644
index 0000000000000000000000000000000000000000..1a98d58558f86818b884ae2bde3965ae7264d933
--- /dev/null
+++ b/debian/patches/relax-fundu.diff
@@ -0,0 +1,9 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -284,3 +284,3 @@
+ fts-sys = "0.2.9"
+-fundu = "2.0.0"
++fundu = "1"
+ gcd = "2"
diff --git a/debian/patches/relax-gcd.diff b/debian/patches/relax-gcd.diff
new file mode 100644
index 0000000000000000000000000000000000000000..a4d7d5173c8fee4f5f7f39382b109274bd7c896d
--- /dev/null
+++ b/debian/patches/relax-gcd.diff
@@ -0,0 +1,7 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -286,1 +286,1 @@
+-gcd = "2.3"
++gcd = "2"
diff --git a/debian/patches/relax-hex-literal.diff b/debian/patches/relax-hex-literal.diff
new file mode 100644
index 0000000000000000000000000000000000000000..975d10589830edeecefe2697abe4333f85b7b579
--- /dev/null
+++ b/debian/patches/relax-hex-literal.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -336,7 +336,7 @@ walkdir = "2.5"
+ xattr = "1.3.1"
+ zip = { version = "0", default-features = false, features = ["deflate"] }
+
+-hex = "0.4.3"
++hex = "0"
+ md-5 = "0.10"
+ sha1 = "0.10"
+ sha2 = "0.10"
diff --git a/debian/patches/relax-hostname.diff b/debian/patches/relax-hostname.diff
new file mode 100644
index 0000000000000000000000000000000000000000..4428d88cf3e7eb3c119edd0678943829bf5ce0e4
--- /dev/null
+++ b/debian/patches/relax-hostname.diff
@@ -0,0 +1,7 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -290,1 +290,1 @@
+-hostname = "0.4"
++hostname = "0"
diff --git a/debian/patches/relax-itertools.diff b/debian/patches/relax-itertools.diff
new file mode 100644
index 0000000000000000000000000000000000000000..158a1edf341dbf0a68e643b671cfd606df89e41f
--- /dev/null
+++ b/debian/patches/relax-itertools.diff
@@ -0,0 +1,11 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -289,5 +289,5 @@
+ hostname = "0.4"
+ indicatif = "0.17.8"
+-itertools = "0.13.0"
++itertools = "0"
+ libc = "0.2.153"
+ lscolors = { version = "0.16.0", default-features = false, features = [
diff --git a/debian/patches/relax-libc.diff b/debian/patches/relax-libc.diff
new file mode 100644
index 0000000000000000000000000000000000000000..35940330380099bc805e684a26c4f56ad5771418
--- /dev/null
+++ b/debian/patches/relax-libc.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -289,7 +289,7 @@ half = "1"
+ hostname = "0.4"
+ indicatif = "0.17.8"
+ itertools = "0"
+-libc = "0.2.153"
++libc = "0.2"
+ lscolors = { version = "0.16.0", default-features = false, features = [
+ "gnu_legacy",
+ ] }
diff --git a/debian/patches/relax-lscolors.diff b/debian/patches/relax-lscolors.diff
new file mode 100644
index 0000000000000000000000000000000000000000..2dd5066469b36932406aae1cdf3998c627ee239d
--- /dev/null
+++ b/debian/patches/relax-lscolors.diff
@@ -0,0 +1,18 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -1,3 +1,4 @@
++
+ # coreutils (uutils)
+ # * see the repository LICENSE, README, and CONTRIBUTING files for more information
+
+@@ -290,7 +291,7 @@ hostname = "0.4"
+ indicatif = "0.17.8"
+ itertools = "0"
+ libc = "0.2"
+-lscolors = { version = "0.16.0", default-features = false, features = [
++lscolors = { version = "0", default-features = false, features = [
+ "gnu_legacy",
+ ] }
+ memchr = "2.7.2"
diff --git a/debian/patches/relax-md-5.diff b/debian/patches/relax-md-5.diff
index a8bd2f49d546e7fb060e9e0f6354ad0744cec1f5..e8e3115f66a83a14fe022cb45ac978e1957cdbdf 100644
--- a/debian/patches/relax-md-5.diff
+++ b/debian/patches/relax-md-5.diff
@@ -1,13 +1,13 @@
-Index: coreutils/src/uu/hashsum/Cargo.toml
+Index: coreutils/Cargo.toml
===================================================================
---- coreutils.orig/src/uu/hashsum/Cargo.toml
-+++ coreutils/src/uu/hashsum/Cargo.toml
-@@ -19,7 +19,7 @@ digest = "0.10.6"
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -337,7 +337,7 @@ xattr = "1.3.1"
+ zip = { version = "1.1.4", default-features = false, features = ["deflate"] }
+
hex = "0.4.3"
- memchr = "2"
--md-5 = "0.10.5"
+-md-5 = "0.10.6"
+md-5 = "0.10"
- regex = "1"
- sha1 = "0.10.1"
- sha2 = "0.10.2"
+ sha1 = "0.10.6"
+ sha2 = "0.10.8"
+ sha3 = "0.10.8"
diff --git a/debian/patches/relax-memchr.diff b/debian/patches/relax-memchr.diff
new file mode 100644
index 0000000000000000000000000000000000000000..c900963bfcf4bfd6c62386d10fdc70003160997f
--- /dev/null
+++ b/debian/patches/relax-memchr.diff
@@ -0,0 +1,7 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -297,1 +297,1 @@
+-memchr = "2.7.2"
++memchr = "2.7"
diff --git a/debian/patches/relax-nix.diff b/debian/patches/relax-nix.diff
deleted file mode 100644
index 37657e89e0e021d9db794231c401dd4f5b12738d..0000000000000000000000000000000000000000
--- a/debian/patches/relax-nix.diff
+++ /dev/null
@@ -1,182 +0,0 @@
-Index: coreutils/src/uu/cat/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/cat/Cargo.toml
-+++ coreutils/src/uu/cat/Cargo.toml
-@@ -21,7 +21,7 @@ atty = "0.2"
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["fs", "pipes"] }
-
- [target.'cfg(unix)'.dependencies]
--nix = { version = "0.25", default-features = false }
-+nix = { version = "0", default-features = false }
-
- [[bin]]
- name = "cat"
-Index: coreutils/src/uu/kill/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/kill/Cargo.toml
-+++ coreutils/src/uu/kill/Cargo.toml
-@@ -16,7 +16,7 @@ path = "src/kill.rs"
-
- [dependencies]
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
--nix = { version = "0.25", features = ["signal"] }
-+nix = { version = "0", features = ["signal"] }
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["signals"] }
-
- [[bin]]
-Index: coreutils/src/uu/more/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/more/Cargo.toml
-+++ coreutils/src/uu/more/Cargo.toml
-@@ -23,7 +23,7 @@ unicode-width = "0.1.7"
- unicode-segmentation = "1"
-
- [target.'cfg(all(unix, not(target_os = "fuchsia")))'.dependencies]
--nix = { version = "0.25", default-features = false }
-+nix = { version = "0", default-features = false }
-
- [[bin]]
- name = "more"
-Index: coreutils/src/uu/nice/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/nice/Cargo.toml
-+++ coreutils/src/uu/nice/Cargo.toml
-@@ -17,7 +17,7 @@ path = "src/nice.rs"
- [dependencies]
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
- libc = "0.2.137"
--nix = { version = "0.25", default-features = false }
-+nix = { version = "0", default-features = false }
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
-
- [[bin]]
-Index: coreutils/src/uu/stty/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/stty/Cargo.toml
-+++ coreutils/src/uu/stty/Cargo.toml
-@@ -17,7 +17,7 @@ path = "src/stty.rs"
- [dependencies]
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
--nix = { version="0.25", features = ["term"] }
-+nix = { version="0", features = ["term"] }
-
- [[bin]]
- name = "stty"
-Index: coreutils/src/uu/sync/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/sync/Cargo.toml
-+++ coreutils/src/uu/sync/Cargo.toml
-@@ -20,7 +20,7 @@ libc = "0.2.137"
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["wide"] }
-
- [target.'cfg(any(target_os = "linux", target_os = "android"))'.dependencies]
--nix = "0.25"
-+nix = "0"
-
- [target.'cfg(target_os = "windows")'.dependencies]
- windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_Storage_FileSystem", "Win32_System_WindowsProgramming", "Win32_Foundation"] }
-Index: coreutils/src/uu/tail/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/tail/Cargo.toml
-+++ coreutils/src/uu/tail/Cargo.toml
-@@ -29,7 +29,7 @@ windows-sys = { version = "0.42.0", defa
- winapi-util = { version="0.1.5" }
-
- [target.'cfg(unix)'.dependencies]
--nix = { version = "0.25", features = ["fs"] }
-+nix = { version = "0", features = ["fs"] }
-
- [[bin]]
- name = "tail"
-Index: coreutils/src/uu/timeout/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/timeout/Cargo.toml
-+++ coreutils/src/uu/timeout/Cargo.toml
-@@ -17,7 +17,7 @@ path = "src/timeout.rs"
- [dependencies]
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
- libc = "0.2.137"
--nix = { version = "0.25", default-features = false, features = ["signal"] }
-+nix = { version = "0", default-features = false, features = ["signal"] }
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["process", "signals"] }
-
- [[bin]]
-Index: coreutils/src/uu/tty/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/tty/Cargo.toml
-+++ coreutils/src/uu/tty/Cargo.toml
-@@ -16,7 +16,7 @@ path = "src/tty.rs"
-
- [dependencies]
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
--nix = "0.25"
-+nix = "0"
- atty = "0.2"
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["fs"] }
-
-Index: coreutils/src/uu/wc/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/wc/Cargo.toml
-+++ coreutils/src/uu/wc/Cargo.toml
-@@ -22,7 +22,7 @@ utf-8 = "0.7.6"
- unicode-width = "0.1.8"
-
- [target.'cfg(unix)'.dependencies]
--nix = { version = "0.25", default-features = false }
-+nix = { version = "0", default-features = false }
- libc = "0.2"
-
- [[bin]]
-Index: coreutils/src/uu/yes/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/yes/Cargo.toml
-+++ coreutils/src/uu/yes/Cargo.toml
-@@ -20,7 +20,7 @@ libc = "0.2.137"
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["pipes"] }
-
- [target.'cfg(any(target_os = "linux", target_os = "android"))'.dependencies]
--nix = { version = "0.25", default-features = false }
-+nix = { version = "0", default-features = false }
-
- [[bin]]
- name = "yes"
-Index: coreutils/src/uucore/Cargo.toml
-===================================================================
---- coreutils.orig/src/uucore/Cargo.toml
-+++ coreutils/src/uucore/Cargo.toml
-@@ -38,7 +38,7 @@ os_display = "0.1.3"
-
- [target.'cfg(unix)'.dependencies]
- walkdir = { version="2.3.2", optional=true }
--nix = { version = "0.25", default-features = false, features = ["fs", "uio", "zerocopy"] }
-+nix = { version = "0", default-features = false, features = ["fs", "uio", "zerocopy"] }
-
- [dev-dependencies]
- clap = "4.0"
-Index: coreutils/src/uu/env/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/env/Cargo.toml
-+++ coreutils/src/uu/env/Cargo.toml
-@@ -20,7 +20,7 @@ rust-ini = "0.18.0"
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["signals"]}
-
- [target.'cfg(unix)'.dependencies]
--nix = { version = "0.25", default-features = false, features = ["signal"] }
-+nix = { version = "0", default-features = false, features = ["signal"] }
-
-
- [[bin]]
-Index: coreutils/Cargo.toml
-===================================================================
---- coreutils.orig/Cargo.toml
-+++ coreutils/Cargo.toml
-@@ -411,7 +411,7 @@ procfs = { version = "0.14", default-fea
- rlimit = "0.8.3"
-
- [target.'cfg(unix)'.dev-dependencies]
--nix = { version = "0.25", default-features = false, features = ["process", "signal", "user"] }
-+nix = { version = "0", default-features = false, features = ["process", "signal", "user"] }
- rust-users = { version="0", package="users" }
- rand_pcg = "0.3"
-
diff --git a/debian/patches/relax-nom.diff b/debian/patches/relax-nom.diff
new file mode 100644
index 0000000000000000000000000000000000000000..92897b761beec42511ac390d22666094602c4880
--- /dev/null
+++ b/debian/patches/relax-nom.diff
@@ -0,0 +1,7 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -299,1 +299,1 @@
+-nom = "7.1.3"
++nom = "7"
diff --git a/debian/patches/relax-notify.diff b/debian/patches/relax-notify.diff
index f62c1ac504105c835e866acbffd1cd94657243ab..fa3c4e22df66cd454ca1e4e052f3903e545ab2e1 100644
--- a/debian/patches/relax-notify.diff
+++ b/debian/patches/relax-notify.diff
@@ -1,13 +1,13 @@
-Index: coreutils/src/uu/tail/Cargo.toml
+Index: coreutils/Cargo.toml
===================================================================
---- coreutils.orig/src/uu/tail/Cargo.toml
-+++ coreutils/src/uu/tail/Cargo.toml
-@@ -19,7 +19,7 @@ path = "src/tail.rs"
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
- libc = "0.2.137"
- memchr = "2.5.0"
--notify = { version = "=5.0.0", features=["macos_kqueue"]}
-+notify = "5.0.0"
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["ringbuffer", "lines"] }
- same-file = "1.0.6"
- atty = "0.2"
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -297,7 +297,7 @@ memchr = "2.7.2"
+ memmap2 = "0.9.4"
+ nix = { version = "0.28", default-features = false }
+ nom = "7.1.3"
+-notify = { version = "=6.0.1", features = ["macos_kqueue"] }
++notify = ">= 5, < 7"
+ num-bigint = "0.4.4"
+ num-prime = "0.4.3"
+ num-traits = "0.2.19"
diff --git a/debian/patches/relax-num-traits.diff b/debian/patches/relax-num-traits.diff
new file mode 100644
index 0000000000000000000000000000000000000000..f0215f10b59a7a81957abc465623465a5444ff9a
--- /dev/null
+++ b/debian/patches/relax-num-traits.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -301,7 +301,7 @@ nom = "7"
+ notify = ">= 5, < 7"
+ num-bigint = "0.4"
+ num-prime = "0.4.3"
+-num-traits = "0.2.19"
++num-traits = "0.2"
+ number_prefix = "0.4"
+ once_cell = "1"
+ onig = { version = "~6", default-features = false }
diff --git a/debian/patches/relax-once-cell.diff b/debian/patches/relax-once-cell.diff
index 75190cf28a5e4219bcb8d5997b8c680ac1a69413..aef2fe3094e9b6f1c0f7bc47ed5b444c28408ce2 100644
--- a/debian/patches/relax-once-cell.diff
+++ b/debian/patches/relax-once-cell.diff
@@ -2,47 +2,12 @@ Index: coreutils/Cargo.toml
===================================================================
--- coreutils.orig/Cargo.toml
+++ coreutils/Cargo.toml
-@@ -267,7 +267,7 @@ test = [ "uu_test" ]
- [dependencies]
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
- clap_complete = "4.0"
--once_cell = "1.13.1"
-+once_cell = "1"
- phf = "0.11.1"
- selinux = { version="0.3", optional = true }
- textwrap = { version="0.16.0", features=["terminal_size"] }
-Index: coreutils/src/uu/ls/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/ls/Cargo.toml
-+++ coreutils/src/uu/ls/Cargo.toml
-@@ -24,7 +24,7 @@ terminal_size = "0.2.2"
- glob = "0.3.0"
- lscolors = { version = "0.13.0", default-features=false, features = ["nu-ansi-term"] }
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features = ["entries", "fs"] }
--once_cell = "1.13.1"
-+once_cell = "1"
- atty = "0.2"
- selinux = { version="0.3", optional = true }
-
-Index: coreutils/src/uucore/Cargo.toml
-===================================================================
---- coreutils.orig/src/uucore/Cargo.toml
-+++ coreutils/src/uucore/Cargo.toml
-@@ -33,7 +33,7 @@ data-encoding = { version="2.1", optiona
- data-encoding-macro = { version="0.1.12", optional=true }
- z85 = { version="3.0.5", optional=true }
- libc = { version="0.2.137", optional=true }
--once_cell = "1.13.1"
-+once_cell = "1"
- os_display = "0.1.3"
-
- [target.'cfg(unix)'.dependencies]
-@@ -42,7 +42,7 @@ nix = { version = "0.25", default-featur
-
- [dev-dependencies]
- clap = "4.0"
--once_cell = "1.13"
-+once_cell = "1"
-
- [target.'cfg(target_os = "windows")'.dependencies]
- winapi-util = { version= "0.1.5", optional=true }
+@@ -302,7 +302,7 @@ num-bigint = "0.4.4"
+ num-prime = "0.4.3"
+ num-traits = "0.2.19"
+ number_prefix = "0.4"
+-once_cell = "1.19.0"
++once_cell = "1"
+ onig = { version = "~6", default-features = false }
+ parse_datetime = "0.6.0"
+ phf = "0"
diff --git a/debian/patches/relax-ouroboro.diff b/debian/patches/relax-ouroboro.diff
deleted file mode 100644
index dc286fbf111941e83256eeae6ee188ce4c3c8e4d..0000000000000000000000000000000000000000
--- a/debian/patches/relax-ouroboro.diff
+++ /dev/null
@@ -1,13 +0,0 @@
-Index: coreutils/src/uu/sort/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/sort/Cargo.toml
-+++ coreutils/src/uu/sort/Cargo.toml
-@@ -22,7 +22,7 @@ ctrlc = { version = "3.0", features = ["
- fnv = "1.0.7"
- itertools = "0.10.0"
- memchr = "2.5.0"
--ouroboros = "0.15.5"
-+ouroboros = "0.15"
- rand = "0.8"
- rayon = "1"
- tempfile = "3"
diff --git a/debian/patches/relax-parse-datetime.diff b/debian/patches/relax-parse-datetime.diff
new file mode 100644
index 0000000000000000000000000000000000000000..714b31016219fe903cf8b9cd7cfa769e3af0d369
--- /dev/null
+++ b/debian/patches/relax-parse-datetime.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -305,7 +305,7 @@ num-traits = "0.2"
+ number_prefix = "0.4"
+ once_cell = "1"
+ onig = { version = "~6", default-features = false }
+-parse_datetime = "0.6.0"
++parse_datetime = "0"
+ phf = "0"
+ phf_codegen = "0"
+ platform-info = "2"
diff --git a/debian/patches/relax-platform-info.diff b/debian/patches/relax-platform-info.diff
index c9471b7cce4b46689df0beba1b64d26aed3f7385..16487f6b0bbb8d93c7be6da0a9da924efe3f8ac0 100644
--- a/debian/patches/relax-platform-info.diff
+++ b/debian/patches/relax-platform-info.diff
@@ -1,26 +1,13 @@
-Index: coreutils/src/uu/arch/Cargo.toml
+Index: coreutils/Cargo.toml
===================================================================
---- coreutils.orig/src/uu/arch/Cargo.toml
-+++ coreutils/src/uu/arch/Cargo.toml
-@@ -15,7 +15,7 @@ edition = "2021"
- path = "src/arch.rs"
-
- [dependencies]
--platform-info = "1.0.1"
-+platform-info = "1"
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
-
-Index: coreutils/src/uu/uname/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/uname/Cargo.toml
-+++ coreutils/src/uu/uname/Cargo.toml
-@@ -15,7 +15,7 @@ edition = "2021"
- path = "src/uname.rs"
-
- [dependencies]
--platform-info = "1.0.2"
-+platform-info = "1"
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
-
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -307,7 +307,7 @@ onig = { version = "~6", default-feature
+ parse_datetime = "0.6.0"
+ phf = "0"
+ phf_codegen = "0"
+-platform-info = "2.0.3"
++platform-info = "2"
+ quick-error = "2.0.1"
+ rand = { version = "0.8.5", features = ["small_rng"] }
+ rand_core = "0.6.4"
diff --git a/debian/patches/relax-procfs.diff b/debian/patches/relax-procfs.diff
new file mode 100644
index 0000000000000000000000000000000000000000..f8eae6f968b443c1bb66320bced4a5fc91a5df23
--- /dev/null
+++ b/debian/patches/relax-procfs.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -502,7 +502,7 @@ hex-literal = "0.4.1"
+ rstest = { workspace = true }
+
+ [target.'cfg(any(target_os = "linux", target_os = "android"))'.dev-dependencies]
+-procfs = { version = "0.16", default-features = false }
++procfs = { version = "0", default-features = false }
+
+ [target.'cfg(unix)'.dev-dependencies]
+ nix = { workspace = true, features = ["process", "signal", "user", "term"] }
diff --git a/debian/patches/relax-redoc.diff b/debian/patches/relax-redoc.diff
new file mode 100644
index 0000000000000000000000000000000000000000..57fb3f3ac7032a077a9e2960917db8995d8dce54
--- /dev/null
+++ b/debian/patches/relax-redoc.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -312,7 +312,7 @@ quick-error = "2.0.1"
+ rand = { version = "0.8.5", features = ["small_rng"] }
+ rand_core = "0.6.4"
+ rayon = "1"
+-redox_syscall = "0.5.1"
++redox_syscall = "0"
+ regex = "1"
+ rstest = "0.21.0"
+ rust-ini = "0.21.0"
diff --git a/debian/patches/relax-regex.diff b/debian/patches/relax-regex.diff
index 9415cd26a7dc6bdcc9fe90b7bec4b40695bd87c3..fb24cdf9fd1ba151def1a8e94be1f407e2984c02 100644
--- a/debian/patches/relax-regex.diff
+++ b/debian/patches/relax-regex.diff
@@ -1,65 +1,13 @@
-Index: coreutils/src/uu/csplit/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/csplit/Cargo.toml
-+++ coreutils/src/uu/csplit/Cargo.toml
-@@ -17,7 +17,7 @@ path = "src/csplit.rs"
- [dependencies]
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
- thiserror = "1.0"
--regex = "1.7.0"
-+regex = "1"
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["entries", "fs"] }
-
- [[bin]]
-Index: coreutils/src/uu/hashsum/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/hashsum/Cargo.toml
-+++ coreutils/src/uu/hashsum/Cargo.toml
-@@ -20,7 +20,7 @@ clap = { version = "4.0", features = ["w
- hex = "0.4.3"
- memchr = "2"
- md-5 = "0.10.5"
--regex = "1.7.0"
-+regex = "1"
- sha1 = "0.10.1"
- sha2 = "0.10.2"
- sha3 = "0.10.6"
-Index: coreutils/src/uu/nl/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/nl/Cargo.toml
-+++ coreutils/src/uu/nl/Cargo.toml
-@@ -16,7 +16,7 @@ path = "src/nl.rs"
-
- [dependencies]
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
--regex = "1.7.0"
-+regex = "1"
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
-
- [[bin]]
-Index: coreutils/src/uu/pr/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/pr/Cargo.toml
-+++ coreutils/src/uu/pr/Cargo.toml
-@@ -20,7 +20,7 @@ time = { version = "0.3", features = ["l
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["entries"] }
- quick-error = "2.0.1"
- itertools = "0.10.0"
--regex = "1.7"
-+regex = "1"
-
- [[bin]]
- name = "pr"
-Index: coreutils/src/uu/ptx/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/ptx/Cargo.toml
-+++ coreutils/src/uu/ptx/Cargo.toml
-@@ -16,7 +16,7 @@ path = "src/ptx.rs"
-
- [dependencies]
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
--regex = "1.7.0"
-+regex = "1"
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
-
- [[bin]]
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -313,7 +313,7 @@ rand = { version = "0.8.5", features = [
+ rand_core = "0.6.4"
+ rayon = "1"
+ redox_syscall = "0.5.1"
+-regex = "1.10.4"
++regex = "1"
+ rstest = "0.21.0"
+ rust-ini = "0.21.0"
+ same-file = "1.0.6"
diff --git a/debian/patches/relax-rlimit.diff b/debian/patches/relax-rlimit.diff
new file mode 100644
index 0000000000000000000000000000000000000000..599e7ebda6901a3f7f29e68b3cc24c4d0fbea9f9
--- /dev/null
+++ b/debian/patches/relax-rlimit.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -506,7 +506,7 @@ procfs = { version = "0", default-featur
+
+ [target.'cfg(unix)'.dev-dependencies]
+ nix = { workspace = true, features = ["process", "signal", "user", "term"] }
+-rlimit = "0.10.1"
++rlimit = "0"
+ rand_pcg = "0.3.1"
+ xattr = { workspace = true }
+
diff --git a/debian/patches/relax-rstest.diff b/debian/patches/relax-rstest.diff
new file mode 100644
index 0000000000000000000000000000000000000000..0fb1f17c0f4d36cc5b6bb7fd2d1a0f74050e7f64
--- /dev/null
+++ b/debian/patches/relax-rstest.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -315,7 +315,7 @@ rand_core = "0.6.4"
+ rayon = "1"
+ redox_syscall = "0"
+ regex = "1"
+-rstest = "0.21.0"
++rstest = "0"
+ rust-ini = "0.21.0"
+ same-file = "1.0.6"
+ self_cell = "1.0.4"
diff --git a/debian/patches/relax-self-cell.diff b/debian/patches/relax-self-cell.diff
new file mode 100644
index 0000000000000000000000000000000000000000..02ccd95deea17ba2e371013c424b7d42677a33ba
--- /dev/null
+++ b/debian/patches/relax-self-cell.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -318,7 +318,7 @@ regex = "1"
+ rstest = "0"
+ rust-ini = "0.21.0"
+ same-file = "1.0.6"
+-self_cell = "1.0.4"
++self_cell = "1"
+ selinux = "0.4.4"
+ signal-hook = "0"
+ smallvec = { version = "1", features = ["union"] }
diff --git a/debian/patches/relax-signal-hook.diff b/debian/patches/relax-signal-hook.diff
new file mode 100644
index 0000000000000000000000000000000000000000..5c4074972c096e50fa174690ea68a534bd0911dd
--- /dev/null
+++ b/debian/patches/relax-signal-hook.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -319,7 +319,7 @@ rust-ini = "0"
+ same-file = "1.0.6"
+ self_cell = "1.0.4"
+ selinux = "0.4.4"
+-signal-hook = "0.3.17"
++signal-hook = "0"
+ smallvec = { version = "1", features = ["union"] }
+ tempfile = "3"
+ uutils_term_grid = "0.6"
diff --git a/debian/patches/relax-smallvec.diff b/debian/patches/relax-smallvec.diff
index 2570be8b491d5dfa66e6fae828b282aafd562c64..c32dd748db8a27db90d94fb527c0fc73e8c16507 100644
--- a/debian/patches/relax-smallvec.diff
+++ b/debian/patches/relax-smallvec.diff
@@ -1,13 +1,13 @@
-Index: coreutils/src/uu/factor/Cargo.toml
+Index: coreutils/Cargo.toml
===================================================================
---- coreutils.orig/src/uu/factor/Cargo.toml
-+++ coreutils/src/uu/factor/Cargo.toml
-@@ -19,7 +19,7 @@ clap = { version = "4.0", features = ["w
- #coz = { version = "0.1.3", optional = true }
- num-traits = "0.2.15" # Needs at least version 0.2.15 for "OverflowingAdd"
- rand = { version = "0.8", features = ["small_rng"] }
--smallvec = { version = "1.10", features = ["union"] }
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -320,7 +320,7 @@ same-file = "1.0.6"
+ self_cell = "1.0.4"
+ selinux = "0.4.4"
+ signal-hook = "0.3.17"
+-smallvec = { version = "1.13.2", features = ["union"] }
+smallvec = { version = "1", features = ["union"] }
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
-
- [dev-dependencies]
+ tempfile = "3.10.1"
+ uutils_term_grid = "0.6"
+ terminal_size = "0.3.0"
diff --git a/debian/patches/relax-strum.diff b/debian/patches/relax-strum.diff
deleted file mode 100644
index 3cb096fa7b7085d45552d1ff8538c9a7d7ab1a9b..0000000000000000000000000000000000000000
--- a/debian/patches/relax-strum.diff
+++ /dev/null
@@ -1,15 +0,0 @@
-Index: coreutils/src/uu/uniq/Cargo.toml
-===================================================================
---- coreutils.orig/src/uu/uniq/Cargo.toml
-+++ coreutils/src/uu/uniq/Cargo.toml
-@@ -16,8 +16,8 @@ path = "src/uniq.rs"
-
- [dependencies]
- clap = { version = "4.0", features = ["wrap_help", "cargo"] }
--strum = "0.24.1"
--strum_macros = "0.24.2"
-+strum = "0"
-+strum_macros = "0"
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
-
- [[bin]]
diff --git a/debian/patches/relax-tempfile.diff b/debian/patches/relax-tempfile.diff
new file mode 100644
index 0000000000000000000000000000000000000000..2173675480b123ecf3aeeeb553bf447313ff2270
--- /dev/null
+++ b/debian/patches/relax-tempfile.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -321,7 +321,7 @@ self_cell = "1.0.4"
+ selinux = "0.4.4"
+ signal-hook = "0.3.17"
+ smallvec = { version = "1", features = ["union"] }
+-tempfile = "3.10.1"
++tempfile = "3"
+ uutils_term_grid = "0.6"
+ terminal_size = "0"
+ textwrap = { version = "0.16.1", features = ["terminal_size"] }
diff --git a/debian/patches/relax-term-diff.diff b/debian/patches/relax-term-diff.diff
new file mode 100644
index 0000000000000000000000000000000000000000..d99da6dd36121482e54967eb494af430a3ba3784
--- /dev/null
+++ b/debian/patches/relax-term-diff.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -322,7 +322,7 @@ selinux = "0.4.4"
+ signal-hook = "0"
+ smallvec = { version = "1", features = ["union"] }
+ tempfile = "3"
+-uutils_term_grid = "0.6"
++uutils_term_grid = "0"
+ terminal_size = "0"
+ textwrap = { version = "0.16", features = ["terminal_size"] }
+ thiserror = "1.0.59"
diff --git a/debian/patches/relax-terminal-size.diff b/debian/patches/relax-terminal-size.diff
index b506be83bfa5e9ea71986c8120786c96a617762b..dccc50b6fad89efe89355aad2c8a20bb83c27e84 100644
--- a/debian/patches/relax-terminal-size.diff
+++ b/debian/patches/relax-terminal-size.diff
@@ -1,13 +1,13 @@
-Index: coreutils/src/uu/ls/Cargo.toml
+Index: coreutils/Cargo.toml
===================================================================
---- coreutils.orig/src/uu/ls/Cargo.toml
-+++ coreutils/src/uu/ls/Cargo.toml
-@@ -20,7 +20,7 @@ clap = { version = "4.0", features = ["w
- unicode-width = "0.1.8"
- number_prefix = "0.4"
- term_grid = "0.1.5"
--terminal_size = "0.2.2"
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -323,7 +323,7 @@ signal-hook = "0.3.17"
+ smallvec = { version = "1", features = ["union"] }
+ tempfile = "3.10.1"
+ uutils_term_grid = "0.6"
+-terminal_size = "0.3.0"
+terminal_size = "0"
- glob = "0.3.0"
- lscolors = { version = "0.13.0", default-features=false, features = ["nu-ansi-term"] }
- uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features = ["entries", "fs"] }
+ textwrap = { version = "0.16.1", features = ["terminal_size"] }
+ thiserror = "1.0.59"
+ time = { version = "0.3.36" }
diff --git a/debian/patches/relax-textwrap.diff b/debian/patches/relax-textwrap.diff
new file mode 100644
index 0000000000000000000000000000000000000000..41821a334f9f09b9b16e98ac7efa8f1c9cc24f53
--- /dev/null
+++ b/debian/patches/relax-textwrap.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -325,7 +325,7 @@ smallvec = { version = "1", features = [
+ tempfile = "3"
+ uutils_term_grid = "0.6"
+ terminal_size = "0"
+-textwrap = { version = "0.16.1", features = ["terminal_size"] }
++textwrap = { version = "0.16", features = ["terminal_size"] }
+ thiserror = "1.0.59"
+ time = { version = "0.3.36" }
+ unicode-segmentation = "1"
diff --git a/debian/patches/relax-unicode-segmentation.diff b/debian/patches/relax-unicode-segmentation.diff
index 13b33b3f97e378bc211b6315e6b16d88653a32b1..46bf60bbcf58d89f1d15c05cc2fc99567a316a22 100644
--- a/debian/patches/relax-unicode-segmentation.diff
+++ b/debian/patches/relax-unicode-segmentation.diff
@@ -1,13 +1,13 @@
-Index: coreutils/src/uu/more/Cargo.toml
+Index: coreutils/Cargo.toml
===================================================================
---- coreutils.orig/src/uu/more/Cargo.toml
-+++ coreutils/src/uu/more/Cargo.toml
-@@ -20,7 +20,7 @@ uucore = { version=">=0.0.15", package="
- crossterm = ">=0.19"
- atty = "0.2"
- unicode-width = "0.1.7"
--unicode-segmentation = "1.9.0"
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -327,7 +327,7 @@ terminal_size = "0.3.0"
+ textwrap = { version = "0.16.1", features = ["terminal_size"] }
+ thiserror = "1.0.59"
+ time = { version = "0.3.36" }
+-unicode-segmentation = "1.11.0"
+unicode-segmentation = "1"
-
- [target.'cfg(all(unix, not(target_os = "fuchsia")))'.dependencies]
- nix = { version = "0.25", default-features = false }
+ unicode-width = "0.1.12"
+ utf-8 = "0.7.6"
+ walkdir = "2.5"
diff --git a/debian/patches/relax-users.diff b/debian/patches/relax-users.diff
deleted file mode 100644
index d1d073bb0fe18674410a30f7e6b8fb997d6fea20..0000000000000000000000000000000000000000
--- a/debian/patches/relax-users.diff
+++ /dev/null
@@ -1,13 +0,0 @@
-Index: coreutils/Cargo.toml
-===================================================================
---- coreutils.orig/Cargo.toml
-+++ coreutils/Cargo.toml
-@@ -412,7 +412,7 @@ rlimit = "0.8.3"
-
- [target.'cfg(unix)'.dev-dependencies]
- nix = { version = "0.25", default-features = false, features = ["process", "signal", "user"] }
--rust-users = { version="0.11", package="users" }
-+rust-users = { version="0", package="users" }
- rand_pcg = "0.3"
-
- [build-dependencies]
diff --git a/debian/patches/relax-walkdir.diff b/debian/patches/relax-walkdir.diff
new file mode 100644
index 0000000000000000000000000000000000000000..0918c3cf64b51cb9ef4e18ab7bd6f3a5e5a9758c
--- /dev/null
+++ b/debian/patches/relax-walkdir.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -331,7 +331,7 @@ time = { version = "0.3.36" }
+ unicode-segmentation = "1"
+ unicode-width = "0.1.12"
+ utf-8 = "0.7.6"
+-walkdir = "2.5"
++walkdir = "2"
+ #winapi-util = "0.1.8"
+ #windows-sys = { version = "0.48.0", default-features = false }
+ xattr = "1"
diff --git a/debian/patches/relax-wild.diff b/debian/patches/relax-wild.diff
new file mode 100644
index 0000000000000000000000000000000000000000..e808c984dd9de1d77f9689d88c65b36bdb87489d
--- /dev/null
+++ b/debian/patches/relax-wild.diff
@@ -0,0 +1,13 @@
+Index: coreutils/src/uucore/Cargo.toml
+===================================================================
+--- coreutils.orig/src/uucore/Cargo.toml
++++ coreutils/src/uucore/Cargo.toml
+@@ -23,7 +23,7 @@ uucore_procs = { workspace = true }
+ number_prefix = { workspace = true }
+ dns-lookup = { version = "1", optional = true }
+ dunce = { version = "1", optional = true }
+-wild = "2.2.1"
++wild = "2"
+ glob = { workspace = true }
+ # * optional
+ itertools = { workspace = true, optional = true }
diff --git a/debian/patches/relax-xattr.diff b/debian/patches/relax-xattr.diff
new file mode 100644
index 0000000000000000000000000000000000000000..fb04b004fc33dd01866be3f83dde728f5c027178
--- /dev/null
+++ b/debian/patches/relax-xattr.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -333,7 +333,7 @@ utf-8 = "0.7.6"
+ walkdir = "2.5"
+ #winapi-util = "0.1.8"
+ #windows-sys = { version = "0.48.0", default-features = false }
+-xattr = "1.3.1"
++xattr = "1"
+ zip = { version = "0", default-features = false, features = ["deflate"] }
+
+ hex = "0"
diff --git a/debian/patches/relax-z85.diff b/debian/patches/relax-z85.diff
index 91fc70d210d5e12f32c13b67dd7fa02465ce8919..f35e93ff621e132a424e2cd9be64881ffa67d4e4 100644
--- a/debian/patches/relax-z85.diff
+++ b/debian/patches/relax-z85.diff
@@ -2,12 +2,12 @@ Index: coreutils/src/uucore/Cargo.toml
===================================================================
--- coreutils.orig/src/uucore/Cargo.toml
+++ coreutils/src/uucore/Cargo.toml
-@@ -31,7 +31,7 @@ time = { version="0.3", optional=true, f
+@@ -36,7 +36,7 @@ time = { workspace = true, optional = tr
# * "problem" dependencies (pinned)
- data-encoding = { version="2.1", optional=true }
- data-encoding-macro = { version="0.1.12", optional=true }
--z85 = { version="3.0.5", optional=true }
-+z85 = { version="3", optional=true }
- libc = { version="0.2.137", optional=true }
- once_cell = "1"
+ data-encoding = { version = "2.6", optional = true }
+ data-encoding-macro = { version = "0.1.15", optional = true }
+-z85 = { version = "3.0.5", optional = true }
++z85 = { version = "3", optional = true }
+ libc = { workspace = true, optional = true }
+ once_cell = { workspace = true }
os_display = "0.1.3"
diff --git a/debian/patches/relax-zip.diff b/debian/patches/relax-zip.diff
new file mode 100644
index 0000000000000000000000000000000000000000..d9e1374b18490452fd1002b7ab6d7c591817ddc8
--- /dev/null
+++ b/debian/patches/relax-zip.diff
@@ -0,0 +1,13 @@
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -334,7 +334,7 @@ walkdir = "2.5"
+ #winapi-util = "0.1.8"
+ #windows-sys = { version = "0.48.0", default-features = false }
+ xattr = "1.3.1"
+-zip = { version = "1.1.4", default-features = false, features = ["deflate"] }
++zip = { version = "0", default-features = false, features = ["deflate"] }
+
+ hex = "0.4.3"
+ md-5 = "0.10"
diff --git a/debian/patches/remove-dep-rstest.diff b/debian/patches/remove-dep-rstest.diff
deleted file mode 100644
index 966ecaaaf9ab3f7cd2c4884ec7dd211ce43dfefe..0000000000000000000000000000000000000000
--- a/debian/patches/remove-dep-rstest.diff
+++ /dev/null
@@ -1,13 +0,0 @@
-Index: coreutils/Cargo.toml
-===================================================================
---- coreutils.orig/Cargo.toml
-+++ coreutils/Cargo.toml
-@@ -404,7 +404,7 @@ uucore = { version=">=0.0.17", package="
- walkdir = "2.2"
- atty = "0.2"
- hex-literal = "0.3.1"
--rstest = "0.16.0"
-+#rstest = "0.16.0"
-
- [target.'cfg(any(target_os = "linux", target_os = "android"))'.dev-dependencies]
- procfs = { version = "0.14", default-features = false }
diff --git a/debian/patches/rust-ini-0.18.diff b/debian/patches/rust-ini-0.18.diff
new file mode 100644
index 0000000000000000000000000000000000000000..ceaf07551256464dbfbb1ac4b4e973f632414a4c
--- /dev/null
+++ b/debian/patches/rust-ini-0.18.diff
@@ -0,0 +1,30 @@
+This patch reverts part of https://github.com/uutils/coreutils/commit/19901055a24b7c4cd2446b5e05ab572b1d81318d
+it seems removing the .iter fixes a warning with newer rust-ini but breaks
+the build with older rust-ini
+
+Index: rust-coreutils-0.0.27/Cargo.toml
+===================================================================
+--- rust-coreutils-0.0.27.orig/Cargo.toml
++++ rust-coreutils-0.0.27/Cargo.toml
+@@ -316,7 +316,7 @@ rayon = "1"
+ redox_syscall = "0"
+ regex = "1"
+ rstest = "0"
+-rust-ini = "0.21.0"
++rust-ini = ">= 0.18.0"
+ same-file = "1.0.6"
+ self_cell = "1"
+ selinux = "0.4.4"
+Index: rust-coreutils-0.0.27/src/uu/env/src/env.rs
+===================================================================
+--- rust-coreutils-0.0.27.orig/src/uu/env/src/env.rs
++++ rust-coreutils-0.0.27/src/uu/env/src/env.rs
+@@ -165,7 +165,7 @@ fn load_config_file(opts: &mut Options)
+
+ for (_, prop) in &conf {
+ // ignore all INI section lines (treat them as comments)
+- for (key, value) in prop {
++ for (key, value) in prop.iter() {
+ env::set_var(key, value);
+ }
+ }
diff --git a/debian/patches/series b/debian/patches/series
index a27142d1057bca06457ab764093ecd69dac3198e..208b236fb854e5ef9d8c7d78e65af4c48228f5f2 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1,39 +1,71 @@
-relax-users.diff
-lower-zip.diff
disable-coz.diff
lower-rayon.diff
-relax-cpp-build.diff
-relax-strum.diff
fix-install-path.diff
fix-completion-path.diff
bump-exacl.diff
delegate-ln-to-dh.diff
-relax-once-cell.diff
relax-regex.diff
relax-z85.diff
relax-unicode-segmentation.diff
bump-crossterm.diff
-#add_path.diff
lower-onig.diff
relax-md-5.diff
-lower-half.diff
-relax-ouroboro.diff
relax-notify.diff
-relax-nix.diff
lower-phf.diff
-remove-dep-rstest.diff
relax-platform-info.diff
-relax-bstr.diff
disable-windows.diff
relax-smallvec.diff
fix-hashsum.diff
relax-terminal-size.diff
relax-binary-heap-plus.diff
-unbreak-s390x.patch
+relax-clap.diff
+relax-zip.diff
+relax-chrono.diff
+relax-hex-literal.diff
+relax-tempfile.diff
+relax-procfs.diff
+relax-rlimit.diff
+relax-blake2.diff
+relax-data-encoding.diff
+relax-digest.diff
+relax-dns-lookup.diff
+relax-dunce.diff
+relax-itertools.diff
+relax-gcd.diff
+lower-memmap2.diff
+relax-nom.diff
+relax-redoc.diff
+relax-xattr.diff
+relax-fs-extra.diff
+relax-libc.diff
+relax-once-cell.diff
+relax-bstr.diff
+relax-bigdecimal.diff
+relax-fundu.diff
+relax-signal-hook.diff
+relax-lscolors.diff
+relax-bigint.diff
+relax-num-traits.diff
+relax-walkdir.diff
+relax-wild.diff
+relax-parse-datetime.diff
+relax-byteorder.diff
+relax-rstest.diff
+relax-self-cell.diff
+relax-bytecount.diff
+relax-textwrap.diff
+relax-hostname.diff
+relax-term-diff.diff
+upgrade-term-grid.diff
+use-mem-zeroed.diff
+relax-memchr.diff
+relax-fts.diff
+disable-factor.diff
+fix-prefix.diff
+nix-0.29.diff
+rust-ini-0.18.diff
# Apertis patches
-apertis/HACK-cp-mv-add-dummy-missing-arguments.patch
-apertis/Add-hack-for-missing-argument-to-mkdir.patch
-apertis/tsort-Switch-to-BTreeHash-and-BTreeSet.patch
-apertis/size-optimize.patch
-apertis/Switch-release-builds-back-to-thin-LTO.patch
+apertis/HACK-Add-dummy-missing-argument-to-cp-mv.patch
+apertis/HACK-Add-dummy-missing-argument-to-mkdir.patch
+apertis/Tweak-release-build-profile.patch
diff --git a/debian/patches/unbreak-s390x.patch b/debian/patches/unbreak-s390x.patch
deleted file mode 100644
index 4cf8e64eaf5d9ae01c2b1cfc0a3f9915d07b18a9..0000000000000000000000000000000000000000
--- a/debian/patches/unbreak-s390x.patch
+++ /dev/null
@@ -1,67 +0,0 @@
-From 9796e70a286cea0df080d440c10cedc649b76ec4 Mon Sep 17 00:00:00 2001
-From: Joining7943 <111500881+Joining7943@users.noreply.github.com>
-Date: Mon, 23 Jan 2023 21:13:59 +0100
-Subject: [PATCH] uucore: Fix #4298: Build on s390x and riscv64 architectures
- fails
-
----
- src/uucore/src/lib/features/fs.rs | 2 ++
- src/uucore/src/lib/features/fsext.rs | 4 ++++
- 2 files changed, 6 insertions(+)
-
-diff --git a/src/uucore/src/lib/features/fs.rs b/src/uucore/src/lib/features/fs.rs
-index d5c7cbac1f..c135f4acc7 100644
---- a/src/uucore/src/lib/features/fs.rs
-+++ b/src/uucore/src/lib/features/fs.rs
-@@ -115,6 +115,7 @@ impl FileInformation {
- not(target_os = "android"),
- not(target_os = "freebsd"),
- not(target_arch = "aarch64"),
-+ not(target_arch = "riscv64"),
- target_pointer_width = "64"
- ))]
- return self.0.st_nlink;
-@@ -125,6 +126,7 @@ impl FileInformation {
- target_os = "android",
- target_os = "freebsd",
- target_arch = "aarch64",
-+ target_arch = "riscv64",
- not(target_pointer_width = "64")
- )
- ))]
-diff --git a/src/uucore/src/lib/features/fsext.rs b/src/uucore/src/lib/features/fsext.rs
-index fcace586de..43b1a6cb58 100644
---- a/src/uucore/src/lib/features/fsext.rs
-+++ b/src/uucore/src/lib/features/fsext.rs
-@@ -619,6 +619,7 @@ impl FsMeta for StatFs {
- not(target_vendor = "apple"),
- not(target_os = "android"),
- not(target_os = "freebsd"),
-+ not(target_arch = "s390x"),
- target_pointer_width = "64"
- ))]
- return self.f_bsize;
-@@ -626,6 +627,7 @@ impl FsMeta for StatFs {
- not(target_env = "musl"),
- not(target_os = "freebsd"),
- any(
-+ target_arch = "s390x",
- target_vendor = "apple",
- target_os = "android",
- not(target_pointer_width = "64")
-@@ -681,6 +683,7 @@ impl FsMeta for StatFs {
- not(target_vendor = "apple"),
- not(target_os = "android"),
- not(target_os = "freebsd"),
-+ not(target_arch = "s390x"),
- target_pointer_width = "64"
- ))]
- return self.f_type;
-@@ -690,6 +693,7 @@ impl FsMeta for StatFs {
- target_vendor = "apple",
- target_os = "android",
- target_os = "freebsd",
-+ target_arch = "s390x",
- not(target_pointer_width = "64")
- )
- ))]
diff --git a/debian/patches/upgrade-term-grid.diff b/debian/patches/upgrade-term-grid.diff
new file mode 100644
index 0000000000000000000000000000000000000000..474cdba96769981474c68588564c438c136f71b4
--- /dev/null
+++ b/debian/patches/upgrade-term-grid.diff
@@ -0,0 +1,24 @@
+Index: coreutils/src/uu/ls/src/ls.rs
+===================================================================
+--- coreutils.orig/src/uu/ls/src/ls.rs
++++ coreutils/src/uu/ls/src/ls.rs
+@@ -15,6 +15,7 @@ use lscolors::{LsColors, Style};
+ use ansi_width::ansi_width;
+ use std::{cell::OnceCell, num::IntErrorKind};
+ use std::{collections::HashSet, io::IsTerminal};
++use ansi_width::ansi_width;
+
+ #[cfg(windows)]
+ use std::os::windows::fs::MetadataExt;
+Index: coreutils/Cargo.toml
+===================================================================
+--- coreutils.orig/Cargo.toml
++++ coreutils/Cargo.toml
+@@ -353,6 +353,7 @@ uu_ls = { version = ">=0.0.18", path = "
+ uu_base32 = { version = ">=0.0.18", path = "src/uu/base32" }
+
+ [dependencies]
++unicode-width = { workspace = true }
+ clap = { workspace = true }
+ once_cell = { workspace = true }
+ uucore = { workspace = true }
diff --git a/debian/patches/use-mem-zeroed.diff b/debian/patches/use-mem-zeroed.diff
new file mode 100644
index 0000000000000000000000000000000000000000..29198bee380647cb2f350cc3d04534982ace0c25
--- /dev/null
+++ b/debian/patches/use-mem-zeroed.diff
@@ -0,0 +1,18 @@
+Index: rust-coreutils-0.0.26/src/uu/date/src/date.rs
+===================================================================
+--- rust-coreutils-0.0.26.orig/src/uu/date/src/date.rs
++++ rust-coreutils-0.0.26/src/uu/date/src/date.rs
+@@ -445,10 +445,9 @@ fn set_system_datetime(_date: DateTime<U
+ /// `<https://linux.die.net/man/3/clock_settime>`
+ /// `<https://www.gnu.org/software/libc/manual/html_node/Time-Types.html>`
+ fn set_system_datetime(date: DateTime<Utc>) -> UResult<()> {
+- let timespec = timespec {
+- tv_sec: date.timestamp() as _,
+- tv_nsec: date.timestamp_subsec_nanos() as _,
+- };
++ let mut timespec: timespec = unsafe { std::mem::zeroed() };
++ timespec.tv_sec = date.timestamp() as _;
++ timespec.tv_nsec = date.timestamp_subsec_nanos() as _;
+
+ let result = unsafe { clock_settime(CLOCK_REALTIME, ×pec) };
+
diff --git a/debian/rules b/debian/rules
index 480823be870c2c32354a3416ce4adcd478aa4b80..8f64cf9c71212ddcda124f0b8d78ec31a8e13cad 100755
--- a/debian/rules
+++ b/debian/rules
@@ -7,6 +7,7 @@ export DEB_HOST_RUST_TYPE DEB_HOST_GNU_TYPE
export CARGO_PROFILE_RELEASE_DEBUG=true
export SKIP_UTILS=stdbuf
VERSION := $(shell dpkg-parsechangelog -S Version|sed -e "s|.*~\(.*\)-.*|\1|g")
+UPSTREAM_VERSION := $(shell dpkg-parsechangelog -S Version|cut -d- -f1)
# Build a multicall binary instead of multiple binaries
# to reduce the storage footprint
@@ -21,26 +22,37 @@ override_dh_auto_test:
override_dh_auto_install:
CARGO_HOME=$(CURDIR)/debian/cargo_home DEB_CARGO_CRATE=coreutils_$(VERSION) /usr/share/cargo/bin/cargo prepare-debian debian/cargo_registry --link-from-system
+#use thin rather than full lto on 32-bit to avoid running out of address space.
+ifeq ($(DEB_HOST_ARCH_BITS),32)
+ sed -i 's/lto = true/lto = "thin"/' Cargo.toml
+endif
CARGO_HOME=$(CURDIR)/debian/cargo_home DESTDIR=$(CURDIR)/debian/tmp/ make SELINUX_ENABLED=1 PROFILE=release MULTICALL=$(MULTICALL) install
- rm -rf $(CURDIR)/debian/tmp/usr/local/bin/hostname \
- $(CURDIR)/debian/tmp/usr/local/bin/kill \
- $(CURDIR)/debian/tmp/usr/local/bin/more \
- $(CURDIR)/debian/tmp/usr/local/bin/uptime
+ifeq ($(DEB_HOST_ARCH_BITS),32)
+ sed -i 's/lto = "thin"/lto = true/' Cargo.toml
+endif
# Create the symlink early to be able to generate the manpages
+ cd debian/tmp/usr/share/zsh/site-functions && mkdir rust-coreutils && chmod -x _* && mv _* rust-coreutils
+ cd debian/tmp/usr/share/bash-completion/completions/ && chmod -x rust-*
+ cd debian/tmp/usr/share/fish/vendor_completions.d/ && chmod -x *.fish
+ cd debian/tmp/usr/bin && mv rust-coreutils coreutils && rm rust-*
+# cd debian/tmp/usr/share/fish/vendor_completions.d && for f in *fish; do mv $$f rust-$$f; done
dh_link
override_dh_missing:
dh_missing --fail-missing
-execute_before_dh_installman:
- cd $(CURDIR)/debian/rust-coreutils/usr/bin/; \
- for f in *; do \
- filename=$$(basename $$f); \
- help2man --no-info $$f > $(CURDIR)/docs/$$filename.1; \
- done
-
- cd $(CURDIR)/debian/tmp/usr/bin/; \
- help2man --no-info coreutils > $(CURDIR)/docs/coreutils.1 || true
-
- # test --help returns nothing
- rm -f $(CURDIR)/docs/rust-test.1
+override_dh_dwz:
+ # Don't do anything. fails because of the
+ # https://github.com/rust-lang/rust/issues/66118
+
+#use lower debuginfo level on 32-bit to avoid running out of address space.
+ifeq ($(DEB_HOST_ARCH_BITS),32)
+execute_after_dh_auto_configure:
+ if test -f debian/cargo_home/config; then \
+ sed -i s/debuginfo=2/debuginfo=1/ debian/cargo_home/config; \
+ fi
+endif
+
+override_dh_clean:
+ rm -f Cargo.toml.orig Cargo.lock
+ dh_clean
diff --git a/debian/rust-coreutils.bash-completion b/debian/rust-coreutils.bash-completion
index c0414d11c965f4c57012f52385d0bd3411d55d5c..7405deef25b1caf9a4f77cae58e7e4cbf0fafee4 100644
--- a/debian/rust-coreutils.bash-completion
+++ b/debian/rust-coreutils.bash-completion
@@ -73,6 +73,7 @@ bash-completions/rust-sleep
bash-completions/rust-sort
bash-completions/rust-split
bash-completions/rust-stat
+bash-completions/rust-stdbuf
bash-completions/rust-sum
bash-completions/rust-sync
bash-completions/rust-tac
diff --git a/debian/rust-coreutils.install b/debian/rust-coreutils.install
index d468370418732a98cfb3c51ce68b784d9decc852..4c1890c92a764ff2cb7af79694ed55fac42e7a4b 100644
--- a/debian/rust-coreutils.install
+++ b/debian/rust-coreutils.install
@@ -2,4 +2,4 @@ usr/bin/coreutils /usr/bin
usr/share/bash-completion/completions/
usr/share/zsh/site-functions/rust-coreutils/
-usr/share/fish/completions/
+usr/share/fish/vendor_completions.d/
diff --git a/debian/rust-coreutils.links b/debian/rust-coreutils.links
index a73132e4b5af4ab9011bdc867fe10d651627365e..167ae642089a923ad2ca1e1eea905b11bfce8b93 100644
--- a/debian/rust-coreutils.links
+++ b/debian/rust-coreutils.links
@@ -14,34 +14,34 @@ usr/bin/coreutils usr/bin/shake128sum
usr/bin/coreutils usr/bin/shake256sum
# GNU/Coreutils: Installed in /bin/
-usr/bin/coreutils bin/cat
-usr/bin/coreutils bin/chgrp
-usr/bin/coreutils bin/chmod
-usr/bin/coreutils bin/chown
-usr/bin/coreutils bin/cp
-usr/bin/coreutils bin/date
-usr/bin/coreutils bin/dd
-usr/bin/coreutils bin/df
-usr/bin/coreutils bin/dir
-usr/bin/coreutils bin/echo
-usr/bin/coreutils bin/false
-usr/bin/coreutils bin/ln
-usr/bin/coreutils bin/ls
-usr/bin/coreutils bin/mkdir
-usr/bin/coreutils bin/mknod
-usr/bin/coreutils bin/mktemp
-usr/bin/coreutils bin/mv
-usr/bin/coreutils bin/pwd
-usr/bin/coreutils bin/readlink
-usr/bin/coreutils bin/rm
-usr/bin/coreutils bin/rmdir
-usr/bin/coreutils bin/sleep
-#usr/bin/coreutils bin/stty
-usr/bin/coreutils bin/sync
-usr/bin/coreutils bin/touch
-usr/bin/coreutils bin/true
-usr/bin/coreutils bin/uname
-usr/bin/coreutils bin/vdir
+usr/bin/coreutils usr/bin/cat
+usr/bin/coreutils usr/bin/chgrp
+usr/bin/coreutils usr/bin/chmod
+usr/bin/coreutils usr/bin/chown
+usr/bin/coreutils usr/bin/cp
+usr/bin/coreutils usr/bin/date
+usr/bin/coreutils usr/bin/dd
+usr/bin/coreutils usr/bin/df
+usr/bin/coreutils usr/bin/dir
+usr/bin/coreutils usr/bin/echo
+usr/bin/coreutils usr/bin/false
+usr/bin/coreutils usr/bin/ln
+usr/bin/coreutils usr/bin/ls
+usr/bin/coreutils usr/bin/mkdir
+usr/bin/coreutils usr/bin/mknod
+usr/bin/coreutils usr/bin/mktemp
+usr/bin/coreutils usr/bin/mv
+usr/bin/coreutils usr/bin/pwd
+usr/bin/coreutils usr/bin/readlink
+usr/bin/coreutils usr/bin/rm
+usr/bin/coreutils usr/bin/rmdir
+usr/bin/coreutils usr/bin/sleep
+#usr/bin/coreutils usr/bin/stty
+usr/bin/coreutils usr/bin/sync
+usr/bin/coreutils usr/bin/touch
+usr/bin/coreutils usr/bin/true
+usr/bin/coreutils usr/bin/uname
+usr/bin/coreutils usr/bin/vdir
# GNU/Coreutils: Installed in /usr/bin/
usr/bin/coreutils usr/bin/[
@@ -61,7 +61,7 @@ usr/bin/coreutils usr/bin/du
usr/bin/coreutils usr/bin/env
usr/bin/coreutils usr/bin/expand
usr/bin/coreutils usr/bin/expr
-usr/bin/coreutils usr/bin/factor
+#usr/bin/coreutils usr/bin/factor
usr/bin/coreutils usr/bin/fmt
usr/bin/coreutils usr/bin/fold
usr/bin/coreutils usr/bin/groups
@@ -94,6 +94,7 @@ usr/bin/coreutils usr/bin/shuf
usr/bin/coreutils usr/bin/sort
usr/bin/coreutils usr/bin/split
usr/bin/coreutils usr/bin/stat
+usr/bin/coreutils usr/bin/stdbuf
usr/bin/coreutils usr/bin/sum
usr/bin/coreutils usr/bin/tac
usr/bin/coreutils usr/bin/tail
diff --git a/debian/rust-coreutils.manpages b/debian/rust-coreutils.manpages
index 4ac1cab753011b7c5bfad45fc37c39f289060d98..758980473c4266df8db1f825c361de38691a60ac 100644
--- a/debian/rust-coreutils.manpages
+++ b/debian/rust-coreutils.manpages
@@ -1,2 +1 @@
-docs/*.1
-docs/coreutils.1
+usr/share/man/man1/rust-*.1
diff --git a/debian/source/lintian-overrides b/debian/source/lintian-overrides
index f45ef143f7178017ef32a04a5abd9791ec6fe6cf..67bfea4a72bb20ab5ca073fe1ddedfa96b61692e 100644
--- a/debian/source/lintian-overrides
+++ b/debian/source/lintian-overrides
@@ -1,5 +1,3 @@
# Just tests
-source: source-is-missing *tests/fixtures/install/helloworld_android*
-source: source-is-missing *tests/fixtures/install/helloworld_linux*
-source: unknown-file-in-debian-source format.debcargo.hint
-
+source-is-missing *tests/fixtures/install/helloworld_*
+unknown-file-in-debian-source *debian/source/format.debcargo.hint*
diff --git a/deny.toml b/deny.toml
index a2578384d6f59faa8646eed8796113975ded30e0..3ee9df5c191a575eda14dc724a95f157e99446a5 100644
--- a/deny.toml
+++ b/deny.toml
@@ -6,33 +6,28 @@
[advisories]
db-path = "~/.cargo/advisory-db"
db-urls = ["https://github.com/rustsec/advisory-db"]
-vulnerability = "warn"
-unmaintained = "warn"
+version = 2
yanked = "warn"
-notice = "warn"
ignore = [
- #"RUSTSEC-0000-0000",
+ #"RUSTSEC-0000-0000",
]
# This section is considered when running `cargo deny check licenses`
# More documentation for the licenses section can be found here:
# https://embarkstudios.github.io/cargo-deny/checks/licenses/cfg.html
[licenses]
-unlicensed = "deny"
+version = 2
allow = [
- "MIT",
- "Apache-2.0",
- "ISC",
- "BSD-2-Clause",
- "BSD-2-Clause-FreeBSD",
- "BSD-3-Clause",
- "CC0-1.0",
- "MPL-2.0", # XXX considered copyleft?
- "Unicode-DFS-2016",
+ "MIT",
+ "Apache-2.0",
+ "ISC",
+ "BSD-2-Clause",
+ "BSD-2-Clause-FreeBSD",
+ "BSD-3-Clause",
+ "BSL-1.0",
+ "CC0-1.0",
+ "Unicode-DFS-2016",
]
-copyleft = "deny"
-allow-osi-fsf-free = "neither"
-default = "deny"
confidence-threshold = 0.8
[[licenses.clarify]]
@@ -59,24 +54,63 @@ highlight = "all"
# introduces it.
# spell-checker: disable
skip = [
- # blake2d_simd
- { name = "arrayvec", version = "=0.7.2" },
- # quickcheck
- { name = "env_logger", version = "=0.8.4" },
- # tempfile
- { name = "remove_dir_all", version = "=0.5.3" },
- # console (via indicatif)
- { name = "terminal_size", version = "=0.1.17" },
- # nix
- { name = "memoffset", version = "=0.6.5"},
- # blake2b_simd
- { name = "constant_time_eq", version = "=0.1.5"},
+ # rustix
+ { name = "linux-raw-sys", version = "0.3.8" },
+ # terminal_size
+ { name = "rustix", version = "0.37.26" },
+ # notify
+ { name = "windows-sys", version = "0.45.0" },
+ # various crates
+ { name = "windows-sys", version = "0.48.0" },
+ # windows-sys
+ { name = "windows-targets", version = "0.42.2" },
+ # windows-sys
+ { name = "windows-targets", version = "0.48.0" },
+ # windows-targets
+ { name = "windows_aarch64_gnullvm", version = "0.42.2" },
+ # windows-targets
+ { name = "windows_aarch64_msvc", version = "0.42.2" },
+ # windows-targets
+ { name = "windows_i686_gnu", version = "0.42.2" },
+ # windows-targets
+ { name = "windows_i686_msvc", version = "0.42.2" },
+ # windows-targets
+ { name = "windows_x86_64_gnu", version = "0.42.2" },
+ # windows-targets
+ { name = "windows_x86_64_gnullvm", version = "0.42.2" },
+ # windows-targets
+ { name = "windows_x86_64_msvc", version = "0.42.2" },
+ # windows-targets
+ { name = "windows_aarch64_gnullvm", version = "0.48.0" },
+ # windows-targets
+ { name = "windows_aarch64_msvc", version = "0.48.0" },
+ # windows-targets
+ { name = "windows_i686_gnu", version = "0.48.0" },
+ # windows-targets
+ { name = "windows_i686_msvc", version = "0.48.0" },
+ # windows-targets
+ { name = "windows_x86_64_gnu", version = "0.48.0" },
+ # windows-targets
+ { name = "windows_x86_64_gnullvm", version = "0.48.0" },
+ # windows-targets
+ { name = "windows_x86_64_msvc", version = "0.48.0" },
+ # data-encoding-macro-internal
+ { name = "syn", version = "1.0.109" },
+ # various crates
+ { name = "bitflags", version = "1.3.2" },
+ # clap_builder, textwrap
+ { name = "terminal_size", version = "0.2.6" },
+ # filetime, parking_lot_core
+ { name = "redox_syscall", version = "0.4.1" },
+ # bindgen
+ { name = "itertools", version = "0.12.1" },
]
# spell-checker: enable
# This section is considered when running `cargo deny check sources`.
# More documentation about the 'sources' section can be found here:
# https://embarkstudios.github.io/cargo-deny/checks/sources/cfg.html
+
[sources]
unknown-registry = "warn"
unknown-git = "warn"
diff --git a/docs/.gitignore b/docs/.gitignore
index c669da8f672eb962305768bd56082d42b0afd7e7..be017dfbe7c9d176c4d815cd81446217af6c166c 100644
--- a/docs/.gitignore
+++ b/docs/.gitignore
@@ -1,4 +1,5 @@
book
src/utils
src/SUMMARY.md
+src/platform_table.md
tldr.zip
\ No newline at end of file
diff --git a/docs/book.toml b/docs/book.toml
index b9b31cfaf6199df37191414295e8bcd6d6a9c6af..ff91c465288ee0686e21eae8bc0e751b074f7007 100644
--- a/docs/book.toml
+++ b/docs/book.toml
@@ -6,8 +6,8 @@ src = "src"
title = "uutils Documentation"
[output.html]
-git-repository-url = "https://github.com/rust-lang/cargo/tree/master/src/doc/src"
+git-repository-url = "https://github.com/uutils/coreutils/tree/main/docs/src"
[preprocessor.toc]
command = "mdbook-toc"
-renderer = ["html"]
\ No newline at end of file
+renderer = ["html"]
diff --git a/docs/compiles_table.csv b/docs/compiles_table.csv
index d18854e0e91cc0ad9251493c744692d30b6e62f3..e263067b78d619b2c282611f92373af765ade2a4 100644
--- a/docs/compiles_table.csv
+++ b/docs/compiles_table.csv
@@ -1,21 +1,21 @@
-target,arch,base32,base64,basename,cat,chgrp,chmod,chown,chroot,cksum,comm,cp,csplit,cut,date,df,dircolors,dirname,du,echo,env,expand,expr,factor,false,fmt,fold,groups,hashsum,head,hostid,hostname,id,install,join,kill,link,ln,logname,ls,mkdir,mkfifo,mknod,mktemp,more,mv,nice,nl,nohup,nproc,numfmt,od,paste,pathchk,pinky,printenv,printf,ptx,pwd,readlink,realpath,relpath,rm,rmdir,seq,shred,shuf,sleep,sort,split,stat,stdbuf,sum,sync,tac,tail,tee,test,timeout,touch,tr,true,truncate,tsort,tty,uname,unexpand,uniq,unlink,uptime,users,wc,who,whoami,yes,chcon,pr,dir,vdir,dd,basenc,runcon
-aarch64-unknown-linux-gnu,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-i686-unknown-linux-gnu,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-powerpc64-unknown-linux-gnu,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-riscv64gc-unknown-linux-gnu,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
-x86_64-unknown-linux-gnu,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-aarch64-pc-windows-msvc,0,0,0,0,0,101,101,101,101,0,0,0,0,0,0,0,0,0,101,0,0,0,101,0,0,0,0,101,0,0,0,0,101,101,0,101,0,0,0,101,0,101,101,0,0,0,101,0,101,0,0,0,0,101,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,101,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,101,0,101,0,101,101,0,0,0,0,0,0,0,0
-i686-pc-windows-gnu,0,0,0,0,0,101,101,101,101,0,0,0,0,0,0,0,0,0,101,0,0,0,101,0,0,0,0,101,0,0,0,0,101,101,0,101,0,0,0,0,0,101,101,0,0,0,101,0,101,0,0,0,0,101,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,101,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,101,0,101,0,101,0,0,0,0,0,0,0,0,0
-i686-pc-windows-msvc,0,0,0,0,0,101,101,101,101,0,0,0,0,0,0,0,0,0,101,0,0,0,101,0,0,0,0,101,0,0,0,0,101,101,0,101,0,0,0,0,0,101,101,0,0,0,101,0,101,0,0,0,0,101,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,101,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,101,0,101,0,101,0,0,0,0,0,0,0,0,0
-x86_64-pc-windows-gnu,0,0,0,0,0,101,101,101,101,0,0,0,0,0,0,0,0,0,101,0,0,0,101,0,0,0,0,101,0,0,0,0,101,101,0,101,0,0,0,0,0,101,101,0,0,0,101,0,101,0,0,0,0,101,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,101,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,101,0,101,0,101,0,0,0,0,0,0,0,0,0
-x86_64-pc-windows-msvc,0,0,0,0,0,101,101,101,101,0,0,0,0,0,0,0,0,0,101,0,0,0,101,0,0,0,0,101,0,0,0,0,101,101,0,101,0,0,0,0,0,101,101,0,0,0,101,0,101,0,0,0,0,101,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,101,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,101,0,101,0,101,0,0,0,0,0,0,0,0,0
-x86_64-apple-darwin,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-x86_64-unknown-freebsd,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-x86_64-unknown-netbsd,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,101,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,101,101,0,101,0,0,0,0,0,0,0,0,0
-aarch64-linux-android,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,101,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,101,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,101,101,0,101,0,0,0,0,0,0,0,0,0
-x86_64-linux-android,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,101,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,101,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,101,101,0,101,0,0,0,0,0,0,0,0,0
-x86_64-sun-solaris,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
-wasm32-wasi,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
-x86_64-unknown-redox,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
-aarch64-fuchsia,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
-x86_64-fuchsia,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
+target,arch,base32,base64,basename,cat,chgrp,chmod,chown,chroot,cksum,comm,cp,csplit,cut,date,df,dircolors,dirname,du,echo,env,expand,expr,factor,false,fmt,fold,groups,hashsum,head,hostid,hostname,id,install,join,kill,link,ln,logname,ls,mkdir,mkfifo,mknod,mktemp,more,mv,nice,nl,nohup,nproc,numfmt,od,paste,pathchk,pinky,printenv,printf,ptx,pwd,readlink,realpath,rm,rmdir,seq,shred,shuf,sleep,sort,split,stat,stdbuf,sum,sync,tac,tail,tee,test,timeout,touch,tr,true,truncate,tsort,tty,uname,unexpand,uniq,unlink,uptime,users,wc,who,whoami,yes,chcon,pr,dir,vdir,dd,basenc,runcon
+aarch64-unknown-linux-gnu,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+i686-unknown-linux-gnu,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+powerpc64-unknown-linux-gnu,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+riscv64gc-unknown-linux-gnu,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
+x86_64-unknown-linux-gnu,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+aarch64-pc-windows-msvc,0,0,0,0,0,101,101,101,101,0,0,0,0,0,0,0,0,0,101,0,0,0,101,0,0,0,0,101,0,0,0,0,101,101,0,101,0,0,0,101,0,101,101,0,0,0,101,0,101,0,0,0,0,101,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,101,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,101,0,101,0,101,101,0,0,0,0,0,0,0,0
+i686-pc-windows-gnu,0,0,0,0,0,101,101,101,101,0,0,0,0,0,0,0,0,0,101,0,0,0,101,0,0,0,0,101,0,0,0,0,101,101,0,101,0,0,0,0,0,101,101,0,0,0,101,0,101,0,0,0,0,101,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,101,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,101,0,101,0,101,0,0,0,0,0,0,0,0,0
+i686-pc-windows-msvc,0,0,0,0,0,101,101,101,101,0,0,0,0,0,0,0,0,0,101,0,0,0,101,0,0,0,0,101,0,0,0,0,101,101,0,101,0,0,0,0,0,101,101,0,0,0,101,0,101,0,0,0,0,101,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,101,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,101,0,101,0,101,0,0,0,0,0,0,0,0,0
+x86_64-pc-windows-gnu,0,0,0,0,0,101,101,101,101,0,0,0,0,0,0,0,0,0,101,0,0,0,101,0,0,0,0,101,0,0,0,0,101,101,0,101,0,0,0,0,0,101,101,0,0,0,101,0,101,0,0,0,0,101,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,101,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,101,0,101,0,101,0,0,0,0,0,0,0,0,0
+x86_64-pc-windows-msvc,0,0,0,0,0,101,101,101,101,0,0,0,0,0,0,0,0,0,101,0,0,0,101,0,0,0,0,101,0,0,0,0,101,101,0,101,0,0,0,0,0,101,101,0,0,0,101,0,101,0,0,0,0,101,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,101,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,101,0,101,0,101,0,0,0,0,0,0,0,0,0
+x86_64-apple-darwin,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+x86_64-unknown-freebsd,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+x86_64-unknown-netbsd,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,101,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,101,101,0,101,0,0,0,0,0,0,0,0,0
+aarch64-linux-android,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,101,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,101,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,101,101,0,101,0,0,0,0,0,0,0,0,0
+x86_64-linux-android,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,101,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,101,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,101,101,0,101,0,0,0,0,0,0,0,0,0
+x86_64-sun-solaris,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
+wasm32-wasi,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
+x86_64-unknown-redox,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
+aarch64-fuchsia,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
+x86_64-fuchsia,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
diff --git a/docs/compiles_table.py b/docs/compiles_table.py
index 83c98bed1de72f35e8441f95fe4a5bb8caed6c64..884b0bc39e1b61d043668147d24cd7010fc0eaca 100644
--- a/docs/compiles_table.py
+++ b/docs/compiles_table.py
@@ -10,7 +10,7 @@ from pathlib import Path
# third party dependencies
from tqdm import tqdm
-# spell-checker:ignore (libs) tqdm imap ; (shell/mac) xcrun ; (vars) nargs
+# spell-checker:ignore (libs) tqdm imap ; (shell/mac) xcrun ; (vars) nargs retcode csvfile
BINS_PATH = Path("../src/uu")
CACHE_PATH = Path("compiles_table.csv")
diff --git a/docs/src/build.md b/docs/src/build.md
index 6505b5b6e977b3f0a481e0ee194fec6b4e4336bc..e35b0ebe888b60b510ef75e5e16215f86cbc82c6 100644
--- a/docs/src/build.md
+++ b/docs/src/build.md
@@ -1,3 +1,3 @@
# Build from source
-{{#include ../../README.md:build }}
\ No newline at end of file
+{{#include ../../README.md:build }}
diff --git a/docs/src/contributing.md b/docs/src/contributing.md
index 79ef4d13b5ef248f5df55724982daced71d04e15..f69e1b3778fd1f03e2f84ba377ed6dd4aff1ecb8 100644
--- a/docs/src/contributing.md
+++ b/docs/src/contributing.md
@@ -1 +1,3 @@
-{{ #include ../../CONTRIBUTING.md }}
\ No newline at end of file
+<!-- markdownlint-disable MD041 -->
+
+{{ #include ../../CONTRIBUTING.md }}
diff --git a/docs/src/extensions.md b/docs/src/extensions.md
index 56f2edcc906434dae3082bf9bf2c3479b791fd30..fb91f7d543c83359b7f3599b7c912741f6204c82 100644
--- a/docs/src/extensions.md
+++ b/docs/src/extensions.md
@@ -5,6 +5,26 @@ features that are not supported by GNU coreutils. We take care not to introduce
features that are incompatible with the GNU coreutils. Below is a list of uutils
extensions.
+## General
+
+GNU coreutils provides two ways to define short options taking an argument:
+
+```
+$ ls -w 80
+$ ls -w80
+```
+
+We support a third way:
+
+```
+$ ls -w=80
+```
+
+## `env`
+
+`env` has an additional `-f`/`--file` flag that can parse `.env` files and set
+variables accordingly. This feature is adopted from `dotenv` style packages.
+
## `cp`
`cp` can display a progress bar when the `-g`/`--progress` flag is set.
@@ -36,4 +56,40 @@ therefore welcomed.
## `cut`
-`cut` can separate fields by whitespace (Space and Tab) with `-w` flag. This feature is adopted from [FreeBSD](https://www.freebsd.org/cgi/man.cgi?cut).
\ No newline at end of file
+`cut` can separate fields by whitespace (Space and Tab) with `-w` flag. This
+feature is adopted from [FreeBSD](https://www.freebsd.org/cgi/man.cgi?cut).
+
+## `fmt`
+
+`fmt` has additional flags for prefixes: `-P`/`--skip-prefix`, `-x`/`--exact-prefix`, and
+`-X`/`--exact-skip-prefix`. With `-m`/`--preserve-headers`, an attempt is made to detect and preserve
+mail headers in the input. `-q`/`--quick` breaks lines more quickly. And `-T`/`--tab-width` defines the
+number of spaces representing a tab when determining the line length.
+
+## `seq`
+
+`seq` provides `-t`/`--terminator` to set the terminator character.
+
+## `ls`
+
+GNU `ls` provides two ways to use a long listing format: `-l` and `--format=long`. We support a
+third way: `--long`.
+
+GNU `ls --sort=VALUE` only supports special non-default sort orders.
+We support `--sort=name`, which makes it possible to override an earlier value.
+
+## `du`
+
+`du` allows `birth` and `creation` as values for the `--time` argument to show the creation time. It
+also provides a `-v`/`--verbose` flag.
+
+## `id`
+
+`id` has three additional flags:
+* `-P` displays the id as a password file entry
+* `-p` makes the output human-readable
+* `-A` displays the process audit user ID
+
+## `uptime`
+
+Similar to the proc-ps implementation and unlike GNU/Coreutils, `uptime` provides `-s`/`--since` to show since when the system is up.
diff --git a/docs/src/index.md b/docs/src/index.md
index 7bac8b8166a04fbc718e9b7bf0618a86dd27a4e9..0212b752659d4577c058f488485bd8ef3e7d95d3 100644
--- a/docs/src/index.md
+++ b/docs/src/index.md
@@ -1,5 +1,9 @@
+<!-- markdownlint-disable MD041 -->
+
{{#include logo.svg}}
+<!-- markdownlint-disable MD033 -->
+
<style>
/* Make the logo a bit bigger and center */
#logo {
diff --git a/docs/src/installation.md b/docs/src/installation.md
index cb5c8916369e1a8e3c0f22ae1c0e16f4b5f2a926..80afdda53f7150ad1e8d2dcd2ba522d1a0c0d9d8 100644
--- a/docs/src/installation.md
+++ b/docs/src/installation.md
@@ -1,4 +1,4 @@
-<!-- spell-checker:ignore pacman pamac nixpkgs -->
+<!-- spell-checker:ignore pacman pamac nixpkgs openmandriva conda winget openembedded yocto bblayers bitbake -->
# Installation
@@ -6,14 +6,15 @@ This is a list of uutils packages in various distributions and package managers.
Note that these are packaged by third-parties and the packages might contain
patches.
-You can also [build uutils from source](/build.md).
+You can also [build uutils from source](build.md).
<!-- toc -->
## Cargo
-[](https://repology.org/project/uutils-coreutils/versions)
-```bash
+[](https://crates.io/crates/coreutils)
+
+```shell
# Linux
cargo install coreutils --features unix
# MacOs
@@ -23,11 +24,12 @@ cargo install coreutils --features windows
```
## Linux
+
### Alpine
[](https://pkgs.alpinelinux.org/packages?name=uutils-coreutils)
-```bash
+```shell
apk update uutils-coreutils
```
@@ -35,69 +37,137 @@ apk update uutils-coreutils
### Arch
-[](https://archlinux.org/packages/community/x86_64/uutils-coreutils/)
+[](https://archlinux.org/packages/extra/x86_64/uutils-coreutils/)
-```bash
+```shell
pacman -S uutils-coreutils
```
### Debian
-[](https://packages.debian.org/sid/source/rust-coreutils)
+[](https://packages.debian.org/sid/source/rust-coreutils)
-```bash
+```shell
apt install rust-coreutils
+# To use it:
+export PATH=/usr/lib/cargo/bin/coreutils:$PATH
```
-> **Note**: Requires the `unstable` repository.
+### Gentoo
+
+[](https://packages.gentoo.org/packages/sys-apps/uutils-coreutils)
+
+```shell
+emerge -pv sys-apps/uutils-coreutils
+```
### Manjaro
-
-[](https://repology.org/project/uutils-coreutils/versions)
-[](https://repology.org/project/uutils-coreutils/versions)
-```bash
+[](https://packages.manjaro.org/?query=uutils-coreutils)
+[](https://packages.manjaro.org/?query=uutils-coreutils)
+[](https://packages.manjaro.org/?query=uutils-coreutils)
+
+```shell
pacman -S uutils-coreutils
# or
pamac install uutils-coreutils
```
### NixOS
-[](https://repology.org/project/uutils-coreutils/versions)
-```bash
+[](https://search.nixos.org/packages?query=uutils-coreutils)
+
+```shell
nix-env -iA nixos.uutils-coreutils
```
+### OpenMandriva Lx
+
+[](https://repology.org/project/uutils-coreutils/versions)
+
+```shell
+dnf install uutils-coreutils
+```
+
+### Ubuntu
+
+[](https://packages.ubuntu.com/source/lunar/rust-coreutils)
+
+```shell
+apt install rust-coreutils
+# To use it:
+export PATH=/usr/lib/cargo/bin/coreutils:$PATH
+```
+
## MacOS
### Homebrew
+
[](https://formulae.brew.sh/formula/uutils-coreutils)
-```bash
+```shell
brew install uutils-coreutils
```
### MacPorts
+
[](https://ports.macports.org/port/coreutils-uutils/)
```
port install coreutils-uutils
```
+## FreeBSD
+
+[](https://repology.org/project/rust-coreutils/versions)
+
+```sh
+pkg install rust-coreutils
+```
+
## Windows
+### Winget
+
+```shell
+winget install uutils.coreutils
+```
+
### Scoop
-[](https://scoop.sh/#/apps?q=uutils-coreutils&s=0&d=1&o=true)
-```bash
+[Scoop package](https://scoop.sh/#/apps?q=uutils-coreutils&s=0&d=1&o=true)
+
+```shell
scoop install uutils-coreutils
```
+## Alternative installers
+
+### Conda
+
+[Conda package](https://anaconda.org/conda-forge/uutils-coreutils)
+
+```
+conda install -c conda-forge uutils-coreutils
+```
+
+### Yocto
+
+[Yocto recipe](https://github.com/openembedded/meta-openembedded/tree/master/meta-oe/recipes-core/uutils-coreutils)
+
+The uutils-coreutils recipe is provided as part of the meta-openembedded yocto layer.
+Clone [poky](https://github.com/yoctoproject/poky) and [meta-openembedded](https://github.com/openembedded/meta-openembedded/tree/master), add
+`meta-openembedded/meta-oe` as layer in your `build/conf/bblayers.conf` file,
+and then either call `bitbake uutils-coreutils`, or use
+`PREFERRED_PROVIDER_coreutils = "uutils-coreutils"` in your `build/conf/local.conf` file and
+then build your usual yocto image.
+
## Non-standard packages
### `coreutils-hybrid` (AUR)
[](https://aur.archlinux.org/packages/coreutils-hybrid)
-A GNU coreutils / uutils coreutils hybrid package. Uses stable uutils programs mixed with GNU counterparts if uutils counterpart is unfinished or buggy.
+A GNU coreutils / uutils coreutils hybrid package. Uses stable uutils
+programs mixed with GNU counterparts if uutils counterpart is
+unfinished or buggy.
diff --git a/docs/src/multicall.md b/docs/src/multicall.md
index 5d7b8b169589dea219ef4a635a1082206c99b910..f4e29906bd2a6e258966067c3c706741fcd6d176 100644
--- a/docs/src/multicall.md
+++ b/docs/src/multicall.md
@@ -1,4 +1,5 @@
-# Multi-call binary
+# Multi-call binary
+
uutils includes a multi-call binary from which the utils can be invoked. This
reduces the binary size of the binary and can be useful for portability.
@@ -12,6 +13,7 @@ coreutils [util] [util options]
The `--help` flag will print a list of available utils.
## Example
-```
+
+```shell
coreutils ls -l
-```
\ No newline at end of file
+```
diff --git a/docs/src/oranda.css b/docs/src/oranda.css
new file mode 100644
index 0000000000000000000000000000000000000000..5581cc0c57fd5d3986a3986db8acc52ddf0c1f87
--- /dev/null
+++ b/docs/src/oranda.css
@@ -0,0 +1,4 @@
+.logo {
+ display: block;
+ height: 170px;
+}
diff --git a/docs/src/packaging.md b/docs/src/packaging.md
new file mode 100644
index 0000000000000000000000000000000000000000..40c90fa0639d77086808c276825b8d5161ca3121
--- /dev/null
+++ b/docs/src/packaging.md
@@ -0,0 +1,86 @@
+# Packaging coreutils
+
+<!-- spell-checker:ignore debuginfo manpages backtraces -->
+
+> **Note**: This page is intended as a guide for packaging the uutils coreutils
+> for package maintainers. Normal users probably do not need to read this. If you
+> just want to install the coreutils, look at the
+> [installation](installation.md) instructions.
+
+The maintainers of this project do not have the capacity to maintain packages
+for every distribution and package manager out there. Therefore, we encourage
+other people to package the uutils coreutils for their preferred distributions.
+You do not need to ask permission for this and you can do this however you want
+as long as you comply with the license. However, we do like to hear and
+advertise where the uutils coreutils are available, so please do let us know!
+
+## License
+
+The uutils coreutils are licensed under the MIT license. See the
+[LICENSE](https://github.com/uutils/coreutils/blob/main/LICENSE) for the full
+license text. Make sure to add attribution and the license text to the package
+to comply with the license.
+
+## Package
+
+We recommend to name the package `uutils-coreutils`. Just `uutils` is incorrect,
+because that is the name of the organization, which also includes other
+projects.
+
+## Selecting the utils to include
+
+Not all utils are available on all platforms. To get the full set of utils for a
+particular platform, you must enable the feature flag with the platform name.
+For example, on Unix-like system, use `--features unix` and `--features windows`
+on Windows.
+
+For a more fine-grained selection, you can enable just the features with the
+name of the utils you want to include and disable the default feature set.
+
+Additionally, support for SELinux must explicitly enabled with the
+`feat_selinux` feature.
+
+We recommend including all the utilities that a platform supports.
+
+## Compilation parameters
+
+There are several compile-time flags that allow you to tune the coreutils to
+your particular needs. Some distributions, for example, might choose to
+minimize the binary size as much as possible.
+
+This can be achieved by customizing the configuration passed to cargo. You can
+view the full documentation in the
+[cargo documentation](https://doc.rust-lang.org/cargo/reference/profiles.html).
+
+We provide three release profiles out of the box, though you may want to tweak
+them:
+
+- `release`: This is the standard Rust release profile, but with link-time
+ optimization enabled. It is a balance between compile time, performance and a
+ reasonable amount of debug info. The main drawback of this profile is that the
+ binary is quite large (roughly 2x the GNU coreutils).
+- `release-fast`: Every setting is tuned for the best performance, at the cost
+ of compile time. This binary is still quite large.
+- `release-small`: Generates the smallest binary possible. This strips _all_
+ debug info from the binary and leads to worse backtraces. The performance of
+ this profile is also really good as it is close to the `release-fast` profile,
+ but with all debuginfo stripped.
+
+For the precise definition of these profiles, you can look at the root
+[`Cargo.toml`](https://github.com/uutils/coreutils/blob/main/Cargo.toml).
+
+The profiles above are just examples. We encourage package maintainers to decide
+for themselves what the best parameters for their distribution are. For example,
+a distribution focused on embedded systems would probably choose
+`release-small`, but another distribution focused on security might enable
+bounds checks.
+
+It is also possible to split the debuginfo into a separate package. See the
+[`split-debuginfo`](https://doc.rust-lang.org/cargo/reference/profiles.html#split-debuginfo)
+option in `cargo`.
+
+## Additional artifacts
+
+This project supports automatically generating manpages and shell completion
+files which you may want to include in the package. See the page on
+[building from source](build.md) for how to generate these.
diff --git a/docs/src/platforms.md b/docs/src/platforms.md
new file mode 100644
index 0000000000000000000000000000000000000000..b84516e3f69558087449dba5ce3bc63fed5b26be
--- /dev/null
+++ b/docs/src/platforms.md
@@ -0,0 +1,45 @@
+# Platform support
+
+<!-- markdownlint-disable MD033 -->
+
+uutils aims to be as "universal" as possible, meaning that we try to support
+many platforms. However, it is infeasible for us to guarantee that every
+platform works. Just like Rust itself, we therefore have multiple tiers of
+platform support, with different guarantees. We support two tiers of platforms:
+
+ - **Tier 1**: All applicable utils are compiled and tested in CI for these
+ platforms.
+ - **Tier 2**: These platforms are supported but not actively tested. We do accept
+ fixes for these platforms.
+
+> **Note**: The tiers are dictated by our CI. We would happily accept a job
+> in the CI for testing more platforms, bumping those platforms to tier 1.
+
+## Platforms per tier
+
+The platforms in tier 1 and the platforms that we test in CI are listed below.
+
+| Operating system | Tested targets |
+| ---------------- | -------------- |
+| **Linux** | `x86_64-unknown-linux-gnu` <br> `x86_64-unknown-linux-musl` <br> `arm-unknown-linux-gnueabihf` <br> `i686-unknown-linux-gnu` <br> `aarch64-unknown-linux-gnu` |
+| **macOS** | `x86_64-apple-darwin` |
+| **Windows** | `i686-pc-windows-msvc` <br> `x86_64-pc-windows-gnu` <br> `x86_64-pc-windows-msvc` |
+| **FreeBSD** | `x86_64-unknown-freebsd` |
+| **Android** | `i686-linux-android` |
+
+The platforms in tier 2 are more vague, but include:
+
+ - untested variations of the platforms above,
+ - Redox OS,
+ - and BSDs such as OpenBSD, NetBSD & DragonFlyBSD.
+
+## Utility compatibility per platform
+
+Not all utils work on every platform. For instance, `chgrp` is not supported on
+Windows, because Windows does not have the concept of groups. Below is a full table
+detailing which utilities are supported for the tier 1 platforms.
+
+Note that for some utilities, not all functionality is supported on each
+platform. This is documented per utility.
+
+{{ #include platform_table.md }}
diff --git a/docs/src/test_coverage.md b/docs/src/test_coverage.md
index bf4c721299a1cb460a8b3e78430c2373974c68f2..b8376058873c2e9c29e4dace3f47f8920bed44ab 100644
--- a/docs/src/test_coverage.md
+++ b/docs/src/test_coverage.md
@@ -1,5 +1,7 @@
# GNU Test Coverage
+<!-- markdownlint-disable MD033 -->
+
uutils is actively tested against the GNU coreutils test suite. The results
below are automatically updated every day.
diff --git a/oranda.json b/oranda.json
new file mode 100644
index 0000000000000000000000000000000000000000..0a6856a8813bc05174aac9eb703c4313e1991f9c
--- /dev/null
+++ b/oranda.json
@@ -0,0 +1,18 @@
+{
+ "project": {
+ "name": "uutils coreutils"
+ },
+ "build": {
+ "path_prefix": "coreutils"
+ },
+ "components": {
+ "changelog": {
+ "read_changelog_file": false
+ }
+ },
+ "styles": {
+ "theme": "light",
+ "logo": "docs/src/logo.svg",
+ "additional_css": ["docs/src/oranda.css"]
+ }
+}
diff --git a/release_notes.md b/release_notes.md
deleted file mode 100644
index 1fc04be80db9c05a5e129bed5c78203f8775d04f..0000000000000000000000000000000000000000
--- a/release_notes.md
+++ /dev/null
@@ -1,168 +0,0 @@
-## Highlights
-
-* The minimum supported Rust version is now 1.60.
-* Clap has been updated to version 4, bringing some changes in the formatting of help strings.
-* `cp` has been gotten many small improvements that improve compatibility.
-* `dd` has been simplified and has better compatibility.
-* `env` now reraises signals from the child process.
-* `ls -l` now shows more information on Windows.
-* `uname` is now available for all supported platforms, instead of Unix-like platforms only.
-* `cp` and `mv` have the ability to show a progress bar. This is an extension over GNU coreutils and inspired by [`advcpmv`](https://github.com/jarun/advcpmv).
-* There have been refactors, fixes and performance improvements in many utils, see below for details.
-
-## GNU test suite compatibility
-
-Many utils have gotten minor changes to improve GNU compatibility. Below is a summary of the progress. See https://github.com/uutils/coreutils-tracking/ for more details
-
-| result | 0.0.16 | 0.0.17 | change |
-|--------|-------:|-------:|-------:|
-| pass | 322 | 338 | +16 |
-| skip | 49 | 48 | -1 |
-| fail | 217 | 204 | -13 |
-| error | 5 | 3 | -2 |
-
-## Changes
-
-The PR's listed below are a selection of all the contributions in this release.
-
-### General
-
-* Bump MSRV to 1.60 by @tertsdiepraam in https://github.com/uutils/coreutils/pull/3994
-* Clap 4 by @tertsdiepraam in https://github.com/uutils/coreutils/pull/3991
-* Migrate from `winapi` to `windows-sys` by @niyaznigmatullin in https://github.com/uutils/coreutils/pull/4065
-* Run the toybox testsuite by @sylvestre in https://github.com/uutils/coreutils/pull/4222
-* Use normal use declarations to import macros by @miles170 in https://github.com/uutils/coreutils/pull/4151
-* Add installation page to docs with package managers by @tertsdiepraam in https://github.com/uutils/coreutils/pull/4048
-* Test utilities
- * Add `UChild`, an abstraction for `std::process::Child` by @Joining7943 in https://github.com/uutils/coreutils/pull/4136
- * Add possibility to set timeout for UCommand and UChild. Add `rstest` with timeout macro to dev dependencies by @Joining7943 in https://github.com/uutils/coreutils/pull/4231
- * Put `#[track_caller]` on assertion functions in test utils by @tertsdiepraam in https://github.com/uutils/coreutils/pull/4252
-* `uucore`
- * Add automatic conversion for `nix::Errno` by @orhun in https://github.com/uutils/coreutils/pull/4060
- * Add `prompt_yes` macro by @tertsdiepraam in https://github.com/uutils/coreutils/pull/4148
- * Add `sprintf()` function by @jfinkels in https://github.com/uutils/coreutils/pull/4185
- * Add options to parse_size::Parser by @trasua in https://github.com/uutils/coreutils/pull/4224
-
-### `chown`
-* Fails when `XXXX.` or `XXXX:` is provided (when XXXX is numeric value) by @sylvestre in https://github.com/uutils/coreutils/pull/4081
-
-### `cp`
-* Move `copy_directory()` to its own module by @jfinkels in https://github.com/uutils/coreutils/pull/3901
-* Correctly copy ancestor dirs in `--parents` mode by @jfinkels in https://github.com/uutils/coreutils/pull/4071
-* `cp -i --update source existing` should not do anything and exit 0 by @sylvestre in https://github.com/uutils/coreutils/pull/4078
-* Implement `--copy-contents` option for fifos by @jfinkels in https://github.com/uutils/coreutils/pull/3978
-* Remove interactive mode message on 'no' by @sssemil in https://github.com/uutils/coreutils/pull/4069
-* Use sparse copy on `--sparse=always` by @jfinkels in https://github.com/uutils/coreutils/pull/4030
-* Add progress bar by @tertsdiepraam in https://github.com/uutils/coreutils/pull/3903 and improved by @djedi23 in https://github.com/uutils/coreutils/pull/4179 and @ctsk in https://github.com/uutils/coreutils/pull/4221
-* Restrict copy through dangling symlink with `-f` by @jfinkels in https://github.com/uutils/coreutils/pull/4074
-* Force copying file to itself with `--backup` by @jfinkels in https://github.com/uutils/coreutils/pull/3966
-* Make `--preserve` use the defaults when empty by @sssemil in https://github.com/uutils/coreutils/pull/4123
-* Fix `cp --force --backup f f` fails on macOS by @miles170 in https://github.com/uutils/coreutils/pull/4166
-* Preserve hard links when target already exists by @jfinkels in https://github.com/uutils/coreutils/pull/4208
-* Fix `--verbose --parents` output for both files and directories by @jfinkels in https://github.com/uutils/coreutils/pull/4184
-* Force link between two files that exist by @jfinkels in https://github.com/uutils/coreutils/pull/4213
-* Remove empty line from version output by @cakebaker in https://github.com/uutils/coreutils/pull/4283
-* Require preserve only certain attributes by @sssemil in https://github.com/uutils/coreutils/pull/4099
-* Restrict permissions when copying FIFO by @jfinkels in https://github.com/uutils/coreutils/pull/4211
-
-### `csplit`
-* Rename var to simplify format strings by @cakebaker in https://github.com/uutils/coreutils/pull/4266
-
-### `cut`
-* Add whitespace option for separating fields by @TechHara in https://github.com/uutils/coreutils/pull/4232
-
-### `date`
-* Catch panic from invalid format string by @jaggededgedjustice in https://github.com/uutils/coreutils/pull/4240
-
-### `dd`
-* Allow B as a suffix for count, seek, and skip by @jfinkels in https://github.com/uutils/coreutils/pull/4137
-* Create Dest enum and simpler Output struct by @jfinkels in https://github.com/uutils/coreutils/pull/4134
-* Don't allocate buffer if count=0 by @jfinkels in https://github.com/uutils/coreutils/pull/4130
-* Correctly set file size when conv=sparse by @jfinkels in https://github.com/uutils/coreutils/pull/4191
-* Fix rendering of SI and IEC byte counts by @jfinkels in https://github.com/uutils/coreutils/pull/3653
-* Fix progress line if 1 byte written by @jfinkels in https://github.com/uutils/coreutils/pull/4194
-
-### `env`
-* Reraise signal from child process by @tertsdiepraam in https://github.com/uutils/coreutils/pull/4011
-
-### `expr`
-* Multiple fixes and tests added by @rivy in https://github.com/uutils/coreutils/pull/4248
-
-### `factor`
-* Trim the input to fix some busybox results by @sylvestre in https://github.com/uutils/coreutils/pull/4215
-
-### `hashsum`
-* Warn on file not found rather than fail by @dmatos2012 in https://github.com/uutils/coreutils/pull/4064
-* Enable testing `--no-names` by @tertsdiepraam and @huijeong-kim in https://github.com/uutils/coreutils/pull/4088
-
-### `install`
-* No longer fails when target directory does not exist by @bruecke in https://github.com/uutils/coreutils/pull/3950
-
-### `ls`
-* Show more info in long format on Windows by @tertsdiepraam in https://github.com/uutils/coreutils/pull/4014
-* Use `libc::{major, minor}` to calculate device number by @SteveLauC in https://github.com/uutils/coreutils/pull/4120
-
-### `mktemp`
-* Allow default missing value by @dmatos2012 in https://github.com/uutils/coreutils/pull/4091
-
-### `mv`
-* `mv -i --update source existing` should not do anything and exit 0 by @sylvestre in https://github.com/uutils/coreutils/pull/4078
-* Add progress bar by @ctsk in https://github.com/uutils/coreutils/pull/4220
-
-### `numfmt`
-* Handle negative zero values by @cakebaker in https://github.com/uutils/coreutils/pull/4076
-* Allow hyphen values for `--field` option by @cakebaker in https://github.com/uutils/coreutils/pull/4090
-* Round values if precision is 0 by @cakebaker in https://github.com/uutils/coreutils/pull/4089
-* Allow `-` in field list by @cakebaker in https://github.com/uutils/coreutils/pull/4094
-* Allow ` ` as field separator by @cakebaker in https://github.com/uutils/coreutils/pull/4096
-* Add test for `--field -` (all fields) by @cakebaker in https://github.com/uutils/coreutils/pull/4093
-
-### `pr`
-* Simplify format strings by @cakebaker in https://github.com/uutils/coreutils/pull/4264
-* Add missing `\` before line breaks by @cakebaker in https://github.com/uutils/coreutils/pull/4273
-
-### `printenv`
-* Weird env variable names should trigger an error. by @sylvestre in https://github.com/uutils/coreutils/pull/4113
-
-### `pwd`
-* Support the env variable `POSIXLY_CORRECT` by @sylvestre in https://github.com/uutils/coreutils/pull/4085
-
-### `rm`
-* GNU test `rm3` now passes by @palaster in https://github.com/uutils/coreutils/pull/4013
-
-### `seq`
-* Simplify format strings by @cakebaker in https://github.com/uutils/coreutils/pull/4264
-
-### `sleep`
-* Fix argument parsing and errors by @rivy in https://github.com/uutils/coreutils/pull/4268
-
-### `sort`
-* Allow a sort mode to appear multiple times by @tertsdiepraam in https://github.com/uutils/coreutils/pull/4132
-
-### `split`
-* Implement round-robin arg to `--number` by @jfinkels in https://github.com/uutils/coreutils/pull/3281
-* Match GNU semantics for missing EOF by @andrewbaptist in https://github.com/uutils/coreutils/pull/4009
-* Fix "backticks are unbalanced" warnings by @cakebaker in https://github.com/uutils/coreutils/pull/4181
-
-### `stat`
-* Show more info in long format on Windows by @tertsdiepraam in https://github.com/uutils/coreutils/pull/4014
-* Refactor by @tertsdiepraam in https://github.com/uutils/coreutils/pull/4150
-
-### `sum`
-* Fix output of about string by @cakebaker in https://github.com/uutils/coreutils/pull/4274
-* Fix output when using BSD sum algo (-r) by @cakebaker in https://github.com/uutils/coreutils/pull/4278
-
-### `tail`
-* Refactor handling of warnings and early exits by @Joining7943 in https://github.com/uutils/coreutils/pull/4135
-
-### `touch`
-* Add support for some relative times by @jfinkels in https://github.com/uutils/coreutils/pull/4193
-
-### `uname`
-* build: `uname` is WinOS-compatible; move to 'Tier1' feature by @rivy in https://github.com/uutils/coreutils/pull/4245
-* change/uname ~ update and revise by @rivy in https://github.com/uutils/coreutils/pull/4279
-
-## New Contributors
-@huijeong-kim (https://github.com/uutils/coreutils/pull/4027), @orhun (https://github.com/uutils/coreutils/pull/4070), @SteveLauC (https://github.com/uutils/coreutils/pull/4120), @miles170 (https://github.com/uutils/coreutils/pull/4151), @djedi23 (https://github.com/uutils/coreutils/pull/4179), @bruecke (https://github.com/uutils/coreutils/pull/3950), @ctsk (https://github.com/uutils/coreutils/pull/4221), @trasua (https://github.com/uutils/coreutils/pull/4224), @TechHara (https://github.com/uutils/coreutils/pull/4232)
-
-**Full Changelog**: https://github.com/uutils/coreutils/compare/0.0.16...0.0.17
\ No newline at end of file
diff --git a/src/bin/coreutils.rs b/src/bin/coreutils.rs
index 08c0774ba7f1b330b51cf7949e095e43fe9dd642..6edb70821dfc22d4e99369b9b6b3cee0507649bd 100644
--- a/src/bin/coreutils.rs
+++ b/src/bin/coreutils.rs
@@ -1,10 +1,10 @@
// This file is part of the uutils coreutils package.
//
-// (c) Michael Gehring <mg@ebfe.org>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
+// spell-checker:ignore manpages mangen
+
use clap::{Arg, Command};
use clap_complete::Shell;
use std::cmp;
@@ -41,10 +41,11 @@ fn binary_path(args: &mut impl Iterator<Item = OsString>) -> PathBuf {
}
}
-fn name(binary_path: &Path) -> &str {
- binary_path.file_stem().unwrap().to_str().unwrap()
+fn name(binary_path: &Path) -> Option<&str> {
+ binary_path.file_stem()?.to_str()
}
+#[allow(clippy::cognitive_complexity)]
fn main() {
uucore::panic::mute_sigpipe_panic();
@@ -52,7 +53,10 @@ fn main() {
let mut args = uucore::args_os();
let binary = binary_path(&mut args);
- let binary_as_util = name(&binary);
+ let binary_as_util = name(&binary).unwrap_or_else(|| {
+ usage(&utils, "<unknown binary name>");
+ process::exit(0);
+ });
// binary name equals util name?
if let Some(&(uumain, _)) = utils.get(binary_as_util) {
@@ -86,9 +90,20 @@ fn main() {
None => not_found(&util_os),
};
- if util == "completion" {
- gen_completions(args, &utils);
- }
+ match util {
+ "completion" => gen_completions(args, &utils),
+ "manpage" => gen_manpage(args, &utils),
+ "--list" => {
+ let mut utils: Vec<_> = utils.keys().collect();
+ utils.sort();
+ for util in utils {
+ println!("{util}");
+ }
+ process::exit(0);
+ }
+ // Not a special command: fallthrough to calling a util
+ _ => {}
+ };
match utils.get(util) {
Some(&(uumain, _)) => {
@@ -167,10 +182,50 @@ fn gen_completions<T: uucore::Args>(
process::exit(0);
}
+/// Generate the manpage for the utility in the first parameter
+fn gen_manpage<T: uucore::Args>(
+ args: impl Iterator<Item = OsString>,
+ util_map: &UtilityMap<T>,
+) -> ! {
+ let all_utilities: Vec<_> = std::iter::once("coreutils")
+ .chain(util_map.keys().copied())
+ .collect();
+
+ let matches = Command::new("manpage")
+ .about("Prints manpage to stdout")
+ .arg(
+ Arg::new("utility")
+ .value_parser(clap::builder::PossibleValuesParser::new(all_utilities))
+ .required(true),
+ )
+ .get_matches_from(std::iter::once(OsString::from("manpage")).chain(args));
+
+ let utility = matches.get_one::<String>("utility").unwrap();
+
+ let command = if utility == "coreutils" {
+ gen_coreutils_app(util_map)
+ } else {
+ util_map.get(utility).unwrap().1()
+ };
+
+ let man = clap_mangen::Man::new(command);
+ man.render(&mut io::stdout())
+ .expect("Man page generation failed");
+ io::stdout().flush().unwrap();
+ process::exit(0);
+}
+
fn gen_coreutils_app<T: uucore::Args>(util_map: &UtilityMap<T>) -> Command {
let mut command = Command::new("coreutils");
- for (_, (_, sub_app)) in util_map {
- command = command.subcommand(sub_app());
+ for (name, (_, sub_app)) in util_map {
+ // Recreate a small subcommand with only the relevant info
+ // (name & short description)
+ let about = sub_app()
+ .get_about()
+ .expect("Could not get the 'about'")
+ .to_string();
+ let sub_app = Command::new(name).about(about);
+ command = command.subcommand(sub_app);
}
command
}
diff --git a/src/bin/uudoc.rs b/src/bin/uudoc.rs
index fe28323f2c07bf847779eec671d3b50d94764276..77c7a2fcfdd2d15e0113d26b27a789da4deeb693 100644
--- a/src/bin/uudoc.rs
+++ b/src/bin/uudoc.rs
@@ -2,7 +2,7 @@
//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
-// spell-checker:ignore tldr
+// spell-checker:ignore tldr uuhelp
use clap::Command;
use std::collections::HashMap;
@@ -42,6 +42,7 @@ fn main() -> io::Result<()> {
[Introduction](index.md)\n\
* [Installation](installation.md)\n\
* [Build from source](build.md)\n\
+ * [Platform support](platforms.md)\n\
* [Contributing](contributing.md)\n\
* [GNU test coverage](test_coverage.md)\n\
* [Extensions](extensions.md)\n\
@@ -53,7 +54,7 @@ fn main() -> io::Result<()> {
println!("Gathering utils per platform");
let utils_per_platform = {
let mut map = HashMap::new();
- for platform in ["unix", "macos", "windows"] {
+ for platform in ["unix", "macos", "windows", "unix_android"] {
let platform_utils: Vec<String> = String::from_utf8(
std::process::Command::new("./util/show-utils.sh")
.arg(format!("--features=feat_os_{}", platform))
@@ -61,6 +62,7 @@ fn main() -> io::Result<()> {
.stdout,
)
.unwrap()
+ .trim()
.split(' ')
.map(ToString::to_string)
.collect();
@@ -75,6 +77,7 @@ fn main() -> io::Result<()> {
.stdout,
)
.unwrap()
+ .trim()
.split(' ')
.map(ToString::to_string)
.collect();
@@ -83,9 +86,47 @@ fn main() -> io::Result<()> {
map
};
- println!("Writing to utils");
let mut utils = utils.entries().collect::<Vec<_>>();
utils.sort();
+
+ println!("Writing util per platform table");
+ {
+ let mut platform_table_file = File::create("docs/src/platform_table.md").unwrap();
+
+ // sum, cksum, b2sum, etc. are all available on all platforms, but not in the data structure
+ // otherwise, we check the map for the util name.
+ let check_supported = |name: &str, platform: &str| {
+ if name.ends_with("sum") || utils_per_platform[platform].iter().any(|u| u == name) {
+ "✓"
+ } else {
+ " "
+ }
+ };
+ writeln!(
+ platform_table_file,
+ "| util | Linux | macOS | Windows | FreeBSD | Android |\n\
+ | ---------------- | ----- | ----- | ------- | ------- | ------- |"
+ )?;
+ for (&name, _) in &utils {
+ if name == "[" {
+ continue;
+ }
+ // The alignment is not necessary, but makes the output a bit more
+ // pretty when viewed as plain markdown.
+ writeln!(
+ platform_table_file,
+ "| {:<16} | {:<5} | {:<5} | {:<7} | {:<7} | {:<7} |",
+ format!("**{name}**"),
+ check_supported(name, "linux"),
+ check_supported(name, "macos"),
+ check_supported(name, "windows"),
+ check_supported(name, "unix"),
+ check_supported(name, "unix_android"),
+ )?;
+ }
+ }
+
+ println!("Writing to utils");
for (&name, (_, command)) in utils {
if name == "[" {
continue;
@@ -133,7 +174,7 @@ impl<'a, 'b> MDWriter<'a, 'b> {
write!(self.w, "# {}\n\n", self.name)?;
self.additional()?;
self.usage()?;
- self.description()?;
+ self.about()?;
self.options()?;
self.after_help()?;
self.examples()
@@ -177,54 +218,34 @@ impl<'a, 'b> MDWriter<'a, 'b> {
}
fn usage(&mut self) -> io::Result<()> {
- writeln!(self.w, "\n```")?;
- let mut usage: String = self
- .command
- .render_usage()
- .to_string()
- .lines()
- .map(|l| l.strip_prefix("Usage:").unwrap_or(l))
- .map(|l| l.trim())
- .filter(|l| !l.is_empty())
- .collect::<Vec<_>>()
- .join("\n");
- usage = usage
- .to_string()
- .replace(uucore::execution_phrase(), self.name);
- writeln!(self.w, "{}", usage)?;
- writeln!(self.w, "```")
- }
+ if let Some(markdown) = &self.markdown {
+ let usage = uuhelp_parser::parse_usage(markdown);
+ let usage = usage.replace("{}", self.name);
- fn description(&mut self) -> io::Result<()> {
- if let Some(after_help) = self.markdown_section("about") {
- return writeln!(self.w, "\n\n{}", after_help);
+ writeln!(self.w, "\n```")?;
+ writeln!(self.w, "{}", usage)?;
+ writeln!(self.w, "```")
+ } else {
+ Ok(())
}
+ }
- if let Some(about) = self
- .command
- .get_long_about()
- .or_else(|| self.command.get_about())
- {
- writeln!(self.w, "{}", about)
+ fn about(&mut self) -> io::Result<()> {
+ if let Some(markdown) = &self.markdown {
+ writeln!(self.w, "{}", uuhelp_parser::parse_about(markdown))
} else {
Ok(())
}
}
fn after_help(&mut self) -> io::Result<()> {
- if let Some(after_help) = self.markdown_section("after help") {
- return writeln!(self.w, "\n\n{}", after_help);
+ if let Some(markdown) = &self.markdown {
+ if let Some(after_help) = uuhelp_parser::parse_section("after help", markdown) {
+ return writeln!(self.w, "\n\n{after_help}");
+ }
}
- if let Some(after_help) = self
- .command
- .get_after_long_help()
- .or_else(|| self.command.get_after_help())
- {
- writeln!(self.w, "\n\n{}", after_help)
- } else {
- Ok(())
- }
+ Ok(())
}
fn examples(&mut self) -> io::Result<()> {
@@ -236,6 +257,10 @@ impl<'a, 'b> MDWriter<'a, 'b> {
} else if let Some(f) = get_zip_content(zip, &format!("pages/linux/{}.md", self.name)) {
f
} else {
+ println!(
+ "Warning: Could not find tldr examples for page '{}'",
+ self.name
+ );
return Ok(());
};
@@ -274,10 +299,10 @@ impl<'a, 'b> MDWriter<'a, 'b> {
write!(self.w, "<dt>")?;
let mut first = true;
for l in arg.get_long_and_visible_aliases().unwrap_or_default() {
- if !first {
- write!(self.w, ", ")?;
- } else {
+ if first {
first = false;
+ } else {
+ write!(self.w, ", ")?;
}
write!(self.w, "<code>")?;
write!(self.w, "--{}", l)?;
@@ -295,10 +320,10 @@ impl<'a, 'b> MDWriter<'a, 'b> {
write!(self.w, "</code>")?;
}
for s in arg.get_short_and_visible_aliases().unwrap_or_default() {
- if !first {
- write!(self.w, ", ")?;
- } else {
+ if first {
first = false;
+ } else {
+ write!(self.w, ", ")?;
}
write!(self.w, "<code>")?;
write!(self.w, "-{}", s)?;
@@ -327,32 +352,6 @@ impl<'a, 'b> MDWriter<'a, 'b> {
}
writeln!(self.w, "</dl>\n")
}
-
- fn markdown_section(&self, section: &str) -> Option<String> {
- let md = self.markdown.as_ref()?;
- let section = section.to_lowercase();
-
- fn is_section_header(line: &str, section: &str) -> bool {
- line.strip_prefix("##")
- .map_or(false, |l| l.trim().to_lowercase() == section)
- }
-
- let result = md
- .lines()
- .skip_while(|&l| !is_section_header(l, §ion))
- .skip(1)
- .take_while(|l| !l.starts_with("##"))
- .collect::<Vec<_>>()
- .join("\n")
- .trim()
- .to_string();
-
- if result != "" {
- Some(result)
- } else {
- None
- }
- }
}
fn get_zip_content(archive: &mut ZipArchive<impl Read + Seek>, name: &str) -> Option<String> {
diff --git a/src/uu/arch/Cargo.toml b/src/uu/arch/Cargo.toml
index 7d90f1bd2bfc09edb8ba4b123ce63fa3ea9b4176..19727339a2df9c4f667b97c5b8535009e20ccc61 100644
--- a/src/uu/arch/Cargo.toml
+++ b/src/uu/arch/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_arch"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "arch ~ (uutils) display machine architecture"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/arch.rs"
[dependencies]
-platform-info = "1.0.1"
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+platform-info = { workspace = true }
+clap = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "arch"
diff --git a/src/uu/arch/arch.md b/src/uu/arch/arch.md
new file mode 100644
index 0000000000000000000000000000000000000000..a4ba2e75fce21293c19d3686cd1ad53bb91e86b0
--- /dev/null
+++ b/src/uu/arch/arch.md
@@ -0,0 +1,11 @@
+# arch
+
+```
+arch
+```
+
+Display machine architecture
+
+## After Help
+
+Determine architecture name for current machine.
diff --git a/src/uu/arch/src/arch.rs b/src/uu/arch/src/arch.rs
index 62a07159ee3f5196c9ec097b7cad819f42c96fd8..0d71a8183794dfce31e61106b28591fec1e576a4 100644
--- a/src/uu/arch/src/arch.rs
+++ b/src/uu/arch/src/arch.rs
@@ -1,25 +1,24 @@
// This file is part of the uutils coreutils package.
//
-// (c) Smigle00 <smigle00@gmail.com>
-// (c) Jian Zeng <anonymousknight96 AT gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
use platform_info::*;
use clap::{crate_version, Command};
-use uucore::error::{FromIo, UResult};
+use uucore::error::{UResult, USimpleError};
+use uucore::{help_about, help_section};
-static ABOUT: &str = "Display machine architecture";
-static SUMMARY: &str = "Determine architecture name for current machine.";
+static ABOUT: &str = help_about!("arch.md");
+static SUMMARY: &str = help_section!("after help", "arch.md");
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
uu_app().try_get_matches_from(args)?;
- let uts = PlatformInfo::new().map_err_context(|| "cannot get system name".to_string())?;
- println!("{}", uts.machine().trim());
+ let uts = PlatformInfo::new().map_err(|_e| USimpleError::new(1, "cannot get system name"))?;
+
+ println!("{}", uts.machine().to_string_lossy().trim());
Ok(())
}
diff --git a/src/uu/base32/Cargo.toml b/src/uu/base32/Cargo.toml
index 172ac60869f10872dca81d6908774eecc70a3d89..8500f7c711afb67ec2ad7bf3c033f43c334eb011 100644
--- a/src/uu/base32/Cargo.toml
+++ b/src/uu/base32/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_base32"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "base32 ~ (uutils) decode/encode input (base32-encoding)"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/base32.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features = ["encoding"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["encoding"] }
[[bin]]
name = "base32"
diff --git a/src/uu/base32/base32.md b/src/uu/base32/base32.md
index 0889292ce8a6cc52d7696446810c5c7db1248371..1805d433bd37b7380e972b353547f84a24cb36ed 100644
--- a/src/uu/base32/base32.md
+++ b/src/uu/base32/base32.md
@@ -1,17 +1,14 @@
# base32
-## Usage
```
base32 [OPTION]... [FILE]
```
-## About
-
encode/decode data and print to standard output
With no FILE, or when FILE is -, read standard input.
-The data are encoded as described for the base32 alphabet in RFC
-4648. When decoding, the input may contain newlines in addition
+The data are encoded as described for the base32 alphabet in RFC 4648.
+When decoding, the input may contain newlines in addition
to the bytes of the formal base32 alphabet. Use --ignore-garbage
to attempt to recover from any other non-alphabet bytes in the
encoded stream.
diff --git a/src/uu/base32/src/base32.rs b/src/uu/base32/src/base32.rs
index 01932e67553c95d34cb3b2e61494d30d0465636c..09250421c252fd9db6e9c85ba4ceeda8612ef1e4 100644
--- a/src/uu/base32/src/base32.rs
+++ b/src/uu/base32/src/base32.rs
@@ -1,18 +1,16 @@
// This file is part of the uutils coreutils package.
//
-// (c) Jian Zeng <anonymousknight96@gmail.com>
-//
-// For the full copyright and license information, please view the LICENSE file
-// that was distributed with this source code.
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::io::{stdin, Read};
use clap::Command;
-use uucore::{encoding::Format, error::UResult, help_section, help_usage};
+use uucore::{encoding::Format, error::UResult, help_about, help_usage};
pub mod base_common;
-const ABOUT: &str = help_section!("about", "base32.md");
+const ABOUT: &str = help_about!("base32.md");
const USAGE: &str = help_usage!("base32.md");
#[uucore::main]
diff --git a/src/uu/base32/src/base_common.rs b/src/uu/base32/src/base_common.rs
index f68aa6b86c96c1c6201a7c7adbe6eaf62f1c544e..897722dd36e03019d14f23f8a5285fff990b547b 100644
--- a/src/uu/base32/src/base_common.rs
+++ b/src/uu/base32/src/base_common.rs
@@ -1,16 +1,12 @@
// This file is part of the uutils coreutils package.
//
-// (c) Jordy Dickinson <jordy.dickinson@gmail.com>
-// (c) Jian Zeng <anonymousknight96@gmail.com>
-// (c) Alex Lyon <arcterus@mail.com>
-//
-// For the full copyright and license information, please view the LICENSE file
-// that was distributed with this source code.
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::io::{stdout, Read, Write};
use uucore::display::Quotable;
-use uucore::encoding::{wrap_print, Data, Format};
+use uucore::encoding::{wrap_print, Data, EncodeError, Format};
use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
use uucore::format_usage;
@@ -58,7 +54,7 @@ impl Config {
format!("{}: No such file or directory", name.maybe_quote()),
));
}
- Some(name.to_owned())
+ Some(name.clone())
}
}
None => None,
@@ -91,8 +87,7 @@ pub fn parse_base_cmd_args(
usage: &str,
) -> UResult<Config> {
let command = base_app(about, usage);
- let arg_list = args.collect_lossy();
- Config::from(&command.try_get_matches_from(arg_list)?)
+ Config::from(&command.try_get_matches_from(args)?)
}
pub fn base_app(about: &'static str, usage: &str) -> Command {
@@ -107,23 +102,24 @@ pub fn base_app(about: &'static str, usage: &str) -> Command {
.short('d')
.long(options::DECODE)
.help("decode data")
- .action(ArgAction::SetTrue),
+ .action(ArgAction::SetTrue)
+ .overrides_with(options::DECODE),
)
.arg(
Arg::new(options::IGNORE_GARBAGE)
.short('i')
.long(options::IGNORE_GARBAGE)
.help("when decoding, ignore non-alphabetic characters")
- .action(ArgAction::SetTrue),
+ .action(ArgAction::SetTrue)
+ .overrides_with(options::IGNORE_GARBAGE),
)
.arg(
Arg::new(options::WRAP)
.short('w')
.long(options::WRAP)
.value_name("COLS")
- .help(
- "wrap encoded lines after COLS character (default 76, 0 to disable wrapping)",
- ),
+ .help("wrap encoded lines after COLS character (default 76, 0 to disable wrapping)")
+ .overrides_with(options::WRAP),
)
// "multiple" arguments are used to check whether there is more than one
// file passed in.
@@ -160,18 +156,7 @@ pub fn handle_input<R: Read>(
data = data.line_wrap(wrap);
}
- if !decode {
- match data.encode() {
- Ok(s) => {
- wrap_print(&data, &s);
- Ok(())
- }
- Err(_) => Err(USimpleError::new(
- 1,
- "error: invalid input (length must be multiple of 4 characters)",
- )),
- }
- } else {
+ if decode {
match data.decode() {
Ok(s) => {
// Silent the warning as we want to the error message
@@ -184,5 +169,17 @@ pub fn handle_input<R: Read>(
}
Err(_) => Err(USimpleError::new(1, "error: invalid input")),
}
+ } else {
+ match data.encode() {
+ Ok(s) => {
+ wrap_print(&data, &s);
+ Ok(())
+ }
+ Err(EncodeError::InvalidInput) => Err(USimpleError::new(1, "error: invalid input")),
+ Err(_) => Err(USimpleError::new(
+ 1,
+ "error: invalid input (length must be multiple of 4 characters)",
+ )),
+ }
}
}
diff --git a/src/uu/base64/Cargo.toml b/src/uu/base64/Cargo.toml
index 790af595d7b5c1cf0df28b99698183e4e0644228..77da5ac921bd4707674133e9d0e8460c63fea03e 100644
--- a/src/uu/base64/Cargo.toml
+++ b/src/uu/base64/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_base64"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "base64 ~ (uutils) decode/encode input (base64-encoding)"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/base64.rs"
[dependencies]
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features = ["encoding"] }
-uu_base32 = { version=">=0.0.17", package="uu_base32", path="../base32"}
+uucore = { workspace = true, features = ["encoding"] }
+uu_base32 = { workspace = true }
[[bin]]
name = "base64"
diff --git a/src/uu/base64/base64.md b/src/uu/base64/base64.md
index 89b9cb618c335704f6c80bc84e8ce806c5132e9f..ed3aa4f76383f443a0dd4bcbc02146433d4cfdfd 100644
--- a/src/uu/base64/base64.md
+++ b/src/uu/base64/base64.md
@@ -1,17 +1,14 @@
# base64
-## Usage
```
base64 [OPTION]... [FILE]
```
-## About
-
encode/decode data and print to standard output
With no FILE, or when FILE is -, read standard input.
-The data are encoded as described for the base64 alphabet in RFC
-3548. When decoding, the input may contain newlines in addition
+The data are encoded as described for the base64 alphabet in RFC 3548.
+When decoding, the input may contain newlines in addition
to the bytes of the formal base64 alphabet. Use --ignore-garbage
to attempt to recover from any other non-alphabet bytes in the
encoded stream.
diff --git a/src/uu/base64/src/base64.rs b/src/uu/base64/src/base64.rs
index 932a1f0c7d5eb23b8c742dc03cde9b339c8d0ace..6544638bdaee816e1f3a6b7b188ca97f31c17c6b 100644
--- a/src/uu/base64/src/base64.rs
+++ b/src/uu/base64/src/base64.rs
@@ -1,19 +1,16 @@
// This file is part of the uutils coreutils package.
//
-// (c) Jordy Dickinson <jordy.dickinson@gmail.com>
-// (c) Jian Zeng <anonymousknight96@gmail.com>
-//
-// For the full copyright and license information, please view the LICENSE file
-// that was distributed with this source code.
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use uu_base32::base_common;
pub use uu_base32::uu_app;
-use uucore::{encoding::Format, error::UResult, help_section, help_usage};
+use uucore::{encoding::Format, error::UResult, help_about, help_usage};
use std::io::{stdin, Read};
-const ABOUT: &str = help_section!("about", "base64.md");
+const ABOUT: &str = help_about!("base64.md");
const USAGE: &str = help_usage!("base64.md");
#[uucore::main]
diff --git a/src/uu/basename/Cargo.toml b/src/uu/basename/Cargo.toml
index ef326334dcacd34a393ed7a62101b07b0bfe474f..ff3949a29ad290cd68aeed52eeb8f663dbea4e16 100644
--- a/src/uu/basename/Cargo.toml
+++ b/src/uu/basename/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_basename"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "basename ~ (uutils) display PATHNAME with leading directory components removed"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/basename.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "basename"
diff --git a/src/uu/basename/basename.md b/src/uu/basename/basename.md
new file mode 100644
index 0000000000000000000000000000000000000000..ee87fa76d4e3b8ab527f1b4470cf8eee19e4a393
--- /dev/null
+++ b/src/uu/basename/basename.md
@@ -0,0 +1,9 @@
+# basename
+
+```
+basename [-z] NAME [SUFFIX]
+basename OPTION... NAME...
+```
+
+Print NAME with any leading directory components removed
+If specified, also remove a trailing SUFFIX
diff --git a/src/uu/basename/src/basename.rs b/src/uu/basename/src/basename.rs
index 613c4d67cbdbcf9ad6b77e466e47c5fcea9bc6b1..f502fb234660cc76de505c261202c400a962c5b7 100644
--- a/src/uu/basename/src/basename.rs
+++ b/src/uu/basename/src/basename.rs
@@ -1,7 +1,5 @@
// This file is part of the uutils coreutils package.
//
-// (c) Jimmy Lu <jimmy.lu.2011@gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
@@ -11,13 +9,12 @@ use clap::{crate_version, Arg, ArgAction, Command};
use std::path::{is_separator, PathBuf};
use uucore::display::Quotable;
use uucore::error::{UResult, UUsageError};
-use uucore::format_usage;
+use uucore::line_ending::LineEnding;
+use uucore::{format_usage, help_about, help_usage};
-static ABOUT: &str = r#"Print NAME with any leading directory components removed
-If specified, also remove a trailing SUFFIX"#;
+static ABOUT: &str = help_about!("basename.md");
-const USAGE: &str = "{} NAME [SUFFIX]
- {} OPTION... NAME...";
+const USAGE: &str = help_usage!("basename.md");
pub mod options {
pub static MULTIPLE: &str = "multiple";
@@ -30,86 +27,48 @@ pub mod options {
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let args = args.collect_lossy();
- // Since options have to go before names,
- // if the first argument is not an option, then there is no option,
- // and that implies there is exactly one name (no option => no -a option),
- // so simple format is used
- if args.len() > 1 && !args[1].starts_with('-') {
- if args.len() > 3 {
- return Err(UUsageError::new(
- 1,
- format!("extra operand {}", args[3].to_string().quote()),
- ));
- }
- let suffix = if args.len() > 2 { args[2].as_ref() } else { "" };
- println!("{}", basename(&args[1], suffix));
- return Ok(());
- }
-
//
// Argument parsing
//
let matches = uu_app().try_get_matches_from(args)?;
- // too few arguments
- if !matches.contains_id(options::NAME) {
- return Err(UUsageError::new(1, "missing operand".to_string()));
- }
+ let line_ending = LineEnding::from_zero_flag(matches.get_flag(options::ZERO));
- let opt_suffix = matches.get_one::<String>(options::SUFFIX).is_some();
- let opt_multiple = matches.get_flag(options::MULTIPLE);
- let opt_zero = matches.get_flag(options::ZERO);
- let multiple_paths = opt_suffix || opt_multiple;
- let name_args_count = matches
+ let mut name_args = matches
.get_many::<String>(options::NAME)
- .map(|n| n.len())
- .unwrap_or(0);
-
- // too many arguments
- if !multiple_paths && name_args_count > 2 {
- return Err(UUsageError::new(
- 1,
- format!(
- "extra operand {}",
- matches
- .get_many::<String>(options::NAME)
- .unwrap()
- .nth(2)
- .unwrap()
- .quote()
- ),
- ));
+ .unwrap_or_default()
+ .collect::<Vec<_>>();
+ if name_args.is_empty() {
+ return Err(UUsageError::new(1, "missing operand".to_string()));
}
-
- let suffix = if opt_suffix {
- matches.get_one::<String>(options::SUFFIX).unwrap()
- } else if !opt_multiple && name_args_count > 1 {
+ let multiple_paths =
+ matches.get_one::<String>(options::SUFFIX).is_some() || matches.get_flag(options::MULTIPLE);
+ let suffix = if multiple_paths {
matches
- .get_many::<String>(options::NAME)
- .unwrap()
- .nth(1)
- .unwrap()
+ .get_one::<String>(options::SUFFIX)
+ .cloned()
+ .unwrap_or_default()
} else {
- ""
+ // "simple format"
+ match name_args.len() {
+ 0 => panic!("already checked"),
+ 1 => String::default(),
+ 2 => name_args.pop().unwrap().clone(),
+ _ => {
+ return Err(UUsageError::new(
+ 1,
+ format!("extra operand {}", name_args[2].quote(),),
+ ));
+ }
+ }
};
//
// Main Program Processing
//
- let paths: Vec<_> = if multiple_paths {
- matches.get_many::<String>(options::NAME).unwrap().collect()
- } else {
- matches
- .get_many::<String>(options::NAME)
- .unwrap()
- .take(1)
- .collect()
- };
-
- let line_ending = if opt_zero { "\0" } else { "\n" };
- for path in paths {
- print!("{}{}", basename(path, suffix), line_ending);
+ for path in name_args {
+ print!("{}{}", basename(path, &suffix), line_ending);
}
Ok(())
@@ -126,27 +85,31 @@ pub fn uu_app() -> Command {
.short('a')
.long(options::MULTIPLE)
.help("support multiple arguments and treat each as a NAME")
- .action(ArgAction::SetTrue),
+ .action(ArgAction::SetTrue)
+ .overrides_with(options::MULTIPLE),
)
.arg(
Arg::new(options::NAME)
.action(clap::ArgAction::Append)
.value_hint(clap::ValueHint::AnyPath)
- .hide(true),
+ .hide(true)
+ .trailing_var_arg(true),
)
.arg(
Arg::new(options::SUFFIX)
.short('s')
.long(options::SUFFIX)
.value_name("SUFFIX")
- .help("remove a trailing SUFFIX; implies -a"),
+ .help("remove a trailing SUFFIX; implies -a")
+ .overrides_with(options::SUFFIX),
)
.arg(
Arg::new(options::ZERO)
.short('z')
.long(options::ZERO)
.help("end each output line with NUL, not newline")
- .action(ArgAction::SetTrue),
+ .action(ArgAction::SetTrue)
+ .overrides_with(options::ZERO),
)
}
diff --git a/src/uu/basenc/Cargo.toml b/src/uu/basenc/Cargo.toml
index b98b3ac9d03af6a5486a9766f0f39e90d11bfb5f..6d0a85de3623820d84519c8071e15d0f444c257e 100644
--- a/src/uu/basenc/Cargo.toml
+++ b/src/uu/basenc/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_basenc"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "basenc ~ (uutils) decode/encode input"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/basenc.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features = ["encoding"] }
-uu_base32 = { version=">=0.0.17", package="uu_base32", path="../base32"}
+clap = { workspace = true }
+uucore = { workspace = true, features = ["encoding"] }
+uu_base32 = { workspace = true }
[[bin]]
name = "basenc"
diff --git a/src/uu/basenc/basenc.md b/src/uu/basenc/basenc.md
new file mode 100644
index 0000000000000000000000000000000000000000..001babe9e6b914c11333e6e03bae57666a1ab9c8
--- /dev/null
+++ b/src/uu/basenc/basenc.md
@@ -0,0 +1,12 @@
+# basenc
+
+```
+basenc [OPTION]... [FILE]
+```
+
+Encode/decode data and print to standard output
+With no FILE, or when FILE is -, read standard input.
+
+When decoding, the input may contain newlines in addition to the bytes of
+the formal alphabet. Use --ignore-garbage to attempt to recover
+from any other non-alphabet bytes in the encoded stream.
diff --git a/src/uu/basenc/src/basenc.rs b/src/uu/basenc/src/basenc.rs
index cb9e38879e98bc228d3e17679b8b5dcae8941acb..ed117b22a0d5782750efdd76830ca990cb1703fa 100644
--- a/src/uu/basenc/src/basenc.rs
+++ b/src/uu/basenc/src/basenc.rs
@@ -1,10 +1,7 @@
// This file is part of the uutils coreutils package.
//
-// (c) Jordy Dickinson <jordy.dickinson@gmail.com>
-// (c) Jian Zeng <anonymousknight96@gmail.com>
-//
-// For the full copyright and license information, please view the LICENSE file
-// that was distributed with this source code.
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//spell-checker:ignore (args) lsbf msbf
@@ -19,36 +16,51 @@ use uucore::{
use std::io::{stdin, Read};
use uucore::error::UClapError;
-static ABOUT: &str = "\
-encode/decode data and print to standard output
-With no FILE, or when FILE is -, read standard input.
+use uucore::{help_about, help_usage};
-When decoding, the input may contain newlines in addition to the bytes of
-the formal alphabet. Use --ignore-garbage to attempt to recover
-from any other non-alphabet bytes in the encoded stream.
-";
+const ABOUT: &str = help_about!("basenc.md");
+const USAGE: &str = help_usage!("basenc.md");
-const ENCODINGS: &[(&str, Format)] = &[
- ("base64", Format::Base64),
- ("base64url", Format::Base64Url),
- ("base32", Format::Base32),
- ("base32hex", Format::Base32Hex),
- ("base16", Format::Base16),
- ("base2lsbf", Format::Base2Lsbf),
- ("base2msbf", Format::Base2Msbf),
- ("z85", Format::Z85),
+const ENCODINGS: &[(&str, Format, &str)] = &[
+ ("base64", Format::Base64, "same as 'base64' program"),
+ ("base64url", Format::Base64Url, "file- and url-safe base64"),
+ ("base32", Format::Base32, "same as 'base32' program"),
+ (
+ "base32hex",
+ Format::Base32Hex,
+ "extended hex alphabet base32",
+ ),
+ ("base16", Format::Base16, "hex encoding"),
+ (
+ "base2lsbf",
+ Format::Base2Lsbf,
+ "bit string with least significant bit (lsb) first",
+ ),
+ (
+ "base2msbf",
+ Format::Base2Msbf,
+ "bit string with most significant bit (msb) first",
+ ),
+ (
+ "z85",
+ Format::Z85,
+ "ascii85-like encoding;\n\
+ when encoding, input length must be a multiple of 4;\n\
+ when decoding, input length must be a multiple of 5",
+ ),
];
-const USAGE: &str = "{} [OPTION]... [FILE]";
-
pub fn uu_app() -> Command {
let mut command = base_common::base_app(ABOUT, USAGE);
for encoding in ENCODINGS {
- command = command.arg(
- Arg::new(encoding.0)
- .long(encoding.0)
- .action(ArgAction::SetTrue),
- );
+ let raw_arg = Arg::new(encoding.0)
+ .long(encoding.0)
+ .help(encoding.2)
+ .action(ArgAction::SetTrue);
+ let overriding_arg = ENCODINGS
+ .iter()
+ .fold(raw_arg, |arg, enc| arg.overrides_with(enc.0));
+ command = command.arg(overriding_arg);
}
command
}
diff --git a/src/uu/cat/Cargo.toml b/src/uu/cat/Cargo.toml
index 5241795672e5d6214875d63ebc0313cf67d1a50c..6eaafae56b24a7073880f66395efbe22fa85e69a 100644
--- a/src/uu/cat/Cargo.toml
+++ b/src/uu/cat/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_cat"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "cat ~ (uutils) concatenate and display input"
@@ -15,13 +15,12 @@ edition = "2021"
path = "src/cat.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-thiserror = "1.0"
-atty = "0.2"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["fs", "pipes"] }
+clap = { workspace = true }
+thiserror = { workspace = true }
+uucore = { workspace = true, features = ["fs", "pipes"] }
[target.'cfg(unix)'.dependencies]
-nix = { version = "0.25", default-features = false }
+nix = { workspace = true }
[[bin]]
name = "cat"
diff --git a/src/uu/cat/cat.md b/src/uu/cat/cat.md
new file mode 100644
index 0000000000000000000000000000000000000000..efcd317eb41082c4421e47474e51e16997439206
--- /dev/null
+++ b/src/uu/cat/cat.md
@@ -0,0 +1,8 @@
+# cat
+
+```
+cat [OPTION]... [FILE]...
+```
+
+Concatenate FILE(s), or standard input, to standard output
+With no FILE, or when FILE is -, read standard input.
diff --git a/src/uu/cat/src/cat.rs b/src/uu/cat/src/cat.rs
index d29ed3c303cd3854f2ccaf66269f1d5f17f20d7e..b239dc87a41d80aad1177fc837a58975228278a4 100644
--- a/src/uu/cat/src/cat.rs
+++ b/src/uu/cat/src/cat.rs
@@ -1,19 +1,12 @@
// This file is part of the uutils coreutils package.
//
-// (c) Jordi Boggiano <j.boggiano@seld.be>
-// (c) Evgeniy Klyuchikov <evgeniy.klyuchikov@gmail.com>
-// (c) Joshua S. Miller <jsmiller@uchicago.edu>
-// (c) Ãrni Dagur <arni@dagur.eu>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
-// spell-checker:ignore (ToDO) nonprint nonblank nonprinting
-
-// last synced with: cat (GNU coreutils) 8.13
+// spell-checker:ignore (ToDO) nonprint nonblank nonprinting ELOOP
use clap::{crate_version, Arg, ArgAction, Command};
use std::fs::{metadata, File};
-use std::io::{self, Read, Write};
+use std::io::{self, IsTerminal, Read, Write};
use thiserror::Error;
use uucore::display::Quotable;
use uucore::error::UResult;
@@ -33,11 +26,10 @@ use std::net::Shutdown;
use std::os::unix::fs::FileTypeExt;
#[cfg(unix)]
use std::os::unix::net::UnixStream;
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
-static USAGE: &str = "{} [OPTION]... [FILE]...";
-static ABOUT: &str = "Concatenate FILE(s), or standard input, to standard output
-With no FILE, or when FILE is -, read standard input.";
+const USAGE: &str = help_usage!("cat.md");
+const ABOUT: &str = help_about!("cat.md");
#[derive(Error, Debug)]
enum CatError {
@@ -58,6 +50,8 @@ enum CatError {
IsDirectory,
#[error("input file is output file")]
OutputIsInput,
+ #[error("Too many levels of symbolic links")]
+ TooManySymlinks,
}
type CatResult<T> = Result<T, CatError>;
@@ -176,12 +170,11 @@ mod options {
pub static SHOW_NONPRINTING_TABS: &str = "t";
pub static SHOW_TABS: &str = "show-tabs";
pub static SHOW_NONPRINTING: &str = "show-nonprinting";
+ pub static IGNORED_U: &str = "ignored-u";
}
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_ignore();
-
let matches = uu_app().try_get_matches_from(args)?;
let number_mode = if matches.get_flag(options::NUMBER_NONBLANK) {
@@ -192,7 +185,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
NumberingMode::None
};
- let show_nonprint = vec![
+ let show_nonprint = [
options::SHOW_ALL.to_owned(),
options::SHOW_NONPRINTING_ENDS.to_owned(),
options::SHOW_NONPRINTING_TABS.to_owned(),
@@ -201,7 +194,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
.iter()
.any(|v| matches.get_flag(v));
- let show_ends = vec![
+ let show_ends = [
options::SHOW_ENDS.to_owned(),
options::SHOW_ALL.to_owned(),
options::SHOW_NONPRINTING_ENDS.to_owned(),
@@ -209,7 +202,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
.iter()
.any(|v| matches.get_flag(v));
- let show_tabs = vec![
+ let show_tabs = [
options::SHOW_ALL.to_owned(),
options::SHOW_TABS.to_owned(),
options::SHOW_NONPRINTING_TABS.to_owned(),
@@ -219,7 +212,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let squeeze_blank = matches.get_flag(options::SQUEEZE_BLANK);
let files: Vec<String> = match matches.get_many::<String>(options::FILE) {
- Some(v) => v.clone().map(|v| v.to_owned()).collect(),
+ Some(v) => v.cloned().collect(),
None => vec!["-".to_owned()],
};
@@ -239,6 +232,7 @@ pub fn uu_app() -> Command {
.override_usage(format_usage(USAGE))
.about(ABOUT)
.infer_long_args(true)
+ .args_override_self(true)
.arg(
Arg::new(options::FILE)
.hide(true)
@@ -257,7 +251,8 @@ pub fn uu_app() -> Command {
.short('b')
.long(options::NUMBER_NONBLANK)
.help("number nonempty output lines, overrides -n")
- .overrides_with(options::NUMBER)
+ // Note: This MUST NOT .overrides_with(options::NUMBER)!
+ // In clap, overriding is symmetric, so "-b -n" counts as "-n", which is not what we want.
.action(ArgAction::SetTrue),
)
.arg(
@@ -290,7 +285,6 @@ pub fn uu_app() -> Command {
.arg(
Arg::new(options::SHOW_NONPRINTING_TABS)
.short('t')
- .long(options::SHOW_NONPRINTING_TABS)
.help("equivalent to -vT")
.action(ArgAction::SetTrue),
)
@@ -308,6 +302,12 @@ pub fn uu_app() -> Command {
.help("use ^ and M- notation, except for LF (\\n) and TAB (\\t)")
.action(ArgAction::SetTrue),
)
+ .arg(
+ Arg::new(options::IGNORED_U)
+ .short('u')
+ .help("(ignored)")
+ .action(ArgAction::SetTrue),
+ )
}
fn cat_handle<R: FdReadable>(
@@ -333,7 +333,7 @@ fn cat_path(
let stdin = io::stdin();
let mut handle = InputHandle {
reader: stdin,
- is_interactive: atty::is(atty::Stream::Stdin),
+ is_interactive: std::io::stdin().is_terminal(),
};
cat_handle(&mut handle, options, state)
}
@@ -410,7 +410,23 @@ fn get_input_type(path: &str) -> CatResult<InputType> {
return Ok(InputType::StdIn);
}
- let ft = metadata(path)?.file_type();
+ let ft = match metadata(path) {
+ Ok(md) => md.file_type(),
+ Err(e) => {
+ if let Some(raw_error) = e.raw_os_error() {
+ // On Unix-like systems, the error code for "Too many levels of symbolic links" is 40 (ELOOP).
+ // we want to provide a proper error message in this case.
+ #[cfg(not(any(target_os = "macos", target_os = "freebsd")))]
+ let too_many_symlink_code = 40;
+ #[cfg(any(target_os = "macos", target_os = "freebsd"))]
+ let too_many_symlink_code = 62;
+ if raw_error == too_many_symlink_code {
+ return Err(CatError::TooManySymlinks);
+ }
+ }
+ return Err(CatError::Io(e));
+ }
+ };
match ft {
#[cfg(unix)]
ft if ft.is_block_device() => Ok(InputType::BlockDevice),
@@ -424,7 +440,7 @@ fn get_input_type(path: &str) -> CatResult<InputType> {
ft if ft.is_file() => Ok(InputType::File),
ft if ft.is_symlink() => Ok(InputType::SymLink),
_ => Err(CatError::UnknownFiletype {
- ft_debug: format!("{:?}", ft),
+ ft_debug: format!("{ft:?}"),
}),
}
}
@@ -474,22 +490,7 @@ fn write_lines<R: FdReadable>(
while pos < n {
// skip empty line_number enumerating them if needed
if in_buf[pos] == b'\n' {
- // \r followed by \n is printed as ^M when show_ends is enabled, so that \r\n prints as ^M$
- if state.skipped_carriage_return && options.show_ends {
- writer.write_all(b"^M")?;
- state.skipped_carriage_return = false;
- }
- if !state.at_line_start || !options.squeeze_blank || !state.one_blank_kept {
- state.one_blank_kept = true;
- if state.at_line_start && options.number == NumberingMode::All {
- write!(writer, "{0:6}\t", state.line_number)?;
- state.line_number += 1;
- }
- writer.write_all(options.end_of_line().as_bytes())?;
- if handle.is_interactive {
- writer.flush()?;
- }
- }
+ write_new_line(&mut writer, options, state, handle.is_interactive)?;
state.at_line_start = true;
pos += 1;
continue;
@@ -506,13 +507,8 @@ fn write_lines<R: FdReadable>(
}
// print to end of line or end of buffer
- let offset = if options.show_nonprint {
- write_nonprint_to_end(&in_buf[pos..], &mut writer, options.tab().as_bytes())
- } else if options.show_tabs {
- write_tab_to_end(&in_buf[pos..], &mut writer)
- } else {
- write_to_end(&in_buf[pos..], &mut writer)
- };
+ let offset = write_end(&mut writer, &in_buf[pos..], options);
+
// end of buffer?
if offset + pos == in_buf.len() {
state.at_line_start = false;
@@ -523,10 +519,11 @@ fn write_lines<R: FdReadable>(
} else {
assert_eq!(in_buf[pos + offset], b'\n');
// print suitable end of line
- writer.write_all(options.end_of_line().as_bytes())?;
- if handle.is_interactive {
- writer.flush()?;
- }
+ write_end_of_line(
+ &mut writer,
+ options.end_of_line().as_bytes(),
+ handle.is_interactive,
+ )?;
state.at_line_start = true;
}
pos += offset + 1;
@@ -536,6 +533,41 @@ fn write_lines<R: FdReadable>(
Ok(())
}
+// \r followed by \n is printed as ^M when show_ends is enabled, so that \r\n prints as ^M$
+fn write_new_line<W: Write>(
+ writer: &mut W,
+ options: &OutputOptions,
+ state: &mut OutputState,
+ is_interactive: bool,
+) -> CatResult<()> {
+ if state.skipped_carriage_return && options.show_ends {
+ writer.write_all(b"^M")?;
+ state.skipped_carriage_return = false;
+ }
+ if !state.at_line_start || !options.squeeze_blank || !state.one_blank_kept {
+ state.one_blank_kept = true;
+ if state.at_line_start && options.number == NumberingMode::All {
+ write!(writer, "{0:6}\t", state.line_number)?;
+ state.line_number += 1;
+ }
+ writer.write_all(options.end_of_line().as_bytes())?;
+ if is_interactive {
+ writer.flush()?;
+ }
+ }
+ Ok(())
+}
+
+fn write_end<W: Write>(writer: &mut W, in_buf: &[u8], options: &OutputOptions) -> usize {
+ if options.show_nonprint {
+ write_nonprint_to_end(in_buf, writer, options.tab().as_bytes())
+ } else if options.show_tabs {
+ write_tab_to_end(in_buf, writer)
+ } else {
+ write_to_end(in_buf, writer)
+ }
+}
+
// write***_to_end methods
// Write all symbols till \n or \r or end of buffer is reached
// We need to stop at \r because it may be written as ^M depending on the byte after and settings;
@@ -602,6 +634,18 @@ fn write_nonprint_to_end<W: Write>(in_buf: &[u8], writer: &mut W, tab: &[u8]) ->
count
}
+fn write_end_of_line<W: Write>(
+ writer: &mut W,
+ end_of_line: &[u8],
+ is_interactive: bool,
+) -> CatResult<()> {
+ writer.write_all(end_of_line)?;
+ if is_interactive {
+ writer.flush()?;
+ }
+ Ok(())
+}
+
#[cfg(test)]
mod tests {
use std::io::{stdout, BufWriter};
diff --git a/src/uu/cat/src/splice.rs b/src/uu/cat/src/splice.rs
index 26802c7e6719c25831aa844e9fc958960684a1d8..13daae84d7fd19e52ce34aed39ef8a31e368c80f 100644
--- a/src/uu/cat/src/splice.rs
+++ b/src/uu/cat/src/splice.rs
@@ -1,7 +1,14 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use super::{CatResult, FdReadable, InputHandle};
use nix::unistd;
-use std::os::unix::io::{AsRawFd, RawFd};
+use std::os::{
+ fd::AsFd,
+ unix::io::{AsRawFd, RawFd},
+};
use uucore::pipes::{pipe, splice, splice_exact};
@@ -16,9 +23,9 @@ const BUF_SIZE: usize = 1024 * 16;
/// The `bool` in the result value indicates if we need to fall back to normal
/// copying or not. False means we don't have to.
#[inline]
-pub(super) fn write_fast_using_splice<R: FdReadable>(
- handle: &mut InputHandle<R>,
- write_fd: &impl AsRawFd,
+pub(super) fn write_fast_using_splice<R: FdReadable, S: AsRawFd + AsFd>(
+ handle: &InputHandle<R>,
+ write_fd: &S,
) -> CatResult<bool> {
let (pipe_rd, pipe_wr) = pipe()?;
@@ -34,7 +41,7 @@ pub(super) fn write_fast_using_splice<R: FdReadable>(
// we can recover by copying the data that we have from the
// intermediate pipe to stdout using normal read/write. Then
// we tell the caller to fall back.
- copy_exact(pipe_rd.as_raw_fd(), write_fd.as_raw_fd(), n)?;
+ copy_exact(pipe_rd.as_raw_fd(), write_fd, n)?;
return Ok(true);
}
}
@@ -48,7 +55,7 @@ pub(super) fn write_fast_using_splice<R: FdReadable>(
/// Move exactly `num_bytes` bytes from `read_fd` to `write_fd`.
///
/// Panics if not enough bytes can be read.
-fn copy_exact(read_fd: RawFd, write_fd: RawFd, num_bytes: usize) -> nix::Result<()> {
+fn copy_exact(read_fd: RawFd, write_fd: &impl AsFd, num_bytes: usize) -> nix::Result<()> {
let mut left = num_bytes;
let mut buf = [0; BUF_SIZE];
while left > 0 {
diff --git a/src/uu/chcon/Cargo.toml b/src/uu/chcon/Cargo.toml
index a90308af4581dbacd39aba274aaf86c570e7b359..f167bba977d2330156a021b92189849bdee20bbf 100644
--- a/src/uu/chcon/Cargo.toml
+++ b/src/uu/chcon/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_chcon"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "chcon ~ (uutils) change file security context"
@@ -14,12 +14,12 @@ edition = "2021"
path = "src/chcon.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version = ">=0.0.9", package="uucore", path="../../uucore", features=["entries", "fs", "perms"] }
-selinux = { version = "0.3" }
-fts-sys = { version = "0.2" }
-thiserror = { version = "1.0" }
-libc = { version = "0.2" }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["entries", "fs", "perms"] }
+selinux = { workspace = true }
+thiserror = { workspace = true }
+libc = { workspace = true }
+fts-sys = { workspace = true }
[[bin]]
name = "chcon"
diff --git a/src/uu/chcon/chcon.md b/src/uu/chcon/chcon.md
new file mode 100644
index 0000000000000000000000000000000000000000..64c64f47be792bbf920f99e656820a668c0a9bf7
--- /dev/null
+++ b/src/uu/chcon/chcon.md
@@ -0,0 +1,11 @@
+<!-- spell-checker:ignore (vars) RFILE -->
+# chcon
+
+```
+chcon [OPTION]... CONTEXT FILE...
+chcon [OPTION]... [-u USER] [-r ROLE] [-l RANGE] [-t TYPE] FILE...
+chcon [OPTION]... --reference=RFILE FILE...
+```
+
+Change the SELinux security context of each FILE to CONTEXT.
+With --reference, change the security context of each FILE to that of RFILE.
diff --git a/src/uu/chcon/src/chcon.rs b/src/uu/chcon/src/chcon.rs
index 2abf8d40aae2b8db822ef827ae0346bce182937c..1a804bd3bbfb0c3315f50b3be164fc6122a177d2 100644
--- a/src/uu/chcon/src/chcon.rs
+++ b/src/uu/chcon/src/chcon.rs
@@ -1,13 +1,15 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (vars) RFILE
-
#![allow(clippy::upper_case_acronyms)]
use clap::builder::ValueParser;
use uucore::error::{UResult, USimpleError, UUsageError};
-use uucore::format_usage;
-use uucore::{display::Quotable, show_error, show_warning};
+use uucore::{display::Quotable, format_usage, help_about, help_usage, show_error, show_warning};
-use clap::{Arg, ArgAction, Command};
+use clap::{crate_version, Arg, ArgAction, Command};
use selinux::{OpaqueSecurityContext, SecurityContext};
use std::borrow::Cow;
@@ -21,13 +23,8 @@ mod fts;
use errors::*;
-static VERSION: &str = env!("CARGO_PKG_VERSION");
-static ABOUT: &str = "Change the SELinux security context of each FILE to CONTEXT. \n\
- With --reference, change the security context of each FILE to that of RFILE.";
-const USAGE: &str = "\
- {} [OPTION]... CONTEXT FILE... \n \
- {} [OPTION]... [-u USER] [-r ROLE] [-l RANGE] [-t TYPE] FILE... \n \
- {} [OPTION]... --reference=RFILE FILE...";
+const ABOUT: &str = help_about!("chcon.md");
+const USAGE: &str = help_usage!("chcon.md");
pub mod options {
pub static HELP: &str = "help";
@@ -70,7 +67,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
return Err(r.into());
}
- return Err(UUsageError::new(libc::EXIT_FAILURE, format!("{}.\n", r)));
+ return Err(UUsageError::new(libc::EXIT_FAILURE, format!("{r}.\n")));
}
};
@@ -152,11 +149,12 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
pub fn uu_app() -> Command {
Command::new(uucore::util_name())
- .version(VERSION)
+ .version(crate_version!())
.about(ABOUT)
.override_usage(format_usage(USAGE))
.infer_long_args(true)
.disable_help_flag(true)
+ .args_override_self(true)
.arg(
Arg::new(options::HELP)
.long(options::HELP)
@@ -166,7 +164,7 @@ pub fn uu_app() -> Command {
.arg(
Arg::new(options::dereference::DEREFERENCE)
.long(options::dereference::DEREFERENCE)
- .conflicts_with(options::dereference::NO_DEREFERENCE)
+ .overrides_with(options::dereference::NO_DEREFERENCE)
.help(
"Affect the referent of each symbolic link (this is the default), \
rather than the symbolic link itself.",
@@ -183,7 +181,7 @@ pub fn uu_app() -> Command {
.arg(
Arg::new(options::preserve_root::PRESERVE_ROOT)
.long(options::preserve_root::PRESERVE_ROOT)
- .conflicts_with(options::preserve_root::NO_PRESERVE_ROOT)
+ .overrides_with(options::preserve_root::NO_PRESERVE_ROOT)
.help("Fail to operate recursively on '/'.")
.action(ArgAction::SetTrue),
)
diff --git a/src/uu/chcon/src/errors.rs b/src/uu/chcon/src/errors.rs
index 1082dc601313dd2dd44cf754e73a217dd8b9ac2b..10d5735a0c6046c867c4dd6dca12f97caece966f 100644
--- a/src/uu/chcon/src/errors.rs
+++ b/src/uu/chcon/src/errors.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::ffi::OsString;
use std::fmt::Write;
use std::io;
@@ -67,10 +71,10 @@ impl Error {
pub(crate) fn report_full_error(mut err: &dyn std::error::Error) -> String {
let mut desc = String::with_capacity(256);
- write!(desc, "{}", err).unwrap();
+ write!(desc, "{err}").unwrap();
while let Some(source) = err.source() {
err = source;
- write!(desc, ". {}", err).unwrap();
+ write!(desc, ". {err}").unwrap();
}
desc
}
diff --git a/src/uu/chcon/src/fts.rs b/src/uu/chcon/src/fts.rs
index 89dd6184d4404401e8f8b5b12a7cf45ea5768856..a81cb39b658c4821bf8901c8a358bd386f751b2a 100644
--- a/src/uu/chcon/src/fts.rs
+++ b/src/uu/chcon/src/fts.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::ffi::{CStr, CString, OsStr};
use std::marker::PhantomData;
use std::os::raw::{c_int, c_long, c_short};
diff --git a/src/uu/chgrp/Cargo.toml b/src/uu/chgrp/Cargo.toml
index de00ba95169a464030d1d1870d9c9017732a3462..645235c0f486f17575008ab9d09d7fcbb7f4cc32 100644
--- a/src/uu/chgrp/Cargo.toml
+++ b/src/uu/chgrp/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_chgrp"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "chgrp ~ (uutils) change the group ownership of FILE"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/chgrp.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["entries", "fs", "perms"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["entries", "fs", "perms"] }
[[bin]]
name = "chgrp"
diff --git a/src/uu/chgrp/chgrp.md b/src/uu/chgrp/chgrp.md
new file mode 100644
index 0000000000000000000000000000000000000000..79bc068d2d390a32b568b4eb04f174aa6763da41
--- /dev/null
+++ b/src/uu/chgrp/chgrp.md
@@ -0,0 +1,10 @@
+<!-- spell-checker:ignore (vars) RFILE -->
+
+# chgrp
+
+```
+chgrp [OPTION]... GROUP FILE...
+chgrp [OPTION]... --reference=RFILE FILE...
+```
+
+Change the group of each FILE to GROUP.
diff --git a/src/uu/chgrp/src/chgrp.rs b/src/uu/chgrp/src/chgrp.rs
index 3b8d0bab004a92f7ed1fd349fff5d6ef2af2f688..fba2cef16112e4b9866b35803d06ad79810211fd 100644
--- a/src/uu/chgrp/src/chgrp.rs
+++ b/src/uu/chgrp/src/chgrp.rs
@@ -1,7 +1,5 @@
// This file is part of the uutils coreutils package.
//
-// (c) Jian Zeng <anonymousknight96@gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
@@ -10,31 +8,33 @@
use uucore::display::Quotable;
pub use uucore::entries;
use uucore::error::{FromIo, UResult, USimpleError};
-use uucore::format_usage;
-use uucore::perms::{chown_base, options, IfFrom};
+use uucore::perms::{chown_base, options, GidUidOwnerFilter, IfFrom};
+use uucore::{format_usage, help_about, help_usage};
-use clap::{Arg, ArgAction, ArgMatches, Command};
+use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
use std::fs;
use std::os::unix::fs::MetadataExt;
-static ABOUT: &str = "Change the group of each FILE to GROUP.";
-static VERSION: &str = env!("CARGO_PKG_VERSION");
-
-const USAGE: &str = "\
- {} [OPTION]... GROUP FILE...\n \
- {} [OPTION]... --reference=RFILE FILE...";
+const ABOUT: &str = help_about!("chgrp.md");
+const USAGE: &str = help_usage!("chgrp.md");
-fn parse_gid_and_uid(matches: &ArgMatches) -> UResult<(Option<u32>, Option<u32>, IfFrom)> {
+fn parse_gid_and_uid(matches: &ArgMatches) -> UResult<GidUidOwnerFilter> {
+ let mut raw_group: String = String::new();
let dest_gid = if let Some(file) = matches.get_one::<String>(options::REFERENCE) {
fs::metadata(file)
- .map(|meta| Some(meta.gid()))
+ .map(|meta| {
+ let gid = meta.gid();
+ raw_group = entries::gid2grp(gid).unwrap_or_else(|_| gid.to_string());
+ Some(gid)
+ })
.map_err_context(|| format!("failed to get attributes of {}", file.quote()))?
} else {
let group = matches
.get_one::<String>(options::ARG_GROUP)
.map(|s| s.as_str())
.unwrap_or_default();
+ raw_group = group.to_string();
if group.is_empty() {
None
} else {
@@ -49,7 +49,12 @@ fn parse_gid_and_uid(matches: &ArgMatches) -> UResult<(Option<u32>, Option<u32>,
}
}
};
- Ok((dest_gid, None, IfFrom::All))
+ Ok(GidUidOwnerFilter {
+ dest_gid,
+ dest_uid: None,
+ raw_owner: raw_group,
+ filter: IfFrom::All,
+ })
}
#[uucore::main]
@@ -59,7 +64,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
pub fn uu_app() -> Command {
Command::new(uucore::util_name())
- .version(VERSION)
+ .version(crate_version!())
.about(ABOUT)
.override_usage(format_usage(USAGE))
.infer_long_args(true)
diff --git a/src/uu/chmod/Cargo.toml b/src/uu/chmod/Cargo.toml
index 52335e13a469bf9a1d7c9801029390152ead7dfb..386cde52df98ed4474b2cbe70574351e7a335de5 100644
--- a/src/uu/chmod/Cargo.toml
+++ b/src/uu/chmod/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_chmod"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "chmod ~ (uutils) change mode of FILE"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/chmod.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-libc = "0.2.137"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["fs", "mode"] }
+clap = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true, features = ["fs", "mode"] }
[[bin]]
name = "chmod"
diff --git a/src/uu/chmod/chmod.md b/src/uu/chmod/chmod.md
new file mode 100644
index 0000000000000000000000000000000000000000..d6c2ed2d8e36392125dbdd7009020467f2540cae
--- /dev/null
+++ b/src/uu/chmod/chmod.md
@@ -0,0 +1,16 @@
+<!-- spell-checker:ignore RFILE ugoa -->
+
+# chmod
+
+```
+chmod [OPTION]... MODE[,MODE]... FILE...
+chmod [OPTION]... OCTAL-MODE FILE...
+chmod [OPTION]... --reference=RFILE FILE...
+```
+
+Change the mode of each FILE to MODE.
+With --reference, change the mode of each FILE to that of RFILE.
+
+## After Help
+
+Each MODE is of the form '[ugoa]*([-+=]([rwxXst]*|[ugo]))+|[-+=]?[0-7]+'.
diff --git a/src/uu/chmod/src/chmod.rs b/src/uu/chmod/src/chmod.rs
index c21705ccd8d9ddbfa6b09ea00592b6e3e91613a0..d13257437829e35757029466e66c4229796a41c6 100644
--- a/src/uu/chmod/src/chmod.rs
+++ b/src/uu/chmod/src/chmod.rs
@@ -1,26 +1,26 @@
// This file is part of the uutils coreutils package.
//
-// (c) Alex Lyon <arcterus@mail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
// spell-checker:ignore (ToDO) Chmoder cmode fmode fperm fref ugoa RFILE RFILE's
use clap::{crate_version, Arg, ArgAction, Command};
+use std::ffi::OsString;
use std::fs;
use std::os::unix::fs::{MetadataExt, PermissionsExt};
use std::path::Path;
use uucore::display::Quotable;
-use uucore::error::{ExitCode, UResult, USimpleError, UUsageError};
+use uucore::error::{set_exit_code, ExitCode, UResult, USimpleError, UUsageError};
use uucore::fs::display_permissions_unix;
use uucore::libc::mode_t;
#[cfg(not(windows))]
use uucore::mode;
-use uucore::{format_usage, show_error};
+use uucore::{format_usage, help_about, help_section, help_usage, show, show_error};
-static ABOUT: &str = "Change the mode of each FILE to MODE.
- With --reference, change the mode of each FILE to that of RFILE.";
+const ABOUT: &str = help_about!("chmod.md");
+const USAGE: &str = help_usage!("chmod.md");
+const LONG_USAGE: &str = help_section!("after help", "chmod.md");
mod options {
pub const CHANGES: &str = "changes";
@@ -34,26 +34,65 @@ mod options {
pub const FILE: &str = "FILE";
}
-const USAGE: &str = "\
- {} [OPTION]... MODE[,MODE]... FILE...
- {} [OPTION]... OCTAL-MODE FILE...
- {} [OPTION]... --reference=RFILE FILE...";
+/// Extract negative modes (starting with '-') from the rest of the arguments.
+///
+/// This is mainly required for GNU compatibility, where "non-positional negative" modes are used
+/// as the actual positional MODE. Some examples of these cases are:
+/// * "chmod -w -r file", which is the same as "chmod -w,-r file"
+/// * "chmod -w file -r", which is the same as "chmod -w,-r file"
+///
+/// These can currently not be handled by clap.
+/// Therefore it might be possible that a pseudo MODE is inserted to pass clap parsing.
+/// The pseudo MODE is later replaced by the extracted (and joined) negative modes.
+fn extract_negative_modes(mut args: impl uucore::Args) -> (Option<String>, Vec<OsString>) {
+ // we look up the args until "--" is found
+ // "-mode" will be extracted into parsed_cmode_vec
+ let (parsed_cmode_vec, pre_double_hyphen_args): (Vec<OsString>, Vec<OsString>) =
+ args.by_ref().take_while(|a| a != "--").partition(|arg| {
+ let arg = if let Some(arg) = arg.to_str() {
+ arg.to_string()
+ } else {
+ return false;
+ };
+ arg.len() >= 2
+ && arg.starts_with('-')
+ && matches!(
+ arg.chars().nth(1).unwrap(),
+ 'r' | 'w' | 'x' | 'X' | 's' | 't' | 'u' | 'g' | 'o' | '0'..='7'
+ )
+ });
+
+ let mut clean_args = Vec::new();
+ if !parsed_cmode_vec.is_empty() {
+ // we need a pseudo cmode for clap, which won't be used later.
+ // this is required because clap needs the default "chmod MODE FILE" scheme.
+ clean_args.push("w".into());
+ }
+ clean_args.extend(pre_double_hyphen_args);
+
+ if let Some(arg) = args.next() {
+ // as there is still something left in the iterator, we previously consumed the "--"
+ // -> add it to the args again
+ clean_args.push("--".into());
+ clean_args.push(arg);
+ }
+ clean_args.extend(args);
-fn get_long_usage() -> &'static str {
- "Each MODE is of the form '[ugoa]*([-+=]([rwxXst]*|[ugo]))+|[-+=]?[0-7]+'."
+ let parsed_cmode = Some(
+ parsed_cmode_vec
+ .iter()
+ .map(|s| s.to_str().unwrap())
+ .collect::<Vec<&str>>()
+ .join(","),
+ )
+ .filter(|s| !s.is_empty());
+ (parsed_cmode, clean_args)
}
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let mut args = args.collect_lossy();
-
- // Before we can parse 'args' with clap (and previously getopts),
- // a possible MODE prefix '-' needs to be removed (e.g. "chmod -x FILE").
- let mode_had_minus_prefix = mode::strip_minus_from_mode(&mut args);
-
- let after_help = get_long_usage();
-
- let matches = uu_app().after_help(after_help).try_get_matches_from(args)?;
+ let (parsed_cmode, args) = extract_negative_modes(args.skip(1)); // skip binary name
+ let matches = uu_app().after_help(LONG_USAGE).try_get_matches_from(args)?;
let changes = matches.get_flag(options::CHANGES);
let quiet = matches.get_flag(options::QUIET);
@@ -62,7 +101,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let recursive = matches.get_flag(options::RECURSIVE);
let fmode = match matches.get_one::<String>(options::REFERENCE) {
Some(fref) => match fs::metadata(fref) {
- Ok(meta) => Some(meta.mode()),
+ Ok(meta) => Some(meta.mode() & 0o7777),
Err(err) => {
return Err(USimpleError::new(
1,
@@ -72,13 +111,14 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
},
None => None,
};
- let modes = matches.get_one::<String>(options::MODE).unwrap(); // should always be Some because required
- let cmode = if mode_had_minus_prefix {
- // clap parsing is finished, now put prefix back
- format!("-{}", modes)
+
+ let modes = matches.get_one::<String>(options::MODE);
+ let cmode = if let Some(parsed_cmode) = parsed_cmode {
+ parsed_cmode
} else {
- modes.to_string()
+ modes.unwrap().to_string() // modes is required
};
+ // FIXME: enable non-utf8 paths
let mut files: Vec<String> = matches
.get_many::<String>(options::FILE)
.map(|v| v.map(ToString::to_string).collect())
@@ -115,7 +155,9 @@ pub fn uu_app() -> Command {
.version(crate_version!())
.about(ABOUT)
.override_usage(format_usage(USAGE))
+ .args_override_self(true)
.infer_long_args(true)
+ .no_binary_name(true)
.arg(
Arg::new(options::CHANGES)
.long(options::CHANGES)
@@ -195,40 +237,45 @@ impl Chmoder {
let file = Path::new(filename);
if !file.exists() {
if file.is_symlink() {
- println!(
- "failed to change mode of {} from 0000 (---------) to 0000 (---------)",
- filename.quote()
- );
if !self.quiet {
- return Err(USimpleError::new(
+ show!(USimpleError::new(
1,
format!("cannot operate on dangling symlink {}", filename.quote()),
));
}
+ if self.verbose {
+ println!(
+ "failed to change mode of {} from 0000 (---------) to 1500 (r-x-----T)",
+ filename.quote()
+ );
+ }
} else if !self.quiet {
- return Err(USimpleError::new(
+ show!(USimpleError::new(
1,
format!(
"cannot access {}: No such file or directory",
filename.quote()
- ),
+ )
));
}
- return Err(ExitCode::new(1));
+ // GNU exits with exit code 1 even if -q or --quiet are passed
+ // So we set the exit code, because it hasn't been set yet if `self.quiet` is true.
+ set_exit_code(1);
+ continue;
}
if self.recursive && self.preserve_root && filename == "/" {
return Err(USimpleError::new(
1,
format!(
- "it is dangerous to operate recursively on {}\nuse --no-preserve-root to override this failsafe",
+ "it is dangerous to operate recursively on {}\nchmod: use --no-preserve-root to override this failsafe",
filename.quote()
)
));
}
- if !self.recursive {
- r = self.chmod_file(file).and(r);
- } else {
+ if self.recursive {
r = self.walk_dir(file);
+ } else {
+ r = self.chmod_file(file).and(r);
}
}
r
@@ -288,9 +335,7 @@ impl Chmoder {
let mut new_mode = fperm;
let mut naively_expected_new_mode = new_mode;
for mode in cmode_unwrapped.split(',') {
- // cmode is guaranteed to be Some in this case
- let arr: &[char] = &['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
- let result = if mode.contains(arr) {
+ let result = if mode.chars().any(|c| c.is_ascii_digit()) {
mode::parse_numeric(new_mode, mode, file.is_dir()).map(|v| (v, v))
} else {
mode::parse_symbolic(new_mode, mode, get_umask(), file.is_dir()).map(|m| {
@@ -305,20 +350,22 @@ impl Chmoder {
(m, naive_mode)
})
};
+
match result {
Ok((mode, naive_mode)) => {
new_mode = mode;
naively_expected_new_mode = naive_mode;
}
Err(f) => {
- if !self.quiet {
- return Err(USimpleError::new(1, f));
+ return if self.quiet {
+ Err(ExitCode::new(1))
} else {
- return Err(ExitCode::new(1));
- }
+ Err(USimpleError::new(1, f))
+ };
}
}
}
+
self.change_file(fperm, new_mode, file)?;
// if a permission would have been removed if umask was 0, but it wasn't because umask was not 0, print an error and fail
if (new_mode & !naively_expected_new_mode) != 0 {
@@ -380,3 +427,34 @@ impl Chmoder {
}
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_extract_negative_modes() {
+ // "chmod -w -r file" becomes "chmod -w,-r file". clap does not accept "-w,-r" as MODE.
+ // Therefore, "w" is added as pseudo mode to pass clap.
+ let (c, a) = extract_negative_modes(["-w", "-r", "file"].iter().map(OsString::from));
+ assert_eq!(c, Some("-w,-r".to_string()));
+ assert_eq!(a, ["w", "file"]);
+
+ // "chmod -w file -r" becomes "chmod -w,-r file". clap does not accept "-w,-r" as MODE.
+ // Therefore, "w" is added as pseudo mode to pass clap.
+ let (c, a) = extract_negative_modes(["-w", "file", "-r"].iter().map(OsString::from));
+ assert_eq!(c, Some("-w,-r".to_string()));
+ assert_eq!(a, ["w", "file"]);
+
+ // "chmod -w -- -r file" becomes "chmod -w -r file", where "-r" is interpreted as file.
+ // Again, "w" is needed as pseudo mode.
+ let (c, a) = extract_negative_modes(["-w", "--", "-r", "f"].iter().map(OsString::from));
+ assert_eq!(c, Some("-w".to_string()));
+ assert_eq!(a, ["w", "--", "-r", "f"]);
+
+ // "chmod -- -r file" becomes "chmod -r file".
+ let (c, a) = extract_negative_modes(["--", "-r", "file"].iter().map(OsString::from));
+ assert_eq!(c, None);
+ assert_eq!(a, ["--", "-r", "file"]);
+ }
+}
diff --git a/src/uu/chown/Cargo.toml b/src/uu/chown/Cargo.toml
index 79aa2e4c20927a82a09f46c2d3cc7781d2d93035..45bc0f376e965b9355df08060814bd02bff8920e 100644
--- a/src/uu/chown/Cargo.toml
+++ b/src/uu/chown/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_chown"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "chown ~ (uutils) change the ownership of FILE"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/chown.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["entries", "fs", "perms"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["entries", "fs", "perms"] }
[[bin]]
name = "chown"
diff --git a/src/uu/chown/chown.md b/src/uu/chown/chown.md
new file mode 100644
index 0000000000000000000000000000000000000000..83101c74c73c2345222dc709a081c0ab43433fdb
--- /dev/null
+++ b/src/uu/chown/chown.md
@@ -0,0 +1,9 @@
+<!-- spell-checker:ignore RFILE -->
+# chown
+
+```
+chown [OPTION]... [OWNER][:[GROUP]] FILE...
+chown [OPTION]... --reference=RFILE FILE...
+```
+
+Change file owner and group
diff --git a/src/uu/chown/src/chown.rs b/src/uu/chown/src/chown.rs
index b2a0dcd857872622e97bab71b2a281aa62d5a74e..0e9b8b2423cca3af8122103ed8d1abe845d89e3e 100644
--- a/src/uu/chown/src/chown.rs
+++ b/src/uu/chown/src/chown.rs
@@ -1,7 +1,5 @@
// This file is part of the uutils coreutils package.
//
-// (c) Jian Zeng <anonymousknight96@gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
@@ -9,8 +7,8 @@
use uucore::display::Quotable;
pub use uucore::entries::{self, Group, Locate, Passwd};
-use uucore::format_usage;
-use uucore::perms::{chown_base, options, IfFrom};
+use uucore::perms::{chown_base, options, GidUidOwnerFilter, IfFrom};
+use uucore::{format_usage, help_about, help_usage};
use uucore::error::{FromIo, UResult, USimpleError};
@@ -19,13 +17,11 @@ use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
use std::fs;
use std::os::unix::fs::MetadataExt;
-static ABOUT: &str = "change file owner and group";
+static ABOUT: &str = help_about!("chown.md");
-const USAGE: &str = "\
- {} [OPTION]... [OWNER][:[GROUP]] FILE...
- {} [OPTION]... --reference=RFILE FILE...";
+const USAGE: &str = help_usage!("chown.md");
-fn parse_gid_uid_and_filter(matches: &ArgMatches) -> UResult<(Option<u32>, Option<u32>, IfFrom)> {
+fn parse_gid_uid_and_filter(matches: &ArgMatches) -> UResult<GidUidOwnerFilter> {
let filter = if let Some(spec) = matches.get_one::<String>(options::FROM) {
match parse_spec(spec, ':')? {
(Some(uid), None) => IfFrom::User(uid),
@@ -39,17 +35,34 @@ fn parse_gid_uid_and_filter(matches: &ArgMatches) -> UResult<(Option<u32>, Optio
let dest_uid: Option<u32>;
let dest_gid: Option<u32>;
+ let raw_owner: String;
if let Some(file) = matches.get_one::<String>(options::REFERENCE) {
let meta = fs::metadata(file)
.map_err_context(|| format!("failed to get attributes of {}", file.quote()))?;
- dest_gid = Some(meta.gid());
- dest_uid = Some(meta.uid());
+ let gid = meta.gid();
+ let uid = meta.uid();
+ dest_gid = Some(gid);
+ dest_uid = Some(uid);
+ raw_owner = format!(
+ "{}:{}",
+ entries::uid2usr(uid).unwrap_or_else(|_| uid.to_string()),
+ entries::gid2grp(gid).unwrap_or_else(|_| gid.to_string())
+ );
} else {
- let (u, g) = parse_spec(matches.get_one::<String>(options::ARG_OWNER).unwrap(), ':')?;
+ raw_owner = matches
+ .get_one::<String>(options::ARG_OWNER)
+ .unwrap()
+ .into();
+ let (u, g) = parse_spec(&raw_owner, ':')?;
dest_uid = u;
dest_gid = g;
}
- Ok((dest_gid, dest_uid, filter))
+ Ok(GidUidOwnerFilter {
+ dest_gid,
+ dest_uid,
+ raw_owner,
+ filter,
+ })
}
#[uucore::main]
@@ -182,6 +195,53 @@ pub fn uu_app() -> Command {
)
}
+/// Parses the user string to extract the UID.
+fn parse_uid(user: &str, spec: &str, sep: char) -> UResult<Option<u32>> {
+ if user.is_empty() {
+ return Ok(None);
+ }
+ match Passwd::locate(user) {
+ Ok(u) => Ok(Some(u.uid)), // We have been able to get the uid
+ Err(_) => {
+ // we have NOT been able to find the uid
+ // but we could be in the case where we have user.group
+ if spec.contains('.') && !spec.contains(':') && sep == ':' {
+ // but the input contains a '.' but not a ':'
+ // we might have something like username.groupname
+ // So, try to parse it this way
+ parse_spec(spec, '.').map(|(uid, _)| uid)
+ } else {
+ // It's possible that the `user` string contains a
+ // numeric user ID, in which case, we respect that.
+ match user.parse() {
+ Ok(uid) => Ok(Some(uid)),
+ Err(_) => Err(USimpleError::new(
+ 1,
+ format!("invalid user: {}", spec.quote()),
+ )),
+ }
+ }
+ }
+ }
+}
+
+/// Parses the group string to extract the GID.
+fn parse_gid(group: &str, spec: &str) -> UResult<Option<u32>> {
+ if group.is_empty() {
+ return Ok(None);
+ }
+ match Group::locate(group) {
+ Ok(g) => Ok(Some(g.gid)),
+ Err(_) => match group.parse() {
+ Ok(gid) => Ok(Some(gid)),
+ Err(_) => Err(USimpleError::new(
+ 1,
+ format!("invalid group: {}", spec.quote()),
+ )),
+ },
+ }
+}
+
/// Parse the owner/group specifier string into a user ID and a group ID.
///
/// The `spec` can be of the form:
@@ -200,52 +260,8 @@ fn parse_spec(spec: &str, sep: char) -> UResult<(Option<u32>, Option<u32>)> {
let user = args.next().unwrap_or("");
let group = args.next().unwrap_or("");
- let uid = if !user.is_empty() {
- Some(match Passwd::locate(user) {
- Ok(u) => u.uid, // We have been able to get the uid
- Err(_) =>
- // we have NOT been able to find the uid
- // but we could be in the case where we have user.group
- {
- if spec.contains('.') && !spec.contains(':') && sep == ':' {
- // but the input contains a '.' but not a ':'
- // we might have something like username.groupname
- // So, try to parse it this way
- return parse_spec(spec, '.');
- } else {
- // It's possible that the `user` string contains a
- // numeric user ID, in which case, we respect that.
- match user.parse() {
- Ok(uid) => uid,
- Err(_) => {
- return Err(USimpleError::new(
- 1,
- format!("invalid user: {}", spec.quote()),
- ))
- }
- }
- }
- }
- })
- } else {
- None
- };
- let gid = if !group.is_empty() {
- Some(match Group::locate(group) {
- Ok(g) => g.gid,
- Err(_) => match group.parse() {
- Ok(gid) => gid,
- Err(_) => {
- return Err(USimpleError::new(
- 1,
- format!("invalid group: {}", spec.quote()),
- ));
- }
- },
- })
- } else {
- None
- };
+ let uid = parse_uid(user, spec, sep)?;
+ let gid = parse_gid(group, spec)?;
if user.chars().next().map(char::is_numeric).unwrap_or(false)
&& group.is_empty()
diff --git a/src/uu/chroot/Cargo.toml b/src/uu/chroot/Cargo.toml
index 4a44f9eaa38d6e3c2447dddc82664f19499d0737..d4c01dbdfb40b0976316ddb75e3767d1b03d86ba 100644
--- a/src/uu/chroot/Cargo.toml
+++ b/src/uu/chroot/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_chroot"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "chroot ~ (uutils) run COMMAND under a new root directory"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/chroot.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["entries", "fs"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["entries", "fs"] }
[[bin]]
name = "chroot"
diff --git a/src/uu/chroot/chroot.md b/src/uu/chroot/chroot.md
new file mode 100644
index 0000000000000000000000000000000000000000..3967d08f96383631102ca578b051b0d6f110eb68
--- /dev/null
+++ b/src/uu/chroot/chroot.md
@@ -0,0 +1,8 @@
+<!-- spell-checker:ignore NEWROOT -->
+# chroot
+
+```
+chroot [OPTION]... NEWROOT [COMMAND [ARG]...]
+```
+
+Run COMMAND with root directory set to NEWROOT.
diff --git a/src/uu/chroot/src/chroot.rs b/src/uu/chroot/src/chroot.rs
index c80b4ab87f41ce6e05d89438425b061ff7dc8134..fb20b0ccc46fdd5952f28f3e45fc072f5596b155 100644
--- a/src/uu/chroot/src/chroot.rs
+++ b/src/uu/chroot/src/chroot.rs
@@ -1,8 +1,5 @@
// This file is part of the uutils coreutils package.
//
-// (c) Vsevolod Velichko <torkvemada@sorokdva.net>
-// (c) Jian Zeng <anonymousknight96 AT gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
@@ -19,10 +16,10 @@ use std::process;
use uucore::error::{set_exit_code, UClapError, UResult, UUsageError};
use uucore::fs::{canonicalize, MissingHandling, ResolveMode};
use uucore::libc::{self, chroot, setgid, setgroups, setuid};
-use uucore::{entries, format_usage};
+use uucore::{entries, format_usage, help_about, help_usage};
-static ABOUT: &str = "Run COMMAND with root directory set to NEWROOT.";
-static USAGE: &str = "{} [OPTION]... NEWROOT [COMMAND [ARG]...]";
+static ABOUT: &str = help_about!("chroot.md");
+static USAGE: &str = help_usage!("chroot.md");
mod options {
pub const NEWROOT: &str = "newroot";
@@ -36,8 +33,6 @@ mod options {
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_lossy();
-
let matches = uu_app().try_get_matches_from(args).with_exit_code(125)?;
let default_shell: &'static str = "/bin/sh";
@@ -256,7 +251,7 @@ fn set_main_group(group: &str) -> UResult<()> {
Ok(())
}
-#[cfg(any(target_vendor = "apple", target_os = "freebsd"))]
+#[cfg(any(target_vendor = "apple", target_os = "freebsd", target_os = "openbsd"))]
fn set_groups(groups: &[libc::gid_t]) -> libc::c_int {
unsafe { setgroups(groups.len() as libc::c_int, groups.as_ptr()) }
}
diff --git a/src/uu/chroot/src/error.rs b/src/uu/chroot/src/error.rs
index 059715de15c0f5860809a92fc6a3961a98d734d2..526f1a75a4316d5c58a29f80a0316c0077d79a50 100644
--- a/src/uu/chroot/src/error.rs
+++ b/src/uu/chroot/src/error.rs
@@ -1,7 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore NEWROOT Userspec userspec
//! Errors returned by chroot.
use std::fmt::Display;
@@ -77,8 +77,8 @@ impl Display for ChrootError {
"cannot change root directory to {}: no such directory",
s.quote(),
),
- Self::SetGidFailed(s, e) => write!(f, "cannot set gid to {}: {}", s, e),
- Self::SetGroupsFailed(e) => write!(f, "cannot set groups: {}", e),
+ Self::SetGidFailed(s, e) => write!(f, "cannot set gid to {s}: {e}"),
+ Self::SetGroupsFailed(e) => write!(f, "cannot set groups: {e}"),
Self::SetUserFailed(s, e) => {
write!(f, "cannot set user to {}: {}", s.maybe_quote(), e)
}
diff --git a/src/uu/cksum/Cargo.toml b/src/uu/cksum/Cargo.toml
index 52c7dd7cb8e2a1b0e83d71b0691ddc4be4deea34..43b370988bdf28614fbd7494bcdf615935f050bd 100644
--- a/src/uu/cksum/Cargo.toml
+++ b/src/uu/cksum/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_cksum"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "cksum ~ (uutils) display CRC and size of input"
@@ -15,8 +15,10 @@ edition = "2021"
path = "src/cksum.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["checksum", "encoding", "sum"] }
+hex = { workspace = true }
+regex = { workspace = true }
[[bin]]
name = "cksum"
diff --git a/src/uu/cksum/cksum.md b/src/uu/cksum/cksum.md
new file mode 100644
index 0000000000000000000000000000000000000000..4b0d25f32c3cca6e33c599bfed90d29f4f4d82db
--- /dev/null
+++ b/src/uu/cksum/cksum.md
@@ -0,0 +1,23 @@
+# cksum
+
+```
+cksum [OPTIONS] [FILE]...
+```
+
+Print CRC and size for each file
+
+## After Help
+
+DIGEST determines the digest algorithm and default output format:
+
+- `sysv`: (equivalent to sum -s)
+- `bsd`: (equivalent to sum -r)
+- `crc`: (equivalent to cksum)
+- `md5`: (equivalent to md5sum)
+- `sha1`: (equivalent to sha1sum)
+- `sha224`: (equivalent to sha224sum)
+- `sha256`: (equivalent to sha256sum)
+- `sha384`: (equivalent to sha384sum)
+- `sha512`: (equivalent to sha512sum)
+- `blake2b`: (equivalent to b2sum)
+- `sm3`: (only available through cksum)
diff --git a/src/uu/cksum/src/cksum.rs b/src/uu/cksum/src/cksum.rs
index fc7f901c9ad6dc46de55051c6baa185acd51cb95..0c807c8c481b6d00e9d5f3d4d0db1b72f7f99d9f 100644
--- a/src/uu/cksum/src/cksum.rs
+++ b/src/uu/cksum/src/cksum.rs
@@ -1,138 +1,347 @@
// This file is part of the uutils coreutils package.
//
-// (c) Michael Gehring <mg@ebfe.org>
-//
-// For the full copyright and license information, please view the LICENSE
+// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
-// spell-checker:ignore (ToDO) fname
-use clap::{crate_version, Arg, Command};
+// spell-checker:ignore (ToDO) fname, algo
+use clap::{crate_version, value_parser, Arg, ArgAction, Command};
+use std::ffi::OsStr;
use std::fs::File;
-use std::io::{self, stdin, BufReader, Read};
+use std::io::{self, stdin, stdout, BufReader, Read, Write};
+use std::iter;
use std::path::Path;
-use uucore::display::Quotable;
-use uucore::error::{FromIo, UResult};
-use uucore::{format_usage, show};
-
-// NOTE: CRC_TABLE_LEN *must* be <= 256 as we cast 0..CRC_TABLE_LEN to u8
-const CRC_TABLE_LEN: usize = 256;
-const CRC_TABLE: [u32; CRC_TABLE_LEN] = generate_crc_table();
+use uucore::checksum::{
+ calculate_blake2b_length, detect_algo, digest_reader, perform_checksum_validation,
+ ChecksumError, ALGORITHM_OPTIONS_BLAKE2B, ALGORITHM_OPTIONS_BSD, ALGORITHM_OPTIONS_CRC,
+ ALGORITHM_OPTIONS_SYSV, SUPPORTED_ALGORITHMS,
+};
+use uucore::{
+ encoding,
+ error::{FromIo, UResult, USimpleError},
+ format_usage, help_about, help_section, help_usage, show,
+ sum::{div_ceil, Digest},
+};
-const USAGE: &str = "{} [OPTIONS] [FILE]...";
-const ABOUT: &str = "Print CRC and size for each file";
+const USAGE: &str = help_usage!("cksum.md");
+const ABOUT: &str = help_about!("cksum.md");
+const AFTER_HELP: &str = help_section!("after help", "cksum.md");
-const fn generate_crc_table() -> [u32; CRC_TABLE_LEN] {
- let mut table = [0; CRC_TABLE_LEN];
+#[derive(Debug, PartialEq)]
+enum OutputFormat {
+ Hexadecimal,
+ Raw,
+ Base64,
+}
- let mut i = 0;
- while i < CRC_TABLE_LEN {
- table[i] = crc_entry(i as u8);
+struct Options {
+ algo_name: &'static str,
+ digest: Box<dyn Digest + 'static>,
+ output_bits: usize,
+ tag: bool, // will cover the --untagged option
+ length: Option<usize>,
+ output_format: OutputFormat,
+ asterisk: bool, // if we display an asterisk or not (--binary/--text)
+}
- i += 1;
+/// Calculate checksum
+///
+/// # Arguments
+///
+/// * `options` - CLI options for the assigning checksum algorithm
+/// * `files` - A iterator of OsStr which is a bunch of files that are using for calculating checksum
+#[allow(clippy::cognitive_complexity)]
+fn cksum<'a, I>(mut options: Options, files: I) -> UResult<()>
+where
+ I: Iterator<Item = &'a OsStr>,
+{
+ let files: Vec<_> = files.collect();
+ if options.output_format == OutputFormat::Raw && files.len() > 1 {
+ return Err(Box::new(ChecksumError::RawMultipleFiles));
}
- table
-}
+ for filename in files {
+ let filename = Path::new(filename);
+ let stdin_buf;
+ let file_buf;
+ let not_file = filename == OsStr::new("-");
-const fn crc_entry(input: u8) -> u32 {
- let mut crc = (input as u32) << 24;
+ // Handle the file input
+ let mut file = BufReader::new(if not_file {
+ stdin_buf = stdin();
+ Box::new(stdin_buf) as Box<dyn Read>
+ } else if filename.is_dir() {
+ Box::new(BufReader::new(io::empty())) as Box<dyn Read>
+ } else {
+ file_buf = match File::open(filename) {
+ Ok(file) => file,
+ Err(err) => {
+ show!(err.map_err_context(|| filename.to_string_lossy().to_string()));
+ continue;
+ }
+ };
+ Box::new(file_buf) as Box<dyn Read>
+ });
- let mut i = 0;
- while i < 8 {
- let if_condition = crc & 0x8000_0000;
- let if_body = (crc << 1) ^ 0x04c1_1db7;
- let else_body = crc << 1;
+ if filename.is_dir() {
+ show!(USimpleError::new(
+ 1,
+ format!("{}: Is a directory", filename.display())
+ ));
+ continue;
+ }
- // NOTE: i feel like this is easier to understand than emulating an if statement in bitwise
- // ops
- let condition_table = [else_body, if_body];
+ let (sum_hex, sz) =
+ digest_reader(&mut options.digest, &mut file, false, options.output_bits)
+ .map_err_context(|| "failed to read input".to_string())?;
- crc = condition_table[(if_condition != 0) as usize];
- i += 1;
+ let sum = match options.output_format {
+ OutputFormat::Raw => {
+ let bytes = match options.algo_name {
+ ALGORITHM_OPTIONS_CRC => sum_hex.parse::<u32>().unwrap().to_be_bytes().to_vec(),
+ ALGORITHM_OPTIONS_SYSV | ALGORITHM_OPTIONS_BSD => {
+ sum_hex.parse::<u16>().unwrap().to_be_bytes().to_vec()
+ }
+ _ => hex::decode(sum_hex).unwrap(),
+ };
+ // Cannot handle multiple files anyway, output immediately.
+ stdout().write_all(&bytes)?;
+ return Ok(());
+ }
+ OutputFormat::Hexadecimal => sum_hex,
+ OutputFormat::Base64 => match options.algo_name {
+ ALGORITHM_OPTIONS_CRC | ALGORITHM_OPTIONS_SYSV | ALGORITHM_OPTIONS_BSD => sum_hex,
+ _ => encoding::encode(encoding::Format::Base64, &hex::decode(sum_hex).unwrap())
+ .unwrap(),
+ },
+ };
+ // The BSD checksum output is 5 digit integer
+ let bsd_width = 5;
+ match (options.algo_name, not_file) {
+ (ALGORITHM_OPTIONS_SYSV, true) => println!(
+ "{} {}",
+ sum.parse::<u16>().unwrap(),
+ div_ceil(sz, options.output_bits)
+ ),
+ (ALGORITHM_OPTIONS_SYSV, false) => println!(
+ "{} {} {}",
+ sum.parse::<u16>().unwrap(),
+ div_ceil(sz, options.output_bits),
+ filename.display()
+ ),
+ (ALGORITHM_OPTIONS_BSD, true) => println!(
+ "{:0bsd_width$} {:bsd_width$}",
+ sum.parse::<u16>().unwrap(),
+ div_ceil(sz, options.output_bits)
+ ),
+ (ALGORITHM_OPTIONS_BSD, false) => println!(
+ "{:0bsd_width$} {:bsd_width$} {}",
+ sum.parse::<u16>().unwrap(),
+ div_ceil(sz, options.output_bits),
+ filename.display()
+ ),
+ (ALGORITHM_OPTIONS_CRC, true) => println!("{sum} {sz}"),
+ (ALGORITHM_OPTIONS_CRC, false) => println!("{sum} {sz} {}", filename.display()),
+ (ALGORITHM_OPTIONS_BLAKE2B, _) if options.tag => {
+ if let Some(length) = options.length {
+ // Multiply by 8 here, as we want to print the length in bits.
+ println!("BLAKE2b-{} ({}) = {sum}", length * 8, filename.display());
+ } else {
+ println!("BLAKE2b ({}) = {sum}", filename.display());
+ }
+ }
+ _ => {
+ if options.tag {
+ println!(
+ "{} ({}) = {sum}",
+ options.algo_name.to_ascii_uppercase(),
+ filename.display()
+ );
+ } else {
+ let prefix = if options.asterisk { "*" } else { " " };
+ println!("{sum} {prefix}{}", filename.display());
+ }
+ }
+ }
}
- crc
+ Ok(())
}
-#[inline]
-fn crc_update(crc: u32, input: u8) -> u32 {
- (crc << 8) ^ CRC_TABLE[((crc >> 24) as usize ^ input as usize) & 0xFF]
+mod options {
+ pub const ALGORITHM: &str = "algorithm";
+ pub const FILE: &str = "file";
+ pub const UNTAGGED: &str = "untagged";
+ pub const TAG: &str = "tag";
+ pub const LENGTH: &str = "length";
+ pub const RAW: &str = "raw";
+ pub const BASE64: &str = "base64";
+ pub const CHECK: &str = "check";
+ pub const STRICT: &str = "strict";
+ pub const TEXT: &str = "text";
+ pub const BINARY: &str = "binary";
+ pub const STATUS: &str = "status";
+ pub const WARN: &str = "warn";
+ pub const IGNORE_MISSING: &str = "ignore-missing";
+ pub const QUIET: &str = "quiet";
}
-#[inline]
-fn crc_final(mut crc: u32, mut length: usize) -> u32 {
- while length != 0 {
- crc = crc_update(crc, length as u8);
- length >>= 8;
+/// Determines whether to prompt an asterisk (*) in the output.
+///
+/// This function checks the `tag`, `binary`, and `had_reset` flags and returns a boolean
+/// indicating whether to prompt an asterisk (*) in the output.
+/// It relies on the overrides provided by clap (i.e., `--binary` overrides `--text` and vice versa).
+/// Same for `--tag` and `--untagged`.
+fn prompt_asterisk(tag: bool, binary: bool, had_reset: bool) -> bool {
+ if tag {
+ return false;
+ }
+ if had_reset {
+ return false;
}
+ binary
+}
- !crc
+/**
+ * Determine if we had a reset.
+ * This is basically a hack to support the behavior of cksum
+ * when we have the following arguments:
+ * --binary --tag --untagged
+ * Don't do it with clap because if it struggling with the --overrides_with
+ * marking the value as set even if not present
+ */
+fn had_reset(args: &[String]) -> bool {
+ // Indices where "--binary" or "-b", "--tag", and "--untagged" are found
+ let binary_index = args.iter().position(|x| x == "--binary" || x == "-b");
+ let tag_index = args.iter().position(|x| x == "--tag");
+ let untagged_index = args.iter().position(|x| x == "--untagged");
+
+ // Check if all arguments are present and in the correct order
+ match (binary_index, tag_index, untagged_index) {
+ (Some(b), Some(t), Some(u)) => b < t && t < u,
+ _ => false,
+ }
}
-fn init_byte_array() -> Vec<u8> {
- vec![0; 1024 * 1024]
+/***
+ * cksum has a bunch of legacy behavior.
+ * We handle this in this function to make sure they are self contained
+ * and "easier" to understand
+ */
+fn handle_tag_text_binary_flags(matches: &clap::ArgMatches) -> UResult<(bool, bool)> {
+ let untagged: bool = matches.get_flag(options::UNTAGGED);
+ let tag: bool = matches.get_flag(options::TAG);
+ let tag: bool = tag || !untagged;
+
+ let binary_flag: bool = matches.get_flag(options::BINARY);
+
+ let args: Vec<String> = std::env::args().collect();
+ let had_reset = had_reset(&args);
+
+ let asterisk: bool = prompt_asterisk(tag, binary_flag, had_reset);
+
+ Ok((tag, asterisk))
}
-#[inline]
-fn cksum(fname: &str) -> io::Result<(u32, usize)> {
- let mut crc = 0u32;
- let mut size = 0usize;
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+ let matches = uu_app().try_get_matches_from(args)?;
- let mut rd: Box<dyn Read> = match fname {
- "-" => Box::new(stdin()),
- _ => {
- let p = Path::new(fname);
+ let check = matches.get_flag(options::CHECK);
- // Directories should not give an error, but should be interpreted
- // as empty files to match GNU semantics.
- if p.is_dir() {
- Box::new(BufReader::new(io::empty())) as Box<dyn Read>
+ let algo_name: &str = match matches.get_one::<String>(options::ALGORITHM) {
+ Some(v) => v,
+ None => {
+ if check {
+ // if we are doing a --check, we should not default to crc
+ ""
} else {
- Box::new(BufReader::new(File::open(p)?)) as Box<dyn Read>
+ ALGORITHM_OPTIONS_CRC
}
}
};
- let mut bytes = init_byte_array();
- loop {
- let num_bytes = rd.read(&mut bytes)?;
- if num_bytes == 0 {
- return Ok((crc_final(crc, size), size));
+ if ["bsd", "crc", "sysv"].contains(&algo_name) && check {
+ return Err(ChecksumError::AlgorithmNotSupportedWithCheck.into());
+ }
+
+ let input_length = matches.get_one::<usize>(options::LENGTH);
+
+ let length = match input_length {
+ Some(length) => {
+ if algo_name == ALGORITHM_OPTIONS_BLAKE2B {
+ calculate_blake2b_length(*length)?
+ } else {
+ return Err(ChecksumError::LengthOnlyForBlake2b.into());
+ }
}
- for &b in bytes[..num_bytes].iter() {
- crc = crc_update(crc, b);
+ None => None,
+ };
+
+ if check {
+ let text_flag = matches.get_flag(options::TEXT);
+ let binary_flag = matches.get_flag(options::BINARY);
+ let strict = matches.get_flag(options::STRICT);
+ let status = matches.get_flag(options::STATUS);
+ let warn = matches.get_flag(options::WARN);
+ let ignore_missing = matches.get_flag(options::IGNORE_MISSING);
+ let quiet = matches.get_flag(options::QUIET);
+
+ if binary_flag || text_flag {
+ return Err(ChecksumError::BinaryTextConflict.into());
}
- size += num_bytes;
+ // Determine the appropriate algorithm option to pass
+ let algo_option = if algo_name.is_empty() {
+ None
+ } else {
+ Some(algo_name)
+ };
+
+ // Execute the checksum validation based on the presence of files or the use of stdin
+
+ let files = matches.get_many::<String>(options::FILE).map_or_else(
+ || iter::once(OsStr::new("-")).collect::<Vec<_>>(),
+ |files| files.map(OsStr::new).collect::<Vec<_>>(),
+ );
+ return perform_checksum_validation(
+ files.iter().copied(),
+ strict,
+ status,
+ warn,
+ binary_flag,
+ ignore_missing,
+ quiet,
+ algo_option,
+ length,
+ );
}
-}
-mod options {
- pub static FILE: &str = "file";
-}
+ let (tag, asterisk) = handle_tag_text_binary_flags(&matches)?;
-#[uucore::main]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_ignore();
+ let algo = detect_algo(algo_name, length)?;
- let matches = uu_app().try_get_matches_from(args)?;
+ let output_format = if matches.get_flag(options::RAW) {
+ OutputFormat::Raw
+ } else if matches.get_flag(options::BASE64) {
+ OutputFormat::Base64
+ } else {
+ OutputFormat::Hexadecimal
+ };
- let files: Vec<String> = match matches.get_many::<String>(options::FILE) {
- Some(v) => v.clone().map(|v| v.to_owned()).collect(),
- None => vec![],
+ let opts = Options {
+ algo_name: algo.name,
+ digest: (algo.create_fn)(),
+ output_bits: algo.bits,
+ length,
+ tag,
+ output_format,
+ asterisk,
};
- if files.is_empty() {
- let (crc, size) = cksum("-")?;
- println!("{} {}", crc, size);
- return Ok(());
- }
+ match matches.get_many::<String>(options::FILE) {
+ Some(files) => cksum(opts, files.map(OsStr::new))?,
+ None => cksum(opts, iter::once(OsStr::new("-")))?,
+ };
- for fname in &files {
- match cksum(fname.as_ref()).map_err_context(|| format!("{}", fname.maybe_quote())) {
- Ok((crc, size)) => println!("{} {} {}", crc, size, fname),
- Err(err) => show!(err),
- };
- }
Ok(())
}
@@ -142,10 +351,199 @@ pub fn uu_app() -> Command {
.about(ABOUT)
.override_usage(format_usage(USAGE))
.infer_long_args(true)
+ .args_override_self(true)
.arg(
Arg::new(options::FILE)
.hide(true)
.action(clap::ArgAction::Append)
.value_hint(clap::ValueHint::FilePath),
)
+ .arg(
+ Arg::new(options::ALGORITHM)
+ .long(options::ALGORITHM)
+ .short('a')
+ .help("select the digest type to use. See DIGEST below")
+ .value_name("ALGORITHM")
+ .value_parser(SUPPORTED_ALGORITHMS),
+ )
+ .arg(
+ Arg::new(options::UNTAGGED)
+ .long(options::UNTAGGED)
+ .help("create a reversed style checksum, without digest type")
+ .action(ArgAction::SetTrue)
+ .overrides_with(options::TAG),
+ )
+ .arg(
+ Arg::new(options::TAG)
+ .long(options::TAG)
+ .help("create a BSD style checksum, undo --untagged (default)")
+ .action(ArgAction::SetTrue)
+ .overrides_with(options::UNTAGGED),
+ )
+ .arg(
+ Arg::new(options::LENGTH)
+ .long(options::LENGTH)
+ .value_parser(value_parser!(usize))
+ .short('l')
+ .help(
+ "digest length in bits; must not exceed the max for the blake2 algorithm \
+ and must be a multiple of 8",
+ )
+ .action(ArgAction::Set),
+ )
+ .arg(
+ Arg::new(options::RAW)
+ .long(options::RAW)
+ .help("emit a raw binary digest, not hexadecimal")
+ .action(ArgAction::SetTrue),
+ )
+ .arg(
+ Arg::new(options::STRICT)
+ .long(options::STRICT)
+ .help("exit non-zero for improperly formatted checksum lines")
+ .action(ArgAction::SetTrue),
+ )
+ .arg(
+ Arg::new(options::CHECK)
+ .short('c')
+ .long(options::CHECK)
+ .help("read hashsums from the FILEs and check them")
+ .action(ArgAction::SetTrue)
+ .conflicts_with("tag"),
+ )
+ .arg(
+ Arg::new(options::BASE64)
+ .long(options::BASE64)
+ .help("emit a base64 digest, not hexadecimal")
+ .action(ArgAction::SetTrue)
+ // Even though this could easily just override an earlier '--raw',
+ // GNU cksum does not permit these flags to be combined:
+ .conflicts_with(options::RAW),
+ )
+ .arg(
+ Arg::new(options::TEXT)
+ .long(options::TEXT)
+ .short('t')
+ .hide(true)
+ .overrides_with(options::BINARY)
+ .action(ArgAction::SetTrue),
+ )
+ .arg(
+ Arg::new(options::BINARY)
+ .long(options::BINARY)
+ .short('b')
+ .hide(true)
+ .overrides_with(options::TEXT)
+ .action(ArgAction::SetTrue),
+ )
+ .arg(
+ Arg::new(options::WARN)
+ .short('w')
+ .long("warn")
+ .help("warn about improperly formatted checksum lines")
+ .action(ArgAction::SetTrue),
+ )
+ .arg(
+ Arg::new(options::STATUS)
+ .long("status")
+ .help("don't output anything, status code shows success")
+ .action(ArgAction::SetTrue),
+ )
+ .arg(
+ Arg::new(options::QUIET)
+ .long(options::QUIET)
+ .help("don't print OK for each successfully verified file")
+ .action(ArgAction::SetTrue),
+ )
+ .arg(
+ Arg::new(options::IGNORE_MISSING)
+ .long(options::IGNORE_MISSING)
+ .help("don't fail or report status for missing files")
+ .action(ArgAction::SetTrue),
+ )
+ .after_help(AFTER_HELP)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::had_reset;
+ use crate::calculate_blake2b_length;
+ use crate::prompt_asterisk;
+
+ #[test]
+ fn test_had_reset() {
+ let args = ["--binary", "--tag", "--untagged"]
+ .iter()
+ .map(|&s| s.to_string())
+ .collect::<Vec<String>>();
+ assert!(had_reset(&args));
+
+ let args = ["-b", "--tag", "--untagged"]
+ .iter()
+ .map(|&s| s.to_string())
+ .collect::<Vec<String>>();
+ assert!(had_reset(&args));
+
+ let args = ["-b", "--binary", "--tag", "--untagged"]
+ .iter()
+ .map(|&s| s.to_string())
+ .collect::<Vec<String>>();
+ assert!(had_reset(&args));
+
+ let args = ["--untagged", "--tag", "--binary"]
+ .iter()
+ .map(|&s| s.to_string())
+ .collect::<Vec<String>>();
+ assert!(!had_reset(&args));
+
+ let args = ["--untagged", "--tag", "-b"]
+ .iter()
+ .map(|&s| s.to_string())
+ .collect::<Vec<String>>();
+ assert!(!had_reset(&args));
+
+ let args = ["--binary", "--tag"]
+ .iter()
+ .map(|&s| s.to_string())
+ .collect::<Vec<String>>();
+ assert!(!had_reset(&args));
+
+ let args = ["--tag", "--untagged"]
+ .iter()
+ .map(|&s| s.to_string())
+ .collect::<Vec<String>>();
+ assert!(!had_reset(&args));
+
+ let args = ["--text", "--untagged"]
+ .iter()
+ .map(|&s| s.to_string())
+ .collect::<Vec<String>>();
+ assert!(!had_reset(&args));
+
+ let args = ["--binary", "--untagged"]
+ .iter()
+ .map(|&s| s.to_string())
+ .collect::<Vec<String>>();
+ assert!(!had_reset(&args));
+ }
+
+ #[test]
+ fn test_prompt_asterisk() {
+ assert!(!prompt_asterisk(true, false, false));
+ assert!(!prompt_asterisk(false, false, true));
+ assert!(prompt_asterisk(false, true, false));
+ assert!(!prompt_asterisk(false, false, false));
+ }
+
+ #[test]
+ fn test_calculate_length() {
+ assert_eq!(calculate_blake2b_length(256).unwrap(), Some(32));
+ assert_eq!(calculate_blake2b_length(512).unwrap(), None);
+ assert_eq!(calculate_blake2b_length(256).unwrap(), Some(32));
+ calculate_blake2b_length(255).unwrap_err();
+
+ calculate_blake2b_length(33).unwrap_err();
+
+ calculate_blake2b_length(513).unwrap_err();
+ }
}
diff --git a/src/uu/comm/Cargo.toml b/src/uu/comm/Cargo.toml
index eec6711bbaa543278d4a8b6d29aad0e19cf64137..3e699a672e57c0ddd6f09e12bd4f4ed356c3a9f7 100644
--- a/src/uu/comm/Cargo.toml
+++ b/src/uu/comm/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_comm"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "comm ~ (uutils) compare sorted inputs"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/comm.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "comm"
diff --git a/src/uu/comm/comm.md b/src/uu/comm/comm.md
new file mode 100644
index 0000000000000000000000000000000000000000..91f4467d44342c97d46fecddd4a0fa71b428eb39
--- /dev/null
+++ b/src/uu/comm/comm.md
@@ -0,0 +1,13 @@
+# comm
+
+```
+comm [OPTION]... FILE1 FILE2
+```
+
+Compare two sorted files line by line.
+
+When FILE1 or FILE2 (not both) is -, read standard input.
+
+With no options, produce three-column output. Column one contains
+lines unique to FILE1, column two contains lines unique to FILE2,
+and column three contains lines common to both files.
diff --git a/src/uu/comm/src/comm.rs b/src/uu/comm/src/comm.rs
index a3b4bbde2b8b480f2384debf06c2cdef256e7809..f83717292840c5af6371bc104a185a888cfac44a 100644
--- a/src/uu/comm/src/comm.rs
+++ b/src/uu/comm/src/comm.rs
@@ -1,7 +1,5 @@
// This file is part of the uutils coreutils package.
//
-// (c) Michael Gehring <mg@ebfe.org>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
@@ -11,15 +9,14 @@ use std::cmp::Ordering;
use std::fs::File;
use std::io::{self, stdin, BufRead, BufReader, Stdin};
use std::path::Path;
-use uucore::error::FromIo;
-use uucore::error::UResult;
-use uucore::format_usage;
+use uucore::error::{FromIo, UResult, USimpleError};
+use uucore::line_ending::LineEnding;
+use uucore::{format_usage, help_about, help_usage};
use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
-static ABOUT: &str = "compare two sorted files line by line";
-static LONG_HELP: &str = "";
-const USAGE: &str = "{} [OPTION]... FILE1 FILE2";
+const ABOUT: &str = help_about!("comm.md");
+const USAGE: &str = help_usage!("comm.md");
mod options {
pub const COLUMN_1: &str = "1";
@@ -29,53 +26,57 @@ mod options {
pub const DELIMITER_DEFAULT: &str = "\t";
pub const FILE_1: &str = "FILE1";
pub const FILE_2: &str = "FILE2";
+ pub const TOTAL: &str = "total";
+ pub const ZERO_TERMINATED: &str = "zero-terminated";
}
-fn mkdelim(col: usize, opts: &ArgMatches) -> String {
- let mut s = String::new();
- let delim = match opts.get_one::<String>(options::DELIMITER).unwrap().as_str() {
- "" => "\0",
- delim => delim,
- };
-
- if col > 1 && !opts.get_flag(options::COLUMN_1) {
- s.push_str(delim.as_ref());
- }
- if col > 2 && !opts.get_flag(options::COLUMN_2) {
- s.push_str(delim.as_ref());
- }
+enum Input {
+ Stdin(Stdin),
+ FileIn(BufReader<File>),
+}
- s
+struct LineReader {
+ line_ending: LineEnding,
+ input: Input,
}
-fn ensure_nl(line: &mut String) {
- if !line.ends_with('\n') {
- line.push('\n');
+impl LineReader {
+ fn new(input: Input, line_ending: LineEnding) -> Self {
+ Self { input, line_ending }
}
-}
-enum LineReader {
- Stdin(Stdin),
- FileIn(BufReader<File>),
-}
+ fn read_line(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+ let line_ending = self.line_ending.into();
-impl LineReader {
- fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {
- match *self {
- Self::Stdin(ref mut r) => r.read_line(buf),
- Self::FileIn(ref mut r) => r.read_line(buf),
+ let result = match &mut self.input {
+ Input::Stdin(r) => r.lock().read_until(line_ending, buf),
+ Input::FileIn(r) => r.read_until(line_ending, buf),
+ };
+
+ if !buf.ends_with(&[line_ending]) {
+ buf.push(line_ending);
}
+
+ result
}
}
-fn comm(a: &mut LineReader, b: &mut LineReader, opts: &ArgMatches) {
- let delim: Vec<String> = (0..4).map(|col| mkdelim(col, opts)).collect();
+fn comm(a: &mut LineReader, b: &mut LineReader, delim: &str, opts: &ArgMatches) {
+ let width_col_1 = usize::from(!opts.get_flag(options::COLUMN_1));
+ let width_col_2 = usize::from(!opts.get_flag(options::COLUMN_2));
- let ra = &mut String::new();
+ let delim_col_2 = delim.repeat(width_col_1);
+ let delim_col_3 = delim.repeat(width_col_1 + width_col_2);
+
+ let ra = &mut Vec::new();
let mut na = a.read_line(ra);
- let rb = &mut String::new();
+ let rb = &mut Vec::new();
let mut nb = b.read_line(rb);
+ let mut total_col_1 = 0;
+ let mut total_col_2 = 0;
+ let mut total_col_3 = 0;
+
while na.is_ok() || nb.is_ok() {
let ord = match (na.is_ok(), nb.is_ok()) {
(false, true) => Ordering::Greater,
@@ -92,55 +93,82 @@ fn comm(a: &mut LineReader, b: &mut LineReader, opts: &ArgMatches) {
match ord {
Ordering::Less => {
if !opts.get_flag(options::COLUMN_1) {
- ensure_nl(ra);
- print!("{}{}", delim[1], ra);
+ print!("{}", String::from_utf8_lossy(ra));
}
ra.clear();
na = a.read_line(ra);
+ total_col_1 += 1;
}
Ordering::Greater => {
if !opts.get_flag(options::COLUMN_2) {
- ensure_nl(rb);
- print!("{}{}", delim[2], rb);
+ print!("{delim_col_2}{}", String::from_utf8_lossy(rb));
}
rb.clear();
nb = b.read_line(rb);
+ total_col_2 += 1;
}
Ordering::Equal => {
if !opts.get_flag(options::COLUMN_3) {
- ensure_nl(ra);
- print!("{}{}", delim[3], ra);
+ print!("{delim_col_3}{}", String::from_utf8_lossy(ra));
}
ra.clear();
rb.clear();
na = a.read_line(ra);
nb = b.read_line(rb);
+ total_col_3 += 1;
}
}
}
+
+ if opts.get_flag(options::TOTAL) {
+ let line_ending = LineEnding::from_zero_flag(opts.get_flag(options::ZERO_TERMINATED));
+ print!("{total_col_1}{delim}{total_col_2}{delim}{total_col_3}{delim}total{line_ending}");
+ }
}
-fn open_file(name: &str) -> io::Result<LineReader> {
- match name {
- "-" => Ok(LineReader::Stdin(stdin())),
- _ => {
- let f = File::open(Path::new(name))?;
- Ok(LineReader::FileIn(BufReader::new(f)))
- }
+fn open_file(name: &str, line_ending: LineEnding) -> io::Result<LineReader> {
+ if name == "-" {
+ Ok(LineReader::new(Input::Stdin(stdin()), line_ending))
+ } else {
+ let f = File::open(Path::new(name))?;
+ Ok(LineReader::new(
+ Input::FileIn(BufReader::new(f)),
+ line_ending,
+ ))
}
}
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_lossy();
-
let matches = uu_app().try_get_matches_from(args)?;
+ let line_ending = LineEnding::from_zero_flag(matches.get_flag(options::ZERO_TERMINATED));
let filename1 = matches.get_one::<String>(options::FILE_1).unwrap();
let filename2 = matches.get_one::<String>(options::FILE_2).unwrap();
- let mut f1 = open_file(filename1).map_err_context(|| filename1.to_string())?;
- let mut f2 = open_file(filename2).map_err_context(|| filename2.to_string())?;
-
- comm(&mut f1, &mut f2, &matches);
+ let mut f1 = open_file(filename1, line_ending).map_err_context(|| filename1.to_string())?;
+ let mut f2 = open_file(filename2, line_ending).map_err_context(|| filename2.to_string())?;
+
+ // Due to default_value(), there must be at least one value here, thus unwrap() must not panic.
+ let all_delimiters = matches
+ .get_many::<String>(options::DELIMITER)
+ .unwrap()
+ .map(String::from)
+ .collect::<Vec<_>>();
+ for delim in &all_delimiters[1..] {
+ // Note that this check is very different from ".conflicts_with_self(true).action(ArgAction::Set)",
+ // as this accepts duplicate *identical* arguments.
+ if delim != &all_delimiters[0] {
+ // Note: This intentionally deviate from the GNU error message by inserting the word "conflicting".
+ return Err(USimpleError::new(
+ 1,
+ "multiple conflicting output delimiters specified",
+ ));
+ }
+ }
+ let delim = match &*all_delimiters[0] {
+ "" => "\0",
+ delim => delim,
+ };
+ comm(&mut f1, &mut f2, delim, &matches);
Ok(())
}
@@ -148,9 +176,9 @@ pub fn uu_app() -> Command {
Command::new(uucore::util_name())
.version(crate_version!())
.about(ABOUT)
- .after_help(LONG_HELP)
.override_usage(format_usage(USAGE))
.infer_long_args(true)
+ .args_override_self(true)
.arg(
Arg::new(options::COLUMN_1)
.short('1')
@@ -175,8 +203,18 @@ pub fn uu_app() -> Command {
.help("separate columns with STR")
.value_name("STR")
.default_value(options::DELIMITER_DEFAULT)
+ .allow_hyphen_values(true)
+ .action(ArgAction::Append)
.hide_default_value(true),
)
+ .arg(
+ Arg::new(options::ZERO_TERMINATED)
+ .long(options::ZERO_TERMINATED)
+ .short('z')
+ .overrides_with(options::ZERO_TERMINATED)
+ .help("line delimiter is NUL, not newline")
+ .action(ArgAction::SetTrue),
+ )
.arg(
Arg::new(options::FILE_1)
.required(true)
@@ -187,4 +225,10 @@ pub fn uu_app() -> Command {
.required(true)
.value_hint(clap::ValueHint::FilePath),
)
+ .arg(
+ Arg::new(options::TOTAL)
+ .long(options::TOTAL)
+ .help("output a summary")
+ .action(ArgAction::SetTrue),
+ )
}
diff --git a/src/uu/cp/Cargo.toml b/src/uu/cp/Cargo.toml
index 03477e2874f7981ba954ce7494f24bfbd0bc3d21..a39258f49be5151b05e2f4409667bb093b21d684 100644
--- a/src/uu/cp/Cargo.toml
+++ b/src/uu/cp/Cargo.toml
@@ -1,10 +1,10 @@
[package]
name = "uu_cp"
-version = "0.0.17"
+version = "0.0.27"
authors = [
- "Jordy Dickinson <jordy.dickinson@gmail.com>",
- "Joshua S. Miller <jsmiller@uchicago.edu>",
- "uutils developers",
+ "Jordy Dickinson <jordy.dickinson@gmail.com>",
+ "Joshua S. Miller <jsmiller@uchicago.edu>",
+ "uutils developers",
]
license = "MIT"
description = "cp ~ (uutils) copy SOURCE to DESTINATION"
@@ -19,18 +19,25 @@ edition = "2021"
path = "src/cp.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-filetime = "0.2"
-libc = "0.2.137"
-quick-error = "2.0.1"
-selinux = { version="0.3", optional=true }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["entries", "fs", "perms", "mode"] }
-walkdir = "2.2"
-indicatif = "0.17"
+clap = { workspace = true }
+filetime = { workspace = true }
+libc = { workspace = true }
+quick-error = { workspace = true }
+selinux = { workspace = true, optional = true }
+uucore = { workspace = true, features = [
+ "backup-control",
+ "entries",
+ "fs",
+ "perms",
+ "mode",
+ "update-control",
+] }
+walkdir = { workspace = true }
+indicatif = { workspace = true }
[target.'cfg(unix)'.dependencies]
-xattr="0.2.3"
-exacl= { version = "0.9.0", optional=true }
+xattr = { workspace = true }
+exacl = { workspace = true, optional = true }
[[bin]]
name = "cp"
diff --git a/src/uu/cp/README.md b/src/uu/cp/README.md
index 13399c3b1d807c156abcecb10e9c940df65f9a32..d40e29194fb13d1340b65ea53f3a3a279928697a 100644
--- a/src/uu/cp/README.md
+++ b/src/uu/cp/README.md
@@ -1,18 +1,18 @@
<!-- markdownlint-disable first-line-heading -->
<!-- spell-checker:ignore (markdown) markdownlint -->
-## Feature list
+# Feature list
<!-- spell-checker:ignore (options) linkgs reflink -->
-### To Do
+## To Do
- [ ] cli-symbolic-links
- [ ] context
- [ ] copy-contents
- [ ] sparse
-### Completed
+## Completed
- [x] archive
- [x] attributes-only
diff --git a/src/uu/cp/cp.md b/src/uu/cp/cp.md
new file mode 100644
index 0000000000000000000000000000000000000000..7485340f2ace73bda551f27a8cabb7c25259a346
--- /dev/null
+++ b/src/uu/cp/cp.md
@@ -0,0 +1,25 @@
+# cp
+
+```
+cp [OPTION]... [-T] SOURCE DEST
+cp [OPTION]... SOURCE... DIRECTORY
+cp [OPTION]... -t DIRECTORY SOURCE...
+```
+
+Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.
+
+## After Help
+
+Do not copy a non-directory that has an existing destination with the same or newer modification timestamp;
+instead, silently skip the file without failing. If timestamps are being preserved, the comparison is to the
+source timestamp truncated to the resolutions of the destination file system and of the system calls used to
+update timestamps; this avoids duplicate work if several `cp -pu` commands are executed with the same source
+and destination. This option is ignored if the `-n` or `--no-clobber` option is also specified. Also, if
+`--preserve=links` is also specified (like with `cp -au` for example), that will take precedence; consequently,
+depending on the order that files are processed from the source, newer files in the destination may be replaced,
+to mirror hard links in the source. which gives more control over which existing files in the destination are
+replaced, and its value can be one of the following:
+
+* `all` This is the default operation when an `--update` option is not specified, and results in all existing files in the destination being replaced.
+* `none` This is similar to the `--no-clobber` option, in that no files in the destination are replaced, but also skipping a file does not induce a failure.
+* `older` This is the default operation when `--update` is specified, and results in files being replaced if they’re older than the corresponding source file.
diff --git a/src/uu/cp/src/copydir.rs b/src/uu/cp/src/copydir.rs
index 2af1bdb7c279e59f8dba6002486d965da1ce300e..627f5a4de322a7ded1ab7c5dc7bf396d151b0db9 100644
--- a/src/uu/cp/src/copydir.rs
+++ b/src/uu/cp/src/copydir.rs
@@ -1,14 +1,14 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
-// spell-checker:ignore TODO canonicalizes direntry pathbuf symlinked
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore TODO canonicalizes direntry pathbuf symlinked IRWXO IRWXG
//! Recursively copy the contents of a directory.
//!
//! See the [`copy_directory`] function for more information.
#[cfg(windows)]
use std::borrow::Cow;
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
use std::env;
use std::fs;
use std::io;
@@ -17,15 +17,17 @@ use std::path::{Path, PathBuf, StripPrefixError};
use indicatif::ProgressBar;
use uucore::display::Quotable;
use uucore::error::UIoError;
-use uucore::fs::{canonicalize, FileInformation, MissingHandling, ResolveMode};
+use uucore::fs::{
+ canonicalize, path_ends_with_terminator, FileInformation, MissingHandling, ResolveMode,
+};
use uucore::show;
use uucore::show_error;
use uucore::uio_error;
use walkdir::{DirEntry, WalkDir};
use crate::{
- aligned_ancestors, context_for, copy_attributes, copy_file, copy_link, preserve_hardlinks,
- CopyResult, Error, Options, TargetSlice,
+ aligned_ancestors, context_for, copy_attributes, copy_file, copy_link, CopyResult, Error,
+ Options,
};
/// Ensure a Windows path starts with a `\\?`.
@@ -33,8 +35,8 @@ use crate::{
fn adjust_canonicalization(p: &Path) -> Cow<Path> {
// In some cases, \\? can be missing on some Windows paths. Add it at the
// beginning unless the path is prefixed with a device namespace.
- const VERBATIM_PREFIX: &str = r#"\\?"#;
- const DEVICE_NS_PREFIX: &str = r#"\\."#;
+ const VERBATIM_PREFIX: &str = r"\\?";
+ const DEVICE_NS_PREFIX: &str = r"\\.";
let has_prefix = p
.components()
@@ -87,13 +89,16 @@ struct Context<'a> {
/// The target path to which the directory will be copied.
target: &'a Path,
+
+ /// The source path from which the directory will be copied.
+ root: &'a Path,
}
impl<'a> Context<'a> {
fn new(root: &'a Path, target: &'a Path) -> std::io::Result<Self> {
let current_dir = env::current_dir()?;
let root_path = current_dir.join(root);
- let root_parent = if target.exists() {
+ let root_parent = if target.exists() && !root.to_str().unwrap().ends_with("/.") {
root_path.parent().map(|p| p.to_path_buf())
} else {
Some(root_path)
@@ -102,6 +107,7 @@ impl<'a> Context<'a> {
current_dir,
root_parent,
target,
+ root,
})
}
}
@@ -156,11 +162,26 @@ struct Entry {
}
impl Entry {
- fn new(context: &Context, direntry: &DirEntry) -> Result<Self, StripPrefixError> {
+ fn new(
+ context: &Context,
+ direntry: &DirEntry,
+ no_target_dir: bool,
+ ) -> Result<Self, StripPrefixError> {
let source_relative = direntry.path().to_path_buf();
let source_absolute = context.current_dir.join(&source_relative);
- let descendant =
+ let mut descendant =
get_local_to_root_parent(&source_absolute, context.root_parent.as_deref())?;
+ if no_target_dir {
+ let source_is_dir = direntry.path().is_dir();
+ if path_ends_with_terminator(context.target) && source_is_dir {
+ if let Err(e) = std::fs::create_dir_all(context.target) {
+ eprintln!("Failed to create directory: {}", e);
+ }
+ } else {
+ descendant = descendant.strip_prefix(context.root)?.to_path_buf();
+ }
+ }
+
let local_to_target = context.target.join(descendant);
let target_is_file = context.target.is_file();
Ok(Self {
@@ -192,7 +213,7 @@ where
// `path.ends_with(".")` does not seem to work
path.as_ref().display().to_string().ends_with("/.")
}
-
+#[allow(clippy::too_many_arguments)]
/// Copy a single entry during a directory traversal.
fn copy_direntry(
progress_bar: &Option<ProgressBar>,
@@ -200,7 +221,8 @@ fn copy_direntry(
options: &Options,
symlinked_files: &mut HashSet<FileInformation>,
preserve_hard_links: bool,
- hard_links: &mut Vec<(String, u64)>,
+ copied_destinations: &HashSet<PathBuf>,
+ copied_files: &mut HashMap<FileInformation, PathBuf>,
) -> CopyResult<()> {
let Entry {
source_absolute,
@@ -224,12 +246,7 @@ fn copy_direntry(
if target_is_file {
return Err("cannot overwrite non-directory with directory".into());
} else {
- // TODO Since the calling code is traversing from the root
- // of the directory structure, I don't think
- // `create_dir_all()` will have any benefit over
- // `create_dir()`, since all the ancestor directories
- // should have already been created.
- fs::create_dir_all(&local_to_target)?;
+ build_dir(options, &local_to_target, false)?;
if options.verbose {
println!("{}", context_for(&source_relative, &local_to_target));
}
@@ -240,30 +257,28 @@ fn copy_direntry(
// If the source is not a directory, then we need to copy the file.
if !source_absolute.is_dir() {
if preserve_hard_links {
- let dest = local_to_target.as_path().to_path_buf();
- let found_hard_link = preserve_hardlinks(hard_links, &source_absolute, &dest)?;
- if !found_hard_link {
- match copy_file(
- progress_bar,
- &source_absolute,
- local_to_target.as_path(),
- options,
- symlinked_files,
- false,
- ) {
- Ok(_) => Ok(()),
- Err(err) => {
- if source_absolute.is_symlink() {
- // silent the error with a symlink
- // In case we do --archive, we might copy the symlink
- // before the file itself
- Ok(())
- } else {
- Err(err)
- }
+ match copy_file(
+ progress_bar,
+ &source_absolute,
+ local_to_target.as_path(),
+ options,
+ symlinked_files,
+ copied_destinations,
+ copied_files,
+ false,
+ ) {
+ Ok(_) => Ok(()),
+ Err(err) => {
+ if source_absolute.is_symlink() {
+ // silent the error with a symlink
+ // In case we do --archive, we might copy the symlink
+ // before the file itself
+ Ok(())
+ } else {
+ Err(err)
}
- }?;
- }
+ }
+ }?;
} else {
// At this point, `path` is just a plain old file.
// Terminate this function immediately if there is any
@@ -277,6 +292,8 @@ fn copy_direntry(
local_to_target.as_path(),
options,
symlinked_files,
+ copied_destinations,
+ copied_files,
false,
) {
Ok(_) => {}
@@ -304,18 +321,17 @@ fn copy_direntry(
///
/// Any errors encountered copying files in the tree will be logged but
/// will not cause a short-circuit.
+#[allow(clippy::too_many_arguments)]
pub(crate) fn copy_directory(
progress_bar: &Option<ProgressBar>,
root: &Path,
- target: &TargetSlice,
+ target: &Path,
options: &Options,
symlinked_files: &mut HashSet<FileInformation>,
+ copied_destinations: &HashSet<PathBuf>,
+ copied_files: &mut HashMap<FileInformation, PathBuf>,
source_in_command_line: bool,
) -> CopyResult<()> {
- if !options.recursive {
- return Err(format!("omitting directory {}", root.quote()).into());
- }
-
// if no-dereference is enabled and this is a symlink, copy it as a file
if !options.dereference(source_in_command_line) && root.is_symlink() {
return copy_file(
@@ -324,10 +340,16 @@ pub(crate) fn copy_directory(
target,
options,
symlinked_files,
+ copied_destinations,
+ copied_files,
source_in_command_line,
);
}
+ if !options.recursive {
+ return Err(format!("-r not specified; omitting directory {}", root.quote()).into());
+ }
+
// check if root is a prefix of target
if path_has_prefix(target, root)? {
return Err(format!(
@@ -349,8 +371,7 @@ pub(crate) fn copy_directory(
let tmp = if options.parents {
if let Some(parent) = root.parent() {
let new_target = target.join(parent);
- std::fs::create_dir_all(&new_target)?;
-
+ build_dir(options, &new_target, true)?;
if options.verbose {
// For example, if copying file `a/b/c` and its parents
// to directory `d/`, then print
@@ -372,7 +393,6 @@ pub(crate) fn copy_directory(
};
let target = tmp.as_path();
- let mut hard_links: Vec<(String, u64)> = vec![];
let preserve_hard_links = options.preserve_hard_links();
// Collect some paths here that are invariant during the traversal
@@ -380,7 +400,7 @@ pub(crate) fn copy_directory(
// the target directory.
let context = match Context::new(root, target) {
Ok(c) => c,
- Err(e) => return Err(format!("failed to get current directory {}", e).into()),
+ Err(e) => return Err(format!("failed to get current directory {e}").into()),
};
// Traverse the contents of the directory, copying each one.
@@ -390,22 +410,35 @@ pub(crate) fn copy_directory(
{
match direntry_result {
Ok(direntry) => {
- let entry = Entry::new(&context, &direntry)?;
+ let entry = Entry::new(&context, &direntry, options.no_target_dir)?;
copy_direntry(
progress_bar,
entry,
options,
symlinked_files,
preserve_hard_links,
- &mut hard_links,
+ copied_destinations,
+ copied_files,
)?;
}
// Print an error message, but continue traversing the directory.
Err(e) => show_error!("{}", e),
}
}
+
// Copy the attributes from the root directory to the target directory.
- copy_attributes(root, target, &options.attributes)?;
+ if options.parents {
+ let dest = target.join(root.file_name().unwrap());
+ copy_attributes(root, dest.as_path(), &options.attributes)?;
+ for (x, y) in aligned_ancestors(root, dest.as_path()) {
+ if let Ok(src) = canonicalize(x, MissingHandling::Normal, ResolveMode::Physical) {
+ copy_attributes(&src, y, &options.attributes)?;
+ }
+ }
+ } else {
+ copy_attributes(root, target, &options.attributes)?;
+ }
+
Ok(())
}
@@ -433,11 +466,48 @@ pub fn path_has_prefix(p1: &Path, p2: &Path) -> io::Result<bool> {
Ok(pathbuf1.starts_with(pathbuf2))
}
+/// Builds a directory at the specified path with the given options.
+///
+/// # Notes
+/// - It excludes certain permissions if ownership or special mode bits could
+/// potentially change.
+/// - The `recursive` flag determines whether parent directories should be created
+/// if they do not already exist.
+// we need to allow unused_variable since `options` might be unused in non unix systems
+#[allow(unused_variables)]
+fn build_dir(options: &Options, path: &PathBuf, recursive: bool) -> CopyResult<()> {
+ let mut builder = fs::DirBuilder::new();
+ builder.recursive(recursive);
+ // To prevent unauthorized access before the folder is ready,
+ // exclude certain permissions if ownership or special mode bits
+ // could potentially change.
+ #[cfg(unix)]
+ {
+ // we need to allow trivial casts here because some systems like linux have u32 constants in
+ // in libc while others don't.
+ #[allow(clippy::unnecessary_cast)]
+ let mut excluded_perms =
+ if matches!(options.attributes.ownership, crate::Preserve::Yes { .. }) {
+ libc::S_IRWXG | libc::S_IRWXO // exclude rwx for group and other
+ } else if matches!(options.attributes.mode, crate::Preserve::Yes { .. }) {
+ libc::S_IWGRP | libc::S_IWOTH //exclude w for group and other
+ } else {
+ 0
+ } as u32;
+ excluded_perms |= uucore::mode::get_umask();
+ let mode = !excluded_perms & 0o777; //use only the last three octet bits
+ std::os::unix::fs::DirBuilderExt::mode(&mut builder, mode);
+ }
+ builder.create(path)?;
+ Ok(())
+}
+
#[cfg(test)]
mod tests {
use super::ends_with_slash_dot;
#[test]
+ #[allow(clippy::cognitive_complexity)]
fn test_ends_with_slash_dot() {
assert!(ends_with_slash_dot("/."));
assert!(ends_with_slash_dot("./."));
diff --git a/src/uu/cp/src/cp.rs b/src/uu/cp/src/cp.rs
index 96227cec2f9c32c8e44db5abfdde8235774aefd8..7207673a5ffe4815ba2b0aed429f7876d039390f 100644
--- a/src/uu/cp/src/cp.rs
+++ b/src/uu/cp/src/cp.rs
@@ -1,32 +1,23 @@
-#![allow(clippy::missing_safety_doc)]
-#![allow(clippy::extra_unused_lifetimes)]
-
// This file is part of the uutils coreutils package.
//
-// (c) Jordy Dickinson <jordy.dickinson@gmail.com>
-// (c) Joshua S. Miller <jsmiller@uchicago.edu>
-//
-// For the full copyright and license information, please view the LICENSE file
-// that was distributed with this source code.
-
-// spell-checker:ignore (ToDO) copydir ficlone fiemap ftruncate linkgs lstat nlink nlinks pathbuf pwrite reflink strs xattrs symlinked deduplicated advcpmv
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore (ToDO) copydir ficlone fiemap ftruncate linkgs lstat nlink nlinks pathbuf pwrite reflink strs xattrs symlinked deduplicated advcpmv nushell IRWXG IRWXO IRWXU IRWXUGO IRWXU IRWXG IRWXO IRWXUGO
use quick_error::quick_error;
-use std::borrow::Cow;
-use std::collections::HashSet;
-use std::env;
+use std::cmp::Ordering;
+use std::collections::{HashMap, HashSet};
#[cfg(not(windows))]
use std::ffi::CString;
-use std::fs::{self, File, OpenOptions};
+use std::fs::{self, File, Metadata, OpenOptions, Permissions};
use std::io;
#[cfg(unix)]
use std::os::unix::ffi::OsStrExt;
#[cfg(unix)]
use std::os::unix::fs::{FileTypeExt, PermissionsExt};
use std::path::{Path, PathBuf, StripPrefixError};
-use std::string::ToString;
-use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
+use clap::{builder::ValueParser, crate_version, Arg, ArgAction, ArgMatches, Command};
use filetime::FileTime;
use indicatif::{ProgressBar, ProgressStyle};
#[cfg(unix)]
@@ -34,18 +25,27 @@ use libc::mkfifo;
use quick_error::ResultExt;
use platform::copy_on_write;
-use uucore::backup_control::{self, BackupMode};
use uucore::display::Quotable;
use uucore::error::{set_exit_code, UClapError, UError, UResult, UUsageError};
use uucore::fs::{
- canonicalize, paths_refer_to_same_file, FileInformation, MissingHandling, ResolveMode,
+ are_hardlinks_to_same_file, canonicalize, get_filename, is_symlink_loop,
+ path_ends_with_terminator, paths_refer_to_same_file, FileInformation, MissingHandling,
+ ResolveMode,
+};
+use uucore::{backup_control, update_control};
+// These are exposed for projects (e.g. nushell) that want to create an `Options` value, which
+// requires these enum.
+pub use uucore::{backup_control::BackupMode, update_control::UpdateMode};
+use uucore::{
+ format_usage, help_about, help_section, help_usage, prompt_yes,
+ shortcut_value_parser::ShortcutValueParser, show_error, show_warning, util_name,
};
-use uucore::{crash, format_usage, prompt_yes, show_error, show_warning};
use crate::copydir::copy_directory;
mod copydir;
mod platform;
+
quick_error! {
#[derive(Debug)]
pub enum Error {
@@ -78,6 +78,7 @@ quick_error! {
StripPrefixError(err: StripPrefixError) { from() }
/// Result of a skipped file
+ /// Currently happens when "no" is selected in interactive mode
Skipped { }
/// Result of a skipped file
@@ -91,7 +92,7 @@ quick_error! {
/// Invalid arguments to backup
Backup(description: String) { display("{}\nTry '{} --help' for more information.", description, uucore::execution_phrase()) }
- NotADirectory(path: String) { display("'{}' is not a directory", path) }
+ NotADirectory(path: PathBuf) { display("'{}' is not a directory", path.display()) }
}
}
@@ -102,12 +103,8 @@ impl UError for Error {
}
pub type CopyResult<T> = Result<T, Error>;
-pub type Source = PathBuf;
-pub type SourceSlice = Path;
-pub type Target = PathBuf;
-pub type TargetSlice = Path;
-/// Specifies whether when overwrite files
+/// Specifies how to overwrite files.
#[derive(Clone, Copy, Eq, PartialEq)]
pub enum ClobberMode {
Force,
@@ -115,7 +112,7 @@ pub enum ClobberMode {
Standard,
}
-/// Specifies whether when overwrite files
+/// Specifies whether files should be overwritten.
#[derive(Clone, Copy, Eq, PartialEq)]
pub enum OverwriteMode {
/// [Default] Always overwrite existing files
@@ -142,12 +139,15 @@ pub enum SparseMode {
Never,
}
-/// Specifies the expected file type of copy target
+/// The expected file type of copy target
+#[derive(Copy, Clone)]
pub enum TargetType {
Directory,
File,
}
+/// Copy action to perform
+#[derive(PartialEq)]
pub enum CopyMode {
Link,
SymLink,
@@ -156,85 +156,205 @@ pub enum CopyMode {
AttrOnly,
}
-#[derive(Debug)]
+/// Preservation settings for various attributes
+///
+/// It should be derived from options as follows:
+///
+/// - if there is a list of attributes to preserve (i.e. `--preserve=ATTR_LIST`) parse that list with [`Attributes::parse_iter`],
+/// - if `-p` or `--preserve` is given without arguments, use [`Attributes::DEFAULT`],
+/// - if `-a`/`--archive` is passed, use [`Attributes::ALL`],
+/// - if `-d` is passed use [`Attributes::LINKS`],
+/// - otherwise, use [`Attributes::NONE`].
+///
+/// For full compatibility with GNU, these options should also combine. We
+/// currently only do a best effort imitation of that behavior, because it is
+/// difficult to achieve in clap, especially with `--no-preserve`.
+#[derive(Debug, PartialEq)]
pub struct Attributes {
#[cfg(unix)]
- ownership: Preserve,
- mode: Preserve,
- timestamps: Preserve,
- context: Preserve,
- links: Preserve,
- xattr: Preserve,
-}
-
-impl Attributes {
- pub(crate) fn max(&mut self, other: Self) {
- #[cfg(unix)]
- {
- self.ownership = self.ownership.max(other.ownership);
- }
- self.mode = self.mode.max(other.mode);
- self.timestamps = self.timestamps.max(other.timestamps);
- self.context = self.context.max(other.context);
- self.links = self.links.max(other.links);
- self.xattr = self.xattr.max(other.xattr);
- }
+ pub ownership: Preserve,
+ pub mode: Preserve,
+ pub timestamps: Preserve,
+ pub context: Preserve,
+ pub links: Preserve,
+ pub xattr: Preserve,
}
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Preserve {
- No,
+ // explicit means whether the --no-preserve flag is used or not to distinguish out the default value.
+ // e.g. --no-preserve=mode means mode = No { explicit = true }
+ No { explicit: bool },
Yes { required: bool },
}
-impl Preserve {
- /// Preservation level should only increase, with no preservation being the lowest option,
- /// preserve but don't require - middle, and preserve and require - top.
- pub(crate) fn max(&self, other: Self) -> Self {
+impl PartialOrd for Preserve {
+ fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+ Some(self.cmp(other))
+ }
+}
+
+impl Ord for Preserve {
+ fn cmp(&self, other: &Self) -> Ordering {
match (self, other) {
- (Self::Yes { required: true }, _) | (_, Self::Yes { required: true }) => {
- Self::Yes { required: true }
- }
- (Self::Yes { required: false }, _) | (_, Self::Yes { required: false }) => {
- Self::Yes { required: false }
- }
- _ => Self::No,
+ (Self::No { .. }, Self::No { .. }) => Ordering::Equal,
+ (Self::Yes { .. }, Self::No { .. }) => Ordering::Greater,
+ (Self::No { .. }, Self::Yes { .. }) => Ordering::Less,
+ (
+ Self::Yes { required: req_self },
+ Self::Yes {
+ required: req_other,
+ },
+ ) => req_self.cmp(req_other),
}
}
}
-/// Re-usable, extensible copy options
+/// Options for the `cp` command
+///
+/// All options are public so that the options can be programmatically
+/// constructed by other crates, such as nushell. That means that this struct
+/// is part of our public API. It should therefore not be changed without good
+/// reason.
+///
+/// The fields are documented with the arguments that determine their value.
#[allow(dead_code)]
pub struct Options {
- attributes_only: bool,
- backup: BackupMode,
- copy_contents: bool,
- cli_dereference: bool,
- copy_mode: CopyMode,
- dereference: bool,
- no_target_dir: bool,
- one_file_system: bool,
- overwrite: OverwriteMode,
- parents: bool,
- sparse_mode: SparseMode,
- strip_trailing_slashes: bool,
- reflink_mode: ReflinkMode,
- attributes: Attributes,
- recursive: bool,
- backup_suffix: String,
- target_dir: Option<String>,
- update: bool,
- verbose: bool,
- progress_bar: bool,
+ /// `--attributes-only`
+ pub attributes_only: bool,
+ /// `--backup[=CONTROL]`, `-b`
+ pub backup: BackupMode,
+ /// `--copy-contents`
+ pub copy_contents: bool,
+ /// `-H`
+ pub cli_dereference: bool,
+ /// Determines the type of copying that should be done
+ ///
+ /// Set by the following arguments:
+ /// - `-l`, `--link`: [`CopyMode::Link`]
+ /// - `-s`, `--symbolic-link`: [`CopyMode::SymLink`]
+ /// - `-u`, `--update[=WHEN]`: [`CopyMode::Update`]
+ /// - `--attributes-only`: [`CopyMode::AttrOnly`]
+ /// - otherwise: [`CopyMode::Copy`]
+ pub copy_mode: CopyMode,
+ /// `-L`, `--dereference`
+ pub dereference: bool,
+ /// `-T`, `--no-target-dir`
+ pub no_target_dir: bool,
+ /// `-x`, `--one-file-system`
+ pub one_file_system: bool,
+ /// Specifies what to do with an existing destination
+ ///
+ /// Set by the following arguments:
+ /// - `-i`, `--interactive`: [`OverwriteMode::Interactive`]
+ /// - `-n`, `--no-clobber`: [`OverwriteMode::NoClobber`]
+ /// - otherwise: [`OverwriteMode::Clobber`]
+ ///
+ /// The `Interactive` and `Clobber` variants have a [`ClobberMode`] argument,
+ /// set by the following arguments:
+ /// - `-f`, `--force`: [`ClobberMode::Force`]
+ /// - `--remove-destination`: [`ClobberMode::RemoveDestination`]
+ /// - otherwise: [`ClobberMode::Standard`]
+ pub overwrite: OverwriteMode,
+ /// `--parents`
+ pub parents: bool,
+ /// `--sparse[=WHEN]`
+ pub sparse_mode: SparseMode,
+ /// `--strip-trailing-slashes`
+ pub strip_trailing_slashes: bool,
+ /// `--reflink[=WHEN]`
+ pub reflink_mode: ReflinkMode,
+ /// `--preserve=[=ATTRIBUTE_LIST]` and `--no-preserve=ATTRIBUTE_LIST`
+ pub attributes: Attributes,
+ /// `-R`, `-r`, `--recursive`
+ pub recursive: bool,
+ /// `-S`, `--suffix`
+ pub backup_suffix: String,
+ /// `-t`, `--target-directory`
+ pub target_dir: Option<PathBuf>,
+ /// `--update[=UPDATE]`
+ pub update: UpdateMode,
+ /// `--debug`
+ pub debug: bool,
+ /// `-v`, `--verbose`
+ pub verbose: bool,
+ /// `-g`, `--progress`
+ pub progress_bar: bool,
}
-static ABOUT: &str = "Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.";
-static EXIT_ERR: i32 = 1;
+/// Enum representing various debug states of the offload and reflink actions.
+#[derive(Debug)]
+#[allow(dead_code)] // All of them are used on Linux
+enum OffloadReflinkDebug {
+ Unknown,
+ No,
+ Yes,
+ Avoided,
+ Unsupported,
+}
+
+/// Enum representing various debug states of the sparse detection.
+#[derive(Debug)]
+#[allow(dead_code)] // silent for now until we use them
+enum SparseDebug {
+ Unknown,
+ No,
+ Zeros,
+ SeekHole,
+ SeekHoleZeros,
+ Unsupported,
+}
+
+/// Struct that contains the debug state for each action in a file copy operation.
+#[derive(Debug)]
+struct CopyDebug {
+ offload: OffloadReflinkDebug,
+ reflink: OffloadReflinkDebug,
+ sparse_detection: SparseDebug,
+}
-const USAGE: &str = "\
- {} [OPTION]... [-T] SOURCE DEST
- {} [OPTION]... SOURCE... DIRECTORY
- {} [OPTION]... -t DIRECTORY SOURCE...";
+impl OffloadReflinkDebug {
+ fn to_string(&self) -> &'static str {
+ match self {
+ Self::No => "no",
+ Self::Yes => "yes",
+ Self::Avoided => "avoided",
+ Self::Unsupported => "unsupported",
+ Self::Unknown => "unknown",
+ }
+ }
+}
+
+impl SparseDebug {
+ fn to_string(&self) -> &'static str {
+ match self {
+ Self::No => "no",
+ Self::Zeros => "zeros",
+ Self::SeekHole => "SEEK_HOLE",
+ Self::SeekHoleZeros => "SEEK_HOLE + zeros",
+ Self::Unsupported => "unsupported",
+ Self::Unknown => "unknown",
+ }
+ }
+}
+
+/// This function prints the debug information of a file copy operation if
+/// no hard link or symbolic link is required, and data copy is required.
+/// It prints the debug information of the offload, reflink, and sparse detection actions.
+fn show_debug(copy_debug: &CopyDebug) {
+ println!(
+ "copy offload: {}, reflink: {}, sparse detection: {}",
+ copy_debug.offload.to_string(),
+ copy_debug.reflink.to_string(),
+ copy_debug.sparse_detection.to_string(),
+ );
+}
+
+const ABOUT: &str = help_about!("cp.md");
+const USAGE: &str = help_usage!("cp.md");
+const AFTER_HELP: &str = help_section!("after help", "cp.md");
+
+static EXIT_ERR: i32 = 1;
// Argument constants
mod options {
@@ -266,7 +386,7 @@ mod options {
pub const STRIP_TRAILING_SLASHES: &str = "strip-trailing-slashes";
pub const SYMBOLIC_LINK: &str = "symbolic-link";
pub const TARGET_DIRECTORY: &str = "target-directory";
- pub const UPDATE: &str = "update";
+ pub const DEBUG: &str = "debug";
pub const VERBOSE: &str = "verbose";
}
@@ -285,6 +405,11 @@ static PRESERVABLE_ATTRIBUTES: &[&str] = &[
static PRESERVABLE_ATTRIBUTES: &[&str] =
&["mode", "timestamps", "context", "links", "xattr", "all"];
+const PRESERVE_DEFAULT_VALUES: &str = if cfg!(unix) {
+ "mode,ownership,timestamp"
+} else {
+ "mode,timestamp"
+};
pub fn uu_app() -> Command {
const MODE_ARGS: &[&str] = &[
options::LINK,
@@ -297,7 +422,12 @@ pub fn uu_app() -> Command {
.version(crate_version!())
.about(ABOUT)
.override_usage(format_usage(USAGE))
+ .after_help(format!(
+ "{AFTER_HELP}\n\n{}",
+ backup_control::BACKUP_CONTROL_LONG_HELP
+ ))
.infer_long_args(true)
+ .args_override_self(true)
.arg(
Arg::new(options::TARGET_DIRECTORY)
.short('t')
@@ -305,6 +435,7 @@ pub fn uu_app() -> Command {
.long(options::TARGET_DIRECTORY)
.value_name(options::TARGET_DIRECTORY)
.value_hint(clap::ValueHint::DirPath)
+ .value_parser(ValueParser::path_buf())
.help("copy all SOURCE arguments into target-directory"),
)
.arg(
@@ -341,8 +472,8 @@ pub fn uu_app() -> Command {
)
.arg(
Arg::new(options::RECURSIVE)
- .short('r')
- .visible_short_alias('R')
+ .short('R')
+ .visible_short_alias('r')
.long(options::RECURSIVE)
// --archive sets this option
.help("copy directories recursively")
@@ -354,6 +485,12 @@ pub fn uu_app() -> Command {
.help("remove any trailing slashes from each SOURCE argument")
.action(ArgAction::SetTrue),
)
+ .arg(
+ Arg::new(options::DEBUG)
+ .long(options::DEBUG)
+ .help("explain how a file is copied. Implies -v")
+ .action(ArgAction::SetTrue),
+ )
.arg(
Arg::new(options::VERBOSE)
.short('v')
@@ -394,16 +531,8 @@ pub fn uu_app() -> Command {
.arg(backup_control::arguments::backup())
.arg(backup_control::arguments::backup_no_args())
.arg(backup_control::arguments::suffix())
- .arg(
- Arg::new(options::UPDATE)
- .short('u')
- .long(options::UPDATE)
- .help(
- "copy only when the SOURCE file is newer than the destination file \
- or when the destination file is missing",
- )
- .action(ArgAction::SetTrue),
- )
+ .arg(update_control::arguments::update())
+ .arg(update_control::arguments::update_no_args())
.arg(
Arg::new(options::REFLINK)
.long(options::REFLINK)
@@ -411,7 +540,7 @@ pub fn uu_app() -> Command {
.overrides_with_all(MODE_ARGS)
.require_equals(true)
.default_missing_value("always")
- .value_parser(["auto", "always", "never"])
+ .value_parser(ShortcutValueParser::new(["auto", "always", "never"]))
.num_args(0..=1)
.help("control clone/CoW copies. See below"),
)
@@ -427,16 +556,11 @@ pub fn uu_app() -> Command {
.long(options::PRESERVE)
.action(ArgAction::Append)
.use_value_delimiter(true)
- .value_parser(clap::builder::PossibleValuesParser::new(
- PRESERVABLE_ATTRIBUTES,
- ))
+ .value_parser(ShortcutValueParser::new(PRESERVABLE_ATTRIBUTES))
.num_args(0..)
+ .require_equals(true)
.value_name("ATTR_LIST")
- .overrides_with_all([
- options::ARCHIVE,
- options::PRESERVE_DEFAULT_ATTRIBUTES,
- options::NO_PRESERVE,
- ])
+ .default_missing_value(PRESERVE_DEFAULT_VALUES)
// -d sets this option
// --archive sets this option
.help(
@@ -448,19 +572,18 @@ pub fn uu_app() -> Command {
Arg::new(options::PRESERVE_DEFAULT_ATTRIBUTES)
.short('p')
.long(options::PRESERVE_DEFAULT_ATTRIBUTES)
- .overrides_with_all([options::PRESERVE, options::NO_PRESERVE, options::ARCHIVE])
.help("same as --preserve=mode,ownership(unix only),timestamps")
.action(ArgAction::SetTrue),
)
.arg(
Arg::new(options::NO_PRESERVE)
.long(options::NO_PRESERVE)
+ .action(ArgAction::Append)
+ .use_value_delimiter(true)
+ .value_parser(ShortcutValueParser::new(PRESERVABLE_ATTRIBUTES))
+ .num_args(0..)
+ .require_equals(true)
.value_name("ATTR_LIST")
- .overrides_with_all([
- options::PRESERVE_DEFAULT_ATTRIBUTES,
- options::PRESERVE,
- options::ARCHIVE,
- ])
.help("don't preserve the specified attributes"),
)
.arg(
@@ -497,11 +620,6 @@ pub fn uu_app() -> Command {
Arg::new(options::ARCHIVE)
.short('a')
.long(options::ARCHIVE)
- .overrides_with_all([
- options::PRESERVE_DEFAULT_ATTRIBUTES,
- options::PRESERVE,
- options::NO_PRESERVE,
- ])
.help("Same as -dR --preserve=all")
.action(ArgAction::SetTrue),
)
@@ -522,8 +640,8 @@ pub fn uu_app() -> Command {
Arg::new(options::SPARSE)
.long(options::SPARSE)
.value_name("WHEN")
- .value_parser(["never", "auto", "always"])
- .help("NotImplemented: control creation of sparse files. See below"),
+ .value_parser(ShortcutValueParser::new(["never", "auto", "always"]))
+ .help("control creation of sparse files. See below"),
)
// TODO: implement the following args
.arg(
@@ -558,19 +676,18 @@ pub fn uu_app() -> Command {
.arg(
Arg::new(options::PATHS)
.action(ArgAction::Append)
- .value_hint(clap::ValueHint::AnyPath),
+ .value_hint(clap::ValueHint::AnyPath)
+ .value_parser(ValueParser::path_buf()),
)
}
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let matches = uu_app()
- .after_help(backup_control::BACKUP_CONTROL_LONG_HELP)
- .try_get_matches_from(args);
+ let matches = uu_app().try_get_matches_from(args);
// The error is parsed here because we do not want version or help being printed to stderr.
if let Err(e) = matches {
- let mut app = uu_app().after_help(backup_control::BACKUP_CONTROL_LONG_HELP);
+ let mut app = uu_app();
match e.kind() {
clap::error::ErrorKind::DisplayHelp => {
@@ -579,7 +696,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
clap::error::ErrorKind::DisplayVersion => print!("{}", app.render_version()),
_ => return Err(Box::new(e.with_exit_code(1))),
};
- } else if let Ok(matches) = matches {
+ } else if let Ok(mut matches) = matches {
let options = Options::from_matches(&matches)?;
if options.overwrite == OverwriteMode::NoClobber && options.backup != BackupMode::NoBackup {
@@ -589,12 +706,12 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
));
}
- let paths: Vec<String> = matches
- .get_many::<String>(options::PATHS)
- .map(|v| v.map(ToString::to_string).collect())
+ let paths: Vec<PathBuf> = matches
+ .remove_many::<PathBuf>(options::PATHS)
+ .map(|v| v.collect())
.unwrap_or_default();
- let (sources, target) = parse_path_args(&paths, &options)?;
+ let (sources, target) = parse_path_args(paths, &options)?;
if let Err(error) = copy(&sources, &target, &options) {
match error {
@@ -641,10 +758,18 @@ impl CopyMode {
Self::Link
} else if matches.get_flag(options::SYMBOLIC_LINK) {
Self::SymLink
- } else if matches.get_flag(options::UPDATE) {
+ } else if matches
+ .get_one::<String>(update_control::arguments::OPT_UPDATE)
+ .is_some()
+ || matches.get_flag(update_control::arguments::OPT_UPDATE_NO_ARG)
+ {
Self::Update
} else if matches.get_flag(options::ATTRIBUTES_ONLY) {
- Self::AttrOnly
+ if matches.get_flag(options::REMOVE_DESTINATION) {
+ Self::Copy
+ } else {
+ Self::AttrOnly
+ }
} else {
Self::Copy
}
@@ -652,67 +777,112 @@ impl CopyMode {
}
impl Attributes {
+ pub const ALL: Self = Self {
+ #[cfg(unix)]
+ ownership: Preserve::Yes { required: true },
+ mode: Preserve::Yes { required: true },
+ timestamps: Preserve::Yes { required: true },
+ context: {
+ #[cfg(feature = "feat_selinux")]
+ {
+ Preserve::Yes { required: false }
+ }
+ #[cfg(not(feature = "feat_selinux"))]
+ {
+ Preserve::No { explicit: false }
+ }
+ },
+ links: Preserve::Yes { required: true },
+ xattr: Preserve::Yes { required: false },
+ };
+
+ pub const NONE: Self = Self {
+ #[cfg(unix)]
+ ownership: Preserve::No { explicit: false },
+ mode: Preserve::No { explicit: false },
+ timestamps: Preserve::No { explicit: false },
+ context: Preserve::No { explicit: false },
+ links: Preserve::No { explicit: false },
+ xattr: Preserve::No { explicit: false },
+ };
+
// TODO: ownership is required if the user is root, for non-root users it's not required.
- // See: https://github.com/coreutils/coreutils/blob/master/src/copy.c#L3181
+ pub const DEFAULT: Self = Self {
+ #[cfg(unix)]
+ ownership: Preserve::Yes { required: true },
+ mode: Preserve::Yes { required: true },
+ timestamps: Preserve::Yes { required: true },
+ xattr: Preserve::Yes { required: true },
+ ..Self::NONE
+ };
+
+ pub const LINKS: Self = Self {
+ links: Preserve::Yes { required: true },
+ ..Self::NONE
+ };
- fn all() -> Self {
+ pub fn union(self, other: &Self) -> Self {
Self {
#[cfg(unix)]
- ownership: Preserve::Yes { required: true },
- mode: Preserve::Yes { required: true },
- timestamps: Preserve::Yes { required: true },
- context: {
- #[cfg(feature = "feat_selinux")]
- {
- Preserve::Yes { required: false }
- }
- #[cfg(not(feature = "feat_selinux"))]
- {
- Preserve::No
- }
- },
- links: Preserve::Yes { required: true },
- xattr: Preserve::Yes { required: false },
+ ownership: self.ownership.max(other.ownership),
+ context: self.context.max(other.context),
+ timestamps: self.timestamps.max(other.timestamps),
+ mode: self.mode.max(other.mode),
+ links: self.links.max(other.links),
+ xattr: self.xattr.max(other.xattr),
}
}
- fn default() -> Self {
+ /// Set the field to Preserve::NO { explicit: true } if the corresponding field
+ /// in other is set to Preserve::Yes { .. }.
+ pub fn diff(self, other: &Self) -> Self {
+ fn update_preserve_field(current: Preserve, other: Preserve) -> Preserve {
+ if matches!(other, Preserve::Yes { .. }) {
+ Preserve::No { explicit: true }
+ } else {
+ current
+ }
+ }
Self {
#[cfg(unix)]
- ownership: Preserve::Yes { required: true },
- mode: Preserve::Yes { required: true },
- timestamps: Preserve::Yes { required: true },
- context: Preserve::No,
- links: Preserve::No,
- xattr: Preserve::No,
+ ownership: update_preserve_field(self.ownership, other.ownership),
+ mode: update_preserve_field(self.mode, other.mode),
+ timestamps: update_preserve_field(self.timestamps, other.timestamps),
+ context: update_preserve_field(self.context, other.context),
+ links: update_preserve_field(self.links, other.links),
+ xattr: update_preserve_field(self.xattr, other.xattr),
}
}
- fn none() -> Self {
- Self {
- #[cfg(unix)]
- ownership: Preserve::No,
- mode: Preserve::No,
- timestamps: Preserve::No,
- context: Preserve::No,
- links: Preserve::No,
- xattr: Preserve::No,
+ pub fn parse_iter<T>(values: impl Iterator<Item = T>) -> Result<Self, Error>
+ where
+ T: AsRef<str>,
+ {
+ let mut new = Self::NONE;
+ for value in values {
+ new = new.union(&Self::parse_single_string(value.as_ref())?);
}
+ Ok(new)
}
/// Tries to match string containing a parameter to preserve with the corresponding entry in the
/// Attributes struct.
- fn try_set_from_string(&mut self, value: &str) -> Result<(), Error> {
- let preserve_yes_required = Preserve::Yes { required: true };
+ fn parse_single_string(value: &str) -> Result<Self, Error> {
+ let value = value.to_lowercase();
- match &*value.to_lowercase() {
- "mode" => self.mode = preserve_yes_required,
+ if value == "all" {
+ return Ok(Self::ALL);
+ }
+
+ let mut new = Self::NONE;
+ let attribute = match value.as_ref() {
+ "mode" => &mut new.mode,
#[cfg(unix)]
- "ownership" => self.ownership = preserve_yes_required,
- "timestamps" => self.timestamps = preserve_yes_required,
- "context" => self.context = preserve_yes_required,
- "links" => self.links = preserve_yes_required,
- "xattr" => self.xattr = preserve_yes_required,
+ "ownership" => &mut new.ownership,
+ "timestamps" => &mut new.timestamps,
+ "context" => &mut new.context,
+ "link" | "links" => &mut new.links,
+ "xattr" => &mut new.xattr,
_ => {
return Err(Error::InvalidArgument(format!(
"invalid attribute {}",
@@ -720,11 +890,15 @@ impl Attributes {
)));
}
};
- Ok(())
+
+ *attribute = Preserve::Yes { required: true };
+
+ Ok(new)
}
}
impl Options {
+ #[allow(clippy::cognitive_complexity)]
fn from_matches(matches: &ArgMatches) -> CopyResult<Self> {
let not_implemented_opts = vec![
#[cfg(not(any(windows, unix)))]
@@ -746,9 +920,10 @@ impl Options {
let recursive = matches.get_flag(options::RECURSIVE) || matches.get_flag(options::ARCHIVE);
let backup_mode = match backup_control::determine_backup_mode(matches) {
- Err(e) => return Err(Error::Backup(format!("{}", e))),
+ Err(e) => return Err(Error::Backup(format!("{e}"))),
Ok(mode) => mode,
};
+ let update_mode = update_control::determine_update_mode(matches);
let backup_suffix = backup_control::determine_backup_suffix(matches);
@@ -757,50 +932,96 @@ impl Options {
// Parse target directory options
let no_target_dir = matches.get_flag(options::NO_TARGET_DIRECTORY);
let target_dir = matches
- .get_one::<String>(options::TARGET_DIRECTORY)
- .map(ToString::to_string);
+ .get_one::<PathBuf>(options::TARGET_DIRECTORY)
+ .cloned();
if let Some(dir) = &target_dir {
- if !Path::new(dir).is_dir() {
+ if !dir.is_dir() {
return Err(Error::NotADirectory(dir.clone()));
}
};
- // Parse attributes to preserve
- let attributes: Attributes = if matches.contains_id(options::PRESERVE) {
- match matches.get_many::<String>(options::PRESERVE) {
- None => Attributes::default(),
- Some(attribute_strs) => {
- let mut attributes: Attributes = Attributes::none();
- let mut attributes_empty = true;
- for attribute_str in attribute_strs {
- attributes_empty = false;
- if attribute_str == "all" {
- attributes.max(Attributes::all());
- } else {
- attributes.try_set_from_string(attribute_str)?;
+ // cp follows POSIX conventions for overriding options such as "-a",
+ // "-d", "--preserve", and "--no-preserve". We can use clap's
+ // override-all behavior to achieve this, but there's a challenge: when
+ // clap overrides an argument, it removes all traces of it from the
+ // match. This poses a problem because flags like "-a" expand to "-dR
+ // --preserve=all", and we only want to override the "--preserve=all"
+ // part. Additionally, we need to handle multiple occurrences of the
+ // same flags. To address this, we create an overriding order from the
+ // matches here.
+ let mut overriding_order: Vec<(usize, &str, Vec<&String>)> = vec![];
+ // We iterate through each overriding option, adding each occurrence of
+ // the option along with its value and index as a tuple, and push it to
+ // `overriding_order`.
+ for option in [
+ options::PRESERVE,
+ options::NO_PRESERVE,
+ options::ARCHIVE,
+ options::PRESERVE_DEFAULT_ATTRIBUTES,
+ options::NO_DEREFERENCE_PRESERVE_LINKS,
+ ] {
+ if let (Ok(Some(val)), Some(index)) = (
+ matches.try_get_one::<bool>(option),
+ // even though it says in the doc that `index_of` would give us
+ // the first index of the argument, when it comes to flag it
+ // gives us the last index where the flag appeared (probably
+ // because it overrides itself). Since it is a flag and it would
+ // have same value across the occurrences we just need the last
+ // index.
+ matches.index_of(option),
+ ) {
+ if *val {
+ overriding_order.push((index, option, vec![]));
+ }
+ } else if let (Some(occurrences), Some(mut indices)) = (
+ matches.get_occurrences::<String>(option),
+ matches.indices_of(option),
+ ) {
+ occurrences.for_each(|val| {
+ if let Some(index) = indices.next() {
+ let val = val.collect::<Vec<&String>>();
+ // As mentioned in the documentation of the indices_of
+ // function, it provides the indices of the individual
+ // values. Therefore, to get the index of the first
+ // value of the next occurrence in the next iteration,
+ // we need to advance the indices iterator by the length
+ // of the current occurrence's values.
+ for _ in 1..val.len() {
+ indices.next();
}
+ overriding_order.push((index, option, val));
}
- // `--preserve` case, use the defaults
- if attributes_empty {
- Attributes::default()
- } else {
- attributes
+ });
+ }
+ }
+ overriding_order.sort_by(|a, b| a.0.cmp(&b.0));
+
+ let mut attributes = Attributes::NONE;
+
+ // Iterate through the `overriding_order` and adjust the attributes accordingly.
+ for (_, option, val) in overriding_order {
+ match option {
+ options::ARCHIVE => {
+ attributes = Attributes::ALL;
+ }
+ options::PRESERVE_DEFAULT_ATTRIBUTES => {
+ attributes = attributes.union(&Attributes::DEFAULT);
+ }
+ options::NO_DEREFERENCE_PRESERVE_LINKS => {
+ attributes = attributes.union(&Attributes::LINKS);
+ }
+ options::PRESERVE => {
+ attributes = attributes.union(&Attributes::parse_iter(val.into_iter())?);
+ }
+ options::NO_PRESERVE => {
+ if !val.is_empty() {
+ attributes = attributes.diff(&Attributes::parse_iter(val.into_iter())?);
}
}
+ _ => (),
}
- } else if matches.get_flag(options::ARCHIVE) {
- // --archive is used. Same as --preserve=all
- Attributes::all()
- } else if matches.get_flag(options::NO_DEREFERENCE_PRESERVE_LINKS) {
- let mut attributes = Attributes::none();
- attributes.links = Preserve::Yes { required: true };
- attributes
- } else if matches.get_flag(options::PRESERVE_DEFAULT_ATTRIBUTES) {
- Attributes::default()
- } else {
- Attributes::none()
- };
+ }
#[cfg(not(feature = "feat_selinux"))]
if let Preserve::Yes { required } = attributes.context {
@@ -822,12 +1043,15 @@ impl Options {
dereference: !(matches.get_flag(options::NO_DEREFERENCE)
|| matches.get_flag(options::NO_DEREFERENCE_PRESERVE_LINKS)
|| matches.get_flag(options::ARCHIVE)
- || recursive)
+ // cp normally follows the link only when not copying recursively or when
+ // --link (-l) is used
+ || (recursive && CopyMode::from_matches(matches)!= CopyMode::Link ))
|| matches.get_flag(options::DEREFERENCE),
one_file_system: matches.get_flag(options::ONE_FILE_SYSTEM),
parents: matches.get_flag(options::PARENTS),
- update: matches.get_flag(options::UPDATE),
- verbose: matches.get_flag(options::VERBOSE),
+ update: update_mode,
+ debug: matches.get_flag(options::DEBUG),
+ verbose: matches.get_flag(options::VERBOSE) || matches.get_flag(options::DEBUG),
strip_trailing_slashes: matches.get_flag(options::STRIP_TRAILING_SLASHES),
reflink_mode: {
if let Some(reflink) = matches.get_one::<String>(options::REFLINK) {
@@ -865,8 +1089,7 @@ impl Options {
"never" => SparseMode::Never,
_ => {
return Err(Error::InvalidArgument(format!(
- "invalid argument {} for \'sparse\'",
- val
+ "invalid argument {val} for \'sparse\'"
)));
}
}
@@ -893,11 +1116,25 @@ impl Options {
fn preserve_hard_links(&self) -> bool {
match self.attributes.links {
- Preserve::No => false,
+ Preserve::No { .. } => false,
Preserve::Yes { .. } => true,
}
}
+ #[cfg(unix)]
+ fn preserve_mode(&self) -> (bool, bool) {
+ match self.attributes.mode {
+ Preserve::No { explicit } => {
+ if explicit {
+ (false, true)
+ } else {
+ (false, false)
+ }
+ }
+ Preserve::Yes { .. } => (true, false),
+ }
+ }
+
/// Whether to force overwriting the destination file.
fn force(&self) -> bool {
matches!(self.overwrite, OverwriteMode::Clobber(ClobberMode::Force))
@@ -909,7 +1146,7 @@ impl TargetType {
///
/// Treat target as a dir if we have multiple sources or the target
/// exists and already is a directory
- fn determine(sources: &[Source], target: &TargetSlice) -> Self {
+ fn determine(sources: &[PathBuf], target: &Path) -> Self {
if sources.len() > 1 || target.is_dir() {
Self::Directory
} else {
@@ -919,12 +1156,16 @@ impl TargetType {
}
/// Returns tuple of (Source paths, Target)
-fn parse_path_args(path_args: &[String], options: &Options) -> CopyResult<(Vec<Source>, Target)> {
- let mut paths = path_args.iter().map(PathBuf::from).collect::<Vec<_>>();
-
+fn parse_path_args(
+ mut paths: Vec<PathBuf>,
+ options: &Options,
+) -> CopyResult<(Vec<PathBuf>, PathBuf)> {
if paths.is_empty() {
// No files specified
return Err("missing file operand".into());
+ } else if paths.len() == 1 && options.target_dir.is_none() {
+ // Only one file specified
+ return Err(format!("missing destination file operand after {:?}", paths[0]).into());
}
// Return an error if the user requested to copy more than one
@@ -937,7 +1178,7 @@ fn parse_path_args(path_args: &[String], options: &Options) -> CopyResult<(Vec<S
Some(ref target) => {
// All path args are sources, and the target dir was
// specified separately
- PathBuf::from(target)
+ target.clone()
}
None => {
// If there was no explicit target-dir, then use the last
@@ -947,6 +1188,9 @@ fn parse_path_args(path_args: &[String], options: &Options) -> CopyResult<(Vec<S
};
if options.strip_trailing_slashes {
+ // clippy::assigning_clones added with Rust 1.78
+ // Rust version = 1.76 on OpenBSD stable/7.5
+ #[cfg_attr(not(target_os = "openbsd"), allow(clippy::assigning_clones))]
for source in &mut paths {
*source = source.components().as_path().to_owned();
}
@@ -955,101 +1199,50 @@ fn parse_path_args(path_args: &[String], options: &Options) -> CopyResult<(Vec<S
Ok((paths, target))
}
-/// Get the inode information for a file.
-fn get_inode(file_info: &FileInformation) -> u64 {
- #[cfg(unix)]
- let result = file_info.inode();
- #[cfg(windows)]
- let result = file_info.file_index();
- result
-}
-
-#[cfg(target_os = "redox")]
-fn preserve_hardlinks(
- hard_links: &mut Vec<(String, u64)>,
- source: &std::path::Path,
- dest: &std::path::Path,
- found_hard_link: &mut bool,
-) -> CopyResult<()> {
- // Redox does not currently support hard links
- Ok(())
-}
-
-/// Hard link a pair of files if needed _and_ record if this pair is a new hard link.
-#[cfg(not(target_os = "redox"))]
-fn preserve_hardlinks(
- hard_links: &mut Vec<(String, u64)>,
- source: &std::path::Path,
- dest: &std::path::Path,
-) -> CopyResult<bool> {
- let info = FileInformation::from_path(source, false)
- .context(format!("cannot stat {}", source.quote()))?;
- let inode = get_inode(&info);
- let nlinks = info.number_of_links();
- let mut found_hard_link = false;
- for (link, link_inode) in hard_links.iter() {
- if *link_inode == inode {
- // Consider the following files:
- //
- // * `src/f` - a regular file
- // * `src/link` - a hard link to `src/f`
- // * `dest/src/f` - a different regular file
- //
- // In this scenario, if we do `cp -a src/ dest/`, it is
- // possible that the order of traversal causes `src/link`
- // to get copied first (to `dest/src/link`). In that case,
- // in order to make sure `dest/src/link` is a hard link to
- // `dest/src/f` and `dest/src/f` has the contents of
- // `src/f`, we delete the existing file to allow the hard
- // linking.
- if file_or_link_exists(dest) && file_or_link_exists(Path::new(link)) {
- std::fs::remove_file(dest)?;
- }
- std::fs::hard_link(link, dest).unwrap();
- found_hard_link = true;
- }
- }
- if !found_hard_link && nlinks > 1 {
- hard_links.push((dest.to_str().unwrap().to_string(), inode));
- }
- Ok(found_hard_link)
-}
-
/// When handling errors, we don't always want to show them to the user. This function handles that.
-/// If the error is printed, returns true, false otherwise.
-fn show_error_if_needed(error: &Error) -> bool {
+fn show_error_if_needed(error: &Error) {
match error {
// When using --no-clobber, we don't want to show
// an error message
- Error::NotAllFilesCopied => (),
- Error::Skipped => (),
+ Error::NotAllFilesCopied => {
+ // Need to return an error code
+ }
+ Error::Skipped => {
+ // touch a b && echo "n"|cp -i a b && echo $?
+ // should return an error from GNU 9.2
+ }
_ => {
show_error!("{}", error);
- return true;
}
}
- false
}
-/// Copy all `sources` to `target`. Returns an
-/// `Err(Error::NotAllFilesCopied)` if at least one non-fatal error was
-/// encountered.
+/// Copy all `sources` to `target`.
///
-/// Behavior depends on path`options`, see [`Options`] for details.
+/// Returns an `Err(Error::NotAllFilesCopied)` if at least one non-fatal error
+/// was encountered.
///
-/// [`Options`]: ./struct.Options.html
-fn copy(sources: &[Source], target: &TargetSlice, options: &Options) -> CopyResult<()> {
+/// Behavior is determined by the `options` parameter, see [`Options`] for details.
+pub fn copy(sources: &[PathBuf], target: &Path, options: &Options) -> CopyResult<()> {
let target_type = TargetType::determine(sources, target);
verify_target_type(target, &target_type)?;
- let preserve_hard_links = options.preserve_hard_links();
-
- let mut hard_links: Vec<(String, u64)> = vec![];
-
let mut non_fatal_errors = false;
let mut seen_sources = HashSet::with_capacity(sources.len());
let mut symlinked_files = HashSet::new();
+ // to remember the copied files for further usage.
+ // the FileInformation implemented the Hash trait by using
+ // 1. inode number
+ // 2. device number
+ // the combination of a file's inode number and device number is unique throughout all the file systems.
+ //
+ // key is the source file's information and the value is the destination filepath.
+ let mut copied_files: HashMap<FileInformation, PathBuf> = HashMap::with_capacity(sources.len());
+ // remember the copied destinations for further usage.
+ // we can't use copied_files as it is because the key is the source file's information.
+ let mut copied_destinations: HashSet<PathBuf> = HashSet::with_capacity(sources.len());
+
let progress_bar = if options.progress_bar {
let pb = ProgressBar::new(disk_usage(sources, options.recursive)?)
.with_style(
@@ -1065,34 +1258,52 @@ fn copy(sources: &[Source], target: &TargetSlice, options: &Options) -> CopyResu
None
};
- for source in sources.iter() {
+ for source in sources {
if seen_sources.contains(source) {
// FIXME: compare sources by the actual file they point to, not their path. (e.g. dir/file == dir/../dir/file in most cases)
- show_warning!("source {} specified more than once", source.quote());
+ show_warning!("source file {} specified more than once", source.quote());
} else {
- let found_hard_link = if preserve_hard_links && !source.is_dir() {
- let dest = construct_dest_path(source, target, &target_type, options)?;
- preserve_hardlinks(&mut hard_links, source, &dest)?
- } else {
- false
- };
- if !found_hard_link {
- if let Err(error) = copy_source(
- &progress_bar,
- source,
- target,
- &target_type,
- options,
- &mut symlinked_files,
- ) {
- if show_error_if_needed(&error) {
- non_fatal_errors = true;
- }
+ let dest = construct_dest_path(source, target, target_type, options)
+ .unwrap_or_else(|_| target.to_path_buf());
+
+ if fs::metadata(&dest).is_ok() && !fs::symlink_metadata(&dest)?.file_type().is_symlink()
+ {
+ // There is already a file and it isn't a symlink (managed in a different place)
+ if copied_destinations.contains(&dest)
+ && options.backup != BackupMode::NumberedBackup
+ {
+ // If the target file was already created in this cp call, do not overwrite
+ return Err(Error::Error(format!(
+ "will not overwrite just-created '{}' with '{}'",
+ dest.display(),
+ source.display()
+ )));
}
}
- seen_sources.insert(source);
+
+ if let Err(error) = copy_source(
+ &progress_bar,
+ source,
+ target,
+ target_type,
+ options,
+ &mut symlinked_files,
+ &copied_destinations,
+ &mut copied_files,
+ ) {
+ show_error_if_needed(&error);
+ non_fatal_errors = true;
+ } else {
+ copied_destinations.insert(dest.clone());
+ }
}
+ seen_sources.insert(source);
+ }
+
+ if let Some(pb) = progress_bar {
+ pb.finish();
}
+
if non_fatal_errors {
Err(Error::NotAllFilesCopied)
} else {
@@ -1102,8 +1313,8 @@ fn copy(sources: &[Source], target: &TargetSlice, options: &Options) -> CopyResu
fn construct_dest_path(
source_path: &Path,
- target: &TargetSlice,
- target_type: &TargetType,
+ target: &Path,
+ target_type: TargetType,
options: &Options,
) -> CopyResult<PathBuf> {
if options.no_target_dir && target.is_dir() {
@@ -1118,10 +1329,14 @@ fn construct_dest_path(
return Err("with --parents, the destination must be a directory".into());
}
- Ok(match *target_type {
+ Ok(match target_type {
TargetType::Directory => {
let root = if options.parents {
- Path::new("")
+ if source_path.has_root() && cfg!(unix) {
+ Path::new("/")
+ } else {
+ Path::new("")
+ }
} else {
source_path.parent().unwrap_or(source_path)
};
@@ -1130,37 +1345,61 @@ fn construct_dest_path(
TargetType::File => target.to_path_buf(),
})
}
-
+#[allow(clippy::too_many_arguments)]
fn copy_source(
progress_bar: &Option<ProgressBar>,
- source: &SourceSlice,
- target: &TargetSlice,
- target_type: &TargetType,
+ source: &Path,
+ target: &Path,
+ target_type: TargetType,
options: &Options,
symlinked_files: &mut HashSet<FileInformation>,
+ copied_destinations: &HashSet<PathBuf>,
+ copied_files: &mut HashMap<FileInformation, PathBuf>,
) -> CopyResult<()> {
let source_path = Path::new(&source);
if source_path.is_dir() {
// Copy as directory
- copy_directory(progress_bar, source, target, options, symlinked_files, true)
+ copy_directory(
+ progress_bar,
+ source,
+ target,
+ options,
+ symlinked_files,
+ copied_destinations,
+ copied_files,
+ true,
+ )
} else {
// Copy as file
let dest = construct_dest_path(source_path, target, target_type, options)?;
- copy_file(
+ let res = copy_file(
progress_bar,
source_path,
dest.as_path(),
options,
symlinked_files,
+ copied_destinations,
+ copied_files,
true,
- )
+ );
+ if options.parents {
+ for (x, y) in aligned_ancestors(source, dest.as_path()) {
+ if let Ok(src) = canonicalize(x, MissingHandling::Normal, ResolveMode::Physical) {
+ copy_attributes(&src, y, &options.attributes)?;
+ }
+ }
+ }
+ res
}
}
impl OverwriteMode {
fn verify(&self, path: &Path) -> CopyResult<()> {
match *self {
- Self::NoClobber => Err(Error::NotAllFilesCopied),
+ Self::NoClobber => {
+ eprintln!("{}: not replacing {}", util_name(), path.quote());
+ Err(Error::NotAllFilesCopied)
+ }
Self::Interactive(_) => {
if prompt_yes!("overwrite {}?", path.quote()) {
Ok(())
@@ -1178,7 +1417,7 @@ impl OverwriteMode {
/// If it's required, then the error is thrown.
fn handle_preserve<F: Fn() -> CopyResult<()>>(p: &Preserve, f: F) -> CopyResult<()> {
match p {
- Preserve::No => {}
+ Preserve::No { .. } => {}
Preserve::Yes { required } => {
let result = f();
if *required {
@@ -1210,8 +1449,8 @@ pub(crate) fn copy_attributes(
let dest_uid = source_metadata.uid();
let dest_gid = source_metadata.gid();
-
- wrap_chown(
+ // gnu compatibility: cp doesn't report an error if it fails to set the ownership.
+ let _ = wrap_chown(
dest,
&dest.symlink_metadata().context(context)?,
Some(dest_uid),
@@ -1219,11 +1458,9 @@ pub(crate) fn copy_attributes(
false,
Verbosity {
groups_only: false,
- level: VerbosityLevel::Normal,
+ level: VerbosityLevel::Silent,
},
- )
- .map_err(Error::Error)?;
-
+ );
Ok(())
})?;
@@ -1280,7 +1517,7 @@ pub(crate) fn copy_attributes(
})?;
handle_preserve(&attributes.xattr, || -> CopyResult<()> {
- #[cfg(unix)]
+ #[cfg(all(unix, not(target_os = "android")))]
{
let xattrs = xattr::list(source)?;
for attr in xattrs {
@@ -1289,7 +1526,7 @@ pub(crate) fn copy_attributes(
}
}
}
- #[cfg(not(unix))]
+ #[cfg(not(all(unix, not(target_os = "android"))))]
{
// The documentation for GNU cp states:
//
@@ -1312,16 +1549,23 @@ pub(crate) fn copy_attributes(
fn symlink_file(
source: &Path,
dest: &Path,
- context: &str,
symlinked_files: &mut HashSet<FileInformation>,
) -> CopyResult<()> {
#[cfg(not(windows))]
{
- std::os::unix::fs::symlink(source, dest).context(context)?;
+ std::os::unix::fs::symlink(source, dest).context(format!(
+ "cannot create symlink {} to {}",
+ get_filename(dest).unwrap_or("invalid file name").quote(),
+ get_filename(source).unwrap_or("invalid file name").quote()
+ ))?;
}
#[cfg(windows)]
{
- std::os::windows::fs::symlink_file(source, dest).context(context)?;
+ std::os::windows::fs::symlink_file(source, dest).context(format!(
+ "cannot create symlink {} to {}",
+ get_filename(dest).unwrap_or("invalid file name").quote(),
+ get_filename(source).unwrap_or("invalid file name").quote()
+ ))?;
}
if let Ok(file_info) = FileInformation::from_path(dest, false) {
symlinked_files.insert(file_info);
@@ -1333,10 +1577,15 @@ fn context_for(src: &Path, dest: &Path) -> String {
format!("{} -> {}", src.quote(), dest.quote())
}
-/// Implements a simple backup copy for the destination file.
+/// Implements a simple backup copy for the destination file .
+/// if is_dest_symlink flag is set to true dest will be renamed to backup_path
/// TODO: for the backup, should this function be replaced by `copy_file(...)`?
-fn backup_dest(dest: &Path, backup_path: &Path) -> CopyResult<PathBuf> {
- fs::copy(dest, backup_path)?;
+fn backup_dest(dest: &Path, backup_path: &Path, is_dest_symlink: bool) -> CopyResult<PathBuf> {
+ if is_dest_symlink {
+ fs::rename(dest, backup_path)?;
+ } else {
+ fs::copy(dest, backup_path)?;
+ }
Ok(backup_path.into())
}
@@ -1345,7 +1594,7 @@ fn backup_dest(dest: &Path, backup_path: &Path) -> CopyResult<PathBuf> {
///
/// Copying to the same file is only allowed if both `--backup` and
/// `--force` are specified and the file is a regular file.
-fn is_forbidden_copy_to_same_file(
+fn is_forbidden_to_copy_to_same_file(
source: &Path,
dest: &Path,
options: &Options,
@@ -1353,10 +1602,38 @@ fn is_forbidden_copy_to_same_file(
) -> bool {
// TODO To match the behavior of GNU cp, we also need to check
// that the file is a regular file.
+ let source_is_symlink = source.is_symlink();
+ let dest_is_symlink = dest.is_symlink();
+ // only disable dereference if both source and dest is symlink and dereference flag is disabled
let dereference_to_compare =
- options.dereference(source_in_command_line) || !source.is_symlink();
- paths_refer_to_same_file(source, dest, dereference_to_compare)
- && !(options.force() && options.backup != BackupMode::NoBackup)
+ options.dereference(source_in_command_line) || (!source_is_symlink || !dest_is_symlink);
+ if !paths_refer_to_same_file(source, dest, dereference_to_compare) {
+ return false;
+ }
+ if options.backup != BackupMode::NoBackup {
+ if options.force() && !source_is_symlink {
+ return false;
+ }
+ if source_is_symlink && !options.dereference {
+ return false;
+ }
+ if dest_is_symlink {
+ return false;
+ }
+ if !dest_is_symlink && !source_is_symlink && dest != source {
+ return false;
+ }
+ }
+ if options.copy_mode == CopyMode::Link {
+ return false;
+ }
+ if options.copy_mode == CopyMode::SymLink && dest_is_symlink {
+ return false;
+ }
+ if dest_is_symlink && source_is_symlink && !options.dereference {
+ return false;
+ }
+ true
}
/// Back up, remove, or leave intact the destination file, depending on the options.
@@ -1365,15 +1642,19 @@ fn handle_existing_dest(
dest: &Path,
options: &Options,
source_in_command_line: bool,
+ copied_files: &mut HashMap<FileInformation, PathBuf>,
) -> CopyResult<()> {
// Disallow copying a file to itself, unless `--force` and
// `--backup` are both specified.
- if is_forbidden_copy_to_same_file(source, dest, options, source_in_command_line) {
+ if is_forbidden_to_copy_to_same_file(source, dest, options, source_in_command_line) {
return Err(format!("{} and {} are the same file", source.quote(), dest.quote()).into());
}
- options.overwrite.verify(dest)?;
+ if options.update != UpdateMode::ReplaceIfOlder {
+ options.overwrite.verify(dest)?;
+ }
+ let mut is_dest_removed = false;
let backup_path = backup_control::get_backup_path(options.backup, dest, &options.backup_suffix);
if let Some(backup_path) = backup_path {
if paths_refer_to_same_file(source, &backup_path, true) {
@@ -1384,20 +1665,52 @@ fn handle_existing_dest(
)
.into());
} else {
- backup_dest(dest, &backup_path)?;
+ is_dest_removed = dest.is_symlink();
+ backup_dest(dest, &backup_path, is_dest_removed)?;
}
}
-
match options.overwrite {
// FIXME: print that the file was removed if --verbose is enabled
OverwriteMode::Clobber(ClobberMode::Force) => {
- if fs::metadata(dest)?.permissions().readonly() {
+ if !is_dest_removed
+ && (is_symlink_loop(dest) || fs::metadata(dest)?.permissions().readonly())
+ {
fs::remove_file(dest)?;
}
}
OverwriteMode::Clobber(ClobberMode::RemoveDestination) => {
fs::remove_file(dest)?;
}
+ OverwriteMode::Clobber(ClobberMode::Standard) => {
+ // Consider the following files:
+ //
+ // * `src/f` - a regular file
+ // * `src/link` - a hard link to `src/f`
+ // * `dest/src/f` - a different regular file
+ //
+ // In this scenario, if we do `cp -a src/ dest/`, it is
+ // possible that the order of traversal causes `src/link`
+ // to get copied first (to `dest/src/link`). In that case,
+ // in order to make sure `dest/src/link` is a hard link to
+ // `dest/src/f` and `dest/src/f` has the contents of
+ // `src/f`, we delete the existing file to allow the hard
+ // linking.
+
+ if options.preserve_hard_links()
+ // only try to remove dest file only if the current source
+ // is hardlink to a file that is already copied
+ && copied_files.contains_key(
+ &FileInformation::from_path(
+ source,
+ options.dereference(source_in_command_line),
+ )
+ .context(format!("cannot stat {}", source.quote()))?,
+ )
+ && !is_dest_removed
+ {
+ fs::remove_file(dest)?;
+ }
+ }
_ => (),
};
@@ -1440,7 +1753,7 @@ fn aligned_ancestors<'a>(source: &'a Path, dest: &'a Path) -> Vec<(&'a Path, &'a
// Get the matching number of elements from the ancestors of the
// destination path (for example, get "d/a" and "d/a/b").
let k = source_ancestors.len();
- let dest_ancestors = &dest_ancestors[1..1 + k];
+ let dest_ancestors = &dest_ancestors[1..=k];
// Now we have two slices of the same length, so we zip them.
let mut result = vec![];
@@ -1454,109 +1767,59 @@ fn aligned_ancestors<'a>(source: &'a Path, dest: &'a Path) -> Vec<(&'a Path, &'a
result
}
-/// Copy the a file from `source` to `dest`. `source` will be dereferenced if
-/// `options.dereference` is set to true. `dest` will be dereferenced only if
-/// the source was not a symlink.
-///
-/// Behavior when copying to existing files is contingent on the
-/// `options.overwrite` mode. If a file is skipped, the return type
-/// should be `Error:Skipped`
-///
-/// The original permissions of `source` will be copied to `dest`
-/// after a successful copy.
-fn copy_file(
+fn print_verbose_output(
+ parents: bool,
progress_bar: &Option<ProgressBar>,
source: &Path,
dest: &Path,
- options: &Options,
- symlinked_files: &mut HashSet<FileInformation>,
- source_in_command_line: bool,
-) -> CopyResult<()> {
- if options.update && options.overwrite == OverwriteMode::Interactive(ClobberMode::Standard) {
- // `cp -i --update old new` when `new` exists doesn't copy anything
- // and exit with 0
- return Ok(());
- }
-
- // Fail if dest is a dangling symlink or a symlink this program created previously
- if dest.is_symlink() {
- if FileInformation::from_path(dest, false)
- .map(|info| symlinked_files.contains(&info))
- .unwrap_or(false)
- {
- return Err(Error::Error(format!(
- "will not copy '{}' through just-created symlink '{}'",
- source.display(),
- dest.display()
- )));
- }
- let copy_contents = options.dereference(source_in_command_line) || !source.is_symlink();
- if copy_contents
- && !dest.exists()
- && !matches!(
- options.overwrite,
- OverwriteMode::Clobber(ClobberMode::RemoveDestination)
- )
- {
- return Err(Error::Error(format!(
- "not writing through dangling symlink '{}'",
- dest.display()
- )));
- }
- }
-
- if file_or_link_exists(dest) {
- handle_existing_dest(source, dest, options, source_in_command_line)?;
+) {
+ if let Some(pb) = progress_bar {
+ // Suspend (hide) the progress bar so the println won't overlap with the progress bar.
+ pb.suspend(|| {
+ print_paths(parents, source, dest);
+ });
+ } else {
+ print_paths(parents, source, dest);
}
+}
- if options.verbose {
- if let Some(pb) = progress_bar {
- // Suspend (hide) the progress bar so the println won't overlap with the progress bar.
- pb.suspend(|| {
- if options.parents {
- // For example, if copying file `a/b/c` and its parents
- // to directory `d/`, then print
- //
- // a -> d/a
- // a/b -> d/a/b
- //
- for (x, y) in aligned_ancestors(source, dest) {
- println!("{} -> {}", x.display(), y.display());
- }
- }
-
- println!("{}", context_for(source, dest));
- });
- } else {
- if options.parents {
- // For example, if copying file `a/b/c` and its parents
- // to directory `d/`, then print
- //
- // a -> d/a
- // a/b -> d/a/b
- //
- for (x, y) in aligned_ancestors(source, dest) {
- println!("{} -> {}", x.display(), y.display());
- }
- }
-
- println!("{}", context_for(source, dest));
+fn print_paths(parents: bool, source: &Path, dest: &Path) {
+ if parents {
+ // For example, if copying file `a/b/c` and its parents
+ // to directory `d/`, then print
+ //
+ // a -> d/a
+ // a/b -> d/a/b
+ //
+ for (x, y) in aligned_ancestors(source, dest) {
+ println!("{} -> {}", x.display(), y.display());
}
}
- // Calculate the context upfront before canonicalizing the path
- let context = context_for(source, dest);
- let context = context.as_str();
+ println!("{}", context_for(source, dest));
+}
- let source_metadata = {
- let result = if options.dereference(source_in_command_line) {
- fs::metadata(source)
- } else {
- fs::symlink_metadata(source)
- };
- result.context(context)?
- };
+/// Handles the copy mode for a file copy operation.
+///
+/// This function determines how to copy a file based on the provided options.
+/// It supports different copy modes, including hard linking, copying, symbolic linking, updating, and attribute-only copying.
+/// It also handles file backups, overwriting, and dereferencing based on the provided options.
+///
+/// # Returns
+///
+/// * `Ok(())` - The file was copied successfully.
+/// * `Err(CopyError)` - An error occurred while copying the file.
+fn handle_copy_mode(
+ source: &Path,
+ dest: &Path,
+ options: &Options,
+ context: &str,
+ source_metadata: &Metadata,
+ symlinked_files: &mut HashSet<FileInformation>,
+ source_in_command_line: bool,
+) -> CopyResult<()> {
let source_file_type = source_metadata.file_type();
+
let source_is_symlink = source_file_type.is_symlink();
#[cfg(unix)]
@@ -1564,36 +1827,13 @@ fn copy_file(
#[cfg(not(unix))]
let source_is_fifo = false;
- let dest_permissions = if dest.exists() {
- dest.symlink_metadata().context(context)?.permissions()
- } else {
- #[allow(unused_mut)]
- let mut permissions = source_metadata.permissions();
- #[cfg(unix)]
- {
- use uucore::mode::get_umask;
-
- let mut mode = permissions.mode();
-
- // remove sticky bit, suid and gid bit
- const SPECIAL_PERMS_MASK: u32 = 0o7000;
- mode &= !SPECIAL_PERMS_MASK;
-
- // apply umask
- mode &= !get_umask();
-
- permissions.set_mode(mode);
- }
- permissions
- };
-
match options.copy_mode {
CopyMode::Link => {
if dest.exists() {
let backup_path =
backup_control::get_backup_path(options.backup, dest, &options.backup_suffix);
if let Some(backup_path) = backup_path {
- backup_dest(dest, &backup_path)?;
+ backup_dest(dest, &backup_path, dest.is_symlink())?;
fs::remove_file(dest)?;
}
if options.overwrite == OverwriteMode::Clobber(ClobberMode::Force) {
@@ -1607,7 +1847,11 @@ fn copy_file(
} else {
fs::hard_link(source, dest)
}
- .context(context)?;
+ .context(format!(
+ "cannot create hard link {} to {}",
+ get_filename(dest).unwrap_or("invalid file name").quote(),
+ get_filename(source).unwrap_or("invalid file name").quote()
+ ))?;
}
CopyMode::Copy => {
copy_helper(
@@ -1624,26 +1868,50 @@ fn copy_file(
if dest.exists() && options.overwrite == OverwriteMode::Clobber(ClobberMode::Force) {
fs::remove_file(dest)?;
}
- symlink_file(source, dest, context, symlinked_files)?;
+ symlink_file(source, dest, symlinked_files)?;
}
CopyMode::Update => {
if dest.exists() {
- let dest_metadata = fs::symlink_metadata(dest)?;
+ match options.update {
+ update_control::UpdateMode::ReplaceAll => {
+ copy_helper(
+ source,
+ dest,
+ options,
+ context,
+ source_is_symlink,
+ source_is_fifo,
+ symlinked_files,
+ )?;
+ }
+ update_control::UpdateMode::ReplaceNone => {
+ if options.debug {
+ println!("skipped {}", dest.quote());
+ }
- let src_time = source_metadata.modified()?;
- let dest_time = dest_metadata.modified()?;
- if src_time <= dest_time {
- return Ok(());
- } else {
- copy_helper(
- source,
- dest,
- options,
- context,
- source_is_symlink,
- source_is_fifo,
- symlinked_files,
- )?;
+ return Ok(());
+ }
+ update_control::UpdateMode::ReplaceIfOlder => {
+ let dest_metadata = fs::symlink_metadata(dest)?;
+
+ let src_time = source_metadata.modified()?;
+ let dest_time = dest_metadata.modified()?;
+ if src_time <= dest_time {
+ return Ok(());
+ } else {
+ options.overwrite.verify(dest)?;
+
+ copy_helper(
+ source,
+ dest,
+ options,
+ context,
+ source_is_symlink,
+ source_is_fifo,
+ symlinked_files,
+ )?;
+ }
+ }
}
} else {
copy_helper(
@@ -1667,8 +1935,229 @@ fn copy_file(
}
};
+ Ok(())
+}
+
+/// Calculates the permissions for the destination file in a copy operation.
+///
+/// If the destination file already exists, its current permissions are returned.
+/// If the destination file does not exist, the source file's permissions are used,
+/// with the `no-preserve` option and the umask taken into account on Unix platforms.
+/// # Returns
+///
+/// * `Ok(Permissions)` - The calculated permissions for the destination file.
+/// * `Err(CopyError)` - An error occurred while getting the metadata of the destination file.
+/// Allow unused variables for Windows (on options)
+#[allow(unused_variables)]
+fn calculate_dest_permissions(
+ dest: &Path,
+ source_metadata: &Metadata,
+ options: &Options,
+ context: &str,
+) -> CopyResult<Permissions> {
+ if dest.exists() {
+ Ok(dest.symlink_metadata().context(context)?.permissions())
+ } else {
+ #[cfg(unix)]
+ {
+ let mut permissions = source_metadata.permissions();
+ let mode = handle_no_preserve_mode(options, permissions.mode());
+
+ // Apply umask
+ use uucore::mode::get_umask;
+ let mode = mode & !get_umask();
+ permissions.set_mode(mode);
+ Ok(permissions)
+ }
+ #[cfg(not(unix))]
+ {
+ let permissions = source_metadata.permissions();
+ Ok(permissions)
+ }
+ }
+}
+
+/// Copy the a file from `source` to `dest`. `source` will be dereferenced if
+/// `options.dereference` is set to true. `dest` will be dereferenced only if
+/// the source was not a symlink.
+///
+/// Behavior when copying to existing files is contingent on the
+/// `options.overwrite` mode. If a file is skipped, the return type
+/// should be `Error:Skipped`
+///
+/// The original permissions of `source` will be copied to `dest`
+/// after a successful copy.
+#[allow(clippy::cognitive_complexity, clippy::too_many_arguments)]
+fn copy_file(
+ progress_bar: &Option<ProgressBar>,
+ source: &Path,
+ dest: &Path,
+ options: &Options,
+ symlinked_files: &mut HashSet<FileInformation>,
+ copied_destinations: &HashSet<PathBuf>,
+ copied_files: &mut HashMap<FileInformation, PathBuf>,
+ source_in_command_line: bool,
+) -> CopyResult<()> {
+ let source_is_symlink = source.is_symlink();
+ let dest_is_symlink = dest.is_symlink();
+ // Fail if dest is a dangling symlink or a symlink this program created previously
+ if dest_is_symlink {
+ if FileInformation::from_path(dest, false)
+ .map(|info| symlinked_files.contains(&info))
+ .unwrap_or(false)
+ {
+ return Err(Error::Error(format!(
+ "will not copy '{}' through just-created symlink '{}'",
+ source.display(),
+ dest.display()
+ )));
+ }
+ // Fail if cp tries to copy two sources of the same name into a single symlink
+ // Example: "cp file1 dir1/file1 tmp" where "tmp" is a directory containing a symlink "file1" pointing to a file named "foo".
+ // foo will contain the contents of "file1" and "dir1/file1" will not be copied over to "tmp/file1"
+ if copied_destinations.contains(dest) {
+ return Err(Error::Error(format!(
+ "will not copy '{}' through just-created symlink '{}'",
+ source.display(),
+ dest.display()
+ )));
+ }
+
+ let copy_contents = options.dereference(source_in_command_line) || !source_is_symlink;
+ if copy_contents
+ && !dest.exists()
+ && !matches!(
+ options.overwrite,
+ OverwriteMode::Clobber(ClobberMode::RemoveDestination)
+ )
+ && !is_symlink_loop(dest)
+ && std::env::var_os("POSIXLY_CORRECT").is_none()
+ {
+ return Err(Error::Error(format!(
+ "not writing through dangling symlink '{}'",
+ dest.display()
+ )));
+ }
+ if paths_refer_to_same_file(source, dest, true)
+ && matches!(
+ options.overwrite,
+ OverwriteMode::Clobber(ClobberMode::RemoveDestination)
+ )
+ {
+ fs::remove_file(dest)?;
+ }
+ }
+
+ if are_hardlinks_to_same_file(source, dest)
+ && source != dest
+ && matches!(
+ options.overwrite,
+ OverwriteMode::Clobber(ClobberMode::RemoveDestination)
+ )
+ {
+ fs::remove_file(dest)?;
+ }
+
+ if file_or_link_exists(dest)
+ && (!options.attributes_only
+ || matches!(
+ options.overwrite,
+ OverwriteMode::Clobber(ClobberMode::RemoveDestination)
+ ))
+ {
+ if paths_refer_to_same_file(source, dest, true) && options.copy_mode == CopyMode::Link {
+ if source_is_symlink {
+ if !dest_is_symlink {
+ return Ok(());
+ }
+ if !options.dereference {
+ return Ok(());
+ }
+ } else if options.backup != BackupMode::NoBackup && !dest_is_symlink {
+ if source == dest {
+ if !options.force() {
+ return Ok(());
+ }
+ } else {
+ return Ok(());
+ }
+ }
+ }
+ handle_existing_dest(source, dest, options, source_in_command_line, copied_files)?;
+ if are_hardlinks_to_same_file(source, dest) {
+ if options.copy_mode == CopyMode::Copy && options.backup != BackupMode::NoBackup {
+ return Ok(());
+ }
+ if options.copy_mode == CopyMode::Link && (!source_is_symlink || !dest_is_symlink) {
+ return Ok(());
+ }
+ }
+ }
+
+ if options.attributes_only
+ && source_is_symlink
+ && !matches!(
+ options.overwrite,
+ OverwriteMode::Clobber(ClobberMode::RemoveDestination)
+ )
+ {
+ return Err(format!(
+ "cannot change attribute {}: Source file is a non regular file",
+ dest.quote()
+ )
+ .into());
+ }
+
+ if options.preserve_hard_links() {
+ // if we encounter a matching device/inode pair in the source tree
+ // we can arrange to create a hard link between the corresponding names
+ // in the destination tree.
+ if let Some(new_source) = copied_files.get(
+ &FileInformation::from_path(source, options.dereference(source_in_command_line))
+ .context(format!("cannot stat {}", source.quote()))?,
+ ) {
+ std::fs::hard_link(new_source, dest)?;
+ return Ok(());
+ };
+ }
+
+ if options.verbose {
+ print_verbose_output(options.parents, progress_bar, source, dest);
+ }
+
+ // Calculate the context upfront before canonicalizing the path
+ let context = context_for(source, dest);
+ let context = context.as_str();
+
+ let source_metadata = {
+ let result = if options.dereference(source_in_command_line) {
+ fs::metadata(source)
+ } else {
+ fs::symlink_metadata(source)
+ };
+ // this is just for gnu tests compatibility
+ result.map_err(|err| {
+ if err.to_string().contains("No such file or directory") {
+ return format!("cannot stat {}: No such file or directory", source.quote());
+ }
+ err.to_string()
+ })?
+ };
+
+ let dest_permissions = calculate_dest_permissions(dest, &source_metadata, options, context)?;
+
+ handle_copy_mode(
+ source,
+ dest,
+ options,
+ context,
+ &source_metadata,
+ symlinked_files,
+ source_in_command_line,
+ )?;
+
// TODO: implement something similar to gnu's lchown
- if !dest.is_symlink() {
+ if !dest_is_symlink {
// Here, to match GNU semantics, we quietly ignore an error
// if a user does not have the correct ownership to modify
// the permissions of a file.
@@ -1678,7 +2167,18 @@ fn copy_file(
fs::set_permissions(dest, dest_permissions).ok();
}
- copy_attributes(source, dest, &options.attributes)?;
+ if options.dereference(source_in_command_line) {
+ if let Ok(src) = canonicalize(source, MissingHandling::Normal, ResolveMode::Physical) {
+ copy_attributes(&src, dest, &options.attributes)?;
+ }
+ } else {
+ copy_attributes(source, dest, &options.attributes)?;
+ }
+
+ copied_files.insert(
+ FileInformation::from_path(source, options.dereference(source_in_command_line))?,
+ dest.to_path_buf(),
+ );
if let Some(progress_bar) = progress_bar {
progress_bar.inc(fs::metadata(source)?.len());
@@ -1687,6 +2187,51 @@ fn copy_file(
Ok(())
}
+#[cfg(unix)]
+fn handle_no_preserve_mode(options: &Options, org_mode: u32) -> u32 {
+ let (is_preserve_mode, is_explicit_no_preserve_mode) = options.preserve_mode();
+ if !is_preserve_mode {
+ use libc::{
+ S_IRGRP, S_IROTH, S_IRUSR, S_IRWXG, S_IRWXO, S_IRWXU, S_IWGRP, S_IWOTH, S_IWUSR,
+ };
+
+ #[cfg(not(any(
+ target_os = "android",
+ target_os = "macos",
+ target_os = "freebsd",
+ target_os = "redox",
+ )))]
+ {
+ const MODE_RW_UGO: u32 = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
+ const S_IRWXUGO: u32 = S_IRWXU | S_IRWXG | S_IRWXO;
+ if is_explicit_no_preserve_mode {
+ return MODE_RW_UGO;
+ } else {
+ return org_mode & S_IRWXUGO;
+ };
+ }
+
+ #[cfg(any(
+ target_os = "android",
+ target_os = "macos",
+ target_os = "freebsd",
+ target_os = "redox",
+ ))]
+ {
+ const MODE_RW_UGO: u32 =
+ (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH) as u32;
+ const S_IRWXUGO: u32 = (S_IRWXU | S_IRWXG | S_IRWXO) as u32;
+ if is_explicit_no_preserve_mode {
+ return MODE_RW_UGO;
+ } else {
+ return org_mode & S_IRWXUGO;
+ };
+ }
+ }
+
+ org_mode
+}
+
/// Copy the file from `source` to `dest` either using the normal `fs::copy` or a
/// copy-on-write scheme if --reflink is specified and the filesystem supports it.
fn copy_helper(
@@ -1703,6 +2248,10 @@ fn copy_helper(
fs::create_dir_all(parent)?;
}
+ if path_ends_with_terminator(dest) && !dest.is_dir() {
+ return Err(Error::NotADirectory(dest.to_path_buf()));
+ }
+
if source.as_os_str() == "/dev/null" {
/* workaround a limitation of fs::copy
* https://github.com/rust-lang/rust/issues/79390
@@ -1714,7 +2263,7 @@ fn copy_helper(
} else if source_is_symlink {
copy_link(source, dest, symlinked_files)?;
} else {
- copy_on_write(
+ let copy_debug = copy_on_write(
source,
dest,
options.reflink_mode,
@@ -1723,6 +2272,10 @@ fn copy_helper(
#[cfg(any(target_os = "linux", target_os = "android", target_os = "macos"))]
source_is_fifo,
)?;
+
+ if !options.attributes_only && options.debug {
+ show_debug(©_debug);
+ }
}
Ok(())
@@ -1752,24 +2305,12 @@ fn copy_link(
) -> CopyResult<()> {
// Here, we will copy the symlink itself (actually, just recreate it)
let link = fs::read_link(source)?;
- let dest: Cow<'_, Path> = if dest.is_dir() {
- match source.file_name() {
- Some(name) => dest.join(name).into(),
- None => crash!(
- EXIT_ERR,
- "cannot stat {}: No such file or directory",
- source.quote()
- ),
- }
- } else {
- // we always need to remove the file to be able to create a symlink,
- // even if it is writeable.
- if dest.is_symlink() || dest.is_file() {
- fs::remove_file(dest)?;
- }
- dest.into()
- };
- symlink_file(&link, &dest, &context_for(&link, &dest), symlinked_files)
+ // we always need to remove the file to be able to create a symlink,
+ // even if it is writeable.
+ if dest.is_symlink() || dest.is_file() {
+ fs::remove_file(dest)?;
+ }
+ symlink_file(&link, dest, symlinked_files)
}
/// Generate an error message if `target` is not the correct `target_type`
@@ -1842,7 +2383,7 @@ fn disk_usage_directory(p: &Path) -> io::Result<u64> {
#[cfg(test)]
mod tests {
- use crate::{aligned_ancestors, localize_to_target};
+ use crate::{aligned_ancestors, localize_to_target, Attributes, Preserve};
use std::path::Path;
#[test]
@@ -1857,11 +2398,59 @@ mod tests {
#[test]
fn test_aligned_ancestors() {
- let actual = aligned_ancestors(&Path::new("a/b/c"), &Path::new("d/a/b/c"));
+ let actual = aligned_ancestors(Path::new("a/b/c"), Path::new("d/a/b/c"));
let expected = vec![
(Path::new("a"), Path::new("d/a")),
(Path::new("a/b"), Path::new("d/a/b")),
];
assert_eq!(actual, expected);
}
+ #[test]
+ fn test_diff_attrs() {
+ assert_eq!(
+ Attributes::ALL.diff(&Attributes {
+ context: Preserve::Yes { required: true },
+ xattr: Preserve::Yes { required: true },
+ ..Attributes::ALL
+ }),
+ Attributes {
+ #[cfg(unix)]
+ ownership: Preserve::No { explicit: true },
+ mode: Preserve::No { explicit: true },
+ timestamps: Preserve::No { explicit: true },
+ context: Preserve::No { explicit: true },
+ links: Preserve::No { explicit: true },
+ xattr: Preserve::No { explicit: true }
+ }
+ );
+ assert_eq!(
+ Attributes {
+ context: Preserve::Yes { required: true },
+ xattr: Preserve::Yes { required: true },
+ ..Attributes::ALL
+ }
+ .diff(&Attributes::NONE),
+ Attributes {
+ context: Preserve::Yes { required: true },
+ xattr: Preserve::Yes { required: true },
+ ..Attributes::ALL
+ }
+ );
+ assert_eq!(
+ Attributes::NONE.diff(&Attributes {
+ context: Preserve::Yes { required: true },
+ xattr: Preserve::Yes { required: true },
+ ..Attributes::ALL
+ }),
+ Attributes {
+ #[cfg(unix)]
+ ownership: Preserve::No { explicit: true },
+ mode: Preserve::No { explicit: true },
+ timestamps: Preserve::No { explicit: true },
+ context: Preserve::No { explicit: true },
+ links: Preserve::No { explicit: true },
+ xattr: Preserve::No { explicit: true }
+ }
+ );
+ }
}
diff --git a/src/uu/cp/src/platform/linux.rs b/src/uu/cp/src/platform/linux.rs
index 7d97813dd4453f1209620baa560b85b694d76ecc..637b8969c45ca633a9d66aecaee779a19ab25a57 100644
--- a/src/uu/cp/src/platform/linux.rs
+++ b/src/uu/cp/src/platform/linux.rs
@@ -1,11 +1,15 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
-// spell-checker:ignore ficlone reflink ftruncate pwrite fiemap
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore ficlone reflink ftruncate pwrite fiemap lseek
+
+use libc::{SEEK_DATA, SEEK_HOLE};
use std::fs::{File, OpenOptions};
use std::io::Read;
-use std::os::unix::fs::OpenOptionsExt;
+use std::os::unix::fs::FileExt;
+use std::os::unix::fs::MetadataExt;
+use std::os::unix::fs::{FileTypeExt, OpenOptionsExt};
use std::os::unix::io::AsRawFd;
use std::path::Path;
@@ -13,7 +17,7 @@ use quick_error::ResultExt;
use uucore::mode::get_umask;
-use crate::{CopyResult, ReflinkMode, SparseMode};
+use crate::{CopyDebug, CopyResult, OffloadReflinkDebug, ReflinkMode, SparseDebug, SparseMode};
// From /usr/include/linux/fs.h:
// #define FICLONE _IOW(0x94, 9, int)
@@ -32,6 +36,25 @@ enum CloneFallback {
/// Use [`std::fs::copy`].
FSCopy,
+
+ /// Use sparse_copy
+ SparseCopy,
+
+ /// Use sparse_copy_without_hole
+ SparseCopyWithoutHole,
+}
+
+/// Type of method used for copying files
+#[derive(Clone, Copy)]
+enum CopyMethod {
+ /// Do a sparse copy
+ SparseCopy,
+ /// Use [`std::fs::copy`].
+ FSCopy,
+ /// Default (can either be sparse_copy or FSCopy)
+ Default,
+ /// Use sparse_copy_without_hole
+ SparseCopyWithoutHole,
}
/// Use the Linux `ioctl_ficlone` API to do a copy-on-write clone.
@@ -53,17 +76,109 @@ where
match fallback {
CloneFallback::Error => Err(std::io::Error::last_os_error()),
CloneFallback::FSCopy => std::fs::copy(source, dest).map(|_| ()),
+ CloneFallback::SparseCopy => sparse_copy(source, dest),
+ CloneFallback::SparseCopyWithoutHole => sparse_copy_without_hole(source, dest),
+ }
+}
+
+/// Checks whether a file contains any non null bytes i.e. any byte != 0x0
+/// This function returns a tuple of (bool, u64, u64) signifying a tuple of (whether a file has
+/// data, its size, no of blocks it has allocated in disk)
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn check_for_data(source: &Path) -> Result<(bool, u64, u64), std::io::Error> {
+ let mut src_file = File::open(source)?;
+ let metadata = src_file.metadata()?;
+
+ let size = metadata.size();
+ let blocks = metadata.blocks();
+ // checks edge case of virtual files in /proc which have a size of zero but contains data
+ if size == 0 {
+ let mut buf: Vec<u8> = vec![0; metadata.blksize() as usize]; // Directly use metadata.blksize()
+ let _ = src_file.read(&mut buf)?;
+ return Ok((buf.iter().any(|&x| x != 0x0), size, 0));
+ }
+
+ let src_fd = src_file.as_raw_fd();
+
+ let result = unsafe { libc::lseek(src_fd, 0, SEEK_DATA) };
+
+ match result {
+ -1 => Ok((false, size, blocks)), // No data found or end of file
+ _ if result >= 0 => Ok((true, size, blocks)), // Data found
+ _ => Err(std::io::Error::last_os_error()),
}
}
+#[cfg(any(target_os = "linux", target_os = "android"))]
+/// Checks whether a file is sparse i.e. it contains holes, uses the crude heuristic blocks < size / 512
+/// Reference:`<https://doc.rust-lang.org/std/os/unix/fs/trait.MetadataExt.html#tymethod.blocks>`
+fn check_sparse_detection(source: &Path) -> Result<bool, std::io::Error> {
+ let src_file = File::open(source)?;
+ let metadata = src_file.metadata()?;
+ let size = metadata.size();
+ let blocks = metadata.blocks();
+
+ if blocks < size / 512 {
+ return Ok(true);
+ }
+ Ok(false)
+}
+
+/// Optimized sparse_copy, doesn't create holes for large sequences of zeros in non sparse_files
+/// Used when --sparse=auto
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn sparse_copy_without_hole<P>(source: P, dest: P) -> std::io::Result<()>
+where
+ P: AsRef<Path>,
+{
+ let src_file = File::open(source)?;
+ let dst_file = File::create(dest)?;
+ let dst_fd = dst_file.as_raw_fd();
+
+ let size = src_file.metadata()?.size();
+ if unsafe { libc::ftruncate(dst_fd, size.try_into().unwrap()) } < 0 {
+ return Err(std::io::Error::last_os_error());
+ }
+ let src_fd = src_file.as_raw_fd();
+ let mut current_offset: isize = 0;
+ loop {
+ let result = unsafe { libc::lseek(src_fd, current_offset.try_into().unwrap(), SEEK_DATA) }
+ .try_into()
+ .unwrap();
+
+ current_offset = result;
+ let hole: isize =
+ unsafe { libc::lseek(src_fd, current_offset.try_into().unwrap(), SEEK_HOLE) }
+ .try_into()
+ .unwrap();
+ if result == -1 || hole == -1 {
+ break;
+ }
+ if result <= -2 || hole <= -2 {
+ return Err(std::io::Error::last_os_error());
+ }
+ let len: isize = hole - current_offset;
+ let mut buf: Vec<u8> = vec![0x0; len as usize];
+ src_file.read_exact_at(&mut buf, current_offset as u64)?;
+ unsafe {
+ libc::pwrite(
+ dst_fd,
+ buf.as_ptr() as *const libc::c_void,
+ len as usize,
+ current_offset.try_into().unwrap(),
+ )
+ };
+ current_offset = hole;
+ }
+ Ok(())
+}
/// Perform a sparse copy from one file to another.
+/// Creates a holes for large sequences of zeros in non_sparse_files, used for --sparse=always
#[cfg(any(target_os = "linux", target_os = "android"))]
fn sparse_copy<P>(source: P, dest: P) -> std::io::Result<()>
where
P: AsRef<Path>,
{
- use std::os::unix::prelude::MetadataExt;
-
let mut src_file = File::open(source)?;
let dst_file = File::create(dest)?;
let dst_fd = dst_file.as_raw_fd();
@@ -97,6 +212,18 @@ where
Ok(())
}
+#[cfg(any(target_os = "linux", target_os = "android"))]
+/// Checks whether an existing destination is a fifo
+fn check_dest_is_fifo(dest: &Path) -> bool {
+ // If our destination file exists and its a fifo , we do a standard copy .
+ let file_type = std::fs::metadata(dest);
+ match file_type {
+ Ok(f) => f.file_type().is_fifo(),
+
+ _ => false,
+ }
+}
+
/// Copy the contents of the given source FIFO to the given file.
fn copy_fifo_contents<P>(source: P, dest: P) -> std::io::Result<u64>
where
@@ -145,24 +272,345 @@ pub(crate) fn copy_on_write(
sparse_mode: SparseMode,
context: &str,
source_is_fifo: bool,
-) -> CopyResult<()> {
+) -> CopyResult<CopyDebug> {
+ let mut copy_debug = CopyDebug {
+ offload: OffloadReflinkDebug::Unknown,
+ reflink: OffloadReflinkDebug::Unsupported,
+ sparse_detection: SparseDebug::No,
+ };
let result = match (reflink_mode, sparse_mode) {
- (ReflinkMode::Never, SparseMode::Always) => sparse_copy(source, dest),
- (ReflinkMode::Never, _) => std::fs::copy(source, dest).map(|_| ()),
- (ReflinkMode::Auto, SparseMode::Always) => sparse_copy(source, dest),
+ (ReflinkMode::Never, SparseMode::Always) => {
+ copy_debug.sparse_detection = SparseDebug::Zeros;
+ // Default SparseDebug val for SparseMode::Always
+ copy_debug.reflink = OffloadReflinkDebug::No;
+ if source_is_fifo {
+ copy_debug.offload = OffloadReflinkDebug::Avoided;
+
+ copy_fifo_contents(source, dest).map(|_| ())
+ } else {
+ let mut copy_method = CopyMethod::Default;
+ let result = handle_reflink_never_sparse_always(source, dest);
+ if let Ok((debug, method)) = result {
+ copy_debug = debug;
+ copy_method = method;
+ }
+
+ match copy_method {
+ CopyMethod::FSCopy => std::fs::copy(source, dest).map(|_| ()),
+ _ => sparse_copy(source, dest),
+ }
+ }
+ }
+ (ReflinkMode::Never, SparseMode::Never) => {
+ copy_debug.reflink = OffloadReflinkDebug::No;
- (ReflinkMode::Auto, _) => {
if source_is_fifo {
+ copy_debug.offload = OffloadReflinkDebug::Avoided;
+
copy_fifo_contents(source, dest).map(|_| ())
} else {
+ let result = handle_reflink_never_sparse_never(source);
+ if let Ok(debug) = result {
+ copy_debug = debug;
+ }
+ std::fs::copy(source, dest).map(|_| ())
+ }
+ }
+ (ReflinkMode::Never, SparseMode::Auto) => {
+ copy_debug.reflink = OffloadReflinkDebug::No;
+
+ if source_is_fifo {
+ copy_debug.offload = OffloadReflinkDebug::Avoided;
+ copy_fifo_contents(source, dest).map(|_| ())
+ } else {
+ let mut copy_method = CopyMethod::Default;
+ let result = handle_reflink_never_sparse_auto(source, dest);
+ if let Ok((debug, method)) = result {
+ copy_debug = debug;
+ copy_method = method;
+ }
+
+ match copy_method {
+ CopyMethod::SparseCopyWithoutHole => sparse_copy_without_hole(source, dest),
+ _ => std::fs::copy(source, dest).map(|_| ()),
+ }
+ }
+ }
+ (ReflinkMode::Auto, SparseMode::Always) => {
+ copy_debug.sparse_detection = SparseDebug::Zeros; // Default SparseDebug val for
+ // SparseMode::Always
+ if source_is_fifo {
+ copy_debug.offload = OffloadReflinkDebug::Avoided;
+
+ copy_fifo_contents(source, dest).map(|_| ())
+ } else {
+ let mut copy_method = CopyMethod::Default;
+ let result = handle_reflink_auto_sparse_always(source, dest);
+ if let Ok((debug, method)) = result {
+ copy_debug = debug;
+ copy_method = method;
+ }
+
+ match copy_method {
+ CopyMethod::FSCopy => clone(source, dest, CloneFallback::FSCopy),
+ _ => clone(source, dest, CloneFallback::SparseCopy),
+ }
+ }
+ }
+
+ (ReflinkMode::Auto, SparseMode::Never) => {
+ copy_debug.reflink = OffloadReflinkDebug::No;
+ if source_is_fifo {
+ copy_debug.offload = OffloadReflinkDebug::Avoided;
+ copy_fifo_contents(source, dest).map(|_| ())
+ } else {
+ let result = handle_reflink_auto_sparse_never(source);
+ if let Ok(debug) = result {
+ copy_debug = debug;
+ }
+
clone(source, dest, CloneFallback::FSCopy)
}
}
- (ReflinkMode::Always, SparseMode::Auto) => clone(source, dest, CloneFallback::Error),
+ (ReflinkMode::Auto, SparseMode::Auto) => {
+ if source_is_fifo {
+ copy_debug.offload = OffloadReflinkDebug::Unsupported;
+ copy_fifo_contents(source, dest).map(|_| ())
+ } else {
+ let mut copy_method = CopyMethod::Default;
+ let result = handle_reflink_auto_sparse_auto(source, dest);
+ if let Ok((debug, method)) = result {
+ copy_debug = debug;
+ copy_method = method;
+ }
+
+ match copy_method {
+ CopyMethod::SparseCopyWithoutHole => {
+ clone(source, dest, CloneFallback::SparseCopyWithoutHole)
+ }
+ _ => clone(source, dest, CloneFallback::FSCopy),
+ }
+ }
+ }
+
+ (ReflinkMode::Always, SparseMode::Auto) => {
+ copy_debug.sparse_detection = SparseDebug::No;
+ copy_debug.reflink = OffloadReflinkDebug::Yes;
+
+ clone(source, dest, CloneFallback::Error)
+ }
(ReflinkMode::Always, _) => {
return Err("`--reflink=always` can be used only with --sparse=auto".into())
}
};
result.context(context)?;
- Ok(())
+ Ok(copy_debug)
+}
+
+/// Handles debug results when flags are "--reflink=auto" and "--sparse=always" and specifies what
+/// type of copy should be used
+fn handle_reflink_auto_sparse_always(
+ source: &Path,
+ dest: &Path,
+) -> Result<(CopyDebug, CopyMethod), std::io::Error> {
+ let mut copy_debug = CopyDebug {
+ offload: OffloadReflinkDebug::Unknown,
+ reflink: OffloadReflinkDebug::Unsupported,
+ sparse_detection: SparseDebug::Zeros,
+ };
+ let mut copy_method = CopyMethod::Default;
+ let (data_flag, size, blocks) = check_for_data(source)?;
+ let sparse_flag = check_sparse_detection(source)?;
+
+ if data_flag || size < 512 {
+ copy_debug.offload = OffloadReflinkDebug::Avoided;
+ }
+ match (sparse_flag, data_flag, blocks) {
+ (true, true, 0) => {
+ // Handling funny files with 0 block allocation but has data
+ // in it
+ copy_method = CopyMethod::FSCopy;
+ copy_debug.sparse_detection = SparseDebug::SeekHoleZeros;
+ }
+ (false, true, 0) => copy_method = CopyMethod::FSCopy,
+
+ (true, false, 0) => copy_debug.sparse_detection = SparseDebug::SeekHole,
+ (true, true, _) => copy_debug.sparse_detection = SparseDebug::SeekHoleZeros,
+
+ (true, false, _) => copy_debug.sparse_detection = SparseDebug::SeekHole,
+
+ (_, _, _) => (),
+ }
+ if check_dest_is_fifo(dest) {
+ copy_method = CopyMethod::FSCopy;
+ }
+ Ok((copy_debug, copy_method))
+}
+
+/// Handles debug results when flags are "--reflink=auto" and "--sparse=auto" and specifies what
+/// type of copy should be used
+fn handle_reflink_never_sparse_never(source: &Path) -> Result<CopyDebug, std::io::Error> {
+ let mut copy_debug = CopyDebug {
+ offload: OffloadReflinkDebug::Unknown,
+ reflink: OffloadReflinkDebug::No,
+ sparse_detection: SparseDebug::No,
+ };
+ let (data_flag, size, _blocks) = check_for_data(source)?;
+ let sparse_flag = check_sparse_detection(source)?;
+
+ if sparse_flag {
+ copy_debug.sparse_detection = SparseDebug::SeekHole;
+ }
+
+ if data_flag || size < 512 {
+ copy_debug.offload = OffloadReflinkDebug::Avoided;
+ }
+ Ok(copy_debug)
+}
+
+/// Handles debug results when flags are "--reflink=auto" and "--sparse=never", files will be copied
+/// through cloning them with fallback switching to std::fs::copy
+fn handle_reflink_auto_sparse_never(source: &Path) -> Result<CopyDebug, std::io::Error> {
+ let mut copy_debug = CopyDebug {
+ offload: OffloadReflinkDebug::Unknown,
+ reflink: OffloadReflinkDebug::No,
+ sparse_detection: SparseDebug::No,
+ };
+
+ let (data_flag, size, _blocks) = check_for_data(source)?;
+ let sparse_flag = check_sparse_detection(source)?;
+
+ if sparse_flag {
+ copy_debug.sparse_detection = SparseDebug::SeekHole;
+ }
+
+ if data_flag || size < 512 {
+ copy_debug.offload = OffloadReflinkDebug::Avoided;
+ }
+ Ok(copy_debug)
+}
+
+/// Handles debug results when flags are "--reflink=auto" and "--sparse=auto" and specifies what
+/// type of copy should be used
+fn handle_reflink_auto_sparse_auto(
+ source: &Path,
+ dest: &Path,
+) -> Result<(CopyDebug, CopyMethod), std::io::Error> {
+ let mut copy_debug = CopyDebug {
+ offload: OffloadReflinkDebug::Unknown,
+ reflink: OffloadReflinkDebug::Unsupported,
+ sparse_detection: SparseDebug::No,
+ };
+
+ let mut copy_method = CopyMethod::Default;
+ let (data_flag, size, blocks) = check_for_data(source)?;
+ let sparse_flag = check_sparse_detection(source)?;
+
+ if (data_flag && size != 0) || (size > 0 && size < 512) {
+ copy_debug.offload = OffloadReflinkDebug::Yes;
+ }
+
+ if data_flag && size == 0 {
+ // Handling /proc/ files
+ copy_debug.offload = OffloadReflinkDebug::Unsupported;
+ }
+ if sparse_flag {
+ if blocks == 0 && data_flag {
+ // Handling other "virtual" files
+ copy_debug.offload = OffloadReflinkDebug::Unsupported;
+
+ copy_method = CopyMethod::FSCopy; // Doing a standard copy for the virtual files
+ } else {
+ copy_method = CopyMethod::SparseCopyWithoutHole;
+ } // Since sparse_flag is true, sparse_detection shall be SeekHole for any non virtual
+ // regular sparse file and the file will be sparsely copied
+ copy_debug.sparse_detection = SparseDebug::SeekHole;
+ }
+
+ if check_dest_is_fifo(dest) {
+ copy_method = CopyMethod::FSCopy;
+ }
+ Ok((copy_debug, copy_method))
+}
+
+/// Handles debug results when flags are "--reflink=never" and "--sparse=auto" and specifies what
+/// type of copy should be used
+fn handle_reflink_never_sparse_auto(
+ source: &Path,
+ dest: &Path,
+) -> Result<(CopyDebug, CopyMethod), std::io::Error> {
+ let mut copy_debug = CopyDebug {
+ offload: OffloadReflinkDebug::Unknown,
+ reflink: OffloadReflinkDebug::No,
+ sparse_detection: SparseDebug::No,
+ };
+
+ let (data_flag, size, blocks) = check_for_data(source)?;
+ let sparse_flag = check_sparse_detection(source)?;
+
+ let mut copy_method = CopyMethod::Default;
+ if data_flag || size < 512 {
+ copy_debug.offload = OffloadReflinkDebug::Avoided;
+ }
+
+ if sparse_flag {
+ if blocks == 0 && data_flag {
+ copy_method = CopyMethod::FSCopy; // Handles virtual files which have size > 0 but no
+ // disk allocation
+ } else {
+ copy_method = CopyMethod::SparseCopyWithoutHole; // Handles regular sparse-files
+ }
+ copy_debug.sparse_detection = SparseDebug::SeekHole;
+ }
+
+ if check_dest_is_fifo(dest) {
+ copy_method = CopyMethod::FSCopy;
+ }
+ Ok((copy_debug, copy_method))
+}
+
+/// Handles debug results when flags are "--reflink=never" and "--sparse=always" and specifies what
+/// type of copy should be used
+fn handle_reflink_never_sparse_always(
+ source: &Path,
+ dest: &Path,
+) -> Result<(CopyDebug, CopyMethod), std::io::Error> {
+ let mut copy_debug = CopyDebug {
+ offload: OffloadReflinkDebug::Unknown,
+ reflink: OffloadReflinkDebug::No,
+ sparse_detection: SparseDebug::Zeros,
+ };
+ let mut copy_method = CopyMethod::SparseCopy;
+
+ let (data_flag, size, blocks) = check_for_data(source)?;
+ let sparse_flag = check_sparse_detection(source)?;
+
+ if data_flag || size < 512 {
+ copy_debug.offload = OffloadReflinkDebug::Avoided;
+ }
+ match (sparse_flag, data_flag, blocks) {
+ (true, true, 0) => {
+ // Handling funny files with 0 block allocation but has data
+ // in it, e.g. files in /sys and other virtual files
+ copy_method = CopyMethod::FSCopy;
+ copy_debug.sparse_detection = SparseDebug::SeekHoleZeros;
+ }
+ (false, true, 0) => copy_method = CopyMethod::FSCopy, // Handling data containing zero sized
+ // files in /proc
+ (true, false, 0) => copy_debug.sparse_detection = SparseDebug::SeekHole, // Handles files
+ // with 0 blocks allocated in disk and
+ (true, true, _) => copy_debug.sparse_detection = SparseDebug::SeekHoleZeros, // Any
+ // sparse_files with data in it will display SeekHoleZeros
+ (true, false, _) => {
+ copy_debug.offload = OffloadReflinkDebug::Unknown;
+ copy_debug.sparse_detection = SparseDebug::SeekHole;
+ }
+
+ (_, _, _) => (),
+ }
+ if check_dest_is_fifo(dest) {
+ copy_method = CopyMethod::FSCopy;
+ }
+
+ Ok((copy_debug, copy_method))
}
diff --git a/src/uu/cp/src/platform/macos.rs b/src/uu/cp/src/platform/macos.rs
index 0aecc146658ca3ba5950b596910a8ad8537f9b61..77bdbbbdb8317571e9f336baea33759ab1fcef3f 100644
--- a/src/uu/cp/src/platform/macos.rs
+++ b/src/uu/cp/src/platform/macos.rs
@@ -1,7 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore reflink
use std::ffi::CString;
use std::fs::{self, File};
@@ -11,7 +11,7 @@ use std::path::Path;
use quick_error::ResultExt;
-use crate::{CopyResult, ReflinkMode, SparseMode};
+use crate::{CopyDebug, CopyResult, OffloadReflinkDebug, ReflinkMode, SparseDebug, SparseMode};
/// Copies `source` to `dest` using copy-on-write if possible.
///
@@ -24,10 +24,15 @@ pub(crate) fn copy_on_write(
sparse_mode: SparseMode,
context: &str,
source_is_fifo: bool,
-) -> CopyResult<()> {
+) -> CopyResult<CopyDebug> {
if sparse_mode != SparseMode::Auto {
return Err("--sparse is only supported on linux".to_string().into());
}
+ let mut copy_debug = CopyDebug {
+ offload: OffloadReflinkDebug::Unknown,
+ reflink: OffloadReflinkDebug::Unsupported,
+ sparse_detection: SparseDebug::Unsupported,
+ };
// Extract paths in a form suitable to be passed to a syscall.
// The unwrap() is safe because they come from the command-line and so contain non nul
@@ -58,8 +63,15 @@ pub(crate) fn copy_on_write(
{
// clonefile(2) fails if the destination exists. Remove it and try again. Do not
// bother to check if removal worked because we're going to try to clone again.
- let _ = fs::remove_file(dest);
- error = pfn(src.as_ptr(), dst.as_ptr(), 0);
+ // first lets make sure the dest file is not read only
+ if fs::metadata(dest).map_or(false, |md| !md.permissions().readonly()) {
+ // remove and copy again
+ // TODO: rewrite this to better match linux behavior
+ // linux first opens the source file and destination file then uses the file
+ // descriptors to do the clone.
+ let _ = fs::remove_file(dest);
+ error = pfn(src.as_ptr(), dst.as_ptr(), 0);
+ }
}
}
}
@@ -69,11 +81,10 @@ pub(crate) fn copy_on_write(
// support COW).
match reflink_mode {
ReflinkMode::Always => {
- return Err(
- format!("failed to clone {:?} from {:?}: {}", source, dest, error).into(),
- )
+ return Err(format!("failed to clone {source:?} from {dest:?}: {error}").into())
}
_ => {
+ copy_debug.reflink = OffloadReflinkDebug::Yes;
if source_is_fifo {
let mut src_file = File::open(source)?;
let mut dst_file = File::create(dest)?;
@@ -85,5 +96,5 @@ pub(crate) fn copy_on_write(
};
}
- Ok(())
+ Ok(copy_debug)
}
diff --git a/src/uu/cp/src/platform/mod.rs b/src/uu/cp/src/platform/mod.rs
index 9dbcefa806f96a8bd6b9543ed0a4eeacd33882f6..c794270686819034872f14a98684fff142ad5d18 100644
--- a/src/uu/cp/src/platform/mod.rs
+++ b/src/uu/cp/src/platform/mod.rs
@@ -1,7 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
#[cfg(target_os = "macos")]
mod macos;
#[cfg(target_os = "macos")]
diff --git a/src/uu/cp/src/platform/other.rs b/src/uu/cp/src/platform/other.rs
index b70da2f2341a3941442be21c62e6b152a247f9e6..7ca1a5ded7c46d0cc4e3f15f649994ee18780849 100644
--- a/src/uu/cp/src/platform/other.rs
+++ b/src/uu/cp/src/platform/other.rs
@@ -1,14 +1,14 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore reflink
use std::fs;
use std::path::Path;
use quick_error::ResultExt;
-use crate::{CopyResult, ReflinkMode, SparseMode};
+use crate::{CopyDebug, CopyResult, OffloadReflinkDebug, ReflinkMode, SparseDebug, SparseMode};
/// Copies `source` to `dest` for systems without copy-on-write
pub(crate) fn copy_on_write(
@@ -17,7 +17,7 @@ pub(crate) fn copy_on_write(
reflink_mode: ReflinkMode,
sparse_mode: SparseMode,
context: &str,
-) -> CopyResult<()> {
+) -> CopyResult<CopyDebug> {
if reflink_mode != ReflinkMode::Never {
return Err("--reflink is only supported on linux and macOS"
.to_string()
@@ -26,8 +26,12 @@ pub(crate) fn copy_on_write(
if sparse_mode != SparseMode::Auto {
return Err("--sparse is only supported on linux".to_string().into());
}
-
+ let copy_debug = CopyDebug {
+ offload: OffloadReflinkDebug::Unsupported,
+ reflink: OffloadReflinkDebug::Unsupported,
+ sparse_detection: SparseDebug::Unsupported,
+ };
fs::copy(source, dest).context(context)?;
- Ok(())
+ Ok(copy_debug)
}
diff --git a/src/uu/csplit/Cargo.toml b/src/uu/csplit/Cargo.toml
index e9406d4787631a68e029590bd19470785f78bf55..e616655abb37cfef4acd541f200d194f278f8930 100644
--- a/src/uu/csplit/Cargo.toml
+++ b/src/uu/csplit/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_csplit"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "csplit ~ (uutils) Output pieces of FILE separated by PATTERN(s) to files 'xx00', 'xx01', ..., and output byte counts of each piece to standard output"
@@ -15,10 +15,10 @@ edition = "2021"
path = "src/csplit.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-thiserror = "1.0"
-regex = "1.7.0"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["entries", "fs"] }
+clap = { workspace = true }
+thiserror = { workspace = true }
+regex = { workspace = true }
+uucore = { workspace = true, features = ["entries", "fs", "format"] }
[[bin]]
name = "csplit"
diff --git a/src/uu/csplit/csplit.md b/src/uu/csplit/csplit.md
new file mode 100644
index 0000000000000000000000000000000000000000..1d428fc8ee652f3d2c582d226518ca5909e57c2d
--- /dev/null
+++ b/src/uu/csplit/csplit.md
@@ -0,0 +1,11 @@
+# csplit
+
+```
+csplit [OPTION]... FILE PATTERN...
+```
+
+Split a file into sections determined by context lines
+
+## After Help
+
+Output pieces of FILE separated by PATTERN(s) to files 'xx00', 'xx01', ..., and output byte counts of each piece to standard output.
diff --git a/src/uu/csplit/src/csplit.rs b/src/uu/csplit/src/csplit.rs
index bfe2f9512813300953f82fdb07630f0345d4da33..7d625d925fa6cb22c418c22e9a0ee58e23f7c43c 100644
--- a/src/uu/csplit/src/csplit.rs
+++ b/src/uu/csplit/src/csplit.rs
@@ -1,4 +1,7 @@
-#![crate_name = "uu_csplit"]
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore rustdoc
#![allow(rustdoc::private_intra_doc_links)]
@@ -13,7 +16,7 @@ use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
use regex::Regex;
use uucore::display::Quotable;
use uucore::error::{FromIo, UResult};
-use uucore::{crash_if_err, format_usage};
+use uucore::{crash_if_err, format_usage, help_about, help_section, help_usage};
mod csplit_error;
mod patterns;
@@ -22,9 +25,9 @@ mod split_name;
use crate::csplit_error::CsplitError;
use crate::split_name::SplitName;
-static ABOUT: &str = "split a file into sections determined by context lines";
-static LONG_HELP: &str = "Output pieces of FILE separated by PATTERN(s) to files 'xx00', 'xx01', ..., and output byte counts of each piece to standard output.";
-const USAGE: &str = "{} [OPTION]... FILE PATTERN...";
+const ABOUT: &str = help_about!("csplit.md");
+const AFTER_HELP: &str = help_section!("after help", "csplit.md");
+const USAGE: &str = help_usage!("csplit.md");
mod options {
pub const SUFFIX_FORMAT: &str = "suffix-format";
@@ -58,15 +61,9 @@ impl CsplitOptions {
split_name: crash_if_err!(
1,
SplitName::new(
- matches
- .get_one::<String>(options::PREFIX)
- .map(|s| s.to_owned()),
- matches
- .get_one::<String>(options::SUFFIX_FORMAT)
- .map(|s| s.to_owned()),
- matches
- .get_one::<String>(options::DIGITS)
- .map(|s| s.to_owned())
+ matches.get_one::<String>(options::PREFIX).cloned(),
+ matches.get_one::<String>(options::SUFFIX_FORMAT).cloned(),
+ matches.get_one::<String>(options::DIGITS).cloned()
)
),
keep_files,
@@ -89,27 +86,26 @@ impl CsplitOptions {
/// - [`CsplitError::MatchNotFound`] if no line matched a regular expression.
/// - [`CsplitError::MatchNotFoundOnRepetition`], like previous but after applying the pattern
/// more than once.
-pub fn csplit<T>(
- options: &CsplitOptions,
- patterns: Vec<patterns::Pattern>,
- input: T,
-) -> Result<(), CsplitError>
+pub fn csplit<T>(options: &CsplitOptions, patterns: &[String], input: T) -> Result<(), CsplitError>
where
T: BufRead,
{
let mut input_iter = InputSplitter::new(input.lines().enumerate());
let mut split_writer = SplitWriter::new(options);
+ let patterns: Vec<patterns::Pattern> = patterns::get_patterns(patterns)?;
let ret = do_csplit(&mut split_writer, patterns, &mut input_iter);
- // consume the rest
- input_iter.rewind_buffer();
- if let Some((_, line)) = input_iter.next() {
- split_writer.new_writer()?;
- split_writer.writeln(&line?)?;
- for (_, line) in input_iter {
+ // consume the rest, unless there was an error
+ if ret.is_ok() {
+ input_iter.rewind_buffer();
+ if let Some((_, line)) = input_iter.next() {
+ split_writer.new_writer()?;
split_writer.writeln(&line?)?;
+ for (_, line) in input_iter {
+ split_writer.writeln(&line?)?;
+ }
+ split_writer.finish_split();
}
- split_writer.finish_split();
}
// delete files on error by default
if ret.is_err() && !options.keep_files {
@@ -127,7 +123,7 @@ where
I: Iterator<Item = (usize, io::Result<String>)>,
{
// split the file based on patterns
- for pattern in patterns.into_iter() {
+ for pattern in patterns {
let pattern_as_str = pattern.to_string();
let is_skip = matches!(pattern, patterns::Pattern::SkipToMatch(_, _, _));
match pattern {
@@ -356,6 +352,7 @@ impl<'a> SplitWriter<'a> {
/// - if no line matched, an [`CsplitError::MatchNotFound`].
/// - if there are not enough lines to accommodate the offset, an
/// [`CsplitError::LineOutOfRange`].
+ #[allow(clippy::cognitive_complexity)]
fn do_to_match<I>(
&mut self,
pattern_as_str: &str,
@@ -551,11 +548,113 @@ where
}
}
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+ let matches = uu_app().try_get_matches_from(args)?;
+
+ // get the file to split
+ let file_name = matches.get_one::<String>(options::FILE).unwrap();
+
+ // get the patterns to split on
+ let patterns: Vec<String> = matches
+ .get_many::<String>(options::PATTERN)
+ .unwrap()
+ .map(|s| s.to_string())
+ .collect();
+ let options = CsplitOptions::new(&matches);
+ if file_name == "-" {
+ let stdin = io::stdin();
+ Ok(csplit(&options, &patterns, stdin.lock())?)
+ } else {
+ let file = File::open(file_name)
+ .map_err_context(|| format!("cannot access {}", file_name.quote()))?;
+ let file_metadata = file
+ .metadata()
+ .map_err_context(|| format!("cannot access {}", file_name.quote()))?;
+ if !file_metadata.is_file() {
+ return Err(CsplitError::NotRegularFile(file_name.to_string()).into());
+ }
+ Ok(csplit(&options, &patterns, BufReader::new(file))?)
+ }
+}
+
+pub fn uu_app() -> Command {
+ Command::new(uucore::util_name())
+ .version(crate_version!())
+ .about(ABOUT)
+ .override_usage(format_usage(USAGE))
+ .args_override_self(true)
+ .infer_long_args(true)
+ .arg(
+ Arg::new(options::SUFFIX_FORMAT)
+ .short('b')
+ .long(options::SUFFIX_FORMAT)
+ .value_name("FORMAT")
+ .help("use sprintf FORMAT instead of %02d"),
+ )
+ .arg(
+ Arg::new(options::PREFIX)
+ .short('f')
+ .long(options::PREFIX)
+ .value_name("PREFIX")
+ .help("use PREFIX instead of 'xx'"),
+ )
+ .arg(
+ Arg::new(options::KEEP_FILES)
+ .short('k')
+ .long(options::KEEP_FILES)
+ .help("do not remove output files on errors")
+ .action(ArgAction::SetTrue),
+ )
+ .arg(
+ Arg::new(options::SUPPRESS_MATCHED)
+ .long(options::SUPPRESS_MATCHED)
+ .help("suppress the lines matching PATTERN")
+ .action(ArgAction::SetTrue),
+ )
+ .arg(
+ Arg::new(options::DIGITS)
+ .short('n')
+ .long(options::DIGITS)
+ .value_name("DIGITS")
+ .help("use specified number of digits instead of 2"),
+ )
+ .arg(
+ Arg::new(options::QUIET)
+ .short('s')
+ .long(options::QUIET)
+ .visible_alias("silent")
+ .help("do not print counts of output file sizes")
+ .action(ArgAction::SetTrue),
+ )
+ .arg(
+ Arg::new(options::ELIDE_EMPTY_FILES)
+ .short('z')
+ .long(options::ELIDE_EMPTY_FILES)
+ .help("remove empty output files")
+ .action(ArgAction::SetTrue),
+ )
+ .arg(
+ Arg::new(options::FILE)
+ .hide(true)
+ .required(true)
+ .value_hint(clap::ValueHint::FilePath),
+ )
+ .arg(
+ Arg::new(options::PATTERN)
+ .hide(true)
+ .action(clap::ArgAction::Append)
+ .required(true),
+ )
+ .after_help(AFTER_HELP)
+}
+
#[cfg(test)]
mod tests {
use super::*;
#[test]
+ #[allow(clippy::cognitive_complexity)]
fn input_splitter() {
let input = vec![
Ok(String::from("aaa")),
@@ -574,7 +673,7 @@ mod tests {
assert_eq!(input_splitter.add_line_to_buffer(0, line), None);
assert_eq!(input_splitter.buffer_len(), 1);
}
- item => panic!("wrong item: {:?}", item),
+ item => panic!("wrong item: {item:?}"),
};
match input_splitter.next() {
@@ -583,7 +682,7 @@ mod tests {
assert_eq!(input_splitter.add_line_to_buffer(1, line), None);
assert_eq!(input_splitter.buffer_len(), 2);
}
- item => panic!("wrong item: {:?}", item),
+ item => panic!("wrong item: {item:?}"),
};
match input_splitter.next() {
@@ -595,7 +694,7 @@ mod tests {
);
assert_eq!(input_splitter.buffer_len(), 2);
}
- item => panic!("wrong item: {:?}", item),
+ item => panic!("wrong item: {item:?}"),
};
input_splitter.rewind_buffer();
@@ -605,7 +704,7 @@ mod tests {
assert_eq!(line, String::from("bbb"));
assert_eq!(input_splitter.buffer_len(), 1);
}
- item => panic!("wrong item: {:?}", item),
+ item => panic!("wrong item: {item:?}"),
};
match input_splitter.next() {
@@ -613,7 +712,7 @@ mod tests {
assert_eq!(line, String::from("ccc"));
assert_eq!(input_splitter.buffer_len(), 0);
}
- item => panic!("wrong item: {:?}", item),
+ item => panic!("wrong item: {item:?}"),
};
match input_splitter.next() {
@@ -621,13 +720,14 @@ mod tests {
assert_eq!(line, String::from("ddd"));
assert_eq!(input_splitter.buffer_len(), 0);
}
- item => panic!("wrong item: {:?}", item),
+ item => panic!("wrong item: {item:?}"),
};
assert!(input_splitter.next().is_none());
}
#[test]
+ #[allow(clippy::cognitive_complexity)]
fn input_splitter_interrupt_rewind() {
let input = vec![
Ok(String::from("aaa")),
@@ -646,7 +746,7 @@ mod tests {
assert_eq!(input_splitter.add_line_to_buffer(0, line), None);
assert_eq!(input_splitter.buffer_len(), 1);
}
- item => panic!("wrong item: {:?}", item),
+ item => panic!("wrong item: {item:?}"),
};
match input_splitter.next() {
@@ -655,7 +755,7 @@ mod tests {
assert_eq!(input_splitter.add_line_to_buffer(1, line), None);
assert_eq!(input_splitter.buffer_len(), 2);
}
- item => panic!("wrong item: {:?}", item),
+ item => panic!("wrong item: {item:?}"),
};
match input_splitter.next() {
@@ -664,7 +764,7 @@ mod tests {
assert_eq!(input_splitter.add_line_to_buffer(2, line), None);
assert_eq!(input_splitter.buffer_len(), 3);
}
- item => panic!("wrong item: {:?}", item),
+ item => panic!("wrong item: {item:?}"),
};
input_splitter.rewind_buffer();
@@ -675,7 +775,7 @@ mod tests {
assert_eq!(input_splitter.add_line_to_buffer(0, line), None);
assert_eq!(input_splitter.buffer_len(), 3);
}
- item => panic!("wrong item: {:?}", item),
+ item => panic!("wrong item: {item:?}"),
};
match input_splitter.next() {
@@ -683,7 +783,7 @@ mod tests {
assert_eq!(line, String::from("aaa"));
assert_eq!(input_splitter.buffer_len(), 2);
}
- item => panic!("wrong item: {:?}", item),
+ item => panic!("wrong item: {item:?}"),
};
match input_splitter.next() {
@@ -691,7 +791,7 @@ mod tests {
assert_eq!(line, String::from("bbb"));
assert_eq!(input_splitter.buffer_len(), 1);
}
- item => panic!("wrong item: {:?}", item),
+ item => panic!("wrong item: {item:?}"),
};
match input_splitter.next() {
@@ -699,7 +799,7 @@ mod tests {
assert_eq!(line, String::from("ccc"));
assert_eq!(input_splitter.buffer_len(), 0);
}
- item => panic!("wrong item: {:?}", item),
+ item => panic!("wrong item: {item:?}"),
};
match input_splitter.next() {
@@ -707,112 +807,9 @@ mod tests {
assert_eq!(line, String::from("ddd"));
assert_eq!(input_splitter.buffer_len(), 0);
}
- item => panic!("wrong item: {:?}", item),
+ item => panic!("wrong item: {item:?}"),
};
assert!(input_splitter.next().is_none());
}
}
-
-#[uucore::main]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_ignore();
-
- let matches = uu_app().try_get_matches_from(args)?;
-
- // get the file to split
- let file_name = matches.get_one::<String>(options::FILE).unwrap();
-
- // get the patterns to split on
- let patterns: Vec<String> = matches
- .get_many::<String>(options::PATTERN)
- .unwrap()
- .map(|s| s.to_string())
- .collect();
- let patterns = patterns::get_patterns(&patterns[..])?;
- let options = CsplitOptions::new(&matches);
- if file_name == "-" {
- let stdin = io::stdin();
- Ok(csplit(&options, patterns, stdin.lock())?)
- } else {
- let file = File::open(file_name)
- .map_err_context(|| format!("cannot access {}", file_name.quote()))?;
- let file_metadata = file
- .metadata()
- .map_err_context(|| format!("cannot access {}", file_name.quote()))?;
- if !file_metadata.is_file() {
- return Err(CsplitError::NotRegularFile(file_name.to_string()).into());
- }
- Ok(csplit(&options, patterns, BufReader::new(file))?)
- }
-}
-
-pub fn uu_app() -> Command {
- Command::new(uucore::util_name())
- .version(crate_version!())
- .about(ABOUT)
- .override_usage(format_usage(USAGE))
- .infer_long_args(true)
- .arg(
- Arg::new(options::SUFFIX_FORMAT)
- .short('b')
- .long(options::SUFFIX_FORMAT)
- .value_name("FORMAT")
- .help("use sprintf FORMAT instead of %02d"),
- )
- .arg(
- Arg::new(options::PREFIX)
- .short('f')
- .long(options::PREFIX)
- .value_name("PREFIX")
- .help("use PREFIX instead of 'xx'"),
- )
- .arg(
- Arg::new(options::KEEP_FILES)
- .short('k')
- .long(options::KEEP_FILES)
- .help("do not remove output files on errors")
- .action(ArgAction::SetTrue),
- )
- .arg(
- Arg::new(options::SUPPRESS_MATCHED)
- .long(options::SUPPRESS_MATCHED)
- .help("suppress the lines matching PATTERN")
- .action(ArgAction::SetTrue),
- )
- .arg(
- Arg::new(options::DIGITS)
- .short('n')
- .long(options::DIGITS)
- .value_name("DIGITS")
- .help("use specified number of digits instead of 2"),
- )
- .arg(
- Arg::new(options::QUIET)
- .short('s')
- .long(options::QUIET)
- .visible_alias("silent")
- .help("do not print counts of output file sizes")
- .action(ArgAction::SetTrue),
- )
- .arg(
- Arg::new(options::ELIDE_EMPTY_FILES)
- .short('z')
- .long(options::ELIDE_EMPTY_FILES)
- .help("remove empty output files")
- .action(ArgAction::SetTrue),
- )
- .arg(
- Arg::new(options::FILE)
- .hide(true)
- .required(true)
- .value_hint(clap::ValueHint::FilePath),
- )
- .arg(
- Arg::new(options::PATTERN)
- .hide(true)
- .action(clap::ArgAction::Append)
- .required(true),
- )
- .after_help(LONG_HELP)
-}
diff --git a/src/uu/csplit/src/csplit_error.rs b/src/uu/csplit/src/csplit_error.rs
index b81a331a226140e0e583837f21b358f189ad440d..4a83b637b0779b69979175ea11beb8e3a9aa9680 100644
--- a/src/uu/csplit/src/csplit_error.rs
+++ b/src/uu/csplit/src/csplit_error.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::io;
use thiserror::Error;
@@ -17,7 +21,7 @@ pub enum CsplitError {
MatchNotFound(String),
#[error("{}: match not found on repetition {}", ._0.quote(), _1)]
MatchNotFoundOnRepetition(String, usize),
- #[error("line number must be greater than zero")]
+ #[error("0: line number must be greater than zero")]
LineNumberIsZero,
#[error("line number '{}' is smaller than preceding line number, {}", _0, _1)]
LineNumberSmallerThanPrevious(usize, usize),
diff --git a/src/uu/csplit/src/patterns.rs b/src/uu/csplit/src/patterns.rs
index 36679496331360777f03e905f5b6c5fbf203ab5c..bd6c4fbfaefc01ae2be692e1fbdb5403ee0db327 100644
--- a/src/uu/csplit/src/patterns.rs
+++ b/src/uu/csplit/src/patterns.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (regex) SKIPTO UPTO ; (vars) ntimes
use crate::csplit_error::CsplitError;
@@ -21,14 +25,14 @@ pub enum Pattern {
SkipToMatch(Regex, i32, ExecutePattern),
}
-impl ToString for Pattern {
- fn to_string(&self) -> String {
+impl std::fmt::Display for Pattern {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
- Self::UpToLine(n, _) => n.to_string(),
- Self::UpToMatch(regex, 0, _) => format!("/{}/", regex.as_str()),
- Self::UpToMatch(regex, offset, _) => format!("/{}/{:+}", regex.as_str(), offset),
- Self::SkipToMatch(regex, 0, _) => format!("%{}%", regex.as_str()),
- Self::SkipToMatch(regex, offset, _) => format!("%{}%{:+}", regex.as_str(), offset),
+ Self::UpToLine(n, _) => write!(f, "{n}"),
+ Self::UpToMatch(regex, 0, _) => write!(f, "/{}/", regex.as_str()),
+ Self::UpToMatch(regex, offset, _) => write!(f, "/{}/{:+}", regex.as_str(), offset),
+ Self::SkipToMatch(regex, 0, _) => write!(f, "%{}%", regex.as_str()),
+ Self::SkipToMatch(regex, offset, _) => write!(f, "%{}%{:+}", regex.as_str(), offset),
}
}
}
@@ -192,7 +196,7 @@ mod tests {
.collect();
let patterns = get_patterns(input.as_slice()).unwrap();
assert_eq!(patterns.len(), 3);
- match patterns.get(0) {
+ match patterns.first() {
Some(Pattern::UpToLine(24, ExecutePattern::Times(1))) => (),
_ => panic!("expected UpToLine pattern"),
};
@@ -207,6 +211,7 @@ mod tests {
}
#[test]
+ #[allow(clippy::cognitive_complexity)]
fn up_to_match_pattern() {
let input: Vec<String> = vec![
"/test1.*end$/",
@@ -222,37 +227,37 @@ mod tests {
.collect();
let patterns = get_patterns(input.as_slice()).unwrap();
assert_eq!(patterns.len(), 5);
- match patterns.get(0) {
+ match patterns.first() {
Some(Pattern::UpToMatch(reg, 0, ExecutePattern::Times(1))) => {
- let parsed_reg = format!("{}", reg);
+ let parsed_reg = format!("{reg}");
assert_eq!(parsed_reg, "test1.*end$");
}
_ => panic!("expected UpToMatch pattern"),
};
match patterns.get(1) {
Some(Pattern::UpToMatch(reg, 0, ExecutePattern::Always)) => {
- let parsed_reg = format!("{}", reg);
+ let parsed_reg = format!("{reg}");
assert_eq!(parsed_reg, "test2.*end$");
}
_ => panic!("expected UpToMatch pattern"),
};
match patterns.get(2) {
Some(Pattern::UpToMatch(reg, 0, ExecutePattern::Times(5))) => {
- let parsed_reg = format!("{}", reg);
+ let parsed_reg = format!("{reg}");
assert_eq!(parsed_reg, "test3.*end$");
}
_ => panic!("expected UpToMatch pattern"),
};
match patterns.get(3) {
Some(Pattern::UpToMatch(reg, 3, ExecutePattern::Times(1))) => {
- let parsed_reg = format!("{}", reg);
+ let parsed_reg = format!("{reg}");
assert_eq!(parsed_reg, "test4.*end$");
}
_ => panic!("expected UpToMatch pattern"),
};
match patterns.get(4) {
Some(Pattern::UpToMatch(reg, -3, ExecutePattern::Times(1))) => {
- let parsed_reg = format!("{}", reg);
+ let parsed_reg = format!("{reg}");
assert_eq!(parsed_reg, "test5.*end$");
}
_ => panic!("expected UpToMatch pattern"),
@@ -260,6 +265,7 @@ mod tests {
}
#[test]
+ #[allow(clippy::cognitive_complexity)]
fn skip_to_match_pattern() {
let input: Vec<String> = vec![
"%test1.*end$%",
@@ -275,37 +281,37 @@ mod tests {
.collect();
let patterns = get_patterns(input.as_slice()).unwrap();
assert_eq!(patterns.len(), 5);
- match patterns.get(0) {
+ match patterns.first() {
Some(Pattern::SkipToMatch(reg, 0, ExecutePattern::Times(1))) => {
- let parsed_reg = format!("{}", reg);
+ let parsed_reg = format!("{reg}");
assert_eq!(parsed_reg, "test1.*end$");
}
_ => panic!("expected SkipToMatch pattern"),
};
match patterns.get(1) {
Some(Pattern::SkipToMatch(reg, 0, ExecutePattern::Always)) => {
- let parsed_reg = format!("{}", reg);
+ let parsed_reg = format!("{reg}");
assert_eq!(parsed_reg, "test2.*end$");
}
_ => panic!("expected SkipToMatch pattern"),
};
match patterns.get(2) {
Some(Pattern::SkipToMatch(reg, 0, ExecutePattern::Times(5))) => {
- let parsed_reg = format!("{}", reg);
+ let parsed_reg = format!("{reg}");
assert_eq!(parsed_reg, "test3.*end$");
}
_ => panic!("expected SkipToMatch pattern"),
};
match patterns.get(3) {
Some(Pattern::SkipToMatch(reg, 3, ExecutePattern::Times(1))) => {
- let parsed_reg = format!("{}", reg);
+ let parsed_reg = format!("{reg}");
assert_eq!(parsed_reg, "test4.*end$");
}
_ => panic!("expected SkipToMatch pattern"),
};
match patterns.get(4) {
Some(Pattern::SkipToMatch(reg, -3, ExecutePattern::Times(1))) => {
- let parsed_reg = format!("{}", reg);
+ let parsed_reg = format!("{reg}");
assert_eq!(parsed_reg, "test5.*end$");
}
_ => panic!("expected SkipToMatch pattern"),
diff --git a/src/uu/csplit/src/split_name.rs b/src/uu/csplit/src/split_name.rs
index e7776c330e215df95fbbbb4e6be317f4d446b006..e2432f3ce10439ec80c1f7e62a4d1789c27d89cb 100644
--- a/src/uu/csplit/src/split_name.rs
+++ b/src/uu/csplit/src/split_name.rs
@@ -1,13 +1,18 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (regex) diuox
-use regex::Regex;
+use uucore::format::{num_format::UnsignedInt, Format, FormatError};
use crate::csplit_error::CsplitError;
/// Computes the filename of a split, taking into consideration a possible user-defined suffix
/// format.
pub struct SplitName {
- fn_split_name: Box<dyn Fn(usize) -> String>,
+ prefix: Vec<u8>,
+ format: Format<UnsignedInt>,
}
impl SplitName {
@@ -32,6 +37,7 @@ impl SplitName {
) -> Result<Self, CsplitError> {
// get the prefix
let prefix = prefix_opt.unwrap_or_else(|| "xx".to_string());
+
// the width for the split offset
let n_digits = n_digits_opt
.map(|opt| {
@@ -40,122 +46,29 @@ impl SplitName {
})
.transpose()?
.unwrap_or(2);
- // translate the custom format into a function
- let fn_split_name: Box<dyn Fn(usize) -> String> = match format_opt {
- None => Box::new(move |n: usize| -> String {
- format!("{}{:0width$}", prefix, n, width = n_digits)
- }),
- Some(custom) => {
- let spec =
- Regex::new(r"(?P<ALL>%((?P<FLAG>[0#-])(?P<WIDTH>\d+)?)?(?P<TYPE>[diuoxX]))")
- .unwrap();
- let mut captures_iter = spec.captures_iter(&custom);
- let custom_fn: Box<dyn Fn(usize) -> String> = match captures_iter.next() {
- Some(captures) => {
- let all = captures.name("ALL").unwrap();
- let before = custom[0..all.start()].to_owned();
- let after = custom[all.end()..].to_owned();
- let width = match captures.name("WIDTH") {
- None => 0,
- Some(m) => m.as_str().parse::<usize>().unwrap(),
- };
- match (captures.name("FLAG"), captures.name("TYPE")) {
- (None, Some(ref t)) => match t.as_str() {
- "d" | "i" | "u" => Box::new(move |n: usize| -> String {
- format!("{}{}{}{}", prefix, before, n, after)
- }),
- "o" => Box::new(move |n: usize| -> String {
- format!("{}{}{:o}{}", prefix, before, n, after)
- }),
- "x" => Box::new(move |n: usize| -> String {
- format!("{}{}{:x}{}", prefix, before, n, after)
- }),
- "X" => Box::new(move |n: usize| -> String {
- format!("{}{}{:X}{}", prefix, before, n, after)
- }),
- _ => return Err(CsplitError::SuffixFormatIncorrect),
- },
- (Some(ref f), Some(ref t)) => {
- match (f.as_str(), t.as_str()) {
- /*
- * zero padding
- */
- // decimal
- ("0", "d" | "i" | "u") => Box::new(move |n: usize| -> String {
- format!("{}{}{:0width$}{}", prefix, before, n, after)
- }),
- // octal
- ("0", "o") => Box::new(move |n: usize| -> String {
- format!("{}{}{:0width$o}{}", prefix, before, n, after)
- }),
- // lower hexadecimal
- ("0", "x") => Box::new(move |n: usize| -> String {
- format!("{}{}{:0width$x}{}", prefix, before, n, after)
- }),
- // upper hexadecimal
- ("0", "X") => Box::new(move |n: usize| -> String {
- format!("{}{}{:0width$X}{}", prefix, before, n, after)
- }),
-
- /*
- * Alternate form
- */
- // octal
- ("#", "o") => Box::new(move |n: usize| -> String {
- format!("{}{}{:>#width$o}{}", prefix, before, n, after)
- }),
- // lower hexadecimal
- ("#", "x") => Box::new(move |n: usize| -> String {
- format!("{}{}{:>#width$x}{}", prefix, before, n, after)
- }),
- // upper hexadecimal
- ("#", "X") => Box::new(move |n: usize| -> String {
- format!("{}{}{:>#width$X}{}", prefix, before, n, after)
- }),
-
- /*
- * Left adjusted
- */
- // decimal
- ("-", "d" | "i" | "u") => Box::new(move |n: usize| -> String {
- format!("{}{}{:<#width$}{}", prefix, before, n, after)
- }),
- // octal
- ("-", "o") => Box::new(move |n: usize| -> String {
- format!("{}{}{:<#width$o}{}", prefix, before, n, after)
- }),
- // lower hexadecimal
- ("-", "x") => Box::new(move |n: usize| -> String {
- format!("{}{}{:<#width$x}{}", prefix, before, n, after)
- }),
- // upper hexadecimal
- ("-", "X") => Box::new(move |n: usize| -> String {
- format!("{}{}{:<#width$X}{}", prefix, before, n, after)
- }),
-
- _ => return Err(CsplitError::SuffixFormatIncorrect),
- }
- }
- _ => return Err(CsplitError::SuffixFormatIncorrect),
- }
- }
- None => return Err(CsplitError::SuffixFormatIncorrect),
- };
-
- // there cannot be more than one format pattern
- if captures_iter.next().is_some() {
- return Err(CsplitError::SuffixFormatTooManyPercents);
- }
- custom_fn
- }
+
+ let format_string = match format_opt {
+ Some(f) => f,
+ None => format!("%0{n_digits}u"),
};
- Ok(Self { fn_split_name })
+ let format = match Format::<UnsignedInt>::parse(format_string) {
+ Ok(format) => Ok(format),
+ Err(FormatError::TooManySpecs(_)) => Err(CsplitError::SuffixFormatTooManyPercents),
+ Err(_) => Err(CsplitError::SuffixFormatIncorrect),
+ }?;
+
+ Ok(Self {
+ prefix: prefix.as_bytes().to_owned(),
+ format,
+ })
}
/// Returns the filename of the i-th split.
pub fn get(&self, n: usize) -> String {
- (self.fn_split_name)(n)
+ let mut v = self.prefix.clone();
+ self.format.fmt(&mut v, n as u64).unwrap();
+ String::from_utf8_lossy(&v).to_string()
}
}
@@ -277,7 +190,7 @@ mod tests {
#[test]
fn alternate_form_octal() {
let split_name = SplitName::new(None, Some(String::from("cst-%#10o-")), None).unwrap();
- assert_eq!(split_name.get(42), "xxcst- 0o52-");
+ assert_eq!(split_name.get(42), "xxcst- 052-");
}
#[test]
@@ -289,7 +202,7 @@ mod tests {
#[test]
fn alternate_form_upper_hex() {
let split_name = SplitName::new(None, Some(String::from("cst-%#10X-")), None).unwrap();
- assert_eq!(split_name.get(42), "xxcst- 0x2A-");
+ assert_eq!(split_name.get(42), "xxcst- 0X2A-");
}
#[test]
@@ -313,19 +226,19 @@ mod tests {
#[test]
fn left_adjusted_octal() {
let split_name = SplitName::new(None, Some(String::from("cst-%-10o-")), None).unwrap();
- assert_eq!(split_name.get(42), "xxcst-0o52 -");
+ assert_eq!(split_name.get(42), "xxcst-52 -");
}
#[test]
fn left_adjusted_lower_hex() {
let split_name = SplitName::new(None, Some(String::from("cst-%-10x-")), None).unwrap();
- assert_eq!(split_name.get(42), "xxcst-0x2a -");
+ assert_eq!(split_name.get(42), "xxcst-2a -");
}
#[test]
fn left_adjusted_upper_hex() {
let split_name = SplitName::new(None, Some(String::from("cst-%-10X-")), None).unwrap();
- assert_eq!(split_name.get(42), "xxcst-0x2A -");
+ assert_eq!(split_name.get(42), "xxcst-2A -");
}
#[test]
diff --git a/src/uu/cut/BENCHMARKING.md b/src/uu/cut/BENCHMARKING.md
index bd94cf93cf96f712119a3781e8360fc8a547970a..0455b55fb1c11d75019f29250d4a0746c172c8eb 100644
--- a/src/uu/cut/BENCHMARKING.md
+++ b/src/uu/cut/BENCHMARKING.md
@@ -1,46 +1,45 @@
-## Benchmarking cut
+# Benchmarking cut
-### Performance profile
+## Performance profile
In normal use cases a significant amount of the total execution time of `cut`
is spent performing I/O. When invoked with the `-f` option (cut fields) some
CPU time is spent on detecting fields (in `Searcher::next`). Other than that
some small amount of CPU time is spent on breaking the input stream into lines.
-
-### How to
+## How to
When fixing bugs or adding features you might want to compare
performance before and after your code changes.
-- `hyperfine` can be used to accurately measure and compare the total
+- `hyperfine` can be used to accurately measure and compare the total
execution time of one or more commands.
- ```
- $ cargo build --release --package uu_cut
+ ```shell
+ cargo build --release --package uu_cut
- $ hyperfine -w3 "./target/release/cut -f2-4,8 -d' ' input.txt" "cut -f2-4,8 -d' ' input.txt"
+ hyperfine -w3 "./target/release/cut -f2-4,8 -d' ' input.txt" "cut -f2-4,8 -d' ' input.txt"
```
+
You can put those two commands in a shell script to be sure that you don't
forget to build after making any changes.
When optimizing or fixing performance regressions seeing the number of times a
function is called, and the amount of time it takes can be useful.
-- `cargo flamegraph` generates flame graphs from function level metrics it records using `perf` or `dtrace`
+- `cargo flamegraph` generates flame graphs from function level metrics it records using `perf` or `dtrace`
+ ```shell
+ cargo flamegraph --bin cut --package uu_cut -- -f1,3-4 input.txt > /dev/null
```
- $ cargo flamegraph --bin cut --package uu_cut -- -f1,3-4 input.txt > /dev/null
- ```
-
-### What to benchmark
+## What to benchmark
There are four different performance paths in `cut` to benchmark.
-- Byte ranges `-c`/`--characters` or `-b`/`--bytes` e.g. `cut -c 2,4,6-`
-- Byte ranges with output delimiters e.g. `cut -c 4- --output-delimiter=/`
-- Fields e.g. `cut -f -4`
-- Fields with output delimiters e.g. `cut -f 7-10 --output-delimiter=:`
+- Byte ranges `-c`/`--characters` or `-b`/`--bytes` e.g. `cut -c 2,4,6-`
+- Byte ranges with output delimiters e.g. `cut -c 4- --output-delimiter=/`
+- Fields e.g. `cut -f -4`
+- Fields with output delimiters e.g. `cut -f 7-10 --output-delimiter=:`
Choose a test input file with large number of lines so that program startup time does not significantly affect the benchmark.
diff --git a/src/uu/cut/Cargo.toml b/src/uu/cut/Cargo.toml
index 9a4a0b950d78965db86186706d09e9a1b9f2acb3..5a3602ce603f8926a0c3fa3088a43a11cde1a91d 100644
--- a/src/uu/cut/Cargo.toml
+++ b/src/uu/cut/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_cut"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "cut ~ (uutils) display byte/field columns of input lines"
@@ -15,11 +15,10 @@ edition = "2021"
path = "src/cut.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
-memchr = "2"
-bstr = "1.0"
-atty = "0.2"
+clap = { workspace = true }
+uucore = { workspace = true, features = ["ranges"] }
+memchr = { workspace = true }
+bstr = { workspace = true }
[[bin]]
name = "cut"
diff --git a/src/uu/cut/cut.md b/src/uu/cut/cut.md
new file mode 100644
index 0000000000000000000000000000000000000000..5c21d23dcf9246ea7e48aed24493fb95dbfb07d8
--- /dev/null
+++ b/src/uu/cut/cut.md
@@ -0,0 +1,112 @@
+# cut
+
+<!-- spell-checker:ignore sourcefile sourcefiles -->
+
+```
+cut OPTION... [FILE]...
+```
+
+Prints specified byte or field columns from each line of stdin or the input files
+
+## After Help
+
+Each call must specify a mode (what to use for columns),
+a sequence (which columns to print), and provide a data source
+
+### Specifying a mode
+
+Use `--bytes` (`-b`) or `--characters` (`-c`) to specify byte mode
+
+Use `--fields` (`-f`) to specify field mode, where each line is broken into
+fields identified by a delimiter character. For example for a typical CSV
+you could use this in combination with setting comma as the delimiter
+
+### Specifying a sequence
+
+A sequence is a group of 1 or more numbers or inclusive ranges separated
+by a commas.
+
+```
+cut -f 2,5-7 some_file.txt
+```
+
+will display the 2nd, 5th, 6th, and 7th field for each source line
+
+Ranges can extend to the end of the row by excluding the second number
+
+```
+cut -f 3- some_file.txt
+```
+
+will display the 3rd field and all fields after for each source line
+
+The first number of a range can be excluded, and this is effectively the
+same as using 1 as the first number: it causes the range to begin at the
+first column. Ranges can also display a single column
+
+```
+cut -f 1,3-5 some_file.txt
+```
+
+will display the 1st, 3rd, 4th, and 5th field for each source line
+
+The `--complement` option, when used, inverts the effect of the sequence
+
+```
+cut --complement -f 4-6 some_file.txt
+```
+
+will display the every field but the 4th, 5th, and 6th
+
+### Specifying a data source
+
+If no `sourcefile` arguments are specified, stdin is used as the source of
+lines to print
+
+If `sourcefile` arguments are specified, stdin is ignored and all files are
+read in consecutively if a `sourcefile` is not successfully read, a warning
+will print to stderr, and the eventual status code will be 1, but cut
+will continue to read through proceeding `sourcefiles`
+
+To print columns from both STDIN and a file argument, use `-` (dash) as a
+`sourcefile` argument to represent stdin.
+
+### Field Mode options
+
+The fields in each line are identified by a delimiter (separator)
+
+#### Set the delimiter
+
+Set the delimiter which separates fields in the file using the
+`--delimiter` (`-d`) option. Setting the delimiter is optional.
+If not set, a default delimiter of Tab will be used.
+
+If the `-w` option is provided, fields will be separated by any number
+of whitespace characters (Space and Tab). The output delimiter will
+be a Tab unless explicitly specified. Only one of `-d` or `-w` option can be specified.
+This is an extension adopted from FreeBSD.
+
+#### Optionally Filter based on delimiter
+
+If the `--only-delimited` (`-s`) flag is provided, only lines which
+contain the delimiter will be printed
+
+#### Replace the delimiter
+
+If the `--output-delimiter` option is provided, the argument used for
+it will replace the delimiter character in each line printed. This is
+useful for transforming tabular data - e.g. to convert a CSV to a
+TSV (tab-separated file)
+
+### Line endings
+
+When the `--zero-terminated` (`-z`) option is used, cut sees \\0 (null) as the
+'line ending' character (both for the purposes of reading lines and
+separating printed lines) instead of \\n (newline). This is useful for
+tabular data where some of the cells may contain newlines
+
+```
+echo 'ab\\0cd' | cut -z -c 1
+```
+
+will result in 'a\\0c\\0'
diff --git a/src/uu/cut/src/cut.rs b/src/uu/cut/src/cut.rs
index 6b49045334491ad8f1641b7541877dbeefbde4fc..35152c85b66eed7e093cdf7a361610008811593a 100644
--- a/src/uu/cut/src/cut.rs
+++ b/src/uu/cut/src/cut.rs
@@ -1,142 +1,70 @@
// This file is part of the uutils coreutils package.
//
-// (c) Rolf Morel <rolfmorel@gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
// spell-checker:ignore (ToDO) delim sourcefiles
use bstr::io::BufReadExt;
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{builder::ValueParser, crate_version, Arg, ArgAction, ArgMatches, Command};
+use std::ffi::OsString;
use std::fs::File;
-use std::io::{stdin, stdout, BufReader, BufWriter, Read, Write};
+use std::io::{stdin, stdout, BufReader, BufWriter, IsTerminal, Read, Write};
+#[cfg(unix)]
+use std::os::unix::ffi::OsStrExt;
use std::path::Path;
use uucore::display::Quotable;
-use uucore::error::{FromIo, UResult, USimpleError};
+use uucore::error::{set_exit_code, FromIo, UResult, USimpleError};
+use uucore::line_ending::LineEnding;
use self::searcher::Searcher;
-use self::whitespace_searcher::WhitespaceSearcher;
+use matcher::{ExactMatcher, Matcher, WhitespaceMatcher};
use uucore::ranges::Range;
-use uucore::{format_usage, show, show_error, show_if_err};
+use uucore::{format_usage, help_about, help_section, help_usage, show_error, show_if_err};
+mod matcher;
mod searcher;
-mod whitespace_searcher;
-
-static USAGE: &str =
- "{} [-d|-w] [-s] [-z] [--output-delimiter] ((-f|-b|-c) {{sequence}}) {{sourcefile}}+";
-static ABOUT: &str =
- "Prints specified byte or field columns from each line of stdin or the input files";
-static LONG_HELP: &str = "
- Each call must specify a mode (what to use for columns),
- a sequence (which columns to print), and provide a data source
-
- Specifying a mode
-
- Use --bytes (-b) or --characters (-c) to specify byte mode
-
- Use --fields (-f) to specify field mode, where each line is broken into
- fields identified by a delimiter character. For example for a typical CSV
- you could use this in combination with setting comma as the delimiter
-
- Specifying a sequence
-
- A sequence is a group of 1 or more numbers or inclusive ranges separated
- by a commas.
-
- cut -f 2,5-7 some_file.txt
- will display the 2nd, 5th, 6th, and 7th field for each source line
-
- Ranges can extend to the end of the row by excluding the the second number
-
- cut -f 3- some_file.txt
- will display the 3rd field and all fields after for each source line
-
- The first number of a range can be excluded, and this is effectively the
- same as using 1 as the first number: it causes the range to begin at the
- first column. Ranges can also display a single column
-
- cut -f 1,3-5 some_file.txt
- will display the 1st, 3rd, 4th, and 5th field for each source line
-
- The --complement option, when used, inverts the effect of the sequence
-
- cut --complement -f 4-6 some_file.txt
- will display the every field but the 4th, 5th, and 6th
-
- Specifying a data source
-
- If no sourcefile arguments are specified, stdin is used as the source of
- lines to print
-
- If sourcefile arguments are specified, stdin is ignored and all files are
- read in consecutively if a sourcefile is not successfully read, a warning
- will print to stderr, and the eventual status code will be 1, but cut
- will continue to read through proceeding sourcefiles
- To print columns from both STDIN and a file argument, use - (dash) as a
- sourcefile argument to represent stdin.
+const USAGE: &str = help_usage!("cut.md");
+const ABOUT: &str = help_about!("cut.md");
+const AFTER_HELP: &str = help_section!("after help", "cut.md");
- Field Mode options
-
- The fields in each line are identified by a delimiter (separator)
-
- Set the delimiter
- Set the delimiter which separates fields in the file using the
- --delimiter (-d) option. Setting the delimiter is optional.
- If not set, a default delimiter of Tab will be used.
-
- If the -w option is provided, fields will be separated by any number
- of whitespace characters (Space and Tab). The output delimiter will
- be a Tab unless explicitly specified. Only one of -d or -w option can be specified.
- This is an extension adopted from FreeBSD.
-
- Optionally Filter based on delimiter
- If the --only-delimited (-s) flag is provided, only lines which
- contain the delimiter will be printed
-
- Replace the delimiter
- If the --output-delimiter option is provided, the argument used for
- it will replace the delimiter character in each line printed. This is
- useful for transforming tabular data - e.g. to convert a CSV to a
- TSV (tab-separated file)
-
- Line endings
-
- When the --zero-terminated (-z) option is used, cut sees \\0 (null) as the
- 'line ending' character (both for the purposes of reading lines and
- separating printed lines) instead of \\n (newline). This is useful for
- tabular data where some of the cells may contain newlines
-
- echo 'ab\\0cd' | cut -z -c 1
- will result in 'a\\0c\\0'
-";
-
-struct Options {
- out_delim: Option<String>,
- zero_terminated: bool,
+struct Options<'a> {
+ out_delimiter: Option<&'a [u8]>,
+ line_ending: LineEnding,
+ field_opts: Option<FieldOptions<'a>>,
}
-enum Delimiter {
+enum Delimiter<'a> {
Whitespace,
- String(String), // FIXME: use char?
+ Slice(&'a [u8]),
}
-struct FieldOptions {
- delimiter: Delimiter,
- out_delimiter: Option<String>,
+struct FieldOptions<'a> {
+ delimiter: Delimiter<'a>,
only_delimited: bool,
- zero_terminated: bool,
}
-enum Mode {
- Bytes(Vec<Range>, Options),
- Characters(Vec<Range>, Options),
- Fields(Vec<Range>, FieldOptions),
+enum Mode<'a> {
+ Bytes(Vec<Range>, Options<'a>),
+ Characters(Vec<Range>, Options<'a>),
+ Fields(Vec<Range>, Options<'a>),
+}
+
+impl Default for Delimiter<'_> {
+ fn default() -> Self {
+ Self::Slice(b"\t")
+ }
+}
+
+impl<'a> From<&'a OsString> for Delimiter<'a> {
+ fn from(s: &'a OsString) -> Self {
+ Self::Slice(os_string_as_bytes(s).unwrap())
+ }
}
fn stdout_writer() -> Box<dyn Write> {
- if atty::is(atty::Stream::Stdout) {
+ if std::io::stdout().is_terminal() {
Box::new(stdout())
} else {
Box::new(BufWriter::new(stdout())) as Box<dyn Write>
@@ -152,14 +80,10 @@ fn list_to_ranges(list: &str, complement: bool) -> Result<Vec<Range>, String> {
}
fn cut_bytes<R: Read>(reader: R, ranges: &[Range], opts: &Options) -> UResult<()> {
- let newline_char = if opts.zero_terminated { b'\0' } else { b'\n' };
+ let newline_char = opts.line_ending.into();
let mut buf_in = BufReader::new(reader);
let mut out = stdout_writer();
- let delim = opts
- .out_delim
- .as_ref()
- .map_or("", String::as_str)
- .as_bytes();
+ let out_delim = opts.out_delimiter.unwrap_or(b"\t");
let result = buf_in.for_byte_record(newline_char, |line| {
let mut print_delim = false;
@@ -168,8 +92,8 @@ fn cut_bytes<R: Read>(reader: R, ranges: &[Range], opts: &Options) -> UResult<()
break;
}
if print_delim {
- out.write_all(delim)?;
- } else if opts.out_delim.is_some() {
+ out.write_all(out_delim)?;
+ } else if opts.out_delimiter.is_some() {
print_delim = true;
}
// change `low` from 1-indexed value to 0-index value
@@ -188,23 +112,22 @@ fn cut_bytes<R: Read>(reader: R, ranges: &[Range], opts: &Options) -> UResult<()
Ok(())
}
-#[allow(clippy::cognitive_complexity)]
-fn cut_fields_delimiter<R: Read>(
+// Output delimiter is explicitly specified
+fn cut_fields_explicit_out_delim<R: Read, M: Matcher>(
reader: R,
+ matcher: &M,
ranges: &[Range],
- delim: &str,
only_delimited: bool,
newline_char: u8,
- out_delim: &str,
+ out_delim: &[u8],
) -> UResult<()> {
let mut buf_in = BufReader::new(reader);
let mut out = stdout_writer();
- let input_delim_len = delim.len();
let result = buf_in.for_byte_record_with_terminator(newline_char, |line| {
let mut fields_pos = 1;
let mut low_idx = 0;
- let mut delim_search = Searcher::new(line, delim.as_bytes()).peekable();
+ let mut delim_search = Searcher::new(matcher, line).peekable();
let mut print_delim = false;
if delim_search.peek().is_none() {
@@ -220,29 +143,35 @@ fn cut_fields_delimiter<R: Read>(
for &Range { low, high } in ranges {
if low - fields_pos > 0 {
+ // current field is not in the range, so jump to the field corresponding to the
+ // beginning of the range if any
low_idx = match delim_search.nth(low - fields_pos - 1) {
- Some(index) => index + input_delim_len,
+ Some((_, last)) => last,
None => break,
};
}
+ // at this point, current field is the first in the range
for _ in 0..=high - low {
+ // skip printing delimiter if this is the first matching field for this line
if print_delim {
- out.write_all(out_delim.as_bytes())?;
+ out.write_all(out_delim)?;
} else {
print_delim = true;
}
match delim_search.next() {
- Some(high_idx) => {
- let segment = &line[low_idx..high_idx];
+ // print the current field up to the next field delim
+ Some((first, last)) => {
+ let segment = &line[low_idx..first];
out.write_all(segment)?;
- low_idx = high_idx + input_delim_len;
+ low_idx = last;
fields_pos = high + 1;
}
None => {
+ // this is the last field in the line, so print the rest
let segment = &line[low_idx..];
out.write_all(segment)?;
@@ -267,12 +196,13 @@ fn cut_fields_delimiter<R: Read>(
Ok(())
}
-fn cut_fields_whitespace<R: Read>(
+// Output delimiter is the same as input delimiter
+fn cut_fields_implicit_out_delim<R: Read, M: Matcher>(
reader: R,
+ matcher: &M,
ranges: &[Range],
only_delimited: bool,
newline_char: u8,
- out_delim: &str,
) -> UResult<()> {
let mut buf_in = BufReader::new(reader);
let mut out = stdout_writer();
@@ -280,7 +210,7 @@ fn cut_fields_whitespace<R: Read>(
let result = buf_in.for_byte_record_with_terminator(newline_char, |line| {
let mut fields_pos = 1;
let mut low_idx = 0;
- let mut delim_search = WhitespaceSearcher::new(line).peekable();
+ let mut delim_search = Searcher::new(matcher, line).peekable();
let mut print_delim = false;
if delim_search.peek().is_none() {
@@ -293,54 +223,38 @@ fn cut_fields_whitespace<R: Read>(
return Ok(true);
}
- // The logic is identical to `cut_fields_delimiter` function above, which uses
- // `Searcher` that iterates over and returns the first position of the delimiter character.
- // The main difference is that `WhitespaceSearcher` returns a pair of the first and last
- // delimiter character positions, since each delimiter sequence length can vary.
+
for &Range { low, high } in ranges {
if low - fields_pos > 0 {
- // current field is not in the range, so jump to the field corresponding to the
- // beginning of the range if any
- low_idx = match delim_search.nth(low - fields_pos - 1) {
- Some((_, last)) => last,
- None => break,
- };
- }
-
- // at this point, current field is the first in the range
- for _ in 0..=high - low {
- // skip printing delimiter if this is the first matching field for this line
- if print_delim {
- out.write_all(out_delim.as_bytes())?;
+ if let Some((first, last)) = delim_search.nth(low - fields_pos - 1) {
+ low_idx = if print_delim { first } else { last }
} else {
- print_delim = true;
+ break;
}
+ }
- match delim_search.next() {
- // print the current field up to the next whitespace
- Some((first, last)) => {
- let segment = &line[low_idx..first];
+ match delim_search.nth(high - low) {
+ Some((first, _)) => {
+ let segment = &line[low_idx..first];
- out.write_all(segment)?;
+ out.write_all(segment)?;
- low_idx = last;
- fields_pos = high + 1;
- }
- None => {
- // this is the last field in the line, so print the rest
- let segment = &line[low_idx..];
+ print_delim = true;
+ low_idx = first;
+ fields_pos = high + 1;
+ }
+ None => {
+ let segment = &line[low_idx..line.len()];
- out.write_all(segment)?;
+ out.write_all(segment)?;
- if line[line.len() - 1] == newline_char {
- return Ok(true);
- }
- break;
+ if line[line.len() - 1] == newline_char {
+ return Ok(true);
}
+ break;
}
}
}
-
out.write_all(&[newline_char])?;
Ok(true)
});
@@ -352,93 +266,40 @@ fn cut_fields_whitespace<R: Read>(
Ok(())
}
-fn cut_fields<R: Read>(reader: R, ranges: &[Range], opts: &FieldOptions) -> UResult<()> {
- let newline_char = if opts.zero_terminated { b'\0' } else { b'\n' };
- match opts.delimiter {
- Delimiter::Whitespace => cut_fields_whitespace(
- reader,
- ranges,
- opts.only_delimited,
- newline_char,
- opts.out_delimiter.as_deref().unwrap_or("\t"),
- ),
- Delimiter::String(ref delimiter) => {
- if let Some(ref o_delim) = opts.out_delimiter {
- return cut_fields_delimiter(
+fn cut_fields<R: Read>(reader: R, ranges: &[Range], opts: &Options) -> UResult<()> {
+ let newline_char = opts.line_ending.into();
+ let field_opts = opts.field_opts.as_ref().unwrap(); // it is safe to unwrap() here - field_opts will always be Some() for cut_fields() call
+ match field_opts.delimiter {
+ Delimiter::Slice(delim) => {
+ let matcher = ExactMatcher::new(delim);
+ match opts.out_delimiter {
+ Some(out_delim) => cut_fields_explicit_out_delim(
reader,
+ &matcher,
ranges,
- delimiter,
- opts.only_delimited,
+ field_opts.only_delimited,
newline_char,
- o_delim,
- );
- }
-
- let mut buf_in = BufReader::new(reader);
- let mut out = stdout_writer();
- let delim_len = delimiter.len();
-
- let result = buf_in.for_byte_record_with_terminator(newline_char, |line| {
- let mut fields_pos = 1;
- let mut low_idx = 0;
- let mut delim_search = Searcher::new(line, delimiter.as_bytes()).peekable();
- let mut print_delim = false;
-
- if delim_search.peek().is_none() {
- if !opts.only_delimited {
- out.write_all(line)?;
- if line[line.len() - 1] != newline_char {
- out.write_all(&[newline_char])?;
- }
- }
-
- return Ok(true);
- }
-
- for &Range { low, high } in ranges {
- if low - fields_pos > 0 {
- if let Some(delim_pos) = delim_search.nth(low - fields_pos - 1) {
- low_idx = if print_delim {
- delim_pos
- } else {
- delim_pos + delim_len
- }
- } else {
- break;
- }
- }
-
- match delim_search.nth(high - low) {
- Some(high_idx) => {
- let segment = &line[low_idx..high_idx];
-
- out.write_all(segment)?;
-
- print_delim = true;
- low_idx = high_idx;
- fields_pos = high + 1;
- }
- None => {
- let segment = &line[low_idx..line.len()];
-
- out.write_all(segment)?;
-
- if line[line.len() - 1] == newline_char {
- return Ok(true);
- }
- break;
- }
- }
- }
- out.write_all(&[newline_char])?;
- Ok(true)
- });
-
- if let Err(e) = result {
- return Err(USimpleError::new(1, e.to_string()));
+ out_delim,
+ ),
+ None => cut_fields_implicit_out_delim(
+ reader,
+ &matcher,
+ ranges,
+ field_opts.only_delimited,
+ newline_char,
+ ),
}
-
- Ok(())
+ }
+ Delimiter::Whitespace => {
+ let matcher = WhitespaceMatcher {};
+ cut_fields_explicit_out_delim(
+ reader,
+ &matcher,
+ ranges,
+ field_opts.only_delimited,
+ newline_char,
+ opts.out_delimiter.unwrap_or(b"\t"),
+ )
}
}
}
@@ -468,6 +329,7 @@ fn cut_files(mut filenames: Vec<String>, mode: &Mode) {
if path.is_dir() {
show_error!("{}: Is a directory", filename.maybe_quote());
+ set_exit_code(1);
continue;
}
@@ -485,6 +347,87 @@ fn cut_files(mut filenames: Vec<String>, mode: &Mode) {
}
}
+// Helper function for processing delimiter values (which could be non UTF-8)
+// It converts OsString to &[u8] for unix targets only
+// On non-unix (i.e. Windows) it will just return an error if delimiter value is not UTF-8
+fn os_string_as_bytes(os_string: &OsString) -> UResult<&[u8]> {
+ #[cfg(unix)]
+ let bytes = os_string.as_bytes();
+
+ #[cfg(not(unix))]
+ let bytes = os_string
+ .to_str()
+ .ok_or_else(|| {
+ uucore::error::UUsageError::new(
+ 1,
+ "invalid UTF-8 was detected in one or more arguments",
+ )
+ })?
+ .as_bytes();
+
+ Ok(bytes)
+}
+
+// Get delimiter and output delimiter from `-d`/`--delimiter` and `--output-delimiter` options respectively
+// Allow either delimiter to have a value that is neither UTF-8 nor ASCII to align with GNU behavior
+fn get_delimiters(
+ matches: &ArgMatches,
+ delimiter_is_equal: bool,
+) -> UResult<(Delimiter, Option<&[u8]>)> {
+ let whitespace_delimited = matches.get_flag(options::WHITESPACE_DELIMITED);
+ let delim_opt = matches.get_one::<OsString>(options::DELIMITER);
+ let delim = match delim_opt {
+ Some(_) if whitespace_delimited => {
+ return Err(USimpleError::new(
+ 1,
+ "invalid input: Only one of --delimiter (-d) or -w option can be specified",
+ ));
+ }
+ Some(os_string) => {
+ // GNU's `cut` supports `-d=` to set the delimiter to `=`.
+ // Clap parsing is limited in this situation, see:
+ // https://github.com/uutils/coreutils/issues/2424#issuecomment-863825242
+ if delimiter_is_equal {
+ Delimiter::Slice(b"=")
+ } else if os_string == "''" || os_string.is_empty() {
+ // treat `''` as empty delimiter
+ Delimiter::Slice(b"\0")
+ } else {
+ // For delimiter `-d` option value - allow both UTF-8 (possibly multi-byte) characters
+ // and Non UTF-8 (and not ASCII) single byte "characters", like `b"\xAD"` to align with GNU behavior
+ let bytes = os_string_as_bytes(os_string)?;
+ if os_string.to_str().is_some_and(|s| s.chars().count() > 1)
+ || os_string.to_str().is_none() && bytes.len() > 1
+ {
+ return Err(USimpleError::new(
+ 1,
+ "the delimiter must be a single character",
+ ));
+ } else {
+ Delimiter::from(os_string)
+ }
+ }
+ }
+ None => {
+ if whitespace_delimited {
+ Delimiter::Whitespace
+ } else {
+ Delimiter::default()
+ }
+ }
+ };
+ let out_delim = matches
+ .get_one::<OsString>(options::OUTPUT_DELIMITER)
+ .map(|os_string| {
+ if os_string.is_empty() || os_string == "''" {
+ b"\0"
+ } else {
+ os_string_as_bytes(os_string).unwrap()
+ }
+ });
+ Ok((delim, out_delim))
+}
+
mod options {
pub const BYTES: &str = "bytes";
pub const CHARACTERS: &str = "characters";
@@ -500,115 +443,68 @@ mod options {
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_ignore();
+ let args = args.collect::<Vec<OsString>>();
- let delimiter_is_equal = args.contains(&"-d=".to_string()); // special case
+ let delimiter_is_equal = args.contains(&OsString::from("-d=")); // special case
let matches = uu_app().try_get_matches_from(args)?;
let complement = matches.get_flag(options::COMPLEMENT);
+ let only_delimited = matches.get_flag(options::ONLY_DELIMITED);
+
+ let (delimiter, out_delimiter) = get_delimiters(&matches, delimiter_is_equal)?;
+ let line_ending = LineEnding::from_zero_flag(matches.get_flag(options::ZERO_TERMINATED));
+
+ // Only one, and only one of cutting mode arguments, i.e. `-b`, `-c`, `-f`,
+ // is expected. The number of those arguments is used for parsing a cutting
+ // mode and handling the error cases.
+ let mode_args_count = [
+ matches.indices_of(options::BYTES),
+ matches.indices_of(options::CHARACTERS),
+ matches.indices_of(options::FIELDS),
+ ]
+ .into_iter()
+ .map(|indices| indices.unwrap_or_default().count())
+ .sum();
let mode_parse = match (
+ mode_args_count,
matches.get_one::<String>(options::BYTES),
matches.get_one::<String>(options::CHARACTERS),
matches.get_one::<String>(options::FIELDS),
) {
- (Some(byte_ranges), None, None) => list_to_ranges(byte_ranges, complement).map(|ranges| {
+ (1, Some(byte_ranges), None, None) => list_to_ranges(byte_ranges, complement).map(|ranges| {
Mode::Bytes(
ranges,
Options {
- out_delim: Some(
- matches
- .get_one::<String>(options::OUTPUT_DELIMITER)
- .map(|s| s.as_str())
- .unwrap_or_default()
- .to_owned(),
- ),
- zero_terminated: matches.get_flag(options::ZERO_TERMINATED),
+ out_delimiter,
+ line_ending,
+ field_opts: None,
},
)
}),
- (None, Some(char_ranges), None) => list_to_ranges(char_ranges, complement).map(|ranges| {
+ (1, None, Some(char_ranges), None) => list_to_ranges(char_ranges, complement).map(|ranges| {
Mode::Characters(
ranges,
Options {
- out_delim: Some(
- matches
- .get_one::<String>(options::OUTPUT_DELIMITER)
- .map(|s| s.as_str())
- .unwrap_or_default()
- .to_owned(),
- ),
- zero_terminated: matches.get_flag(options::ZERO_TERMINATED),
+ out_delimiter,
+ line_ending,
+ field_opts: None,
},
)
}),
- (None, None, Some(field_ranges)) => {
- list_to_ranges(field_ranges, complement).and_then(|ranges| {
- let out_delim = match matches.get_one::<String>(options::OUTPUT_DELIMITER) {
- Some(s) => {
- if s.is_empty() {
- Some("\0".to_owned())
- } else {
- Some(s.to_owned())
- }
- }
- None => None,
- };
-
- let only_delimited = matches.get_flag(options::ONLY_DELIMITED);
- let whitespace_delimited = matches.get_flag(options::WHITESPACE_DELIMITED);
- let zero_terminated = matches.get_flag(options::ZERO_TERMINATED);
-
- match matches.get_one::<String>(options::DELIMITER).map(|s| s.as_str()) {
- Some(_) if whitespace_delimited => {
- Err("invalid input: Only one of --delimiter (-d) or -w option can be specified".into())
- }
- Some(mut delim) => {
- // GNU's `cut` supports `-d=` to set the delimiter to `=`.
- // Clap parsing is limited in this situation, see:
- // https://github.com/uutils/coreutils/issues/2424#issuecomment-863825242
- if delimiter_is_equal {
- delim = "=";
- } else if delim == "''" {
- // treat `''` as empty delimiter
- delim = "";
- }
- if delim.chars().count() > 1 {
- Err("invalid input: The '--delimiter' ('-d') option expects empty or 1 character long, but was provided a value 2 characters or longer".into())
- } else {
- let delim = if delim.is_empty() {
- "\0".to_owned()
- } else {
- delim.to_owned()
- };
-
- Ok(Mode::Fields(
- ranges,
- FieldOptions {
- delimiter: Delimiter::String(delim),
- out_delimiter: out_delim,
- only_delimited,
- zero_terminated,
- },
- ))
- }
- }
- None => Ok(Mode::Fields(
- ranges,
- FieldOptions {
- delimiter: match whitespace_delimited {
- true => Delimiter::Whitespace,
- false => Delimiter::String("\t".to_owned()),
- },
- out_delimiter: out_delim,
- only_delimited,
- zero_terminated,
- },
- )),
- }
- })
- }
- (ref b, ref c, ref f) if b.is_some() || c.is_some() || f.is_some() => Err(
+ (1, None, None, Some(field_ranges)) => list_to_ranges(field_ranges, complement).map(|ranges| {
+ Mode::Fields(
+ ranges,
+ Options {
+ out_delimiter,
+ line_ending,
+ field_opts: Some(FieldOptions {
+ only_delimited,
+ delimiter,
+ })},
+ )
+ }),
+ (2.., _, _, _) => Err(
"invalid usage: expects no more than one of --fields (-f), --chars (-c) or --bytes (-b)".into()
),
_ => Err("invalid usage: expects one of --fields (-f), --chars (-c) or --bytes (-b)".into()),
@@ -639,7 +535,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let files: Vec<String> = matches
.get_many::<String>(options::FILE)
.unwrap_or_default()
- .map(|s| s.to_owned())
+ .cloned()
.collect();
match mode_parse {
@@ -656,15 +552,24 @@ pub fn uu_app() -> Command {
.version(crate_version!())
.override_usage(format_usage(USAGE))
.about(ABOUT)
- .after_help(LONG_HELP)
+ .after_help(AFTER_HELP)
.infer_long_args(true)
+ // While `args_override_self(true)` for some arguments, such as `-d`
+ // and `--output-delimiter`, is consistent to the behavior of GNU cut,
+ // arguments related to cutting mode, i.e. `-b`, `-c`, `-f`, should
+ // cause an error when there is more than one of them, as described in
+ // the manual of GNU cut: "Use one, and only one of -b, -c or -f".
+ // `ArgAction::Append` is used on `-b`, `-c`, `-f` arguments, so that
+ // the occurrences of those could be counted and be handled accordingly.
+ .args_override_self(true)
.arg(
Arg::new(options::BYTES)
.short('b')
.long(options::BYTES)
.help("filter byte columns from the input source")
.allow_hyphen_values(true)
- .value_name("LIST"),
+ .value_name("LIST")
+ .action(ArgAction::Append),
)
.arg(
Arg::new(options::CHARACTERS)
@@ -672,12 +577,14 @@ pub fn uu_app() -> Command {
.long(options::CHARACTERS)
.help("alias for character mode")
.allow_hyphen_values(true)
- .value_name("LIST"),
+ .value_name("LIST")
+ .action(ArgAction::Append),
)
.arg(
Arg::new(options::DELIMITER)
.short('d')
.long(options::DELIMITER)
+ .value_parser(ValueParser::os_string())
.help("specify the delimiter character that separates fields in the input source. Defaults to Tab.")
.value_name("DELIM"),
)
@@ -694,7 +601,8 @@ pub fn uu_app() -> Command {
.long(options::FIELDS)
.help("filter field columns from the input source")
.allow_hyphen_values(true)
- .value_name("LIST"),
+ .value_name("LIST")
+ .action(ArgAction::Append),
)
.arg(
Arg::new(options::COMPLEMENT)
@@ -719,6 +627,7 @@ pub fn uu_app() -> Command {
.arg(
Arg::new(options::OUTPUT_DELIMITER)
.long(options::OUTPUT_DELIMITER)
+ .value_parser(ValueParser::os_string())
.help("in field mode, replace the delimiter in output lines with this option's argument")
.value_name("NEW_DELIM"),
)
diff --git a/src/uu/cut/src/matcher.rs b/src/uu/cut/src/matcher.rs
new file mode 100644
index 0000000000000000000000000000000000000000..953e083b139608ee399b9f407c0ad584864fbf4f
--- /dev/null
+++ b/src/uu/cut/src/matcher.rs
@@ -0,0 +1,126 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use memchr::{memchr, memchr2};
+
+// Find the next matching byte sequence positions
+// Return (first, last) where haystack[first..last] corresponds to the matched pattern
+pub trait Matcher {
+ fn next_match(&self, haystack: &[u8]) -> Option<(usize, usize)>;
+}
+
+// Matches for the exact byte sequence pattern
+pub struct ExactMatcher<'a> {
+ needle: &'a [u8],
+}
+
+impl<'a> ExactMatcher<'a> {
+ pub fn new(needle: &'a [u8]) -> Self {
+ assert!(!needle.is_empty());
+ Self { needle }
+ }
+}
+
+impl<'a> Matcher for ExactMatcher<'a> {
+ fn next_match(&self, haystack: &[u8]) -> Option<(usize, usize)> {
+ let mut pos = 0usize;
+ loop {
+ match memchr(self.needle[0], &haystack[pos..]) {
+ Some(match_idx) => {
+ let match_idx = match_idx + pos; // account for starting from pos
+ if self.needle.len() == 1
+ || haystack[match_idx + 1..].starts_with(&self.needle[1..])
+ {
+ return Some((match_idx, match_idx + self.needle.len()));
+ } else {
+ pos = match_idx + 1;
+ }
+ }
+ None => {
+ return None;
+ }
+ }
+ }
+ }
+}
+
+// Matches for any number of SPACE or TAB
+pub struct WhitespaceMatcher {}
+
+impl Matcher for WhitespaceMatcher {
+ fn next_match(&self, haystack: &[u8]) -> Option<(usize, usize)> {
+ match memchr2(b' ', b'\t', haystack) {
+ Some(match_idx) => {
+ let mut skip = match_idx + 1;
+ while skip < haystack.len() {
+ match haystack[skip] {
+ b' ' | b'\t' => skip += 1,
+ _ => break,
+ }
+ }
+ Some((match_idx, skip))
+ }
+ None => None,
+ }
+ }
+}
+
+#[cfg(test)]
+mod matcher_tests {
+
+ use super::*;
+
+ #[test]
+ fn test_exact_matcher_single_byte() {
+ let matcher = ExactMatcher::new(":".as_bytes());
+ // spell-checker:disable
+ assert_eq!(matcher.next_match("".as_bytes()), None);
+ assert_eq!(matcher.next_match(":".as_bytes()), Some((0, 1)));
+ assert_eq!(matcher.next_match(":abcxyz".as_bytes()), Some((0, 1)));
+ assert_eq!(matcher.next_match("abc:xyz".as_bytes()), Some((3, 4)));
+ assert_eq!(matcher.next_match("abcxyz:".as_bytes()), Some((6, 7)));
+ assert_eq!(matcher.next_match("abcxyz".as_bytes()), None);
+ // spell-checker:enable
+ }
+
+ #[test]
+ fn test_exact_matcher_multi_bytes() {
+ let matcher = ExactMatcher::new("<>".as_bytes());
+ // spell-checker:disable
+ assert_eq!(matcher.next_match("".as_bytes()), None);
+ assert_eq!(matcher.next_match("<>".as_bytes()), Some((0, 2)));
+ assert_eq!(matcher.next_match("<>abcxyz".as_bytes()), Some((0, 2)));
+ assert_eq!(matcher.next_match("abc<>xyz".as_bytes()), Some((3, 5)));
+ assert_eq!(matcher.next_match("abcxyz<>".as_bytes()), Some((6, 8)));
+ assert_eq!(matcher.next_match("abcxyz".as_bytes()), None);
+ // spell-checker:enable
+ }
+
+ #[test]
+ fn test_whitespace_matcher_single_space() {
+ let matcher = WhitespaceMatcher {};
+ // spell-checker:disable
+ assert_eq!(matcher.next_match("".as_bytes()), None);
+ assert_eq!(matcher.next_match(" ".as_bytes()), Some((0, 1)));
+ assert_eq!(matcher.next_match("\tabcxyz".as_bytes()), Some((0, 1)));
+ assert_eq!(matcher.next_match("abc\txyz".as_bytes()), Some((3, 4)));
+ assert_eq!(matcher.next_match("abcxyz ".as_bytes()), Some((6, 7)));
+ assert_eq!(matcher.next_match("abcxyz".as_bytes()), None);
+ // spell-checker:enable
+ }
+
+ #[test]
+ fn test_whitespace_matcher_multi_spaces() {
+ let matcher = WhitespaceMatcher {};
+ // spell-checker:disable
+ assert_eq!(matcher.next_match("".as_bytes()), None);
+ assert_eq!(matcher.next_match(" \t ".as_bytes()), Some((0, 3)));
+ assert_eq!(matcher.next_match("\t\tabcxyz".as_bytes()), Some((0, 2)));
+ assert_eq!(matcher.next_match("abc \txyz".as_bytes()), Some((3, 5)));
+ assert_eq!(matcher.next_match("abcxyz ".as_bytes()), Some((6, 8)));
+ assert_eq!(matcher.next_match("abcxyz".as_bytes()), None);
+ // spell-checker:enable
+ }
+}
diff --git a/src/uu/cut/src/searcher.rs b/src/uu/cut/src/searcher.rs
index d8a0404512f4a448b202ea9bb75f3f25d2eb4bba..21424790eea2345db72d13deef659604805cc2ed 100644
--- a/src/uu/cut/src/searcher.rs
+++ b/src/uu/cut/src/searcher.rs
@@ -1,86 +1,79 @@
// This file is part of the uutils coreutils package.
//
-// (c) Rolf Morel <rolfmorel@gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
-use memchr::memchr;
+// spell-checker:ignore multispace
+
+use super::matcher::Matcher;
-pub struct Searcher<'a> {
- haystack: &'a [u8],
- needle: &'a [u8],
+// Generic searcher that relies on a specific matcher
+pub struct Searcher<'a, 'b, M: Matcher> {
+ matcher: &'a M,
+ haystack: &'b [u8],
position: usize,
}
-impl<'a> Searcher<'a> {
- pub fn new(haystack: &'a [u8], needle: &'a [u8]) -> Searcher<'a> {
- assert!(!needle.is_empty());
- Searcher {
+impl<'a, 'b, M: Matcher> Searcher<'a, 'b, M> {
+ pub fn new(matcher: &'a M, haystack: &'b [u8]) -> Self {
+ Self {
+ matcher,
haystack,
- needle,
position: 0,
}
}
}
-impl<'a> Iterator for Searcher<'a> {
- type Item = usize;
+// Iterate over field delimiters
+// Returns (first, last) positions of each sequence, where `haystack[first..last]`
+// corresponds to the delimiter.
+impl<'a, 'b, M: Matcher> Iterator for Searcher<'a, 'b, M> {
+ type Item = (usize, usize);
fn next(&mut self) -> Option<Self::Item> {
- loop {
- if let Some(match_idx) = memchr(self.needle[0], self.haystack) {
- if self.needle.len() == 1
- || self.haystack[match_idx + 1..].starts_with(&self.needle[1..])
- {
- let match_pos = self.position + match_idx;
- let skip = match_idx + self.needle.len();
- self.haystack = &self.haystack[skip..];
- self.position += skip;
- return Some(match_pos);
- } else {
- let skip = match_idx + 1;
- self.haystack = &self.haystack[skip..];
- self.position += skip;
- // continue
- }
- } else {
- return None;
+ match self.matcher.next_match(&self.haystack[self.position..]) {
+ Some((first, last)) => {
+ let result = (first + self.position, last + self.position);
+ self.position += last;
+ Some(result)
}
+ None => None,
}
}
}
#[cfg(test)]
-mod tests {
+mod exact_searcher_tests {
+ use super::super::matcher::ExactMatcher;
use super::*;
- const NEEDLE: &[u8] = "ab".as_bytes();
-
#[test]
fn test_normal() {
- let iter = Searcher::new("a.a.a".as_bytes(), "a".as_bytes());
- let items: Vec<usize> = iter.collect();
- assert_eq!(vec![0, 2, 4], items);
+ let matcher = ExactMatcher::new("a".as_bytes());
+ let iter = Searcher::new(&matcher, "a.a.a".as_bytes());
+ let items: Vec<(usize, usize)> = iter.collect();
+ assert_eq!(vec![(0, 1), (2, 3), (4, 5)], items);
}
#[test]
fn test_empty() {
- let iter = Searcher::new("".as_bytes(), "a".as_bytes());
- let items: Vec<usize> = iter.collect();
- assert_eq!(vec![] as Vec<usize>, items);
+ let matcher = ExactMatcher::new("a".as_bytes());
+ let iter = Searcher::new(&matcher, "".as_bytes());
+ let items: Vec<(usize, usize)> = iter.collect();
+ assert_eq!(vec![] as Vec<(usize, usize)>, items);
}
- fn test_multibyte(line: &[u8], expected: &[usize]) {
- let iter = Searcher::new(line, NEEDLE);
- let items: Vec<usize> = iter.collect();
+ fn test_multibyte(line: &[u8], expected: &[(usize, usize)]) {
+ let matcher = ExactMatcher::new("ab".as_bytes());
+ let iter = Searcher::new(&matcher, line);
+ let items: Vec<(usize, usize)> = iter.collect();
assert_eq!(expected, items);
}
#[test]
fn test_multibyte_normal() {
- test_multibyte("...ab...ab...".as_bytes(), &[3, 8]);
+ test_multibyte("...ab...ab...".as_bytes(), &[(3, 5), (8, 10)]);
}
#[test]
@@ -90,16 +83,101 @@ mod tests {
#[test]
fn test_multibyte_starting_needle() {
- test_multibyte("ab...ab...".as_bytes(), &[0, 5]);
+ test_multibyte("ab...ab...".as_bytes(), &[(0, 2), (5, 7)]);
}
#[test]
fn test_multibyte_trailing_needle() {
- test_multibyte("...ab...ab".as_bytes(), &[3, 8]);
+ test_multibyte("...ab...ab".as_bytes(), &[(3, 5), (8, 10)]);
}
#[test]
fn test_multibyte_first_byte_false_match() {
- test_multibyte("aA..aCaC..ab..aD".as_bytes(), &[10]);
+ test_multibyte("aA..aCaC..ab..aD".as_bytes(), &[(10, 12)]);
+ }
+
+ #[test]
+ fn test_searcher_with_exact_matcher() {
+ let matcher = ExactMatcher::new("<>".as_bytes());
+ let haystack = "<><>a<>b<><>cd<><>".as_bytes();
+ let mut searcher = Searcher::new(&matcher, haystack);
+ assert_eq!(searcher.next(), Some((0, 2)));
+ assert_eq!(searcher.next(), Some((2, 4)));
+ assert_eq!(searcher.next(), Some((5, 7)));
+ assert_eq!(searcher.next(), Some((8, 10)));
+ assert_eq!(searcher.next(), Some((10, 12)));
+ assert_eq!(searcher.next(), Some((14, 16)));
+ assert_eq!(searcher.next(), Some((16, 18)));
+ assert_eq!(searcher.next(), None);
+ assert_eq!(searcher.next(), None);
+ }
+}
+
+#[cfg(test)]
+mod whitespace_searcher_tests {
+
+ use super::super::matcher::WhitespaceMatcher;
+ use super::*;
+
+ #[test]
+ fn test_space() {
+ let matcher = WhitespaceMatcher {};
+ let iter = Searcher::new(&matcher, " . . ".as_bytes());
+ let items: Vec<(usize, usize)> = iter.collect();
+ assert_eq!(vec![(0, 1), (2, 3), (4, 5)], items);
+ }
+
+ #[test]
+ fn test_tab() {
+ let matcher = WhitespaceMatcher {};
+ let iter = Searcher::new(&matcher, "\t.\t.\t".as_bytes());
+ let items: Vec<(usize, usize)> = iter.collect();
+ assert_eq!(vec![(0, 1), (2, 3), (4, 5)], items);
+ }
+
+ #[test]
+ fn test_empty() {
+ let matcher = WhitespaceMatcher {};
+ let iter = Searcher::new(&matcher, "".as_bytes());
+ let items: Vec<(usize, usize)> = iter.collect();
+ assert_eq!(vec![] as Vec<(usize, usize)>, items);
+ }
+
+ fn test_multispace(line: &[u8], expected: &[(usize, usize)]) {
+ let matcher = WhitespaceMatcher {};
+ let iter = Searcher::new(&matcher, line);
+ let items: Vec<(usize, usize)> = iter.collect();
+ assert_eq!(expected, items);
+ }
+
+ #[test]
+ fn test_multispace_normal() {
+ test_multispace(
+ "... ... \t...\t ... \t ...".as_bytes(),
+ &[(3, 5), (8, 10), (13, 15), (18, 21)],
+ );
+ }
+
+ #[test]
+ fn test_multispace_begin() {
+ test_multispace(" \t\t...".as_bytes(), &[(0, 3)]);
+ }
+
+ #[test]
+ fn test_multispace_end() {
+ test_multispace("...\t ".as_bytes(), &[(3, 6)]);
+ }
+
+ #[test]
+ fn test_searcher_with_whitespace_matcher() {
+ let matcher = WhitespaceMatcher {};
+ let haystack = "\t a b \t cd\t\t".as_bytes();
+ let mut searcher = Searcher::new(&matcher, haystack);
+ assert_eq!(searcher.next(), Some((0, 2)));
+ assert_eq!(searcher.next(), Some((3, 4)));
+ assert_eq!(searcher.next(), Some((5, 8)));
+ assert_eq!(searcher.next(), Some((10, 12)));
+ assert_eq!(searcher.next(), None);
+ assert_eq!(searcher.next(), None);
}
}
diff --git a/src/uu/cut/src/whitespace_searcher.rs b/src/uu/cut/src/whitespace_searcher.rs
deleted file mode 100644
index 8fc8ca5c6e7ce072766ee859793d9807ef6011d7..0000000000000000000000000000000000000000
--- a/src/uu/cut/src/whitespace_searcher.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-// This file is part of the uutils coreutils package.
-//
-// For the full copyright and license information, please view the LICENSE
-// file that was distributed with this source code.
-
-// spell-checker:ignore multispace
-
-use memchr::memchr2;
-
-pub struct WhitespaceSearcher<'a> {
- haystack: &'a [u8],
- position: usize,
-}
-
-impl<'a> WhitespaceSearcher<'a> {
- pub fn new(haystack: &'a [u8]) -> WhitespaceSearcher<'a> {
- WhitespaceSearcher {
- haystack,
- position: 0,
- }
- }
-}
-
-impl<'a> Iterator for WhitespaceSearcher<'a> {
- type Item = (usize, usize);
-
- // Iterate over sequences of consecutive whitespace (space and/or tab) characters.
- // Returns (first, last) positions of each sequence, where `haystack[first..last]`
- // corresponds to the delimiter.
- fn next(&mut self) -> Option<Self::Item> {
- if let Some(match_idx) = memchr2(b' ', b'\t', self.haystack) {
- let mut skip = match_idx + 1;
- while skip < self.haystack.len()
- && (self.haystack[skip] == b' ' || self.haystack[skip] == b'\t')
- {
- skip += 1;
- }
- let match_pos = self.position + match_idx;
- self.haystack = &self.haystack[skip..];
- self.position += skip;
- Some((match_pos, self.position))
- } else {
- None
- }
- }
-}
-
-#[cfg(test)]
-mod tests {
-
- use super::*;
-
- #[test]
- fn test_space() {
- let iter = WhitespaceSearcher::new(" . . ".as_bytes());
- let items: Vec<(usize, usize)> = iter.collect();
- assert_eq!(vec![(0, 1), (2, 3), (4, 5)], items);
- }
-
- #[test]
- fn test_tab() {
- let iter = WhitespaceSearcher::new("\t.\t.\t".as_bytes());
- let items: Vec<(usize, usize)> = iter.collect();
- assert_eq!(vec![(0, 1), (2, 3), (4, 5)], items);
- }
-
- #[test]
- fn test_empty() {
- let iter = WhitespaceSearcher::new("".as_bytes());
- let items: Vec<(usize, usize)> = iter.collect();
- assert_eq!(vec![] as Vec<(usize, usize)>, items);
- }
-
- fn test_multispace(line: &[u8], expected: &[(usize, usize)]) {
- let iter = WhitespaceSearcher::new(line);
- let items: Vec<(usize, usize)> = iter.collect();
- assert_eq!(expected, items);
- }
-
- #[test]
- fn test_multispace_normal() {
- test_multispace(
- "... ... \t...\t ... \t ...".as_bytes(),
- &[(3, 5), (8, 10), (13, 15), (18, 21)],
- );
- }
-
- #[test]
- fn test_multispace_begin() {
- test_multispace(" \t\t...".as_bytes(), &[(0, 3)]);
- }
-
- #[test]
- fn test_multispace_end() {
- test_multispace("...\t ".as_bytes(), &[(3, 6)]);
- }
-}
diff --git a/src/uu/date/Cargo.toml b/src/uu/date/Cargo.toml
index 0bedeabb900dfc1a34eedc8e1494c4565cc141c9..ffdb5e5c6511b0d1a5d0f8aae4468ffca95f8ef1 100644
--- a/src/uu/date/Cargo.toml
+++ b/src/uu/date/Cargo.toml
@@ -1,6 +1,7 @@
+# spell-checker:ignore datetime
[package]
name = "uu_date"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "date ~ (uutils) display or set the current time"
@@ -15,15 +16,19 @@ edition = "2021"
path = "src/date.rs"
[dependencies]
-chrono = { version="^0.4.23", default-features=false, features=["std", "alloc", "clock"]}
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+chrono = { workspace = true }
+clap = { workspace = true }
+uucore = { workspace = true }
+parse_datetime = { workspace = true }
[target.'cfg(unix)'.dependencies]
-libc = "0.2"
+libc = { workspace = true }
[target.'cfg(windows)'.dependencies]
-windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_Foundation", "Win32_System_SystemInformation"] }
+windows-sys = { workspace = true, features = [
+ "Win32_Foundation",
+ "Win32_System_SystemInformation",
+] }
[[bin]]
name = "date"
diff --git a/src/uu/date/date-usage.md b/src/uu/date/date-usage.md
new file mode 100644
index 0000000000000000000000000000000000000000..109bfd3988b3a311eb3f114d27aec1f173da21c0
--- /dev/null
+++ b/src/uu/date/date-usage.md
@@ -0,0 +1,81 @@
+# `date` usage
+
+<!-- spell-checker:ignore (format) hhmm -->
+
+FORMAT controls the output. Interpreted sequences are:
+
+| Sequence | Description | Example |
+| -------- | -------------------------------------------------------------------- | ---------------------- |
+| %% | a literal % | % |
+| %a | locale's abbreviated weekday name | Sun |
+| %A | locale's full weekday name | Sunday |
+| %b | locale's abbreviated month name | Jan |
+| %B | locale's full month name | January |
+| %c | locale's date and time | Thu Mar 3 23:05:25 2005|
+| %C | century; like %Y, except omit last two digits | 20 |
+| %d | day of month | 01 |
+| %D | date; same as %m/%d/%y | 12/31/99 |
+| %e | day of month, space padded; same as %_d | 3 |
+| %F | full date; same as %Y-%m-%d | 2005-03-03 |
+| %g | last two digits of year of ISO week number (see %G) | 05 |
+| %G | year of ISO week number (see %V); normally useful only with %V | 2005 |
+| %h | same as %b | Jan |
+| %H | hour (00..23) | 23 |
+| %I | hour (01..12) | 11 |
+| %j | day of year (001..366) | 062 |
+| %k | hour, space padded ( 0..23); same as %_H | 3 |
+| %l | hour, space padded ( 1..12); same as %_I | 9 |
+| %m | month (01..12) | 03 |
+| %M | minute (00..59) | 30 |
+| %n | a newline | \n |
+| %N | nanoseconds (000000000..999999999) | 123456789 |
+| %p | locale's equivalent of either AM or PM; blank if not known | PM |
+| %P | like %p, but lower case | pm |
+| %q | quarter of year (1..4) | 1 |
+| %r | locale's 12-hour clock time | 11:11:04 PM |
+| %R | 24-hour hour and minute; same as %H:%M | 23:30 |
+| %s | seconds since 1970-01-01 00:00:00 UTC | 1615432800 |
+| %S | second (00..60) | 30 |
+| %t | a tab | \t |
+| %T | time; same as %H:%M:%S | 23:30:30 |
+| %u | day of week (1..7); 1 is Monday | 4 |
+| %U | week number of year, with Sunday as first day of week (00..53) | 10 |
+| %V | ISO week number, with Monday as first day of week (01..53) | 12 |
+| %w | day of week (0..6); 0 is Sunday | 4 |
+| %W | week number of year, with Monday as first day of week (00..53) | 11 |
+| %x | locale's date representation | 03/03/2005 |
+| %X | locale's time representation | 23:30:30 |
+| %y | last two digits of year (00..99) | 05 |
+| %Y | year | 2005 |
+| %z | +hhmm numeric time zone | -0400 |
+| %:z | +hh:mm numeric time zone | -04:00 |
+| %::z | +hh:mm:ss numeric time zone | -04:00:00 |
+| %:::z | numeric time zone with : to necessary precision | -04, +05:30 |
+| %Z | alphabetic time zone abbreviation | EDT |
+
+By default, date pads numeric fields with zeroes.
+The following optional flags may follow '%':
+
+* `-` (hyphen) do not pad the field
+* `_` (underscore) pad with spaces
+* `0` (zero) pad with zeros
+* `^` use upper case if possible
+* `#` use opposite case if possible
+
+After any flags comes an optional field width, as a decimal number;
+then an optional modifier, which is either
+E to use the locale's alternate representations if available, or
+O to use the locale's alternate numeric symbols if available.
+
+Examples:
+Convert seconds since the epoch (1970-01-01 UTC) to a date
+
+```
+date --date='@2147483647'
+```
+
+Show the time on the west coast of the US (use tzselect(1) to find TZ)
+
+```
+TZ='America/Los_Angeles' date
+```
diff --git a/src/uu/date/date-usage.mkd b/src/uu/date/date-usage.mkd
deleted file mode 100644
index 8290010956f7f4124d02b2f08a9510128327be9f..0000000000000000000000000000000000000000
--- a/src/uu/date/date-usage.mkd
+++ /dev/null
@@ -1,78 +0,0 @@
-# `date` usage
-
-<!-- spell-checker:ignore (format) hhmm -->
-
-``` text
-FORMAT controls the output. Interpreted sequences are:
-
- %% a literal %
- %a locale's abbreviated weekday name (e.g., Sun)
- %A locale's full weekday name (e.g., Sunday)
- %b locale's abbreviated month name (e.g., Jan)
- %B locale's full month name (e.g., January)
- %c locale's date and time (e.g., Thu Mar 3 23:05:25 2005)
- %C century; like %Y, except omit last two digits (e.g., 20)
- %d day of month (e.g., 01)
- %D date; same as %m/%d/%y
- %e day of month, space padded; same as %_d
- %F full date; same as %Y-%m-%d
- %g last two digits of year of ISO week number (see %G)
- %G year of ISO week number (see %V); normally useful only with %V
- %h same as %b
- %H hour (00..23)
- %I hour (01..12)
- %j day of year (001..366)
- %k hour, space padded ( 0..23); same as %_H
- %l hour, space padded ( 1..12); same as %_I
- %m month (01..12)
- %M minute (00..59)
- %n a newline
- %N nanoseconds (000000000..999999999)
- %p locale's equivalent of either AM or PM; blank if not known
- %P like %p, but lower case
- %q quarter of year (1..4)
- %r locale's 12-hour clock time (e.g., 11:11:04 PM)
- %R 24-hour hour and minute; same as %H:%M
- %s seconds since 1970-01-01 00:00:00 UTC
- %S second (00..60)
- %t a tab
- %T time; same as %H:%M:%S
- %u day of week (1..7); 1 is Monday
- %U week number of year, with Sunday as first day of week (00..53)
- %V ISO week number, with Monday as first day of week (01..53)
- %w day of week (0..6); 0 is Sunday
- %W week number of year, with Monday as first day of week (00..53)
- %x locale's date representation (e.g., 12/31/99)
- %X locale's time representation (e.g., 23:13:48)
- %y last two digits of year (00..99)
- %Y year
- %z +hhmm numeric time zone (e.g., -0400)
- %:z +hh:mm numeric time zone (e.g., -04:00)
- %::z +hh:mm:ss numeric time zone (e.g., -04:00:00)
- %:::z numeric time zone with : to necessary precision (e.g., -04, +05:30)
- %Z alphabetic time zone abbreviation (e.g., EDT)
-
-By default, date pads numeric fields with zeroes.
-The following optional flags may follow '%':
-
- - (hyphen) do not pad the field
- _ (underscore) pad with spaces
- 0 (zero) pad with zeros
- ^ use upper case if possible
- # use opposite case if possible
-
-After any flags comes an optional field width, as a decimal number;
-then an optional modifier, which is either
-E to use the locale's alternate representations if available, or
-O to use the locale's alternate numeric symbols if available.
-
-Examples:
-Convert seconds since the epoch (1970-01-01 UTC) to a date
- $ date --date='@2147483647'
-
-Show the time on the west coast of the US (use tzselect(1) to find TZ)
- $ TZ='America/Los_Angeles' date
-
-Show the local time for 9AM next Friday on the west coast of the US
- $ date --date='TZ="America/Los_Angeles" 09:00 next Fri'
-```
diff --git a/src/uu/date/date.md b/src/uu/date/date.md
new file mode 100644
index 0000000000000000000000000000000000000000..97f1340169b7b708899a3a8cf165f16a1afb2eb7
--- /dev/null
+++ b/src/uu/date/date.md
@@ -0,0 +1,10 @@
+<!-- spell-checker:ignore Dhhmm -->
+
+# date
+
+```
+date [OPTION]... [+FORMAT]...
+date [OPTION]... [MMDDhhmm[[CC]YY][.ss]]
+```
+
+Print or set the system date and time
diff --git a/src/uu/date/src/date.rs b/src/uu/date/src/date.rs
index 03da2e46d478be37063c463140217ca7d5a37b48..5d6e8fd22e0836afbb8ff3acaacf97009ff38200 100644
--- a/src/uu/date/src/date.rs
+++ b/src/uu/date/src/date.rs
@@ -1,15 +1,12 @@
// This file is part of the uutils coreutils package.
//
-// (c) Anthony Deschamps <anthony.j.deschamps@gmail.com>
-// (c) Sylvestre Ledru <sylvestre@debian.org>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
// spell-checker:ignore (chrono) Datelike Timelike ; (format) DATEFILE MMDDhhmm ; (vars) datetime datetimes
use chrono::format::{Item, StrftimeItems};
-use chrono::{DateTime, FixedOffset, Local, Offset, Utc};
+use chrono::{DateTime, FixedOffset, Local, Offset, TimeDelta, Utc};
#[cfg(windows)]
use chrono::{Datelike, Timelike};
use clap::{crate_version, Arg, ArgAction, Command};
@@ -19,27 +16,23 @@ use std::fs::File;
use std::io::{BufRead, BufReader};
use std::path::PathBuf;
use uucore::display::Quotable;
-#[cfg(not(any(target_os = "macos", target_os = "redox")))]
use uucore::error::FromIo;
use uucore::error::{UResult, USimpleError};
-use uucore::{format_usage, show_error};
+use uucore::{format_usage, help_about, help_usage, show};
#[cfg(windows)]
use windows_sys::Win32::{Foundation::SYSTEMTIME, System::SystemInformation::SetSystemTime};
+use uucore::shortcut_value_parser::ShortcutValueParser;
+
// Options
const DATE: &str = "date";
const HOURS: &str = "hours";
const MINUTES: &str = "minutes";
const SECONDS: &str = "seconds";
-const HOUR: &str = "hour";
-const MINUTE: &str = "minute";
-const SECOND: &str = "second";
const NS: &str = "ns";
-const ABOUT: &str = "print or set the system date and time";
-const USAGE: &str = "\
- {} [OPTION]... [+FORMAT]...
- {} [OPTION]... [MMDDhhmm[[CC]YY][.ss]]";
+const ABOUT: &str = help_about!("date.md");
+const USAGE: &str = help_usage!("date.md");
const OPT_DATE: &str = "date";
const OPT_FORMAT: &str = "format";
@@ -98,6 +91,8 @@ enum DateSource {
Now,
Custom(String),
File(PathBuf),
+ Stdin,
+ Human(TimeDelta),
}
enum Iso8601Format {
@@ -111,13 +106,13 @@ enum Iso8601Format {
impl<'a> From<&'a str> for Iso8601Format {
fn from(s: &str) -> Self {
match s {
- HOURS | HOUR => Self::Hours,
- MINUTES | MINUTE => Self::Minutes,
- SECONDS | SECOND => Self::Seconds,
+ HOURS => Self::Hours,
+ MINUTES => Self::Minutes,
+ SECONDS => Self::Seconds,
NS => Self::Ns,
DATE => Self::Date,
- // Should be caught by clap
- _ => panic!("Invalid format: {}", s),
+ // Note: This is caught by clap via `possible_values`
+ _ => unreachable!(),
}
}
}
@@ -132,15 +127,16 @@ impl<'a> From<&'a str> for Rfc3339Format {
fn from(s: &str) -> Self {
match s {
DATE => Self::Date,
- SECONDS | SECOND => Self::Seconds,
+ SECONDS => Self::Seconds,
NS => Self::Ns,
// Should be caught by clap
- _ => panic!("Invalid format: {}", s),
+ _ => panic!("Invalid format: {s}"),
}
}
}
#[uucore::main]
+#[allow(clippy::cognitive_complexity)]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let matches = uu_app().try_get_matches_from(args)?;
@@ -170,9 +166,18 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
};
let date_source = if let Some(date) = matches.get_one::<String>(OPT_DATE) {
- DateSource::Custom(date.into())
+ let ref_time = Local::now();
+ if let Ok(new_time) = parse_datetime::parse_datetime_at_date(ref_time, date.as_str()) {
+ let duration = new_time.signed_duration_since(ref_time);
+ DateSource::Human(duration)
+ } else {
+ DateSource::Custom(date.into())
+ }
} else if let Some(file) = matches.get_one::<String>(OPT_FILE) {
- DateSource::File(file.into())
+ match file.as_ref() {
+ "-" => DateSource::Stdin,
+ _ => DateSource::File(file.into()),
+ }
} else {
DateSource::Now
};
@@ -205,9 +210,6 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
return set_system_datetime(date);
} else {
- // Declare a file here because it needs to outlive the `dates` iterator.
- let file: File;
-
// Get the current time, either in the local time zone or UTC.
let now: DateTime<FixedOffset> = if settings.utc {
let now = Utc::now();
@@ -224,10 +226,40 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let iter = std::iter::once(date);
Box::new(iter)
}
+ DateSource::Human(relative_time) => {
+ // Get the current DateTime<FixedOffset> for things like "1 year ago"
+ let current_time = DateTime::<FixedOffset>::from(Local::now());
+ // double check the result is overflow or not of the current_time + relative_time
+ // it may cause a panic of chrono::datetime::DateTime add
+ match current_time.checked_add_signed(relative_time) {
+ Some(date) => {
+ let iter = std::iter::once(Ok(date));
+ Box::new(iter)
+ }
+ None => {
+ return Err(USimpleError::new(
+ 1,
+ format!("invalid date {}", relative_time),
+ ));
+ }
+ }
+ }
+ DateSource::Stdin => {
+ let lines = BufReader::new(std::io::stdin()).lines();
+ let iter = lines.map_while(Result::ok).map(parse_date);
+ Box::new(iter)
+ }
DateSource::File(ref path) => {
- file = File::open(path).unwrap();
+ if path.is_dir() {
+ return Err(USimpleError::new(
+ 2,
+ format!("expected file, got directory {}", path.quote()),
+ ));
+ }
+ let file = File::open(path)
+ .map_err_context(|| path.as_os_str().to_string_lossy().to_string())?;
let lines = BufReader::new(file).lines();
- let iter = lines.filter_map(Result::ok).map(parse_date);
+ let iter = lines.map_while(Result::ok).map(parse_date);
Box::new(iter)
}
DateSource::Now => {
@@ -244,6 +276,13 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
Ok(date) => {
// GNU `date` uses `%N` for nano seconds, however crate::chrono uses `%f`
let format_string = &format_string.replace("%N", "%f");
+ // Refuse to pass this string to chrono as it is crashing in this crate
+ if format_string.contains("%#z") {
+ return Err(USimpleError::new(
+ 1,
+ format!("invalid format {}", format_string.replace("%f", "%N")),
+ ));
+ }
// Hack to work around panic in chrono,
// TODO - remove when a fix for https://github.com/chronotope/chrono/issues/623 is released
let format_items = StrftimeItems::new(format_string);
@@ -257,9 +296,12 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
.format_with_items(format_items)
.to_string()
.replace("%f", "%N");
- println!("{}", formatted);
+ println!("{formatted}");
}
- Err((input, _err)) => show_error!("invalid date {}", input.quote()),
+ Err((input, _err)) => show!(USimpleError::new(
+ 1,
+ format!("invalid date {}", input.quote())
+ )),
}
}
}
@@ -293,6 +335,11 @@ pub fn uu_app() -> Command {
.short('I')
.long(OPT_ISO_8601)
.value_name("FMT")
+ .value_parser(ShortcutValueParser::new([
+ DATE, HOURS, MINUTES, SECONDS, NS,
+ ]))
+ .num_args(0..=1)
+ .default_missing_value(OPT_DATE)
.help(ISO_8601_HELP_STRING),
)
.arg(
@@ -306,6 +353,7 @@ pub fn uu_app() -> Command {
Arg::new(OPT_RFC_3339)
.long(OPT_RFC_3339)
.value_name("FMT")
+ .value_parser(ShortcutValueParser::new([DATE, SECONDS, NS]))
.help(RFC_3339_HELP_STRING),
)
.arg(
@@ -365,9 +413,8 @@ fn make_format_string(settings: &Settings) -> &str {
/// If it fails, return a tuple of the `String` along with its `ParseError`.
fn parse_date<S: AsRef<str> + Clone>(
s: S,
-) -> Result<DateTime<FixedOffset>, (String, chrono::format::ParseError)> {
- // TODO: The GNU date command can parse a wide variety of inputs.
- s.as_ref().parse().map_err(|e| (s.as_ref().into(), e))
+) -> Result<DateTime<FixedOffset>, (String, parse_datetime::ParseDateTimeError)> {
+ parse_datetime::parse_datetime(s.as_ref()).map_err(|e| (s.as_ref().into(), e))
}
#[cfg(not(any(unix, windows)))]
@@ -405,10 +452,10 @@ fn set_system_datetime(date: DateTime<Utc>) -> UResult<()> {
let result = unsafe { clock_settime(CLOCK_REALTIME, ×pec) };
- if result != 0 {
- Err(std::io::Error::last_os_error().map_err_context(|| "cannot set date".to_string()))
- } else {
+ if result == 0 {
Ok(())
+ } else {
+ Err(std::io::Error::last_os_error().map_err_context(|| "cannot set date".to_string()))
}
}
diff --git a/src/uu/dd/BENCHMARKING.md b/src/uu/dd/BENCHMARKING.md
index 5fbfe8ae9a307802db46fc6bb1a0be4d423cdd62..4bf27b8ad5398dee98d5b973e38a0018816689ab 100644
--- a/src/uu/dd/BENCHMARKING.md
+++ b/src/uu/dd/BENCHMARKING.md
@@ -45,7 +45,7 @@ be roughly equivalent to the total bytes copied (`blocksize` x `count`).
Some useful invocations for testing would be the following:
-```
+```shell
hyperfine "./target/release/dd bs=4k count=1000000 < /dev/zero > /dev/null"
hyperfine "./target/release/dd bs=1M count=20000 < /dev/zero > /dev/null"
hyperfine "./target/release/dd bs=1G count=10 < /dev/zero > /dev/null"
@@ -57,7 +57,7 @@ Typically you would choose a small blocksize for measuring the performance of
typically does some set amount of work per block which only depends on the size
of the block if conversions are used.
-As an example, https://github.com/uutils/coreutils/pull/3600 made a change to
+As an example, <https://github.com/uutils/coreutils/pull/3600> made a change to
reuse the same buffer between block copies, avoiding the need to reallocate a
new block of memory for each copy. The impact of that change mostly had an
impact on large block size copies because those are the circumstances where the
diff --git a/src/uu/dd/Cargo.toml b/src/uu/dd/Cargo.toml
index 10f08d8c3b1f90013af3396ee4c8dbdc412fa0a6..6d4c41879142acd6c616e9fd01685e0e807a838e 100644
--- a/src/uu/dd/Cargo.toml
+++ b/src/uu/dd/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_dd"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "dd ~ (uutils) copy and convert files"
@@ -15,13 +15,14 @@ edition = "2021"
path = "src/dd.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-gcd = "2.0"
-libc = "0.2"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+gcd = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true, features = ["format", "quoting-style"] }
[target.'cfg(any(target_os = "linux", target_os = "android"))'.dependencies]
-signal-hook = "0.3.14"
+signal-hook = { workspace = true }
+nix = { workspace = true, features = ["fs"] }
[[bin]]
name = "dd"
diff --git a/src/uu/dd/dd.md b/src/uu/dd/dd.md
index b5e16a1bc4735f9f6a338fa326a6a566b9e8e744..504910884c2c32a30c38230daf60878b62d686f5 100644
--- a/src/uu/dd/dd.md
+++ b/src/uu/dd/dd.md
@@ -1,122 +1,126 @@
-<!-- spell-checker:ignore convs iseek oseek -->
# dd
-## About
+<!-- spell-checker:ignore convs iseek oseek -->
+
+```
+dd [OPERAND]...
+dd OPTION
+```
+
Copy, and optionally convert, a file system resource
## After Help
-OPERANDS:
-
- bs=BYTES read and write up to BYTES bytes at a time (default: 512);
- overwrites ibs and obs.
- cbs=BYTES the 'conversion block size' in bytes. Applies to
- the conv=block, and conv=unblock operations.
- conv=CONVS a comma-separated list of conversion options or
- (for legacy reasons) file flags.
- count=N stop reading input after N ibs-sized read operations rather
- than proceeding until EOF. See iflag=count_bytes if stopping
- after N bytes is preferred
- ibs=N the size of buffer used for reads (default: 512)
- if=FILE the file used for input. When not specified, stdin is used instead
- iflag=FLAGS a comma-separated list of input flags which specify how the input
- source is treated. FLAGS may be any of the input-flags or
- general-flags specified below.
- skip=N (or iseek=N) skip N ibs-sized records into input before beginning
- copy/convert operations. See iflag=seek_bytes if seeking N bytes
- is preferred.
- obs=N the size of buffer used for writes (default: 512)
- of=FILE the file used for output. When not specified, stdout is used
- instead
- oflag=FLAGS comma separated list of output flags which specify how the output
- source is treated. FLAGS may be any of the output flags or
- general flags specified below
- seek=N (or oseek=N) seeks N obs-sized records into output before
- beginning copy/convert operations. See oflag=seek_bytes if
- seeking N bytes is preferred
- status=LEVEL controls whether volume and performance stats are written to
- stderr.
-
- When unspecified, dd will print stats upon completion. An example is below.
- 6+0 records in
- 16+0 records out
- 8192 bytes (8.2 kB, 8.0 KiB) copied, 0.00057009 s, 14.4 MB/s
- The first two lines are the 'volume' stats and the final line is
- the 'performance' stats.
- The volume stats indicate the number of complete and partial
- ibs-sized reads, or obs-sized writes that took place during the
- copy. The format of the volume stats is
- <complete>+<partial>. If records have been truncated (see
- conv=block), the volume stats will contain the number of
- truncated records.
-
- Possible LEVEL values are:
- progress: Print periodic performance stats as the copy
- proceeds.
- noxfer: Print final volume stats, but not performance stats.
- none: Do not print any stats.
-
- Printing performance stats is also triggered by the INFO signal
- (where supported), or the USR1 signal. Setting the
- POSIXLY_CORRECT environment variable to any value (including an
- empty value) will cause the USR1 signal to be ignored.
-
-CONVERSION OPTIONS:
-
- ascii convert from EBCDIC to ASCII. This is the inverse of the 'ebcdic'
- option. Implies conv=unblock.
- ebcdic convert from ASCII to EBCDIC. This is the inverse of the 'ascii'
- option. Implies conv=block.
- ibm convert from ASCII to EBCDIC, applying the conventions for '[', ']'
- and '~' specified in POSIX. Implies conv=block.
-
- ucase convert from lower-case to upper-case
- lcase converts from upper-case to lower-case.
-
- block for each newline less than the size indicated by cbs=BYTES, remove
- the newline and pad with spaces up to cbs. Lines longer than cbs are
- truncated.
- unblock for each block of input of the size indicated by cbs=BYTES, remove
- right-trailing spaces and replace with a newline character.
-
- sparse attempts to seek the output when an obs-sized block consists of only
- zeros.
- swab swaps each adjacent pair of bytes. If an odd number of bytes is
- present, the final byte is omitted.
- sync pad each ibs-sided block with zeros. If 'block' or 'unblock' is
- specified, pad with spaces instead.
- excl the output file must be created. Fail if the output file is already
- present.
- nocreat the output file will not be created. Fail if the output file in not
- already present.
- notrunc the output file will not be truncated. If this option is not
- present, output will be truncated when opened.
- noerror all read errors will be ignored. If this option is not present, dd
- will only ignore Error::Interrupted.
- fdatasync data will be written before finishing.
- fsync data and metadata will be written before finishing.
-
-INPUT FLAGS:
-
- count_bytes a value to count=N will be interpreted as bytes.
- skip_bytes a value to skip=N will be interpreted as bytes.
- fullblock wait for ibs bytes from each read. zero-length reads are still
- considered EOF.
-
-OUTPUT FLAGS:
-
- append open file in append mode. Consider setting conv=notrunc as well.
- seek_bytes a value to seek=N will be interpreted as bytes.
-
-GENERAL FLAGS:
-
- direct use direct I/O for data.
- directory fail unless the given input (if used as an iflag) or output (if used
- as an oflag) is a directory.
- dsync use synchronized I/O for data.
- sync use synchronized I/O for data and metadata.
- nonblock use non-blocking I/O.
- noatime do not update access time.
- nocache request that OS drop cache.
- noctty do not assign a controlling tty.
- nofollow do not follow system links.
+### Operands
+
+- `bs=BYTES` : read and write up to BYTES bytes at a time (default: 512);
+ overwrites `ibs` and `obs`.
+- `cbs=BYTES` : the 'conversion block size' in bytes. Applies to the
+ `conv=block`, and `conv=unblock` operations.
+- `conv=CONVS` : a comma-separated list of conversion options or (for legacy
+ reasons) file flags.
+- `count=N` : stop reading input after N ibs-sized read operations rather
+ than proceeding until EOF. See `iflag=count_bytes` if stopping after N bytes
+ is preferred
+- `ibs=N` : the size of buffer used for reads (default: 512)
+- `if=FILE` : the file used for input. When not specified, stdin is used instead
+- `iflag=FLAGS` : a comma-separated list of input flags which specify how the
+ input source is treated. FLAGS may be any of the input-flags or general-flags
+ specified below.
+- `skip=N` (or `iseek=N`) : skip N ibs-sized records into input before beginning
+ copy/convert operations. See iflag=seek_bytes if seeking N bytes is preferred.
+- `obs=N` : the size of buffer used for writes (default: 512)
+- `of=FILE` : the file used for output. When not specified, stdout is used
+ instead
+- `oflag=FLAGS` : comma separated list of output flags which specify how the
+ output source is treated. FLAGS may be any of the output flags or general
+ flags specified below
+- `seek=N` (or `oseek=N`) : seeks N obs-sized records into output before
+ beginning copy/convert operations. See oflag=seek_bytes if seeking N bytes is
+ preferred
+- `status=LEVEL` : controls whether volume and performance stats are written to
+ stderr.
+
+ When unspecified, dd will print stats upon completion. An example is below.
+
+ ```plain
+ 6+0 records in
+ 16+0 records out
+ 8192 bytes (8.2 kB, 8.0 KiB) copied, 0.00057009 s,
+ 14.4 MB/s
+ ```
+
+ The first two lines are the 'volume' stats and the final line is the
+ 'performance' stats.
+ The volume stats indicate the number of complete and partial ibs-sized reads,
+ or obs-sized writes that took place during the copy. The format of the volume
+ stats is `<complete>+<partial>`. If records have been truncated (see
+ `conv=block`), the volume stats will contain the number of truncated records.
+
+ Possible LEVEL values are:
+ - `progress` : Print periodic performance stats as the copy proceeds.
+ - `noxfer` : Print final volume stats, but not performance stats.
+ - `none` : Do not print any stats.
+
+ Printing performance stats is also triggered by the INFO signal (where supported),
+ or the USR1 signal. Setting the POSIXLY_CORRECT environment variable to any value
+ (including an empty value) will cause the USR1 signal to be ignored.
+
+### Conversion Options
+
+- `ascii` : convert from EBCDIC to ASCII. This is the inverse of the `ebcdic`
+ option. Implies `conv=unblock`.
+- `ebcdic` : convert from ASCII to EBCDIC. This is the inverse of the `ascii`
+ option. Implies `conv=block`.
+- `ibm` : convert from ASCII to EBCDIC, applying the conventions for `[`, `]`
+ and `~` specified in POSIX. Implies `conv=block`.
+
+- `ucase` : convert from lower-case to upper-case.
+- `lcase` : converts from upper-case to lower-case.
+
+- `block` : for each newline less than the size indicated by cbs=BYTES, remove
+ the newline and pad with spaces up to cbs. Lines longer than cbs are truncated.
+- `unblock` : for each block of input of the size indicated by cbs=BYTES, remove
+ right-trailing spaces and replace with a newline character.
+
+- `sparse` : attempts to seek the output when an obs-sized block consists of
+ only zeros.
+- `swab` : swaps each adjacent pair of bytes. If an odd number of bytes is
+ present, the final byte is omitted.
+- `sync` : pad each ibs-sided block with zeros. If `block` or `unblock` is
+ specified, pad with spaces instead.
+- `excl` : the output file must be created. Fail if the output file is already
+ present.
+- `nocreat` : the output file will not be created. Fail if the output file in
+ not already present.
+- `notrunc` : the output file will not be truncated. If this option is not
+ present, output will be truncated when opened.
+- `noerror` : all read errors will be ignored. If this option is not present,
+ dd will only ignore Error::Interrupted.
+- `fdatasync` : data will be written before finishing.
+- `fsync` : data and metadata will be written before finishing.
+
+### Input flags
+
+- `count_bytes` : a value to `count=N` will be interpreted as bytes.
+- `skip_bytes` : a value to `skip=N` will be interpreted as bytes.
+- `fullblock` : wait for ibs bytes from each read. zero-length reads are still
+ considered EOF.
+
+### Output flags
+
+- `append` : open file in append mode. Consider setting conv=notrunc as well.
+- `seek_bytes` : a value to seek=N will be interpreted as bytes.
+
+### General Flags
+
+- `direct` : use direct I/O for data.
+- `directory` : fail unless the given input (if used as an iflag) or
+ output (if used as an oflag) is a directory.
+- `dsync` : use synchronized I/O for data.
+- `sync` : use synchronized I/O for data and metadata.
+- `nonblock` : use non-blocking I/O.
+- `noatime` : do not update access time.
+- `nocache` : request that OS drop cache.
+- `noctty` : do not assign a controlling tty.
+- `nofollow` : do not follow system links.
diff --git a/src/uu/dd/src/blocks.rs b/src/uu/dd/src/blocks.rs
index a8d2c1408bf8e6b6b495cddbfd597688d16a36ef..8e5557a2c9bcf8184b34647f66e42a67e164d9c5 100644
--- a/src/uu/dd/src/blocks.rs
+++ b/src/uu/dd/src/blocks.rs
@@ -1,7 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore datastructures rstat rposition cflags ctable
diff --git a/src/uu/dd/src/bufferedoutput.rs b/src/uu/dd/src/bufferedoutput.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6ac3b430046d3666d10f97cfd89d984eb5ac905f
--- /dev/null
+++ b/src/uu/dd/src/bufferedoutput.rs
@@ -0,0 +1,206 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+//
+// spell-checker:ignore wstat towrite cdefg bufferedoutput
+//! Buffer partial output blocks until they are completed.
+//!
+//! Use the [`BufferedOutput`] struct to create a buffered form of the
+//! [`Output`] writer.
+use crate::{Output, WriteStat};
+
+/// Buffer partial output blocks until they are completed.
+///
+/// Complete blocks are written immediately to the inner [`Output`],
+/// but partial blocks are stored in an internal buffer until they are
+/// completed.
+pub(crate) struct BufferedOutput<'a> {
+ /// The unbuffered inner block writer.
+ inner: Output<'a>,
+
+ /// The internal buffer that stores a partial block.
+ ///
+ /// The size of this buffer is always less than the output block
+ /// size (that is, the value of the `obs` command-line option).
+ buf: Vec<u8>,
+}
+
+impl<'a> BufferedOutput<'a> {
+ /// Add partial block buffering to the given block writer.
+ ///
+ /// The internal buffer size is at most the value of `obs` as
+ /// defined in `inner`.
+ pub(crate) fn new(inner: Output<'a>) -> Self {
+ let obs = inner.settings.obs;
+ Self {
+ inner,
+ buf: Vec::with_capacity(obs),
+ }
+ }
+
+ pub(crate) fn discard_cache(&self, offset: libc::off_t, len: libc::off_t) {
+ self.inner.discard_cache(offset, len);
+ }
+
+ /// Flush the partial block stored in the internal buffer.
+ pub(crate) fn flush(&mut self) -> std::io::Result<WriteStat> {
+ let wstat = self.inner.write_blocks(&self.buf)?;
+ let n = wstat.bytes_total.try_into().unwrap();
+ self.buf.drain(0..n);
+ Ok(wstat)
+ }
+
+ /// Synchronize the inner block writer.
+ pub(crate) fn sync(&mut self) -> std::io::Result<()> {
+ self.inner.sync()
+ }
+
+ /// Truncate the underlying file to the current stream position, if possible.
+ pub(crate) fn truncate(&mut self) -> std::io::Result<()> {
+ self.inner.dst.truncate()
+ }
+
+ /// Write the given bytes one block at a time.
+ ///
+ /// Only complete blocks will be written. Partial blocks will be
+ /// buffered until enough bytes have been provided to complete a
+ /// block. The returned [`WriteStat`] object will include the
+ /// number of blocks written during execution of this function.
+ pub(crate) fn write_blocks(&mut self, buf: &[u8]) -> std::io::Result<WriteStat> {
+ // Split the incoming buffer into two parts: the bytes to write
+ // and the bytes to buffer for next time.
+ //
+ // If `buf` does not include enough bytes to form a full block,
+ // just buffer the whole thing and write zero blocks.
+ let n = self.buf.len() + buf.len();
+ let rem = n % self.inner.settings.obs;
+ let i = buf.len().saturating_sub(rem);
+ let (to_write, to_buffer) = buf.split_at(i);
+
+ // Concatenate the old partial block with the new bytes to form
+ // some number of complete blocks.
+ self.buf.extend_from_slice(to_write);
+
+ // Write all complete blocks to the inner block writer.
+ //
+ // For example, if the output block size were 3, the buffered
+ // partial block were `b"ab"` and the new incoming bytes were
+ // `b"cdefg"`, then we would write blocks `b"abc"` and
+ // b`"def"` to the inner block writer.
+ let wstat = self.inner.write_blocks(&self.buf)?;
+
+ // Buffer any remaining bytes as a partial block.
+ //
+ // Continuing the example above, the last byte `b"g"` would be
+ // buffered as a partial block until the next call to
+ // `write_blocks()`.
+ self.buf.clear();
+ self.buf.extend_from_slice(to_buffer);
+
+ Ok(wstat)
+ }
+}
+
+#[cfg(unix)]
+#[cfg(test)]
+mod tests {
+ use crate::bufferedoutput::BufferedOutput;
+ use crate::{Dest, Output, Settings};
+
+ #[test]
+ fn test_buffered_output_write_blocks_empty() {
+ let settings = Settings {
+ obs: 3,
+ ..Default::default()
+ };
+ let inner = Output {
+ dst: Dest::Sink,
+ settings: &settings,
+ };
+ let mut output = BufferedOutput::new(inner);
+ let wstat = output.write_blocks(&[]).unwrap();
+ assert_eq!(wstat.writes_complete, 0);
+ assert_eq!(wstat.writes_partial, 0);
+ assert_eq!(wstat.bytes_total, 0);
+ assert_eq!(output.buf, vec![]);
+ }
+
+ #[test]
+ fn test_buffered_output_write_blocks_partial() {
+ let settings = Settings {
+ obs: 3,
+ ..Default::default()
+ };
+ let inner = Output {
+ dst: Dest::Sink,
+ settings: &settings,
+ };
+ let mut output = BufferedOutput::new(inner);
+ let wstat = output.write_blocks(b"ab").unwrap();
+ assert_eq!(wstat.writes_complete, 0);
+ assert_eq!(wstat.writes_partial, 0);
+ assert_eq!(wstat.bytes_total, 0);
+ assert_eq!(output.buf, b"ab");
+ }
+
+ #[test]
+ fn test_buffered_output_write_blocks_complete() {
+ let settings = Settings {
+ obs: 3,
+ ..Default::default()
+ };
+ let inner = Output {
+ dst: Dest::Sink,
+ settings: &settings,
+ };
+ let mut output = BufferedOutput::new(inner);
+ let wstat = output.write_blocks(b"abcd").unwrap();
+ assert_eq!(wstat.writes_complete, 1);
+ assert_eq!(wstat.writes_partial, 0);
+ assert_eq!(wstat.bytes_total, 3);
+ assert_eq!(output.buf, b"d");
+ }
+
+ #[test]
+ fn test_buffered_output_write_blocks_append() {
+ let settings = Settings {
+ obs: 3,
+ ..Default::default()
+ };
+ let inner = Output {
+ dst: Dest::Sink,
+ settings: &settings,
+ };
+ let mut output = BufferedOutput {
+ inner,
+ buf: b"ab".to_vec(),
+ };
+ let wstat = output.write_blocks(b"cdefg").unwrap();
+ assert_eq!(wstat.writes_complete, 2);
+ assert_eq!(wstat.writes_partial, 0);
+ assert_eq!(wstat.bytes_total, 6);
+ assert_eq!(output.buf, b"g");
+ }
+
+ #[test]
+ fn test_buffered_output_flush() {
+ let settings = Settings {
+ obs: 10,
+ ..Default::default()
+ };
+ let inner = Output {
+ dst: Dest::Sink,
+ settings: &settings,
+ };
+ let mut output = BufferedOutput {
+ inner,
+ buf: b"abc".to_vec(),
+ };
+ let wstat = output.flush().unwrap();
+ assert_eq!(wstat.writes_complete, 0);
+ assert_eq!(wstat.writes_partial, 1);
+ assert_eq!(wstat.bytes_total, 3);
+ assert_eq!(output.buf, vec![]);
+ }
+}
diff --git a/src/uu/dd/src/conversion_tables.rs b/src/uu/dd/src/conversion_tables.rs
index aca2ef9bc819c1b93675736f3a5ddbc4ea54abd1..bdf6398ac7cfb347b57c2c2fa8b3dd53809cc1b7 100644
--- a/src/uu/dd/src/conversion_tables.rs
+++ b/src/uu/dd/src/conversion_tables.rs
@@ -1,7 +1,5 @@
// This file is part of the uutils coreutils package.
//
-// (c) Tyler Steele <tyler.steele@protonmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
diff --git a/src/uu/dd/src/datastructures.rs b/src/uu/dd/src/datastructures.rs
index 6830df63e3b79277f66a6171ddba9a0c658200cc..c0da8c67cbf1668e1633413798c26cc6fa901b31 100644
--- a/src/uu/dd/src/datastructures.rs
+++ b/src/uu/dd/src/datastructures.rs
@@ -1,7 +1,5 @@
// This file is part of the uutils coreutils package.
//
-// (c) Tyler Steele <tyler.steele@protonmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
// spell-checker:ignore ctable, outfile, iseek, oseek
diff --git a/src/uu/dd/src/dd.rs b/src/uu/dd/src/dd.rs
index 8f91080fea86171375e4d63b1abeb86cbb957507..24fab1e2fb30ecc4170276b40f989db3c006298a 100644
--- a/src/uu/dd/src/dd.rs
+++ b/src/uu/dd/src/dd.rs
@@ -1,27 +1,29 @@
// This file is part of the uutils coreutils package.
//
-// (c) Tyler Steele <tyler.steele@protonmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
-// spell-checker:ignore fname, tname, fpath, specfile, testfile, unspec, ifile, ofile, outfile, fullblock, urand, fileio, atoe, atoibm, behaviour, bmax, bremain, cflags, creat, ctable, ctty, datastructures, doesnt, etoa, fileout, fname, gnudd, iconvflags, iseek, nocache, noctty, noerror, nofollow, nolinks, nonblock, oconvflags, oseek, outfile, parseargs, rlen, rmax, rremain, rsofar, rstat, sigusr, wlen, wstat seekable oconv canonicalized
+// spell-checker:ignore fname, ftype, tname, fpath, specfile, testfile, unspec, ifile, ofile, outfile, fullblock, urand, fileio, atoe, atoibm, behaviour, bmax, bremain, cflags, creat, ctable, ctty, datastructures, doesnt, etoa, fileout, fname, gnudd, iconvflags, iseek, nocache, noctty, noerror, nofollow, nolinks, nonblock, oconvflags, oseek, outfile, parseargs, rlen, rmax, rremain, rsofar, rstat, sigusr, wlen, wstat seekable oconv canonicalized fadvise Fadvise FADV DONTNEED ESPIPE bufferedoutput, SETFL
+mod blocks;
+mod bufferedoutput;
+mod conversion_tables;
mod datastructures;
-use datastructures::*;
-
+mod numbers;
mod parseargs;
-use parseargs::Parser;
-
-mod conversion_tables;
-
mod progress;
-use progress::{gen_prog_updater, ProgUpdate, ReadStat, StatusLevel, WriteStat};
-mod blocks;
+use crate::bufferedoutput::BufferedOutput;
use blocks::conv_block_unblock_helper;
-
-mod numbers;
+use datastructures::*;
+#[cfg(any(target_os = "linux", target_os = "android"))]
+use nix::fcntl::FcntlArg::F_SETFL;
+#[cfg(any(target_os = "linux", target_os = "android"))]
+use nix::fcntl::OFlag;
+use parseargs::Parser;
+use progress::ProgUpdateType;
+use progress::{gen_prog_updater, ProgUpdate, ReadStat, StatusLevel, WriteStat};
+use uucore::io::OwnedFileDescriptorOrHandle;
use std::cmp;
use std::env;
@@ -30,20 +32,37 @@ use std::fs::{File, OpenOptions};
use std::io::{self, Read, Seek, SeekFrom, Stdout, Write};
#[cfg(any(target_os = "linux", target_os = "android"))]
use std::os::unix::fs::OpenOptionsExt;
+#[cfg(unix)]
+use std::os::unix::{
+ fs::FileTypeExt,
+ io::{AsRawFd, FromRawFd},
+};
+#[cfg(windows)]
+use std::os::windows::{fs::MetadataExt, io::AsHandle};
use std::path::Path;
-use std::sync::mpsc;
+use std::sync::atomic::AtomicU8;
+use std::sync::{atomic::Ordering::Relaxed, mpsc, Arc};
use std::thread;
-use std::time;
+use std::time::{Duration, Instant};
use clap::{crate_version, Arg, Command};
use gcd::Gcd;
+#[cfg(target_os = "linux")]
+use nix::{
+ errno::Errno,
+ fcntl::{posix_fadvise, PosixFadviseAdvice},
+};
use uucore::display::Quotable;
+#[cfg(unix)]
+use uucore::error::set_exit_code;
use uucore::error::{FromIo, UResult};
-use uucore::help_section;
-use uucore::show_error;
+#[cfg(target_os = "linux")]
+use uucore::show_if_err;
+use uucore::{format_usage, help_about, help_section, help_usage, show_error};
-const ABOUT: &str = help_section!("about", "dd.md");
+const ABOUT: &str = help_about!("dd.md");
const AFTER_HELP: &str = help_section!("after help", "dd.md");
+const USAGE: &str = help_usage!("dd.md");
const BUF_INIT_BYTE: u8 = 0xDD;
/// Final settings after parsing
@@ -61,6 +80,74 @@ struct Settings {
oconv: OConvFlags,
oflags: OFlags,
status: Option<StatusLevel>,
+ /// Whether the output writer should buffer partial blocks until complete.
+ buffered: bool,
+}
+
+/// A timer which triggers on a given interval
+///
+/// After being constructed with [`Alarm::with_interval`], [`Alarm::get_trigger`]
+/// will return [`ALARM_TRIGGER_TIMER`] once per the given [`Duration`].
+/// Alarm can be manually triggered with closure returned by [`Alarm::manual_trigger_fn`].
+/// [`Alarm::get_trigger`] will return [`ALARM_TRIGGER_SIGNAL`] in this case.
+///
+/// Can be cloned, but the trigger status is shared across all instances so only
+/// the first caller each interval will yield true.
+///
+/// When all instances are dropped the background thread will exit on the next interval.
+pub struct Alarm {
+ interval: Duration,
+ trigger: Arc<AtomicU8>,
+}
+
+pub const ALARM_TRIGGER_NONE: u8 = 0;
+pub const ALARM_TRIGGER_TIMER: u8 = 1;
+pub const ALARM_TRIGGER_SIGNAL: u8 = 2;
+
+impl Alarm {
+ /// use to construct alarm timer with duration
+ pub fn with_interval(interval: Duration) -> Self {
+ let trigger = Arc::new(AtomicU8::default());
+
+ let weak_trigger = Arc::downgrade(&trigger);
+ thread::spawn(move || {
+ while let Some(trigger) = weak_trigger.upgrade() {
+ thread::sleep(interval);
+ trigger.store(ALARM_TRIGGER_TIMER, Relaxed);
+ }
+ });
+
+ Self { interval, trigger }
+ }
+
+ /// Returns a closure that allows to manually trigger the alarm
+ ///
+ /// This is useful for cases where more than one alarm even source exists
+ /// In case of `dd` there is the SIGUSR1/SIGINFO case where we want to
+ /// trigger an manual progress report.
+ pub fn manual_trigger_fn(&self) -> Box<dyn Send + Sync + Fn()> {
+ let weak_trigger = Arc::downgrade(&self.trigger);
+ Box::new(move || {
+ if let Some(trigger) = weak_trigger.upgrade() {
+ trigger.store(ALARM_TRIGGER_SIGNAL, Relaxed);
+ }
+ })
+ }
+
+ /// Use this function to poll for any pending alarm event
+ ///
+ /// Returns `ALARM_TRIGGER_NONE` for no pending event.
+ /// Returns `ALARM_TRIGGER_TIMER` if the event was triggered by timer
+ /// Returns `ALARM_TRIGGER_SIGNAL` if the event was triggered manually
+ /// by the closure returned from `manual_trigger_fn`
+ pub fn get_trigger(&self) -> u8 {
+ self.trigger.swap(ALARM_TRIGGER_NONE, Relaxed)
+ }
+
+ // Getter function for the configured interval duration
+ pub fn get_interval(&self) -> Duration {
+ self.interval
+ }
}
/// A number in blocks or bytes
@@ -74,6 +161,12 @@ enum Num {
Bytes(u64),
}
+impl Default for Num {
+ fn default() -> Self {
+ Self::Blocks(0)
+ }
+}
+
impl Num {
fn force_bytes_if(self, force: bool) -> Self {
match self {
@@ -90,30 +183,208 @@ impl Num {
}
}
-struct Input<'a, R: Read> {
- src: R,
- settings: &'a Settings,
+/// Data sources.
+///
+/// Use [`Source::stdin_as_file`] if available to enable more
+/// fine-grained access to reading from stdin.
+enum Source {
+ /// Input from stdin.
+ #[cfg(not(unix))]
+ Stdin(io::Stdin),
+
+ /// Input from a file.
+ File(File),
+
+ /// Input from stdin, opened from its file descriptor.
+ #[cfg(unix)]
+ StdinFile(File),
+
+ /// Input from a named pipe, also known as a FIFO.
+ #[cfg(unix)]
+ Fifo(File),
}
-impl<'a> Input<'a, io::Stdin> {
- fn new(settings: &'a Settings) -> UResult<Self> {
- let mut input = Self {
- src: io::stdin(),
- settings,
- };
+impl Source {
+ /// Create a source from stdin using its raw file descriptor.
+ ///
+ /// This returns an instance of the `Source::StdinFile` variant,
+ /// using the raw file descriptor of [`std::io::Stdin`] to create
+ /// the [`std::fs::File`] parameter. You can use this instead of
+ /// `Source::Stdin` to allow reading from stdin without consuming
+ /// the entire contents of stdin when this process terminates.
+ #[cfg(unix)]
+ fn stdin_as_file() -> Self {
+ let fd = io::stdin().as_raw_fd();
+ let f = unsafe { File::from_raw_fd(fd) };
+ Self::StdinFile(f)
+ }
- if settings.skip > 0 {
- if let Err(e) = input.read_skip(settings.skip) {
- if let io::ErrorKind::UnexpectedEof = e.kind() {
+ /// The length of the data source in number of bytes.
+ ///
+ /// If it cannot be determined, then this function returns 0.
+ fn len(&self) -> std::io::Result<i64> {
+ match self {
+ Self::File(f) => Ok(f.metadata()?.len().try_into().unwrap_or(i64::MAX)),
+ _ => Ok(0),
+ }
+ }
+
+ fn skip(&mut self, n: u64) -> io::Result<u64> {
+ match self {
+ #[cfg(not(unix))]
+ Self::Stdin(stdin) => match io::copy(&mut stdin.take(n), &mut io::sink()) {
+ Ok(m) if m < n => {
show_error!("'standard input': cannot skip to specified offset");
- } else {
- return io::Result::Err(e)
- .map_err_context(|| "I/O error while skipping".to_string());
+ Ok(m)
+ }
+ Ok(m) => Ok(m),
+ Err(e) => Err(e),
+ },
+ #[cfg(unix)]
+ Self::StdinFile(f) => {
+ if let Ok(Some(len)) = try_get_len_of_block_device(f) {
+ if len < n {
+ // GNU compatibility:
+ // this case prints the stats but sets the exit code to 1
+ show_error!("'standard input': cannot skip: Invalid argument");
+ set_exit_code(1);
+ return Ok(len);
+ }
+ }
+ match io::copy(&mut f.take(n), &mut io::sink()) {
+ Ok(m) if m < n => {
+ show_error!("'standard input': cannot skip to specified offset");
+ Ok(m)
+ }
+ Ok(m) => Ok(m),
+ Err(e) => Err(e),
}
}
+ Self::File(f) => f.seek(io::SeekFrom::Current(n.try_into().unwrap())),
+ #[cfg(unix)]
+ Self::Fifo(f) => io::copy(&mut f.take(n), &mut io::sink()),
}
+ }
- Ok(input)
+ /// Discard the system file cache for the given portion of the data source.
+ ///
+ /// `offset` and `len` specify a contiguous portion of the data
+ /// source. This function informs the kernel that the specified
+ /// portion of the source is no longer needed. If not possible,
+ /// then this function returns an error.
+ #[cfg(target_os = "linux")]
+ fn discard_cache(&self, offset: libc::off_t, len: libc::off_t) -> nix::Result<()> {
+ match self {
+ Self::File(f) => {
+ let advice = PosixFadviseAdvice::POSIX_FADV_DONTNEED;
+ posix_fadvise(f.as_raw_fd(), offset, len, advice)
+ }
+ _ => Err(Errno::ESPIPE), // "Illegal seek"
+ }
+ }
+}
+
+impl Read for Source {
+ fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+ match self {
+ #[cfg(not(unix))]
+ Self::Stdin(stdin) => stdin.read(buf),
+ Self::File(f) => f.read(buf),
+ #[cfg(unix)]
+ Self::StdinFile(f) => f.read(buf),
+ #[cfg(unix)]
+ Self::Fifo(f) => f.read(buf),
+ }
+ }
+}
+
+/// The source of the data, configured with the given settings.
+///
+/// Use the [`Input::new_stdin`] or [`Input::new_file`] functions to
+/// construct a new instance of this struct. Then pass the instance to
+/// the [`dd_copy`] function to execute the main copy operation
+/// for `dd`.
+struct Input<'a> {
+ /// The source from which bytes will be read.
+ src: Source,
+
+ /// Configuration settings for how to read the data.
+ settings: &'a Settings,
+}
+
+impl<'a> Input<'a> {
+ /// Instantiate this struct with stdin as a source.
+ fn new_stdin(settings: &'a Settings) -> UResult<Self> {
+ #[cfg(not(unix))]
+ let mut src = {
+ let f = File::from(io::stdin().as_handle().try_clone_to_owned()?);
+ let is_file = if let Ok(metadata) = f.metadata() {
+ // this hack is needed as there is no other way on windows
+ // to differentiate between the case where `seek` works
+ // on a file handle or not. i.e. when the handle is no real
+ // file but a pipe, `seek` is still successful, but following
+ // `read`s are not affected by the seek.
+ metadata.creation_time() != 0
+ } else {
+ false
+ };
+ if is_file {
+ Source::File(f)
+ } else {
+ Source::Stdin(io::stdin())
+ }
+ };
+ #[cfg(unix)]
+ let mut src = Source::stdin_as_file();
+ #[cfg(unix)]
+ if let Source::StdinFile(f) = &src {
+ // GNU compatibility:
+ // this will check whether stdin points to a folder or not
+ if f.metadata()?.is_file() && settings.iflags.directory {
+ show_error!("standard input: not a directory");
+ return Err(1.into());
+ }
+ };
+ if settings.skip > 0 {
+ src.skip(settings.skip)?;
+ }
+ Ok(Self { src, settings })
+ }
+
+ /// Instantiate this struct with the named file as a source.
+ fn new_file(filename: &Path, settings: &'a Settings) -> UResult<Self> {
+ let src = {
+ let mut opts = OpenOptions::new();
+ opts.read(true);
+
+ #[cfg(any(target_os = "linux", target_os = "android"))]
+ if let Some(libc_flags) = make_linux_iflags(&settings.iflags) {
+ opts.custom_flags(libc_flags);
+ }
+
+ opts.open(filename)
+ .map_err_context(|| format!("failed to open {}", filename.quote()))?
+ };
+
+ let mut src = Source::File(src);
+ if settings.skip > 0 {
+ src.skip(settings.skip)?;
+ }
+ Ok(Self { src, settings })
+ }
+
+ /// Instantiate this struct with the named pipe as a source.
+ #[cfg(unix)]
+ fn new_fifo(filename: &Path, settings: &'a Settings) -> UResult<Self> {
+ let mut opts = OpenOptions::new();
+ opts.read(true);
+ #[cfg(any(target_os = "linux", target_os = "android"))]
+ opts.custom_flags(make_linux_iflags(&settings.iflags).unwrap_or(0));
+ let mut src = Source::Fifo(opts.open(filename)?);
+ if settings.skip > 0 {
+ src.skip(settings.skip)?;
+ }
+ Ok(Self { src, settings })
}
}
@@ -146,38 +417,14 @@ fn make_linux_iflags(iflags: &IFlags) -> Option<libc::c_int> {
flag |= libc::O_SYNC;
}
- if flag != 0 {
- Some(flag)
- } else {
+ if flag == 0 {
None
+ } else {
+ Some(flag)
}
}
-impl<'a> Input<'a, File> {
- fn new(filename: &Path, settings: &'a Settings) -> UResult<Self> {
- let mut src = {
- let mut opts = OpenOptions::new();
- opts.read(true);
-
- #[cfg(any(target_os = "linux", target_os = "android"))]
- if let Some(libc_flags) = make_linux_iflags(&settings.iflags) {
- opts.custom_flags(libc_flags);
- }
-
- opts.open(filename)
- .map_err_context(|| format!("failed to open {}", filename.quote()))?
- };
-
- if settings.skip > 0 {
- src.seek(io::SeekFrom::Start(settings.skip))
- .map_err_context(|| "failed to seek in input file".to_string())?;
- }
-
- Ok(Self { src, settings })
- }
-}
-
-impl<'a, R: Read> Read for Input<'a, R> {
+impl<'a> Read for Input<'a> {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
let mut base_idx = 0;
let target_len = buf.len();
@@ -200,7 +447,30 @@ impl<'a, R: Read> Read for Input<'a, R> {
}
}
-impl<'a, R: Read> Input<'a, R> {
+impl<'a> Input<'a> {
+ /// Discard the system file cache for the given portion of the input.
+ ///
+ /// `offset` and `len` specify a contiguous portion of the input.
+ /// This function informs the kernel that the specified portion of
+ /// the input file is no longer needed. If not possible, then this
+ /// function prints an error message to stderr and sets the exit
+ /// status code to 1.
+ #[allow(unused_variables)]
+ fn discard_cache(&self, offset: libc::off_t, len: libc::off_t) {
+ #[cfg(target_os = "linux")]
+ {
+ show_if_err!(self
+ .src
+ .discard_cache(offset, len)
+ .map_err_context(|| "failed to discard cache for: 'standard input'".to_string()));
+ }
+ #[cfg(not(target_os = "linux"))]
+ {
+ // TODO Is there a way to discard filesystem cache on
+ // these other operating systems?
+ }
+ }
+
/// Fills a given buffer.
/// Reads in increments of 'self.ibs'.
/// The start of each ibs-sized read follows the previous one.
@@ -222,13 +492,13 @@ impl<'a, R: Read> Input<'a, R> {
_ => break,
}
}
-
buf.truncate(bytes_total);
Ok(ReadStat {
reads_complete,
reads_partial,
// Records are not truncated when filling.
records_truncated: 0,
+ bytes_total: bytes_total.try_into().unwrap(),
})
}
@@ -239,6 +509,7 @@ impl<'a, R: Read> Input<'a, R> {
let mut reads_complete = 0;
let mut reads_partial = 0;
let mut base_idx = 0;
+ let mut bytes_total = 0;
while base_idx < buf.len() {
let next_blk = cmp::min(base_idx + self.settings.ibs, buf.len());
@@ -247,11 +518,13 @@ impl<'a, R: Read> Input<'a, R> {
match self.read(&mut buf[base_idx..next_blk])? {
0 => break,
rlen if rlen < target_len => {
+ bytes_total += rlen;
reads_partial += 1;
let padding = vec![pad; target_len - rlen];
buf.splice(base_idx + rlen..next_blk, padding.into_iter());
}
- _ => {
+ rlen => {
+ bytes_total += rlen;
reads_complete += 1;
}
}
@@ -264,22 +537,9 @@ impl<'a, R: Read> Input<'a, R> {
reads_complete,
reads_partial,
records_truncated: 0,
+ bytes_total: bytes_total.try_into().unwrap(),
})
}
-
- /// Skips amount_to_read bytes from the Input by copying into a sink
- fn read_skip(&mut self, amount_to_read: u64) -> std::io::Result<()> {
- let copy_result = io::copy(&mut self.src.by_ref().take(amount_to_read), &mut io::sink());
- if let Ok(n) = copy_result {
- if n != amount_to_read {
- io::Result::Err(io::Error::new(io::ErrorKind::UnexpectedEof, ""))
- } else {
- Ok(())
- }
- } else {
- io::Result::Err(copy_result.unwrap_err())
- }
- }
}
enum Density {
@@ -297,6 +557,14 @@ enum Dest {
/// The [`Density`] component indicates whether to attempt to
/// write a sparse file when all-zero blocks are encountered.
File(File, Density),
+
+ /// Output to a named pipe, also known as a FIFO.
+ #[cfg(unix)]
+ Fifo(File),
+
+ /// Output to nothing, dropping each byte written to the output.
+ #[cfg(unix)]
+ Sink,
}
impl Dest {
@@ -307,6 +575,13 @@ impl Dest {
f.flush()?;
f.sync_all()
}
+ #[cfg(unix)]
+ Self::Fifo(f) => {
+ f.flush()?;
+ f.sync_all()
+ }
+ #[cfg(unix)]
+ Self::Sink => Ok(()),
}
}
@@ -317,24 +592,77 @@ impl Dest {
f.flush()?;
f.sync_data()
}
+ #[cfg(unix)]
+ Self::Fifo(f) => {
+ f.flush()?;
+ f.sync_data()
+ }
+ #[cfg(unix)]
+ Self::Sink => Ok(()),
}
}
fn seek(&mut self, n: u64) -> io::Result<u64> {
match self {
Self::Stdout(stdout) => io::copy(&mut io::repeat(0).take(n), stdout),
- Self::File(f, _) => f.seek(io::SeekFrom::Start(n)),
+ Self::File(f, _) => {
+ #[cfg(unix)]
+ if let Ok(Some(len)) = try_get_len_of_block_device(f) {
+ if len < n {
+ // GNU compatibility:
+ // this case prints the stats but sets the exit code to 1
+ show_error!("'standard output': cannot seek: Invalid argument");
+ set_exit_code(1);
+ return Ok(len);
+ }
+ }
+ f.seek(io::SeekFrom::Current(n.try_into().unwrap()))
+ }
+ #[cfg(unix)]
+ Self::Fifo(f) => {
+ // Seeking in a named pipe means *reading* from the pipe.
+ io::copy(&mut f.take(n), &mut io::sink())
+ }
+ #[cfg(unix)]
+ Self::Sink => Ok(0),
}
}
/// Truncate the underlying file to the current stream position, if possible.
fn truncate(&mut self) -> io::Result<()> {
match self {
- Self::Stdout(_) => Ok(()),
Self::File(f, _) => {
let pos = f.stream_position()?;
f.set_len(pos)
}
+ _ => Ok(()),
+ }
+ }
+
+ /// Discard the system file cache for the given portion of the destination.
+ ///
+ /// `offset` and `len` specify a contiguous portion of the
+ /// destination. This function informs the kernel that the
+ /// specified portion of the destination is no longer needed. If
+ /// not possible, then this function returns an error.
+ #[cfg(target_os = "linux")]
+ fn discard_cache(&self, offset: libc::off_t, len: libc::off_t) -> nix::Result<()> {
+ match self {
+ Self::File(f, _) => {
+ let advice = PosixFadviseAdvice::POSIX_FADV_DONTNEED;
+ posix_fadvise(f.as_raw_fd(), offset, len, advice)
+ }
+ _ => Err(Errno::ESPIPE), // "Illegal seek"
+ }
+ }
+
+ /// The length of the data destination in number of bytes.
+ ///
+ /// If it cannot be determined, then this function returns 0.
+ fn len(&self) -> std::io::Result<i64> {
+ match self {
+ Self::File(f, _) => Ok(f.metadata()?.len().try_into().unwrap_or(i64::MAX)),
+ _ => Ok(0),
}
}
}
@@ -357,6 +685,10 @@ impl Write for Dest {
}
Self::File(f, _) => f.write(buf),
Self::Stdout(stdout) => stdout.write(buf),
+ #[cfg(unix)]
+ Self::Fifo(f) => f.write(buf),
+ #[cfg(unix)]
+ Self::Sink => Ok(buf.len()),
}
}
@@ -364,6 +696,10 @@ impl Write for Dest {
match self {
Self::Stdout(stdout) => stdout.flush(),
Self::File(f, _) => f.flush(),
+ #[cfg(unix)]
+ Self::Fifo(f) => f.flush(),
+ #[cfg(unix)]
+ Self::Sink => Ok(()),
}
}
}
@@ -372,7 +708,7 @@ impl Write for Dest {
///
/// Use the [`Output::new_stdout`] or [`Output::new_file`] functions
/// to construct a new instance of this struct. Then use the
-/// [`Output::dd_out`] function to execute the main copy operation for
+/// [`dd_copy`] function to execute the main copy operation for
/// `dd`.
struct Output<'a> {
/// The destination to which bytes will be written.
@@ -422,6 +758,11 @@ impl<'a> Output<'a> {
if !settings.oconv.notrunc {
dst.set_len(settings.seek).ok();
}
+
+ Self::prepare_file(dst, settings)
+ }
+
+ fn prepare_file(dst: File, settings: &'a Settings) -> UResult<Self> {
let density = if settings.oconv.sparse {
Density::Sparse
} else {
@@ -433,6 +774,100 @@ impl<'a> Output<'a> {
Ok(Self { dst, settings })
}
+ /// Instantiate this struct with file descriptor as a destination.
+ ///
+ /// This is useful e.g. for the case when the file descriptor was
+ /// already opened by the system (stdout) and has a state
+ /// (current position) that shall be used.
+ fn new_file_from_stdout(settings: &'a Settings) -> UResult<Self> {
+ let fx = OwnedFileDescriptorOrHandle::from(io::stdout())?;
+ #[cfg(any(target_os = "linux", target_os = "android"))]
+ if let Some(libc_flags) = make_linux_oflags(&settings.oflags) {
+ nix::fcntl::fcntl(
+ fx.as_raw().as_raw_fd(),
+ F_SETFL(OFlag::from_bits_retain(libc_flags)),
+ )?;
+ }
+
+ Self::prepare_file(fx.into_file(), settings)
+ }
+
+ /// Instantiate this struct with the given named pipe as a destination.
+ #[cfg(unix)]
+ fn new_fifo(filename: &Path, settings: &'a Settings) -> UResult<Self> {
+ // We simulate seeking in a FIFO by *reading*, so we open the
+ // file for reading. But then we need to close the file and
+ // re-open it for writing.
+ if settings.seek > 0 {
+ Dest::Fifo(File::open(filename)?).seek(settings.seek)?;
+ }
+ // If `count=0`, then we don't bother opening the file for
+ // writing because that would cause this process to block
+ // indefinitely.
+ if let Some(Num::Blocks(0) | Num::Bytes(0)) = settings.count {
+ let dst = Dest::Sink;
+ return Ok(Self { dst, settings });
+ }
+ // At this point, we know there is at least one block to write
+ // to the output, so we open the file for writing.
+ let mut opts = OpenOptions::new();
+ opts.write(true)
+ .create(!settings.oconv.nocreat)
+ .create_new(settings.oconv.excl)
+ .append(settings.oflags.append);
+ #[cfg(any(target_os = "linux", target_os = "android"))]
+ opts.custom_flags(make_linux_oflags(&settings.oflags).unwrap_or(0));
+ let dst = Dest::Fifo(opts.open(filename)?);
+ Ok(Self { dst, settings })
+ }
+
+ /// Discard the system file cache for the given portion of the output.
+ ///
+ /// `offset` and `len` specify a contiguous portion of the output.
+ /// This function informs the kernel that the specified portion of
+ /// the output file is no longer needed. If not possible, then
+ /// this function prints an error message to stderr and sets the
+ /// exit status code to 1.
+ #[allow(unused_variables)]
+ fn discard_cache(&self, offset: libc::off_t, len: libc::off_t) {
+ #[cfg(target_os = "linux")]
+ {
+ show_if_err!(self
+ .dst
+ .discard_cache(offset, len)
+ .map_err_context(|| "failed to discard cache for: 'standard output'".to_string()));
+ }
+ #[cfg(target_os = "linux")]
+ {
+ // TODO Is there a way to discard filesystem cache on
+ // these other operating systems?
+ }
+ }
+
+ /// writes a block of data. optionally retries when first try didn't complete
+ ///
+ /// this is needed by gnu-test: tests/dd/stats.s
+ /// the write can be interrupted by a system signal.
+ /// e.g. SIGUSR1 which is send to report status
+ /// without retry, the data might not be fully written to destination.
+ fn write_block(&mut self, chunk: &[u8]) -> io::Result<usize> {
+ let full_len = chunk.len();
+ let mut base_idx = 0;
+ loop {
+ match self.dst.write(&chunk[base_idx..]) {
+ Ok(wlen) => {
+ base_idx += wlen;
+ // take iflags.fullblock as oflags shall not have this option
+ if (base_idx >= full_len) || !self.settings.iflags.fullblock {
+ return Ok(base_idx);
+ }
+ }
+ Err(e) if e.kind() == io::ErrorKind::Interrupted => continue,
+ Err(e) => return Err(e),
+ }
+ }
+ }
+
/// Write the given bytes one block at a time.
///
/// This may write partial blocks (for example, if the underlying
@@ -446,7 +881,7 @@ impl<'a> Output<'a> {
let mut bytes_total = 0;
for chunk in buf.chunks(self.settings.obs) {
- let wlen = self.dst.write(chunk)?;
+ let wlen = self.write_block(chunk)?;
if wlen < self.settings.obs {
writes_partial += 1;
} else {
@@ -474,138 +909,306 @@ impl<'a> Output<'a> {
}
}
- /// Copy the given input data to this output, consuming both.
- ///
- /// This method contains the main loop for the `dd` program. Bytes
- /// are read in blocks from `i` and written in blocks to this
- /// output. Read/write statistics are reported to stderr as
- /// configured by the `status` command-line argument.
- ///
- /// # Errors
- ///
- /// If there is a problem reading from the input or writing to
- /// this output.
- fn dd_out<R: Read>(mut self, mut i: Input<R>) -> std::io::Result<()> {
- // The read and write statistics.
- //
- // These objects are counters, initialized to zero. After each
- // iteration of the main loop, each will be incremented by the
- // number of blocks read and written, respectively.
- let mut rstat = ReadStat::default();
- let mut wstat = WriteStat::default();
+ /// Truncate the underlying file to the current stream position, if possible.
+ fn truncate(&mut self) -> std::io::Result<()> {
+ self.dst.truncate()
+ }
+}
- // The time at which the main loop starts executing.
- //
- // When `status=progress` is given on the command-line, the
- // `dd` program reports its progress every second or so. Part
- // of its report includes the throughput in bytes per second,
- // which requires knowing how long the process has been
- // running.
- let start = time::Instant::now();
-
- // A good buffer size for reading.
- //
- // This is an educated guess about a good buffer size based on
- // the input and output block sizes.
- let bsize = calc_bsize(i.settings.ibs, self.settings.obs);
+/// The block writer either with or without partial block buffering.
+enum BlockWriter<'a> {
+ /// Block writer with partial block buffering.
+ ///
+ /// Partial blocks are buffered until completed.
+ Buffered(BufferedOutput<'a>),
- // Start a thread that reports transfer progress.
- //
- // The `dd` program reports its progress after every block is written,
- // at most every 1 second, and only if `status=progress` is given on
- // the command-line or a SIGUSR1 signal is received. We
- // perform this reporting in a new thread so as not to take
- // any CPU time away from the actual reading and writing of
- // data. We send a `ProgUpdate` from the transmitter `prog_tx`
- // to the receives `rx`, and the receiver prints the transfer
- // information.
- let (prog_tx, rx) = mpsc::channel();
- let output_thread = thread::spawn(gen_prog_updater(rx, i.settings.status));
- let mut progress_as_secs = 0;
-
- // Optimization: if no blocks are to be written, then don't
- // bother allocating any buffers.
- if let Some(Num::Blocks(0) | Num::Bytes(0)) = i.settings.count {
- return self.finalize(rstat, wstat, start, &prog_tx, output_thread);
- };
+ /// Block writer without partial block buffering.
+ ///
+ /// Partial blocks are written immediately.
+ Unbuffered(Output<'a>),
+}
- // Create a common buffer with a capacity of the block size.
- // This is the max size needed.
- let mut buf = vec![BUF_INIT_BYTE; bsize];
+impl<'a> BlockWriter<'a> {
+ fn discard_cache(&self, offset: libc::off_t, len: libc::off_t) {
+ match self {
+ Self::Unbuffered(o) => o.discard_cache(offset, len),
+ Self::Buffered(o) => o.discard_cache(offset, len),
+ }
+ }
- // The main read/write loop.
- //
- // Each iteration reads blocks from the input and writes
- // blocks to this output. Read/write statistics are updated on
- // each iteration and cumulative statistics are reported to
- // the progress reporting thread.
- while below_count_limit(&i.settings.count, &rstat, &wstat) {
- // Read a block from the input then write the block to the output.
- //
- // As an optimization, make an educated guess about the
- // best buffer size for reading based on the number of
- // blocks already read and the number of blocks remaining.
- let loop_bsize =
- calc_loop_bsize(&i.settings.count, &rstat, &wstat, i.settings.ibs, bsize);
- let rstat_update = read_helper(&mut i, &mut buf, loop_bsize)?;
- if rstat_update.is_empty() {
- break;
- }
- let wstat_update = self.write_blocks(&buf)?;
-
- // Update the read/write stats and inform the progress thread once per second.
- //
- // If the receiver is disconnected, `send()` returns an
- // error. Since it is just reporting progress and is not
- // crucial to the operation of `dd`, let's just ignore the
- // error.
- rstat += rstat_update;
- wstat += wstat_update;
- let prog_update = ProgUpdate::new(rstat, wstat, start.elapsed(), false);
- if prog_update.duration.as_secs() >= progress_as_secs {
- progress_as_secs = prog_update.duration.as_secs() + 1;
- prog_tx.send(prog_update).unwrap_or(());
- }
+ fn flush(&mut self) -> io::Result<WriteStat> {
+ match self {
+ Self::Unbuffered(_) => Ok(WriteStat::default()),
+ Self::Buffered(o) => o.flush(),
}
- self.finalize(rstat, wstat, start, &prog_tx, output_thread)
}
- /// Flush output, print final stats, and join with the progress thread.
- fn finalize<T>(
- &mut self,
- rstat: ReadStat,
- wstat: WriteStat,
- start: time::Instant,
- prog_tx: &mpsc::Sender<ProgUpdate>,
- output_thread: thread::JoinHandle<T>,
- ) -> std::io::Result<()> {
- // Flush the output, if configured to do so.
- self.sync()?;
+ fn sync(&mut self) -> io::Result<()> {
+ match self {
+ Self::Unbuffered(o) => o.sync(),
+ Self::Buffered(o) => o.sync(),
+ }
+ }
- // Truncate the file to the final cursor location.
- //
+ /// Truncate the file to the final cursor location.
+ fn truncate(&mut self) {
// Calling `set_len()` may result in an error (for example,
// when calling it on `/dev/null`), but we don't want to
// terminate the process when that happens. Instead, we
// suppress the error by calling `Result::ok()`. This matches
// the behavior of GNU `dd` when given the command-line
// argument `of=/dev/null`.
- if !self.settings.oconv.notrunc {
- self.dst.truncate().ok();
+ match self {
+ Self::Unbuffered(o) => o.truncate().ok(),
+ Self::Buffered(o) => o.truncate().ok(),
+ };
+ }
+
+ fn write_blocks(&mut self, buf: &[u8]) -> std::io::Result<WriteStat> {
+ match self {
+ Self::Unbuffered(o) => o.write_blocks(buf),
+ Self::Buffered(o) => o.write_blocks(buf),
}
+ }
+}
- // Print the final read/write statistics.
- let prog_update = ProgUpdate::new(rstat, wstat, start.elapsed(), true);
- prog_tx.send(prog_update).unwrap_or(());
- // Wait for the output thread to finish
- output_thread
- .join()
- .expect("Failed to join with the output thread.");
- Ok(())
+/// depending on the command line arguments, this function
+/// informs the OS to flush/discard the caches for input and/or output file.
+fn flush_caches_full_length(i: &Input, o: &Output) -> std::io::Result<()> {
+ // TODO Better error handling for overflowing `len`.
+ if i.settings.iflags.nocache {
+ let offset = 0;
+ #[allow(clippy::useless_conversion)]
+ let len = i.src.len()?.try_into().unwrap();
+ i.discard_cache(offset, len);
+ }
+ // Similarly, discard the system cache for the output file.
+ //
+ // TODO Better error handling for overflowing `len`.
+ if i.settings.oflags.nocache {
+ let offset = 0;
+ #[allow(clippy::useless_conversion)]
+ let len = o.dst.len()?.try_into().unwrap();
+ o.discard_cache(offset, len);
}
+
+ Ok(())
+}
+
+/// Copy the given input data to this output, consuming both.
+///
+/// This method contains the main loop for the `dd` program. Bytes
+/// are read in blocks from `i` and written in blocks to this
+/// output. Read/write statistics are reported to stderr as
+/// configured by the `status` command-line argument.
+///
+/// # Errors
+///
+/// If there is a problem reading from the input or writing to
+/// this output.
+fn dd_copy(mut i: Input, o: Output) -> std::io::Result<()> {
+ // The read and write statistics.
+ //
+ // These objects are counters, initialized to zero. After each
+ // iteration of the main loop, each will be incremented by the
+ // number of blocks read and written, respectively.
+ let mut rstat = ReadStat::default();
+ let mut wstat = WriteStat::default();
+
+ // The time at which the main loop starts executing.
+ //
+ // When `status=progress` is given on the command-line, the
+ // `dd` program reports its progress every second or so. Part
+ // of its report includes the throughput in bytes per second,
+ // which requires knowing how long the process has been
+ // running.
+ let start = Instant::now();
+
+ // A good buffer size for reading.
+ //
+ // This is an educated guess about a good buffer size based on
+ // the input and output block sizes.
+ let bsize = calc_bsize(i.settings.ibs, o.settings.obs);
+
+ // Start a thread that reports transfer progress.
+ //
+ // The `dd` program reports its progress after every block is written,
+ // at most every 1 second, and only if `status=progress` is given on
+ // the command-line or a SIGUSR1 signal is received. We
+ // perform this reporting in a new thread so as not to take
+ // any CPU time away from the actual reading and writing of
+ // data. We send a `ProgUpdate` from the transmitter `prog_tx`
+ // to the receives `rx`, and the receiver prints the transfer
+ // information.
+ let (prog_tx, rx) = mpsc::channel();
+ let output_thread = thread::spawn(gen_prog_updater(rx, i.settings.status));
+
+ // Whether to truncate the output file after all blocks have been written.
+ let truncate = !o.settings.oconv.notrunc;
+
+ // Optimization: if no blocks are to be written, then don't
+ // bother allocating any buffers.
+ if let Some(Num::Blocks(0) | Num::Bytes(0)) = i.settings.count {
+ // Even though we are not reading anything from the input
+ // file, we still need to honor the `nocache` flag, which
+ // requests that we inform the system that we no longer
+ // need the contents of the input file in a system cache.
+ //
+ flush_caches_full_length(&i, &o)?;
+ return finalize(
+ BlockWriter::Unbuffered(o),
+ rstat,
+ wstat,
+ start,
+ &prog_tx,
+ output_thread,
+ truncate,
+ );
+ };
+
+ // Create a common buffer with a capacity of the block size.
+ // This is the max size needed.
+ let mut buf = vec![BUF_INIT_BYTE; bsize];
+
+ // Spawn a timer thread to provide a scheduled signal indicating when we
+ // should send an update of our progress to the reporting thread.
+ //
+ // This avoids the need to query the OS monotonic clock for every block.
+ let alarm = Alarm::with_interval(Duration::from_secs(1));
+
+ // The signal handler spawns an own thread that waits for signals.
+ // When the signal is received, it calls a handler function.
+ // We inject a handler function that manually triggers the alarm.
+ #[cfg(target_os = "linux")]
+ let signal_handler = progress::SignalHandler::install_signal_handler(alarm.manual_trigger_fn());
+ #[cfg(target_os = "linux")]
+ if let Err(e) = &signal_handler {
+ if Some(StatusLevel::None) != i.settings.status {
+ eprintln!("Internal dd Warning: Unable to register signal handler \n\t{e}");
+ }
+ }
+
+ // Index in the input file where we are reading bytes and in
+ // the output file where we are writing bytes.
+ //
+ // These are updated on each iteration of the main loop.
+ let mut read_offset = 0;
+ let mut write_offset = 0;
+
+ let input_nocache = i.settings.iflags.nocache;
+ let output_nocache = o.settings.oflags.nocache;
+
+ // Add partial block buffering, if needed.
+ let mut o = if o.settings.buffered {
+ BlockWriter::Buffered(BufferedOutput::new(o))
+ } else {
+ BlockWriter::Unbuffered(o)
+ };
+
+ // The main read/write loop.
+ //
+ // Each iteration reads blocks from the input and writes
+ // blocks to this output. Read/write statistics are updated on
+ // each iteration and cumulative statistics are reported to
+ // the progress reporting thread.
+ while below_count_limit(&i.settings.count, &rstat) {
+ // Read a block from the input then write the block to the output.
+ //
+ // As an optimization, make an educated guess about the
+ // best buffer size for reading based on the number of
+ // blocks already read and the number of blocks remaining.
+ let loop_bsize = calc_loop_bsize(&i.settings.count, &rstat, &wstat, i.settings.ibs, bsize);
+ let rstat_update = read_helper(&mut i, &mut buf, loop_bsize)?;
+ if rstat_update.is_empty() {
+ break;
+ }
+ let wstat_update = o.write_blocks(&buf)?;
+
+ // Discard the system file cache for the read portion of
+ // the input file.
+ //
+ // TODO Better error handling for overflowing `offset` and `len`.
+ let read_len = rstat_update.bytes_total;
+ if input_nocache {
+ let offset = read_offset.try_into().unwrap();
+ let len = read_len.try_into().unwrap();
+ i.discard_cache(offset, len);
+ }
+ read_offset += read_len;
+
+ // Discard the system file cache for the written portion
+ // of the output file.
+ //
+ // TODO Better error handling for overflowing `offset` and `len`.
+ let write_len = wstat_update.bytes_total;
+ if output_nocache {
+ let offset = write_offset.try_into().unwrap();
+ let len = write_len.try_into().unwrap();
+ o.discard_cache(offset, len);
+ }
+ write_offset += write_len;
+
+ // Update the read/write stats and inform the progress thread once per second.
+ //
+ // If the receiver is disconnected, `send()` returns an
+ // error. Since it is just reporting progress and is not
+ // crucial to the operation of `dd`, let's just ignore the
+ // error.
+ rstat += rstat_update;
+ wstat += wstat_update;
+ match alarm.get_trigger() {
+ ALARM_TRIGGER_NONE => {}
+ t @ ALARM_TRIGGER_TIMER | t @ ALARM_TRIGGER_SIGNAL => {
+ let tp = match t {
+ ALARM_TRIGGER_TIMER => ProgUpdateType::Periodic,
+ _ => ProgUpdateType::Signal,
+ };
+ let prog_update = ProgUpdate::new(rstat, wstat, start.elapsed(), tp);
+ prog_tx.send(prog_update).unwrap_or(());
+ }
+ _ => {}
+ }
+ }
+
+ finalize(o, rstat, wstat, start, &prog_tx, output_thread, truncate)
+}
+
+/// Flush output, print final stats, and join with the progress thread.
+fn finalize<T>(
+ mut output: BlockWriter,
+ rstat: ReadStat,
+ wstat: WriteStat,
+ start: Instant,
+ prog_tx: &mpsc::Sender<ProgUpdate>,
+ output_thread: thread::JoinHandle<T>,
+ truncate: bool,
+) -> std::io::Result<()> {
+ // Flush the output in case a partial write has been buffered but
+ // not yet written.
+ let wstat_update = output.flush()?;
+
+ // Sync the output, if configured to do so.
+ output.sync()?;
+
+ // Truncate the file to the final cursor location.
+ if truncate {
+ output.truncate();
+ }
+
+ // Print the final read/write statistics.
+ let wstat = wstat + wstat_update;
+ let prog_update = ProgUpdate::new(rstat, wstat, start.elapsed(), ProgUpdateType::Final);
+ prog_tx.send(prog_update).unwrap_or(());
+ // Wait for the output thread to finish
+ output_thread
+ .join()
+ .expect("Failed to join with the output thread.");
+
+ Ok(())
}
#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(clippy::cognitive_complexity)]
fn make_linux_oflags(oflags: &OFlags) -> Option<libc::c_int> {
let mut flag = 0;
@@ -638,19 +1241,20 @@ fn make_linux_oflags(oflags: &OFlags) -> Option<libc::c_int> {
flag |= libc::O_SYNC;
}
- if flag != 0 {
- Some(flag)
- } else {
+ if flag == 0 {
None
+ } else {
+ Some(flag)
}
}
-/// Read helper performs read operations common to all dd reads, and dispatches the buffer to relevant helper functions as dictated by the operations requested by the user.
-fn read_helper<R: Read>(
- i: &mut Input<R>,
- buf: &mut Vec<u8>,
- bsize: usize,
-) -> std::io::Result<ReadStat> {
+/// Read from an input (that is, a source of bytes) into the given buffer.
+///
+/// This function also performs any conversions as specified by
+/// `conv=swab` or `conv=block` command-line arguments. This function
+/// mutates the `buf` argument in-place. The returned [`ReadStat`]
+/// indicates how many blocks were read.
+fn read_helper(i: &mut Input, buf: &mut Vec<u8>, bsize: usize) -> std::io::Result<ReadStat> {
// Local Helper Fns -------------------------------------------------
fn perform_swab(buf: &mut [u8]) {
for base in (1..buf.len()).step_by(2) {
@@ -713,7 +1317,7 @@ fn calc_loop_bsize(
cmp::min(ideal_bsize as u64, rremain * ibs as u64) as usize
}
Some(Num::Bytes(bmax)) => {
- let bmax: u128 = (*bmax).try_into().unwrap();
+ let bmax: u128 = (*bmax).into();
let bremain: u128 = bmax - wstat.bytes_total;
cmp::min(ideal_bsize as u128, bremain) as usize
}
@@ -723,16 +1327,10 @@ fn calc_loop_bsize(
// Decide if the current progress is below a count=N limit or return
// true if no such limit is set.
-fn below_count_limit(count: &Option<Num>, rstat: &ReadStat, wstat: &WriteStat) -> bool {
+fn below_count_limit(count: &Option<Num>, rstat: &ReadStat) -> bool {
match count {
- Some(Num::Blocks(n)) => {
- let n = *n;
- rstat.reads_complete + rstat.reads_partial <= n
- }
- Some(Num::Bytes(n)) => {
- let n = (*n).try_into().unwrap();
- wstat.bytes_total <= n
- }
+ Some(Num::Blocks(n)) => rstat.reads_complete + rstat.reads_partial < *n,
+ Some(Num::Bytes(n)) => rstat.bytes_total < *n,
None => true,
}
}
@@ -772,18 +1370,39 @@ fn is_stdout_redirected_to_seekable_file() -> bool {
let p = Path::new(&s);
match File::open(p) {
Ok(mut f) => {
- f.seek(SeekFrom::Current(0)).is_ok()
- && f.seek(SeekFrom::End(0)).is_ok()
- && f.seek(SeekFrom::Start(0)).is_ok()
+ f.stream_position().is_ok() && f.seek(SeekFrom::End(0)).is_ok() && f.rewind().is_ok()
}
Err(_) => false,
}
}
+/// Try to get the len if it is a block device
+#[cfg(unix)]
+fn try_get_len_of_block_device(file: &mut File) -> io::Result<Option<u64>> {
+ let ftype = file.metadata()?.file_type();
+ if !ftype.is_block_device() {
+ return Ok(None);
+ }
+
+ // FIXME: this can be replaced by file.stream_len() when stable.
+ let len = file.seek(SeekFrom::End(0))?;
+ file.rewind()?;
+ Ok(Some(len))
+}
+
+/// Decide whether the named file is a named pipe, also known as a FIFO.
+#[cfg(unix)]
+fn is_fifo(filename: &str) -> bool {
+ if let Ok(metadata) = std::fs::metadata(filename) {
+ if metadata.file_type().is_fifo() {
+ return true;
+ }
+ }
+ false
+}
+
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_ignore();
-
let matches = uu_app().try_get_matches_from(args)?;
let settings: Settings = Parser::new().parse(
@@ -794,46 +1413,27 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
.collect::<Vec<_>>()[..],
)?;
- match (&settings.infile, &settings.outfile) {
- (Some(infile), Some(outfile)) => {
- let i = Input::<File>::new(Path::new(&infile), &settings)?;
- let o = Output::new_file(Path::new(&outfile), &settings)?;
- o.dd_out(i).map_err_context(|| "IO error".to_string())
- }
- (None, Some(outfile)) => {
- let i = Input::<io::Stdin>::new(&settings)?;
- let o = Output::new_file(Path::new(&outfile), &settings)?;
- o.dd_out(i).map_err_context(|| "IO error".to_string())
- }
- (Some(infile), None) => {
- let i = Input::<File>::new(Path::new(&infile), &settings)?;
- if is_stdout_redirected_to_seekable_file() {
- let filename = stdout_canonicalized();
- let o = Output::new_file(Path::new(&filename), &settings)?;
- o.dd_out(i).map_err_context(|| "IO error".to_string())
- } else {
- let o = Output::new_stdout(&settings)?;
- o.dd_out(i).map_err_context(|| "IO error".to_string())
- }
- }
- (None, None) => {
- let i = Input::<io::Stdin>::new(&settings)?;
- if is_stdout_redirected_to_seekable_file() {
- let filename = stdout_canonicalized();
- let o = Output::new_file(Path::new(&filename), &settings)?;
- o.dd_out(i).map_err_context(|| "IO error".to_string())
- } else {
- let o = Output::new_stdout(&settings)?;
- o.dd_out(i).map_err_context(|| "IO error".to_string())
- }
- }
- }
+ let i = match settings.infile {
+ #[cfg(unix)]
+ Some(ref infile) if is_fifo(infile) => Input::new_fifo(Path::new(&infile), &settings)?,
+ Some(ref infile) => Input::new_file(Path::new(&infile), &settings)?,
+ None => Input::new_stdin(&settings)?,
+ };
+ let o = match settings.outfile {
+ #[cfg(unix)]
+ Some(ref outfile) if is_fifo(outfile) => Output::new_fifo(Path::new(&outfile), &settings)?,
+ Some(ref outfile) => Output::new_file(Path::new(&outfile), &settings)?,
+ None if is_stdout_redirected_to_seekable_file() => Output::new_file_from_stdout(&settings)?,
+ None => Output::new_stdout(&settings)?,
+ };
+ dd_copy(i, o).map_err_context(|| "IO error".to_string())
}
pub fn uu_app() -> Command {
Command::new(uucore::util_name())
.version(crate_version!())
.about(ABOUT)
+ .override_usage(format_usage(USAGE))
.after_help(AFTER_HELP)
.infer_long_args(true)
.arg(Arg::new(options::OPERANDS).num_args(1..))
diff --git a/src/uu/dd/src/numbers.rs b/src/uu/dd/src/numbers.rs
index 1a32180b732297514f9aed319838f13fa1d5273a..8a6fa5a7a37a7cab4d9ccb25a13318ad9a2bf767 100644
--- a/src/uu/dd/src/numbers.rs
+++ b/src/uu/dd/src/numbers.rs
@@ -1,7 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
/// Functions for formatting a number as a magnitude and a unit suffix.
/// The first ten powers of 1024.
@@ -80,7 +80,7 @@ pub(crate) fn to_magnitude_and_suffix(n: u128, suffix_type: SuffixType) -> Strin
//
let quotient = (n as f64) / (base as f64);
if quotient < 10.0 {
- format!("{:.1} {}", quotient, suffix)
+ format!("{quotient:.1} {suffix}")
} else {
format!("{} {}", quotient.round(), suffix)
}
@@ -115,6 +115,7 @@ mod tests {
}
#[test]
+ #[allow(clippy::cognitive_complexity)]
fn test_to_magnitude_and_suffix_not_powers_of_1024() {
assert_eq!(to_magnitude_and_suffix(1, SuffixType::Si), "1.0 B");
assert_eq!(to_magnitude_and_suffix(999, SuffixType::Si), "999 B");
diff --git a/src/uu/dd/src/parseargs.rs b/src/uu/dd/src/parseargs.rs
index beeccc2e36c8e2b6a489855ac59556b55a505644..93d6c63a97d09a1f356ffe81f1505a42269d781f 100644
--- a/src/uu/dd/src/parseargs.rs
+++ b/src/uu/dd/src/parseargs.rs
@@ -1,7 +1,5 @@
// This file is part of the uutils coreutils package.
//
-// (c) Tyler Steele <tyler.steele@protonmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
// spell-checker:ignore ctty, ctable, iseek, oseek, iconvflags, oconvflags parseargs outfile oconv
@@ -37,41 +35,28 @@ pub enum ParseError {
}
/// Contains a temporary state during parsing of the arguments
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Default)]
pub struct Parser {
infile: Option<String>,
outfile: Option<String>,
- ibs: usize,
- obs: usize,
+ /// The block size option specified on the command-line, if any.
+ bs: Option<usize>,
+ /// The input block size option specified on the command-line, if any.
+ ibs: Option<usize>,
+ /// The output block size option specified on the command-line, if any.
+ obs: Option<usize>,
cbs: Option<usize>,
skip: Num,
seek: Num,
count: Option<Num>,
conv: ConvFlags,
+ /// Whether a data-transforming `conv` option has been specified.
+ is_conv_specified: bool,
iflag: IFlags,
oflag: OFlags,
status: Option<StatusLevel>,
}
-impl Default for Parser {
- fn default() -> Self {
- Self {
- ibs: 512,
- obs: 512,
- cbs: None,
- infile: None,
- outfile: None,
- skip: Num::Blocks(0),
- seek: Num::Blocks(0),
- count: None,
- conv: ConvFlags::default(),
- iflag: IFlags::default(),
- oflag: OFlags::default(),
- status: None,
- }
- }
-}
-
#[derive(Debug, Default, PartialEq, Eq)]
pub struct ConvFlags {
ascii: bool,
@@ -214,15 +199,34 @@ impl Parser {
fsync: conv.fsync,
};
+ // Input and output block sizes.
+ //
+ // The `bs` option takes precedence. If either is not
+ // provided, `ibs` and `obs` are each 512 bytes by default.
+ let (ibs, obs) = match self.bs {
+ None => (self.ibs.unwrap_or(512), self.obs.unwrap_or(512)),
+ Some(bs) => (bs, bs),
+ };
+
+ // Whether to buffer partial output blocks until they are completed.
+ //
+ // From the GNU `dd` documentation for the `bs=BYTES` option:
+ //
+ // > [...] if no data-transforming 'conv' option is specified,
+ // > input is copied to the output as soon as it's read, even if
+ // > it is smaller than the block size.
+ //
+ let buffered = self.bs.is_none() || self.is_conv_specified;
+
let skip = self
.skip
.force_bytes_if(self.iflag.skip_bytes)
- .to_bytes(self.ibs as u64);
+ .to_bytes(ibs as u64);
let seek = self
.seek
.force_bytes_if(self.oflag.seek_bytes)
- .to_bytes(self.obs as u64);
+ .to_bytes(obs as u64);
let count = self.count.map(|c| c.force_bytes_if(self.iflag.count_bytes));
@@ -232,8 +236,9 @@ impl Parser {
count,
iconv,
oconv,
- ibs: self.ibs,
- obs: self.obs,
+ ibs,
+ obs,
+ buffered,
infile: self.infile,
outfile: self.outfile,
iflags: self.iflag,
@@ -246,45 +251,44 @@ impl Parser {
match operand.split_once('=') {
None => return Err(ParseError::UnrecognizedOperand(operand.to_string())),
Some((k, v)) => match k {
- "bs" => {
- let bs = self.parse_bytes(k, v)?;
- self.ibs = bs;
- self.obs = bs;
+ "bs" => self.bs = Some(Self::parse_bytes(k, v)?),
+ "cbs" => self.cbs = Some(Self::parse_bytes(k, v)?),
+ "conv" => {
+ self.is_conv_specified = true;
+ self.parse_conv_flags(v)?;
}
- "cbs" => self.cbs = Some(self.parse_bytes(k, v)?),
- "conv" => self.parse_conv_flags(v)?,
- "count" => self.count = Some(self.parse_n(v)?),
- "ibs" => self.ibs = self.parse_bytes(k, v)?,
+ "count" => self.count = Some(Self::parse_n(v)?),
+ "ibs" => self.ibs = Some(Self::parse_bytes(k, v)?),
"if" => self.infile = Some(v.to_string()),
"iflag" => self.parse_input_flags(v)?,
- "obs" => self.obs = self.parse_bytes(k, v)?,
+ "obs" => self.obs = Some(Self::parse_bytes(k, v)?),
"of" => self.outfile = Some(v.to_string()),
"oflag" => self.parse_output_flags(v)?,
- "seek" | "oseek" => self.seek = self.parse_n(v)?,
- "skip" | "iseek" => self.skip = self.parse_n(v)?,
- "status" => self.status = Some(self.parse_status_level(v)?),
+ "seek" | "oseek" => self.seek = Self::parse_n(v)?,
+ "skip" | "iseek" => self.skip = Self::parse_n(v)?,
+ "status" => self.status = Some(Self::parse_status_level(v)?),
_ => return Err(ParseError::UnrecognizedOperand(operand.to_string())),
},
}
Ok(())
}
- fn parse_n(&self, val: &str) -> Result<Num, ParseError> {
+ fn parse_n(val: &str) -> Result<Num, ParseError> {
let n = parse_bytes_with_opt_multiplier(val)?;
- Ok(if val.ends_with('B') {
+ Ok(if val.contains('B') {
Num::Bytes(n)
} else {
Num::Blocks(n)
})
}
- fn parse_bytes(&self, arg: &str, val: &str) -> Result<usize, ParseError> {
+ fn parse_bytes(arg: &str, val: &str) -> Result<usize, ParseError> {
parse_bytes_with_opt_multiplier(val)?
.try_into()
.map_err(|_| ParseError::BsOutOfRange(arg.to_string()))
}
- fn parse_status_level(&self, val: &str) -> Result<StatusLevel, ParseError> {
+ fn parse_status_level(val: &str) -> Result<StatusLevel, ParseError> {
match val {
"none" => Ok(StatusLevel::None),
"noxfer" => Ok(StatusLevel::Noxfer),
@@ -293,8 +297,9 @@ impl Parser {
}
}
+ #[allow(clippy::cognitive_complexity)]
fn parse_input_flags(&mut self, val: &str) -> Result<(), ParseError> {
- let mut i = &mut self.iflag;
+ let i = &mut self.iflag;
for f in val.split(',') {
match f {
// Common flags
@@ -303,7 +308,7 @@ impl Parser {
"directory" => linux_only!(f, i.directory = true),
"dsync" => linux_only!(f, i.dsync = true),
"sync" => linux_only!(f, i.sync = true),
- "nocache" => return Err(ParseError::Unimplemented(f.to_string())),
+ "nocache" => linux_only!(f, i.nocache = true),
"nonblock" => linux_only!(f, i.nonblock = true),
"noatime" => linux_only!(f, i.noatime = true),
"noctty" => linux_only!(f, i.noctty = true),
@@ -324,8 +329,9 @@ impl Parser {
Ok(())
}
+ #[allow(clippy::cognitive_complexity)]
fn parse_output_flags(&mut self, val: &str) -> Result<(), ParseError> {
- let mut o = &mut self.oflag;
+ let o = &mut self.oflag;
for f in val.split(',') {
match f {
// Common flags
@@ -334,7 +340,7 @@ impl Parser {
"directory" => linux_only!(f, o.directory = true),
"dsync" => linux_only!(f, o.dsync = true),
"sync" => linux_only!(f, o.sync = true),
- "nocache" => return Err(ParseError::Unimplemented(f.to_string())),
+ "nocache" => linux_only!(f, o.nocache = true),
"nonblock" => linux_only!(f, o.nonblock = true),
"noatime" => linux_only!(f, o.noatime = true),
"noctty" => linux_only!(f, o.noctty = true),
@@ -355,7 +361,7 @@ impl Parser {
}
fn parse_conv_flags(&mut self, val: &str) -> Result<(), ParseError> {
- let mut c = &mut self.conv;
+ let c = &mut self.conv;
for f in val.split(',') {
match f {
// Conversion
@@ -394,7 +400,7 @@ impl std::fmt::Display for ParseError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::UnrecognizedOperand(arg) => {
- write!(f, "Unrecognized operand '{}'", arg)
+ write!(f, "Unrecognized operand '{arg}'")
}
Self::MultipleFmtTable => {
write!(
@@ -421,32 +427,31 @@ impl std::fmt::Display for ParseError {
)
}
Self::ConvFlagNoMatch(arg) => {
- write!(f, "Unrecognized conv=CONV -> {}", arg)
+ write!(f, "Unrecognized conv=CONV -> {arg}")
}
Self::MultiplierStringParseFailure(arg) => {
- write!(f, "Unrecognized byte multiplier -> {}", arg)
+ write!(f, "Unrecognized byte multiplier -> {arg}")
}
Self::MultiplierStringOverflow(arg) => {
write!(
f,
- "Multiplier string would overflow on current system -> {}",
- arg
+ "Multiplier string would overflow on current system -> {arg}"
)
}
Self::BlockUnblockWithoutCBS => {
write!(f, "conv=block or conv=unblock specified without cbs=N")
}
Self::StatusLevelNotRecognized(arg) => {
- write!(f, "status=LEVEL not recognized -> {}", arg)
+ write!(f, "status=LEVEL not recognized -> {arg}")
}
Self::BsOutOfRange(arg) => {
- write!(f, "{}=N cannot fit into memory", arg)
+ write!(f, "{arg}=N cannot fit into memory")
}
Self::Unimplemented(arg) => {
- write!(f, "feature not implemented on this system -> {}", arg)
+ write!(f, "feature not implemented on this system -> {arg}")
}
Self::InvalidNumber(arg) => {
- write!(f, "invalid number: ‘{}’", arg)
+ write!(f, "invalid number: ‘{arg}’")
}
}
}
@@ -485,6 +490,8 @@ fn parse_bytes_only(s: &str) -> Result<u64, ParseError> {
/// 512. You can also use standard block size suffixes like `'k'` for
/// 1024.
///
+/// If the number would be too large, return [`std::u64::MAX`] instead.
+///
/// # Errors
///
/// If a number cannot be parsed or if the multiplication would cause
@@ -502,17 +509,16 @@ fn parse_bytes_only(s: &str) -> Result<u64, ParseError> {
fn parse_bytes_no_x(full: &str, s: &str) -> Result<u64, ParseError> {
let parser = SizeParser {
capital_b_bytes: true,
+ no_empty_numeric: true,
..Default::default()
};
let (num, multiplier) = match (s.find('c'), s.rfind('w'), s.rfind('b')) {
- (None, None, None) => match parser.parse(s) {
+ (None, None, None) => match parser.parse_u64(s) {
Ok(n) => (n, 1),
+ Err(ParseSizeError::SizeTooBig(_)) => (u64::MAX, 1),
Err(ParseSizeError::InvalidSuffix(_) | ParseSizeError::ParseFailure(_)) => {
return Err(ParseError::InvalidNumber(full.to_string()))
}
- Err(ParseSizeError::SizeTooBig(_)) => {
- return Err(ParseError::MultiplierStringOverflow(full.to_string()))
- }
},
(Some(i), None, None) => (parse_bytes_only(&s[..i])?, 1),
(None, Some(i), None) => (parse_bytes_only(&s[..i])?, 2),
@@ -625,22 +631,42 @@ fn conversion_mode(
#[cfg(test)]
mod tests {
- use crate::parseargs::parse_bytes_with_opt_multiplier;
+ use crate::parseargs::{parse_bytes_with_opt_multiplier, Parser};
+ use crate::Num;
+ use std::matches;
+ const BIG: &str = "9999999999999999999999999999999999999999999999999999999999999";
#[test]
- fn test_parse_bytes_with_opt_multiplier() {
+ fn test_parse_bytes_with_opt_multiplier_invalid() {
+ assert!(parse_bytes_with_opt_multiplier("123asdf").is_err());
+ }
+
+ #[test]
+ fn test_parse_bytes_with_opt_multiplier_without_x() {
assert_eq!(parse_bytes_with_opt_multiplier("123").unwrap(), 123);
assert_eq!(parse_bytes_with_opt_multiplier("123c").unwrap(), 123); // 123 * 1
assert_eq!(parse_bytes_with_opt_multiplier("123w").unwrap(), 123 * 2);
assert_eq!(parse_bytes_with_opt_multiplier("123b").unwrap(), 123 * 512);
- assert_eq!(parse_bytes_with_opt_multiplier("123x3").unwrap(), 123 * 3);
assert_eq!(parse_bytes_with_opt_multiplier("123k").unwrap(), 123 * 1024);
- assert_eq!(parse_bytes_with_opt_multiplier("1x2x3").unwrap(), 6); // 1 * 2 * 3
+ assert_eq!(parse_bytes_with_opt_multiplier(BIG).unwrap(), u64::MAX);
+ }
+ #[test]
+ fn test_parse_bytes_with_opt_multiplier_with_x() {
+ assert_eq!(parse_bytes_with_opt_multiplier("123x3").unwrap(), 123 * 3);
+ assert_eq!(parse_bytes_with_opt_multiplier("1x2x3").unwrap(), 6); // 1 * 2 * 3
assert_eq!(
parse_bytes_with_opt_multiplier("1wx2cx3w").unwrap(),
2 * 2 * (3 * 2) // (1 * 2) * (2 * 1) * (3 * 2)
);
- assert!(parse_bytes_with_opt_multiplier("123asdf").is_err());
+ }
+ #[test]
+ fn test_parse_n() {
+ for arg in ["1x8x4", "1c", "123b", "123w"] {
+ assert!(matches!(Parser::parse_n(arg), Ok(Num::Blocks(_))));
+ }
+ for arg in ["1Bx8x4", "2Bx8", "2Bx8B", "2x8B"] {
+ assert!(matches!(Parser::parse_n(arg), Ok(Num::Bytes(_))));
+ }
}
}
diff --git a/src/uu/dd/src/parseargs/unit_tests.rs b/src/uu/dd/src/parseargs/unit_tests.rs
index 7084f8114e3d4797343f34b50be0fb765cecc54b..baeafdd56aefa2f77e482453b45261f8339c2cc1 100644
--- a/src/uu/dd/src/parseargs/unit_tests.rs
+++ b/src/uu/dd/src/parseargs/unit_tests.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore fname, tname, fpath, specfile, testfile, unspec, ifile, ofile, outfile, fullblock, urand, fileio, atoe, atoibm, behaviour, bmax, bremain, btotal, cflags, creat, ctable, ctty, datastructures, doesnt, etoa, fileout, fname, gnudd, iconvflags, iseek, nocache, noctty, noerror, nofollow, nolinks, nonblock, oconvflags, oseek, outfile, parseargs, rlen, rmax, rposition, rremain, rsofar, rstat, sigusr, sigval, wlen, wstat, oconv
use super::*;
@@ -9,6 +13,7 @@ use crate::parseargs::Parser;
use crate::StatusLevel;
#[cfg(not(any(target_os = "linux", target_os = "android")))]
+#[allow(clippy::useless_vec)]
#[test]
fn unimplemented_flags_should_error_non_linux() {
let mut succeeded = Vec::new();
@@ -51,34 +56,34 @@ fn unimplemented_flags_should_error_non_linux() {
}
#[test]
+#[allow(clippy::useless_vec)]
fn unimplemented_flags_should_error() {
let mut succeeded = Vec::new();
// The following flags are not implemented
- for flag in ["cio", "nocache", "nolinks", "text", "binary"] {
- let args = vec![format!("iflag={}", flag)];
+ for flag in ["cio", "nolinks", "text", "binary"] {
+ let args = vec![format!("iflag={flag}")];
if Parser::new()
.parse(&args.iter().map(AsRef::as_ref).collect::<Vec<_>>()[..])
.is_ok()
{
- succeeded.push(format!("iflag={}", flag));
+ succeeded.push(format!("iflag={flag}"));
}
- let args = vec![format!("oflag={}", flag)];
+ let args = vec![format!("oflag={flag}")];
if Parser::new()
.parse(&args.iter().map(AsRef::as_ref).collect::<Vec<_>>()[..])
.is_ok()
{
- succeeded.push(format!("iflag={}", flag));
+ succeeded.push(format!("iflag={flag}"));
}
}
assert!(
succeeded.is_empty(),
- "The following flags did not panic as expected: {:?}",
- succeeded
+ "The following flags did not panic as expected: {succeeded:?}"
);
}
@@ -100,6 +105,7 @@ fn test_status_level_none() {
}
#[test]
+#[allow(clippy::cognitive_complexity)]
fn test_all_top_level_args_no_leading_dashes() {
let args = &[
"if=foo.file",
@@ -354,6 +360,7 @@ fn parse_icf_tokens_remaining() {
fsync: true,
..Default::default()
},
+ is_conv_specified: true,
..Default::default()
})
);
@@ -501,14 +508,6 @@ mod test_64bit_arch {
);
}
-#[test]
-#[should_panic]
-fn test_overflow_panic() {
- let bs_str = format!("{}KiB", u64::MAX);
-
- parse_bytes_with_opt_multiplier(&bs_str).unwrap();
-}
-
#[test]
#[should_panic]
fn test_neg_panic() {
diff --git a/src/uu/dd/src/progress.rs b/src/uu/dd/src/progress.rs
index 9302bc7a6ff23204e08352bc9378166ef4c98e11..268b3d5f4ea52155ea5ed75b22922ba53e133e9c 100644
--- a/src/uu/dd/src/progress.rs
+++ b/src/uu/dd/src/progress.rs
@@ -1,7 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore btotal sigval
//! Read and write progress tracking for dd.
//!
@@ -11,23 +11,26 @@
//! updater that runs in its own thread.
use std::io::Write;
use std::sync::mpsc;
+#[cfg(target_os = "linux")]
+use std::thread::JoinHandle;
use std::time::Duration;
-use crate::numbers::{to_magnitude_and_suffix, SuffixType};
-
-// On Linux, we register a signal handler that prints progress updates.
#[cfg(target_os = "linux")]
-use signal_hook::consts::signal;
-#[cfg(target_os = "linux")]
-use std::{
- env,
- error::Error,
- sync::{
- atomic::{AtomicUsize, Ordering},
- Arc,
- },
+use signal_hook::iterator::Handle;
+use uucore::{
+ error::UResult,
+ format::num_format::{FloatVariant, Formatter},
};
+use crate::numbers::{to_magnitude_and_suffix, SuffixType};
+
+#[derive(PartialEq, Eq)]
+pub(crate) enum ProgUpdateType {
+ Periodic,
+ Signal,
+ Final,
+}
+
/// Summary statistics for read and write progress of dd for a given duration.
pub(crate) struct ProgUpdate {
/// Read statistics.
@@ -48,7 +51,7 @@ pub(crate) struct ProgUpdate {
/// The status of the write.
///
/// True if the write is completed, false if still in-progress.
- pub(crate) complete: bool,
+ pub(crate) update_type: ProgUpdateType,
}
impl ProgUpdate {
@@ -57,13 +60,13 @@ impl ProgUpdate {
read_stat: ReadStat,
write_stat: WriteStat,
duration: Duration,
- complete: bool,
+ update_type: ProgUpdateType,
) -> Self {
Self {
read_stat,
write_stat,
duration,
- complete,
+ update_type,
}
}
@@ -76,9 +79,9 @@ impl ProgUpdate {
/// ```rust,ignore
/// use std::io::Cursor;
/// use std::time::Duration;
- /// use crate::progress::{ProgUpdate, ReadState, WriteStat};
+ /// use crate::progress::{ProgUpdate, ReadStat, WriteStat};
///
- /// let read_stat = ReadStat::new(1, 2, 3);
+ /// let read_stat = ReadStat::new(1, 2, 3, 999);
/// let write_stat = WriteStat::new(4, 5, 6);
/// let duration = Duration::new(789, 0);
/// let prog_update = ProgUpdate {
@@ -100,7 +103,7 @@ impl ProgUpdate {
match self.read_stat.records_truncated {
0 => {}
1 => writeln!(w, "1 truncated record")?,
- n => writeln!(w, "{} truncated records", n)?,
+ n => writeln!(w, "{n} truncated records")?,
}
Ok(())
}
@@ -118,7 +121,7 @@ impl ProgUpdate {
/// ```rust,ignore
/// use std::io::Cursor;
/// use std::time::Duration;
- /// use crate::progress::{ProgUpdate, ReadState, WriteStat};
+ /// use crate::progress::ProgUpdate;
///
/// let prog_update = ProgUpdate {
/// read_stat: Default::default(),
@@ -131,7 +134,7 @@ impl ProgUpdate {
/// prog_update.write_prog_line(&mut cursor, rewrite).unwrap();
/// assert_eq!(cursor.get_ref(), b"0 bytes copied, 1.0 s, 0.0 B/s\n");
/// ```
- fn write_prog_line(&self, w: &mut impl Write, rewrite: bool) -> std::io::Result<()> {
+ fn write_prog_line(&self, w: &mut impl Write, rewrite: bool) -> UResult<()> {
// The total number of bytes written as a string, in SI and IEC format.
let btotal = self.write_stat.bytes_total;
let btotal_metric = to_magnitude_and_suffix(btotal, SuffixType::Si);
@@ -148,37 +151,38 @@ impl ProgUpdate {
// (`\n`) at the end.
let (carriage_return, newline) = if rewrite { ("\r", "") } else { ("", "\n") };
+ // The duration should be formatted as in `printf %g`.
+ let mut duration_str = Vec::new();
+ uucore::format::num_format::Float {
+ variant: FloatVariant::Shortest,
+ ..Default::default()
+ }
+ .fmt(&mut duration_str, duration)?;
+ // We assume that printf will output valid UTF-8
+ let duration_str = std::str::from_utf8(&duration_str).unwrap();
+
// If the number of bytes written is sufficiently large, then
// print a more concise representation of the number, like
// "1.2 kB" and "1.0 KiB".
match btotal {
1 => write!(
w,
- "{}{} byte copied, {:.1} s, {}/s{}",
- carriage_return, btotal, duration, transfer_rate, newline,
- ),
+ "{carriage_return}{btotal} byte copied, {duration_str} s, {transfer_rate}/s{newline}",
+ )?,
0..=999 => write!(
w,
- "{}{} bytes copied, {:.1} s, {}/s{}",
- carriage_return, btotal, duration, transfer_rate, newline,
- ),
+ "{carriage_return}{btotal} bytes copied, {duration_str} s, {transfer_rate}/s{newline}",
+ )?,
1000..=1023 => write!(
w,
- "{}{} bytes ({}) copied, {:.1} s, {}/s{}",
- carriage_return, btotal, btotal_metric, duration, transfer_rate, newline,
- ),
+ "{carriage_return}{btotal} bytes ({btotal_metric}) copied, {duration_str} s, {transfer_rate}/s{newline}",
+ )?,
_ => write!(
w,
- "{}{} bytes ({}, {}) copied, {:.1} s, {}/s{}",
- carriage_return,
- btotal,
- btotal_metric,
- btotal_bin,
- duration,
- transfer_rate,
- newline,
- ),
- }
+ "{carriage_return}{btotal} bytes ({btotal_metric}, {btotal_bin}) copied, {duration_str} s, {transfer_rate}/s{newline}",
+ )?,
+ };
+ Ok(())
}
/// Write all summary statistics.
@@ -194,7 +198,7 @@ impl ProgUpdate {
/// ```rust,ignore
/// use std::io::Cursor;
/// use std::time::Duration;
- /// use crate::progress::{ProgUpdate, ReadState, WriteStat};
+ /// use crate::progress::ProgUpdate;
///
/// let prog_update = ProgUpdate {
/// read_stat: Default::default(),
@@ -210,7 +214,7 @@ impl ProgUpdate {
/// assert_eq!(iter.next().unwrap(), b"");
/// assert!(iter.next().is_none());
/// ```
- fn write_transfer_stats(&self, w: &mut impl Write, new_line: bool) -> std::io::Result<()> {
+ fn write_transfer_stats(&self, w: &mut impl Write, new_line: bool) -> UResult<()> {
if new_line {
writeln!(w)?;
}
@@ -279,16 +283,20 @@ pub(crate) struct ReadStat {
///
/// A truncated record can only occur in `conv=block` mode.
pub(crate) records_truncated: u32,
+
+ /// The total number of bytes read.
+ pub(crate) bytes_total: u64,
}
impl ReadStat {
/// Create a new instance.
#[allow(dead_code)]
- fn new(complete: u64, partial: u64, truncated: u32) -> Self {
+ fn new(complete: u64, partial: u64, truncated: u32, bytes_total: u64) -> Self {
Self {
reads_complete: complete,
reads_partial: partial,
records_truncated: truncated,
+ bytes_total,
}
}
@@ -318,6 +326,7 @@ impl std::ops::AddAssign for ReadStat {
reads_complete: self.reads_complete + other.reads_complete,
reads_partial: self.reads_partial + other.reads_partial,
records_truncated: self.records_truncated + other.records_truncated,
+ bytes_total: self.bytes_total + other.bytes_total,
}
}
}
@@ -377,6 +386,17 @@ impl std::ops::AddAssign for WriteStat {
}
}
+impl std::ops::Add for WriteStat {
+ type Output = Self;
+ fn add(self, other: Self) -> Self {
+ Self {
+ writes_complete: self.writes_complete + other.writes_complete,
+ writes_partial: self.writes_partial + other.writes_partial,
+ bytes_total: self.bytes_total + other.bytes_total,
+ }
+ }
+}
+
/// How much detail to report when printing transfer statistics.
///
/// This corresponds to the available settings of the `status`
@@ -411,7 +431,7 @@ pub(crate) fn gen_prog_updater(
let mut progress_printed = false;
while let Ok(update) = rx.recv() {
// Print the final read/write statistics.
- if update.complete {
+ if update.update_type == ProgUpdateType::Final {
update.print_final_stats(print_level, progress_printed);
return;
}
@@ -423,6 +443,49 @@ pub(crate) fn gen_prog_updater(
}
}
+/// signal handler listens for SIGUSR1 signal and runs provided closure.
+#[cfg(target_os = "linux")]
+pub(crate) struct SignalHandler {
+ handle: Handle,
+ thread: Option<JoinHandle<()>>,
+}
+
+#[cfg(target_os = "linux")]
+impl SignalHandler {
+ pub(crate) fn install_signal_handler(
+ f: Box<dyn Send + Sync + Fn()>,
+ ) -> Result<Self, std::io::Error> {
+ use signal_hook::consts::signal::*;
+ use signal_hook::iterator::Signals;
+
+ let mut signals = Signals::new([SIGUSR1])?;
+ let handle = signals.handle();
+ let thread = std::thread::spawn(move || {
+ for signal in &mut signals {
+ match signal {
+ SIGUSR1 => (*f)(),
+ _ => unreachable!(),
+ }
+ }
+ });
+
+ Ok(Self {
+ handle,
+ thread: Some(thread),
+ })
+ }
+}
+
+#[cfg(target_os = "linux")]
+impl Drop for SignalHandler {
+ fn drop(&mut self) {
+ self.handle.close();
+ if let Some(thread) = std::mem::take(&mut self.thread) {
+ thread.join().unwrap();
+ }
+ }
+}
+
/// Return a closure that can be used in its own thread to print progress info.
///
/// This function returns a closure that receives [`ProgUpdate`]
@@ -437,53 +500,31 @@ pub(crate) fn gen_prog_updater(
rx: mpsc::Receiver<ProgUpdate>,
print_level: Option<StatusLevel>,
) -> impl Fn() {
- // TODO: SIGINFO: Trigger progress line reprint. BSD-style Linux only.
- const SIGUSR1_USIZE: usize = signal::SIGUSR1 as usize;
- fn posixly_correct() -> bool {
- env::var("POSIXLY_CORRECT").is_ok()
- }
- fn register_linux_signal_handler(sigval: Arc<AtomicUsize>) -> Result<(), Box<dyn Error>> {
- if !posixly_correct() {
- signal_hook::flag::register_usize(signal::SIGUSR1, sigval, SIGUSR1_USIZE)?;
- }
-
- Ok(())
- }
// --------------------------------------------------------------
move || {
- let sigval = Arc::new(AtomicUsize::new(0));
-
- register_linux_signal_handler(sigval.clone()).unwrap_or_else(|e| {
- if Some(StatusLevel::None) != print_level {
- eprintln!(
- "Internal dd Warning: Unable to register signal handler \n\t{}",
- e
- );
- }
- });
-
// Holds the state of whether we have printed the current progress.
// This is needed so that we know whether or not to print a newline
// character before outputting non-progress data.
let mut progress_printed = false;
while let Ok(update) = rx.recv() {
- // Print the final read/write statistics.
- if update.complete {
- update.print_final_stats(print_level, progress_printed);
- return;
- }
- // (Re)print status line if progress is requested.
- if Some(StatusLevel::Progress) == print_level && !update.complete {
- update.reprint_prog_line();
- progress_printed = true;
- }
- // Handle signals and set the signal to un-seen.
- // This will print a maximum of 1 time per second, even though it
- // should be printing on every SIGUSR1.
- if let SIGUSR1_USIZE = sigval.swap(0, Ordering::Relaxed) {
- update.print_transfer_stats(progress_printed);
- // Reset the progress printed, since print_transfer_stats always prints a newline.
- progress_printed = false;
+ match update.update_type {
+ ProgUpdateType::Final => {
+ // Print the final read/write statistics.
+ update.print_final_stats(print_level, progress_printed);
+ return;
+ }
+ ProgUpdateType::Periodic => {
+ // (Re)print status line if progress is requested.
+ if Some(StatusLevel::Progress) == print_level {
+ update.reprint_prog_line();
+ progress_printed = true;
+ }
+ }
+ ProgUpdateType::Signal => {
+ update.print_transfer_stats(progress_printed);
+ // Reset the progress printed, since print_transfer_stats always prints a newline.
+ progress_printed = false;
+ }
}
}
}
@@ -499,19 +540,28 @@ mod tests {
fn prog_update_write(n: u128) -> ProgUpdate {
ProgUpdate {
- read_stat: Default::default(),
+ read_stat: ReadStat::default(),
write_stat: WriteStat {
bytes_total: n,
..Default::default()
},
duration: Duration::new(1, 0), // one second
- complete: false,
+ update_type: super::ProgUpdateType::Periodic,
+ }
+ }
+
+ fn prog_update_duration(duration: Duration) -> ProgUpdate {
+ ProgUpdate {
+ read_stat: ReadStat::default(),
+ write_stat: WriteStat::default(),
+ duration,
+ update_type: super::ProgUpdateType::Periodic,
}
}
#[test]
fn test_read_stat_report() {
- let read_stat = ReadStat::new(1, 2, 3);
+ let read_stat = ReadStat::new(1, 2, 3, 4);
let mut cursor = Cursor::new(vec![]);
read_stat.report(&mut cursor).unwrap();
assert_eq!(cursor.get_ref(), b"1+2 records in\n");
@@ -527,15 +577,15 @@ mod tests {
#[test]
fn test_prog_update_write_io_lines() {
- let read_stat = ReadStat::new(1, 2, 3);
+ let read_stat = ReadStat::new(1, 2, 3, 4);
let write_stat = WriteStat::new(4, 5, 6);
let duration = Duration::new(789, 0);
- let complete = false;
+ let update_type = super::ProgUpdateType::Periodic;
let prog_update = ProgUpdate {
read_stat,
write_stat,
duration,
- complete,
+ update_type,
};
let mut cursor = Cursor::new(vec![]);
@@ -549,10 +599,10 @@ mod tests {
#[test]
fn test_prog_update_write_prog_line() {
let prog_update = ProgUpdate {
- read_stat: Default::default(),
- write_stat: Default::default(),
+ read_stat: ReadStat::default(),
+ write_stat: WriteStat::default(),
duration: Duration::new(1, 0), // one second
- complete: false,
+ update_type: super::ProgUpdateType::Periodic,
};
let mut cursor = Cursor::new(vec![]);
@@ -565,24 +615,24 @@ mod tests {
// 0 bytes copied, 7.9151e-05 s, 0.0 kB/s
//
// The throughput still does not match GNU dd.
- assert_eq!(cursor.get_ref(), b"0 bytes copied, 1.0 s, 0.0 B/s\n");
+ assert_eq!(cursor.get_ref(), b"0 bytes copied, 1 s, 0.0 B/s\n");
let prog_update = prog_update_write(1);
let mut cursor = Cursor::new(vec![]);
prog_update.write_prog_line(&mut cursor, rewrite).unwrap();
- assert_eq!(cursor.get_ref(), b"1 byte copied, 1.0 s, 0.0 B/s\n");
+ assert_eq!(cursor.get_ref(), b"1 byte copied, 1 s, 0.0 B/s\n");
let prog_update = prog_update_write(999);
let mut cursor = Cursor::new(vec![]);
prog_update.write_prog_line(&mut cursor, rewrite).unwrap();
- assert_eq!(cursor.get_ref(), b"999 bytes copied, 1.0 s, 0.0 B/s\n");
+ assert_eq!(cursor.get_ref(), b"999 bytes copied, 1 s, 0.0 B/s\n");
let prog_update = prog_update_write(1000);
let mut cursor = Cursor::new(vec![]);
prog_update.write_prog_line(&mut cursor, rewrite).unwrap();
assert_eq!(
cursor.get_ref(),
- b"1000 bytes (1.0 kB) copied, 1.0 s, 1.0 kB/s\n"
+ b"1000 bytes (1.0 kB) copied, 1 s, 1.0 kB/s\n"
);
let prog_update = prog_update_write(1023);
@@ -590,7 +640,7 @@ mod tests {
prog_update.write_prog_line(&mut cursor, rewrite).unwrap();
assert_eq!(
cursor.get_ref(),
- b"1023 bytes (1.0 kB) copied, 1.0 s, 1.0 kB/s\n"
+ b"1023 bytes (1.0 kB) copied, 1 s, 1.0 kB/s\n"
);
let prog_update = prog_update_write(1024);
@@ -598,17 +648,17 @@ mod tests {
prog_update.write_prog_line(&mut cursor, rewrite).unwrap();
assert_eq!(
cursor.get_ref(),
- b"1024 bytes (1.0 kB, 1.0 KiB) copied, 1.0 s, 1.0 kB/s\n"
+ b"1024 bytes (1.0 kB, 1.0 KiB) copied, 1 s, 1.0 kB/s\n"
);
}
#[test]
fn write_transfer_stats() {
let prog_update = ProgUpdate {
- read_stat: Default::default(),
- write_stat: Default::default(),
+ read_stat: ReadStat::default(),
+ write_stat: WriteStat::default(),
duration: Duration::new(1, 0), // one second
- complete: false,
+ update_type: super::ProgUpdateType::Periodic,
};
let mut cursor = Cursor::new(vec![]);
prog_update
@@ -617,7 +667,7 @@ mod tests {
let mut iter = cursor.get_ref().split(|v| *v == b'\n');
assert_eq!(iter.next().unwrap(), b"0+0 records in");
assert_eq!(iter.next().unwrap(), b"0+0 records out");
- assert_eq!(iter.next().unwrap(), b"0 bytes copied, 1.0 s, 0.0 B/s");
+ assert_eq!(iter.next().unwrap(), b"0 bytes copied, 1 s, 0.0 B/s");
assert_eq!(iter.next().unwrap(), b"");
assert!(iter.next().is_none());
}
@@ -626,21 +676,30 @@ mod tests {
fn write_final_transfer_stats() {
// Tests the formatting of the final statistics written after a progress line.
let prog_update = ProgUpdate {
- read_stat: Default::default(),
- write_stat: Default::default(),
+ read_stat: ReadStat::default(),
+ write_stat: WriteStat::default(),
duration: Duration::new(1, 0), // one second
- complete: false,
+ update_type: super::ProgUpdateType::Periodic,
};
let mut cursor = Cursor::new(vec![]);
let rewrite = true;
prog_update.write_prog_line(&mut cursor, rewrite).unwrap();
prog_update.write_transfer_stats(&mut cursor, true).unwrap();
let mut iter = cursor.get_ref().split(|v| *v == b'\n');
- assert_eq!(iter.next().unwrap(), b"\r0 bytes copied, 1.0 s, 0.0 B/s");
+ assert_eq!(iter.next().unwrap(), b"\r0 bytes copied, 1 s, 0.0 B/s");
assert_eq!(iter.next().unwrap(), b"0+0 records in");
assert_eq!(iter.next().unwrap(), b"0+0 records out");
- assert_eq!(iter.next().unwrap(), b"0 bytes copied, 1.0 s, 0.0 B/s");
+ assert_eq!(iter.next().unwrap(), b"0 bytes copied, 1 s, 0.0 B/s");
assert_eq!(iter.next().unwrap(), b"");
assert!(iter.next().is_none());
}
+
+ #[test]
+ fn test_duration_precision() {
+ let prog_update = prog_update_duration(Duration::from_nanos(123));
+ let mut cursor = Cursor::new(vec![]);
+ let rewrite = false;
+ prog_update.write_prog_line(&mut cursor, rewrite).unwrap();
+ assert_eq!(cursor.get_ref(), b"0 bytes copied, 1.23e-07 s, 0.0 B/s\n");
+ }
}
diff --git a/src/uu/df/Cargo.toml b/src/uu/df/Cargo.toml
index 0a229415c6d8348cf8eb33df727bd8f5465172b6..d82a00822d910d987b45faf7e4f45f7aed21cbe4 100644
--- a/src/uu/df/Cargo.toml
+++ b/src/uu/df/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_df"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "df ~ (uutils) display file system information"
@@ -15,9 +15,12 @@ edition = "2021"
path = "src/df.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["libc", "fsext"] }
-unicode-width = "0.1.9"
+clap = { workspace = true }
+uucore = { workspace = true, features = ["libc", "fsext"] }
+unicode-width = { workspace = true }
+
+[dev-dependencies]
+tempfile = "3.10.1"
[[bin]]
name = "df"
diff --git a/src/uu/df/df.md b/src/uu/df/df.md
new file mode 100644
index 0000000000000000000000000000000000000000..1a192f8fd01ec8b09b4f39cdea97482ad620edc0
--- /dev/null
+++ b/src/uu/df/df.md
@@ -0,0 +1,18 @@
+# df
+
+```
+df [OPTION]... [FILE]...
+```
+
+Show information about the file system on which each FILE resides,
+or all file systems by default.
+
+## After Help
+
+Display values are in units of the first available SIZE from --block-size,
+and the DF_BLOCK_SIZE, BLOCK_SIZE and BLOCKSIZE environment variables.
+Otherwise, units default to 1024 bytes (or 512 if POSIXLY_CORRECT is set).
+
+SIZE is an integer and optional unit (example: 10M is 10*1024*1024).
+Units are K, M, G, T, P, E, Z, Y (powers of 1024) or KB, MB,... (powers
+of 1000).
diff --git a/src/uu/df/src/blocks.rs b/src/uu/df/src/blocks.rs
index 79151f817311be9eec3635b664a309e95e4d1626..d7a689d8c86938b5678207d59d821a9442f855e1 100644
--- a/src/uu/df/src/blocks.rs
+++ b/src/uu/df/src/blocks.rs
@@ -1,7 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//! Types for representing and displaying block sizes.
use crate::{OPT_BLOCKSIZE, OPT_PORTABILITY};
use clap::ArgMatches;
@@ -9,7 +9,7 @@ use std::{env, fmt};
use uucore::{
display::Quotable,
- parse_size::{parse_size, ParseSizeError},
+ parse_size::{parse_size_u64, ParseSizeError},
};
/// The first ten powers of 1024.
@@ -91,12 +91,12 @@ pub(crate) fn to_magnitude_and_suffix(n: u128, suffix_type: SuffixType) -> Strin
let suffix = suffixes[i];
if rem == 0 {
- format!("{}{}", quot, suffix)
+ format!("{quot}{suffix}")
} else {
let tenths_place = rem / (bases[i] / 10);
if rem % (bases[i] / 10) == 0 {
- format!("{}.{}{}", quot, tenths_place, suffix)
+ format!("{quot}.{tenths_place}{suffix}")
} else if tenths_place + 1 == 10 || quot >= 10 {
format!("{}{}", quot + 1, suffix)
} else {
@@ -165,7 +165,7 @@ impl Default for BlockSize {
pub(crate) fn read_block_size(matches: &ArgMatches) -> Result<BlockSize, ParseSizeError> {
if matches.contains_id(OPT_BLOCKSIZE) {
let s = matches.get_one::<String>(OPT_BLOCKSIZE).unwrap();
- let bytes = parse_size(s)?;
+ let bytes = parse_size_u64(s)?;
if bytes > 0 {
Ok(BlockSize::Bytes(bytes))
@@ -184,7 +184,7 @@ pub(crate) fn read_block_size(matches: &ArgMatches) -> Result<BlockSize, ParseSi
fn block_size_from_env() -> Option<u64> {
for env_var in ["DF_BLOCK_SIZE", "BLOCK_SIZE", "BLOCKSIZE"] {
if let Ok(env_size) = env::var(env_var) {
- if let Ok(size) = parse_size(&env_size) {
+ if let Ok(size) = parse_size_u64(&env_size) {
return Some(size);
} else {
return None;
@@ -205,7 +205,7 @@ impl fmt::Display for BlockSize {
to_magnitude_and_suffix(*n as u128, SuffixType::Si)
};
- write!(f, "{}", s)
+ write!(f, "{s}")
}
}
}
@@ -239,6 +239,7 @@ mod tests {
}
#[test]
+ #[allow(clippy::cognitive_complexity)]
fn test_to_magnitude_and_suffix_not_powers_of_1024() {
assert_eq!(to_magnitude_and_suffix(1, SuffixType::Si), "1B");
assert_eq!(to_magnitude_and_suffix(999, SuffixType::Si), "999B");
diff --git a/src/uu/df/src/columns.rs b/src/uu/df/src/columns.rs
index f9515d791582e6a34a050ef6379bab73b5bbac86..3c0a244192e2177c081760da4e3bc2f37154960f 100644
--- a/src/uu/df/src/columns.rs
+++ b/src/uu/df/src/columns.rs
@@ -1,7 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore itotal iused iavail ipcent pcent squashfs
use crate::{OPT_INODES, OPT_OUTPUT, OPT_PRINT_TYPE};
use clap::{parser::ValueSource, ArgMatches};
@@ -201,6 +201,7 @@ impl Column {
// 14 = length of "Filesystem" plus 4 spaces
Self::Source => 14,
Self::Used => 5,
+ Self::Size => 5,
// the shortest headers have a length of 4 chars so we use that as the minimum width
_ => 4,
}
diff --git a/src/uu/df/src/df.rs b/src/uu/df/src/df.rs
index a0760539950403e2ab301cb3ffef3682f328b304..c21ba98471add83f9a14261b4fbc599215a4b4f8 100644
--- a/src/uu/df/src/df.rs
+++ b/src/uu/df/src/df.rs
@@ -1,10 +1,7 @@
// This file is part of the uutils coreutils package.
//
-// (c) Fangxu Hu <framlog@gmail.com>
-// (c) Sylvestre Ledru <sylvestre@debian.org>
-//
-// For the full copyright and license information, please view the LICENSE file
-// that was distributed with this source code.
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore itotal iused iavail ipcent pcent tmpfs squashfs lofs
mod blocks;
mod columns;
@@ -19,7 +16,7 @@ use uucore::error::FromIo;
use uucore::error::{UError, UResult, USimpleError};
use uucore::fsext::{read_fs_list, MountInfo};
use uucore::parse_size::ParseSizeError;
-use uucore::{format_usage, show};
+use uucore::{format_usage, help_about, help_section, help_usage, show};
use clap::{crate_version, parser::ValueSource, Arg, ArgAction, ArgMatches, Command};
@@ -33,16 +30,9 @@ use crate::columns::{Column, ColumnError};
use crate::filesystem::Filesystem;
use crate::table::Table;
-static ABOUT: &str = "Show information about the file system on which each FILE resides,\n\
- or all file systems by default.";
-const USAGE: &str = "{} [OPTION]... [FILE]...";
-const LONG_HELP: &str = "Display values are in units of the first available SIZE from --block-size,
-and the DF_BLOCK_SIZE, BLOCK_SIZE and BLOCKSIZE environment variables.
-Otherwise, units default to 1024 bytes (or 512 if POSIXLY_CORRECT is set).
-
-SIZE is an integer and optional unit (example: 10M is 10*1024*1024).
-Units are K, M, G, T, P, E, Z, Y (powers of 1024) or KB, MB,... (powers
-of 1000).";
+const ABOUT: &str = help_about!("df.md");
+const USAGE: &str = help_usage!("df.md");
+const AFTER_HELP: &str = help_section!("after help", "df.md");
static OPT_HELP: &str = "help";
static OPT_ALL: &str = "all";
@@ -146,10 +136,10 @@ impl fmt::Display for OptionsError {
}
// TODO This needs to vary based on whether `--block-size`
// or `-B` were provided.
- Self::InvalidBlockSize(s) => write!(f, "invalid --block-size argument {}", s),
+ Self::InvalidBlockSize(s) => write!(f, "invalid --block-size argument {s}"),
// TODO This needs to vary based on whether `--block-size`
// or `-B` were provided.
- Self::InvalidSuffix(s) => write!(f, "invalid suffix in --block-size argument {}", s),
+ Self::InvalidSuffix(s) => write!(f, "invalid suffix in --block-size argument {s}"),
Self::ColumnError(ColumnError::MultipleColumns(s)) => write!(
f,
"option --output: field {} used more than once",
@@ -240,7 +230,7 @@ impl Options {
}
}
- (!intersected_types.is_empty()).then(|| intersected_types)
+ (!intersected_types.is_empty()).then_some(intersected_types)
}
}
@@ -346,7 +336,7 @@ fn filter_mount_list(vmi: Vec<MountInfo>, opt: &Options) -> Vec<MountInfo> {
fn get_all_filesystems(opt: &Options) -> Result<Vec<Filesystem>, std::io::Error> {
// Run a sync call before any operation if so instructed.
if opt.sync {
- #[cfg(not(windows))]
+ #[cfg(not(any(windows, target_os = "redox")))]
unsafe {
#[cfg(not(target_os = "android"))]
uucore::libc::sync();
@@ -487,7 +477,7 @@ pub fn uu_app() -> Command {
.version(crate_version!())
.about(ABOUT)
.override_usage(format_usage(USAGE))
- .after_help(LONG_HELP)
+ .after_help(AFTER_HELP)
.infer_long_args(true)
.disable_help_flag(true)
.arg(
@@ -753,7 +743,7 @@ mod tests {
#[test]
fn test_remote_included() {
- let opt = Default::default();
+ let opt = Options::default();
let m = mount_info("ext4", "/mnt/foo", true, false);
assert!(is_included(&m, &opt));
}
@@ -780,7 +770,7 @@ mod tests {
#[test]
fn test_dummy_excluded() {
- let opt = Default::default();
+ let opt = Options::default();
let m = mount_info("ext4", "/mnt/foo", false, true);
assert!(!is_included(&m, &opt));
}
@@ -871,11 +861,11 @@ mod tests {
mod filter_mount_list {
- use crate::filter_mount_list;
+ use crate::{filter_mount_list, Options};
#[test]
fn test_empty() {
- let opt = Default::default();
+ let opt = Options::default();
let mount_infos = vec![];
assert!(filter_mount_list(mount_infos, &opt).is_empty());
}
diff --git a/src/uu/df/src/filesystem.rs b/src/uu/df/src/filesystem.rs
index aac63ac9dee8fd14694e19ff8db8e2e991ae4ee8..821c99ab4738f49f79022d368382cdb577c29bcb 100644
--- a/src/uu/df/src/filesystem.rs
+++ b/src/uu/df/src/filesystem.rs
@@ -1,7 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//! Provides a summary representation of a filesystem.
//!
//! A [`Filesystem`] struct represents a device containing a
@@ -42,7 +42,7 @@ pub(crate) struct Filesystem {
/// This function returns the element of `mounts` on which `path` is
/// mounted. If there are no matches, this function returns
/// [`None`]. If there are two or more matches, then the single
-/// [`MountInfo`] with the longest mount directory is returned.
+/// [`MountInfo`] with the device name corresponding to the entered path.
///
/// If `canonicalize` is `true`, then the `path` is canonicalized
/// before checking whether it matches any mount directories.
@@ -68,9 +68,19 @@ where
path.as_ref().to_path_buf()
};
+ // Find the potential mount point that matches entered path
let maybe_mount_point = mounts
.iter()
- .find(|mi| mi.dev_name.eq(&path.to_string_lossy()));
+ // Create pair MountInfo, canonicalized device name
+ // TODO Abstract from accessing real filesystem to
+ // make code more testable
+ .map(|m| (m, std::fs::canonicalize(&m.dev_name)))
+ // Ignore non existing paths
+ .filter(|m| m.1.is_ok())
+ .map(|m| (m.0, m.1.ok().unwrap()))
+ // Try to find canonicalized device name corresponding to entered path
+ .find(|m| m.1.eq(&path))
+ .map(|m| m.0);
maybe_mount_point.or_else(|| {
mounts
@@ -83,9 +93,7 @@ where
impl Filesystem {
// TODO: resolve uuid in `mount_info.dev_name` if exists
pub(crate) fn new(mount_info: MountInfo, file: Option<String>) -> Option<Self> {
- let _stat_path = if !mount_info.mount_dir.is_empty() {
- mount_info.mount_dir.clone()
- } else {
+ let _stat_path = if mount_info.mount_dir.is_empty() {
#[cfg(unix)]
{
mount_info.dev_name.clone()
@@ -95,6 +103,8 @@ impl Filesystem {
// On windows, we expect the volume id
mount_info.dev_id.clone()
}
+ } else {
+ mount_info.mount_dir.clone()
};
#[cfg(unix)]
let usage = FsUsage::new(statfs(_stat_path).ok()?);
@@ -148,12 +158,12 @@ mod tests {
// Create a fake `MountInfo` with the given directory name.
fn mount_info(mount_dir: &str) -> MountInfo {
MountInfo {
- dev_id: Default::default(),
- dev_name: Default::default(),
- fs_type: Default::default(),
+ dev_id: String::default(),
+ dev_name: String::default(),
+ fs_type: String::default(),
mount_dir: String::from(mount_dir),
- mount_option: Default::default(),
- mount_root: Default::default(),
+ mount_option: String::default(),
+ mount_root: String::default(),
remote: Default::default(),
dummy: Default::default(),
}
@@ -210,11 +220,20 @@ mod tests {
}
#[test]
+ // clippy::assigning_clones added with Rust 1.78
+ // Rust version = 1.76 on OpenBSD stable/7.5
+ #[cfg_attr(not(target_os = "openbsd"), allow(clippy::assigning_clones))]
fn test_dev_name_match() {
+ let tmp = tempfile::TempDir::new().expect("Failed to create temp dir");
+ let dev_name = std::fs::canonicalize(tmp.path())
+ .expect("Failed to canonicalize tmp path")
+ .to_string_lossy()
+ .to_string();
+
let mut mount_info = mount_info("/foo");
- mount_info.dev_name = "/dev/sda2".to_string();
+ mount_info.dev_name = dev_name.clone();
let mounts = [mount_info];
- let actual = mount_info_from_path(&mounts, "/dev/sda2", false).unwrap();
+ let actual = mount_info_from_path(&mounts, dev_name, false).unwrap();
assert!(mount_info_eq(actual, &mounts[0]));
}
}
diff --git a/src/uu/df/src/table.rs b/src/uu/df/src/table.rs
index 63a135831fc967657b080885dcfefa6ba57cf894..daa30d1eef56bcc6a01b152af0294704eb92fc13 100644
--- a/src/uu/df/src/table.rs
+++ b/src/uu/df/src/table.rs
@@ -1,8 +1,8 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
-// spell-checker:ignore tmpfs Pcent Itotal Iused Iavail Ipcent
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore tmpfs Pcent Itotal Iused Iavail Ipcent nosuid nodev
//! The filesystem usage data table.
//!
//! A table ([`Table`]) comprises a header row ([`Header`]) and a
@@ -58,13 +58,13 @@ pub(crate) struct Row {
bytes_capacity: Option<f64>,
/// Total number of inodes in the filesystem.
- inodes: u64,
+ inodes: u128,
/// Number of used inodes.
- inodes_used: u64,
+ inodes_used: u128,
/// Number of free inodes.
- inodes_free: u64,
+ inodes_free: u128,
/// Percentage of inodes that are used, given as a float between 0 and 1.
///
@@ -152,8 +152,10 @@ impl From<Filesystem> for Row {
ffree,
..
} = fs.usage;
- let bused = blocks - bfree;
- let fused = files - ffree;
+
+ // On Windows WSL, files can be less than ffree. Protect such cases via saturating_sub.
+ let bused = blocks.saturating_sub(bfree);
+ let fused = files.saturating_sub(ffree);
Self {
file: fs.file,
fs_device: dev_name,
@@ -176,9 +178,9 @@ impl From<Filesystem> for Row {
} else {
Some(bavail as f64 / ((bused + bavail) as f64))
},
- inodes: files,
- inodes_used: fused,
- inodes_free: ffree,
+ inodes: files as u128,
+ inodes_used: fused as u128,
+ inodes_free: ffree as u128,
inodes_usage: if files == 0 {
None
} else {
@@ -233,9 +235,9 @@ impl<'a> RowFormatter<'a> {
/// Get a string giving the scaled version of the input number.
///
/// The scaling factor is defined in the `options` field.
- fn scaled_inodes(&self, size: u64) -> String {
+ fn scaled_inodes(&self, size: u128) -> String {
if let Some(h) = self.options.human_readable {
- to_magnitude_and_suffix(size.into(), SuffixType::HumanReadable(h))
+ to_magnitude_and_suffix(size, SuffixType::HumanReadable(h))
} else {
size.to_string()
}
@@ -393,12 +395,6 @@ impl Table {
let values = fmt.get_values();
total += row;
- for (i, value) in values.iter().enumerate() {
- if UnicodeWidthStr::width(value.as_str()) > widths[i] {
- widths[i] = UnicodeWidthStr::width(value.as_str());
- }
- }
-
rows.push(values);
}
}
@@ -408,6 +404,16 @@ impl Table {
rows.push(total_row.get_values());
}
+ // extend the column widths (in chars) for long values in rows
+ // do it here, after total row was added to the list of rows
+ for row in &rows {
+ for (i, value) in row.iter().enumerate() {
+ if UnicodeWidthStr::width(value.as_str()) > widths[i] {
+ widths[i] = UnicodeWidthStr::width(value.as_str());
+ }
+ }
+ }
+
Self {
rows,
widths,
@@ -438,7 +444,7 @@ impl fmt::Display for Table {
Alignment::Left => {
if is_last_col {
// no trailing spaces in last column
- write!(f, "{}", elem)?;
+ write!(f, "{elem}")?;
} else {
write!(f, "{:<width$}", elem, width = self.widths[i])?;
}
@@ -464,9 +470,11 @@ impl fmt::Display for Table {
#[cfg(test)]
mod tests {
+ use std::vec;
+
use crate::blocks::HumanReadable;
use crate::columns::Column;
- use crate::table::{Header, HeaderMode, Row, RowFormatter};
+ use crate::table::{Header, HeaderMode, Row, RowFormatter, Table};
use crate::{BlockSize, Options};
const COLUMNS_WITH_FS_TYPE: [Column; 7] = [
@@ -513,7 +521,7 @@ mod tests {
#[test]
fn test_default_header() {
- let options = Default::default();
+ let options = Options::default();
assert_eq!(
Header::get_headers(&options),
vec!(
@@ -815,4 +823,120 @@ mod tests {
assert_eq!(get_formatted_values(1000, 1000, 0), vec!("1", "1", "0"));
assert_eq!(get_formatted_values(1001, 1000, 1), vec!("2", "1", "1"));
}
+
+ #[test]
+ fn test_row_converter_with_invalid_numbers() {
+ // copy from wsl linux
+ let d = crate::Filesystem {
+ file: None,
+ mount_info: crate::MountInfo {
+ dev_id: "28".to_string(),
+ dev_name: "none".to_string(),
+ fs_type: "9p".to_string(),
+ mount_dir: "/usr/lib/wsl/drivers".to_string(),
+ mount_option: "ro,nosuid,nodev,noatime".to_string(),
+ mount_root: "/".to_string(),
+ remote: false,
+ dummy: false,
+ },
+ usage: crate::table::FsUsage {
+ blocksize: 4096,
+ blocks: 244029695,
+ bfree: 125085030,
+ bavail: 125085030,
+ bavail_top_bit_set: false,
+ files: 999,
+ ffree: 1000000,
+ },
+ };
+
+ let row = Row::from(d);
+
+ assert_eq!(row.inodes_used, 0);
+ }
+
+ #[test]
+ fn test_table_column_width_computation_include_total_row() {
+ let d1 = crate::Filesystem {
+ file: None,
+ mount_info: crate::MountInfo {
+ dev_id: "28".to_string(),
+ dev_name: "none".to_string(),
+ fs_type: "9p".to_string(),
+ mount_dir: "/usr/lib/wsl/drivers".to_string(),
+ mount_option: "ro,nosuid,nodev,noatime".to_string(),
+ mount_root: "/".to_string(),
+ remote: false,
+ dummy: false,
+ },
+ usage: crate::table::FsUsage {
+ blocksize: 4096,
+ blocks: 244029695,
+ bfree: 125085030,
+ bavail: 125085030,
+ bavail_top_bit_set: false,
+ files: 99999999999,
+ ffree: 999999,
+ },
+ };
+
+ let filesystems = vec![d1.clone(), d1];
+
+ let mut options = Options {
+ show_total: true,
+ columns: vec![
+ Column::Source,
+ Column::Itotal,
+ Column::Iused,
+ Column::Iavail,
+ ],
+ ..Default::default()
+ };
+
+ let table_w_total = Table::new(&options, filesystems.clone());
+ assert_eq!(
+ table_w_total.to_string(),
+ "Filesystem Inodes IUsed IFree\n\
+ none 99999999999 99999000000 999999\n\
+ none 99999999999 99999000000 999999\n\
+ total 199999999998 199998000000 1999998"
+ );
+
+ options.show_total = false;
+
+ let table_w_o_total = Table::new(&options, filesystems);
+ assert_eq!(
+ table_w_o_total.to_string(),
+ "Filesystem Inodes IUsed IFree\n\
+ none 99999999999 99999000000 999999\n\
+ none 99999999999 99999000000 999999"
+ );
+ }
+
+ #[test]
+ fn test_row_accumulation_u64_overflow() {
+ let total = u64::MAX as u128;
+ let used1 = 3000u128;
+ let used2 = 50000u128;
+
+ let mut row1 = Row {
+ inodes: total,
+ inodes_used: used1,
+ inodes_free: total - used1,
+ ..Default::default()
+ };
+
+ let row2 = Row {
+ inodes: total,
+ inodes_used: used2,
+ inodes_free: total - used2,
+ ..Default::default()
+ };
+
+ row1 += row2;
+
+ assert_eq!(row1.inodes, total * 2);
+ assert_eq!(row1.inodes_used, used1 + used2);
+ assert_eq!(row1.inodes_free, total * 2 - used1 - used2);
+ }
}
diff --git a/src/uu/dir/Cargo.toml b/src/uu/dir/Cargo.toml
index 09746b94cb7139e9a16fdd7c206a0befebc706b1..089dc45c549c8e4f65de82816dd3a7b7cb1634ff 100644
--- a/src/uu/dir/Cargo.toml
+++ b/src/uu/dir/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_dir"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "shortcut to ls -C -b"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/dir.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo", "env"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["entries", "fs"] }
-uu_ls = { version = ">=0.0.17", path="../ls"}
+clap = { workspace = true, features = ["env"] }
+uucore = { workspace = true, features = ["entries", "fs", "quoting-style"] }
+uu_ls = { workspace = true }
[[bin]]
name = "dir"
diff --git a/src/uu/dir/src/dir.rs b/src/uu/dir/src/dir.rs
index 6caf7bbe81c56f2b41861c3ad6946229104e2adb..e255295119acae9863f65cfff4d0ccfb82d34663 100644
--- a/src/uu/dir/src/dir.rs
+++ b/src/uu/dir/src/dir.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) gmnsii <gmnsii@protonmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use clap::Command;
use std::ffi::OsString;
diff --git a/src/uu/dircolors/Cargo.toml b/src/uu/dircolors/Cargo.toml
index 434b22d3afa4bc044aefa345bc18e037c543c435..3ca6e040b5547e619d47785eed91b2e442639654 100644
--- a/src/uu/dircolors/Cargo.toml
+++ b/src/uu/dircolors/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_dircolors"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "dircolors ~ (uutils) display commands to set LS_COLORS"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/dircolors.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["colors"] }
[[bin]]
name = "dircolors"
diff --git a/src/uu/dircolors/README.md b/src/uu/dircolors/README.md
index 7a02c0c4ba6e381382371a61e01e7fc5b680cb34..ce8aa965f93e730736d60c0a26c2e685643c82b4 100644
--- a/src/uu/dircolors/README.md
+++ b/src/uu/dircolors/README.md
@@ -1,18 +1,18 @@
-## How to update the internal database
+# How to update the internal database
Create the test fixtures by writing the output of the GNU dircolors commands to the fixtures folder:
-```
-$ dircolors --print-database > /PATH_TO_COREUTILS/tests/fixtures/dircolors/internal.expected
-$ dircolors --print-ls-colors > /PATH_TO_COREUTILS/tests/fixtures/dircolors/ls_colors.expected
-$ dircolors -b > /PATH_TO_COREUTILS/tests/fixtures/dircolors/bash_def.expected
-$ dircolors -c > /PATH_TO_COREUTILS/tests/fixtures/dircolors/csh_def.expected
+```shell
+dircolors --print-database > /PATH_TO_COREUTILS/tests/fixtures/dircolors/internal.expected
+dircolors --print-ls-colors > /PATH_TO_COREUTILS/tests/fixtures/dircolors/ls_colors.expected
+dircolors -b > /PATH_TO_COREUTILS/tests/fixtures/dircolors/bash_def.expected
+dircolors -c > /PATH_TO_COREUTILS/tests/fixtures/dircolors/csh_def.expected
```
Run the tests:
-```
-$ cargo test --features "dircolors" --no-default-features
+```shell
+cargo test --features "dircolors" --no-default-features
```
Edit `/PATH_TO_COREUTILS/src/uu/dircolors/src/colors.rs` until the tests pass.
diff --git a/src/uu/dircolors/dircolors.md b/src/uu/dircolors/dircolors.md
new file mode 100644
index 0000000000000000000000000000000000000000..959b8fd19bca110e9abaca738bd35fb02df1a7c2
--- /dev/null
+++ b/src/uu/dircolors/dircolors.md
@@ -0,0 +1,13 @@
+# dircolors
+
+```
+dircolors [OPTION]... [FILE]
+```
+
+Output commands to set the LS_COLORS environment variable.
+
+## After Help
+
+If FILE is specified, read it to determine which colors to use for which
+file types and extensions. Otherwise, a precompiled database is used.
+For details on the format of these files, run 'dircolors --print-database'
diff --git a/src/uu/dircolors/src/colors.rs b/src/uu/dircolors/src/colors.rs
deleted file mode 100644
index d864a23b3666d2ed60fbf1ded84d34568a6ff916..0000000000000000000000000000000000000000
--- a/src/uu/dircolors/src/colors.rs
+++ /dev/null
@@ -1,221 +0,0 @@
-// spell-checker:ignore (ToDO) EIGHTBIT ETERM MULTIHARDLINK cpio dtterm jfbterm konsole kterm mlterm rmvb rxvt stat'able svgz tmux webm xspf COLORTERM tzst avif tzst mjpg mjpeg webp dpkg rpmnew rpmorig rpmsave
-
-pub const INTERNAL_DB: &str = r#"# Configuration file for dircolors, a utility to help you set the
-# LS_COLORS environment variable used by GNU ls with the --color option.
-# Copyright (C) 1996-2022 Free Software Foundation, Inc.
-# Copying and distribution of this file, with or without modification,
-# are permitted provided the copyright notice and this notice are preserved.
-# The keywords COLOR, OPTIONS, and EIGHTBIT (honored by the
-# slackware version of dircolors) are recognized but ignored.
-# Global config options can be specified before TERM or COLORTERM entries
-# Below are TERM or COLORTERM entries, which can be glob patterns, which
-# restrict following config to systems with matching environment variables.
-COLORTERM ?*
-TERM Eterm
-TERM ansi
-TERM *color*
-TERM con[0-9]*x[0-9]*
-TERM cons25
-TERM console
-TERM cygwin
-TERM *direct*
-TERM dtterm
-TERM gnome
-TERM hurd
-TERM jfbterm
-TERM konsole
-TERM kterm
-TERM linux
-TERM linux-c
-TERM mlterm
-TERM putty
-TERM rxvt*
-TERM screen*
-TERM st
-TERM terminator
-TERM tmux*
-TERM vt100
-TERM xterm*
-# Below are the color init strings for the basic file types.
-# One can use codes for 256 or more colors supported by modern terminals.
-# The default color codes use the capabilities of an 8 color terminal
-# with some additional attributes as per the following codes:
-# Attribute codes:
-# 00=none 01=bold 04=underscore 05=blink 07=reverse 08=concealed
-# Text color codes:
-# 30=black 31=red 32=green 33=yellow 34=blue 35=magenta 36=cyan 37=white
-# Background color codes:
-# 40=black 41=red 42=green 43=yellow 44=blue 45=magenta 46=cyan 47=white
-#NORMAL 00 # no color code at all
-#FILE 00 # regular file: use no color at all
-RESET 0 # reset to "normal" color
-DIR 01;34 # directory
-LINK 01;36 # symbolic link. (If you set this to 'target' instead of a
- # numerical value, the color is as for the file pointed to.)
-MULTIHARDLINK 00 # regular file with more than one link
-FIFO 40;33 # pipe
-SOCK 01;35 # socket
-DOOR 01;35 # door
-BLK 40;33;01 # block device driver
-CHR 40;33;01 # character device driver
-ORPHAN 40;31;01 # symlink to nonexistent file, or non-stat'able file ...
-MISSING 00 # ... and the files they point to
-SETUID 37;41 # file that is setuid (u+s)
-SETGID 30;43 # file that is setgid (g+s)
-CAPABILITY 00 # file with capability (very expensive to lookup)
-STICKY_OTHER_WRITABLE 30;42 # dir that is sticky and other-writable (+t,o+w)
-OTHER_WRITABLE 34;42 # dir that is other-writable (o+w) and not sticky
-STICKY 37;44 # dir with the sticky bit set (+t) and not other-writable
-# This is for files with execute permission:
-EXEC 01;32
-# List any file extensions like '.gz' or '.tar' that you would like ls
-# to color below. Put the extension, a space, and the color init string.
-# (and any comments you want to add after a '#')
-# If you use DOS-style suffixes, you may want to uncomment the following:
-#.cmd 01;32 # executables (bright green)
-#.exe 01;32
-#.com 01;32
-#.btm 01;32
-#.bat 01;32
-# Or if you want to color scripts even if they do not have the
-# executable bit actually set.
-#.sh 01;32
-#.csh 01;32
- # archives or compressed (bright red)
-.tar 01;31
-.tgz 01;31
-.arc 01;31
-.arj 01;31
-.taz 01;31
-.lha 01;31
-.lz4 01;31
-.lzh 01;31
-.lzma 01;31
-.tlz 01;31
-.txz 01;31
-.tzo 01;31
-.t7z 01;31
-.zip 01;31
-.z 01;31
-.dz 01;31
-.gz 01;31
-.lrz 01;31
-.lz 01;31
-.lzo 01;31
-.xz 01;31
-.zst 01;31
-.tzst 01;31
-.bz2 01;31
-.bz 01;31
-.tbz 01;31
-.tbz2 01;31
-.tz 01;31
-.deb 01;31
-.rpm 01;31
-.jar 01;31
-.war 01;31
-.ear 01;31
-.sar 01;31
-.rar 01;31
-.alz 01;31
-.ace 01;31
-.zoo 01;31
-.cpio 01;31
-.7z 01;31
-.rz 01;31
-.cab 01;31
-.wim 01;31
-.swm 01;31
-.dwm 01;31
-.esd 01;31
-# image formats
-.avif 01;35
-.jpg 01;35
-.jpeg 01;35
-.mjpg 01;35
-.mjpeg 01;35
-.gif 01;35
-.bmp 01;35
-.pbm 01;35
-.pgm 01;35
-.ppm 01;35
-.tga 01;35
-.xbm 01;35
-.xpm 01;35
-.tif 01;35
-.tiff 01;35
-.png 01;35
-.svg 01;35
-.svgz 01;35
-.mng 01;35
-.pcx 01;35
-.mov 01;35
-.mpg 01;35
-.mpeg 01;35
-.m2v 01;35
-.mkv 01;35
-.webm 01;35
-.webp 01;35
-.ogm 01;35
-.mp4 01;35
-.m4v 01;35
-.mp4v 01;35
-.vob 01;35
-.qt 01;35
-.nuv 01;35
-.wmv 01;35
-.asf 01;35
-.rm 01;35
-.rmvb 01;35
-.flc 01;35
-.avi 01;35
-.fli 01;35
-.flv 01;35
-.gl 01;35
-.dl 01;35
-.xcf 01;35
-.xwd 01;35
-.yuv 01;35
-.cgm 01;35
-.emf 01;35
-# https://wiki.xiph.org/MIME_Types_and_File_Extensions
-.ogv 01;35
-.ogx 01;35
-# audio formats
-.aac 00;36
-.au 00;36
-.flac 00;36
-.m4a 00;36
-.mid 00;36
-.midi 00;36
-.mka 00;36
-.mp3 00;36
-.mpc 00;36
-.ogg 00;36
-.ra 00;36
-.wav 00;36
-# https://wiki.xiph.org/MIME_Types_and_File_Extensions
-.oga 00;36
-.opus 00;36
-.spx 00;36
-.xspf 00;36
-# backup files
-*~ 00;90
-*# 00;90
-.bak 00;90
-.old 00;90
-.orig 00;90
-.part 00;90
-.rej 00;90
-.swp 00;90
-.tmp 00;90
-.dpkg-dist 00;90
-.dpkg-old 00;90
-.ucf-dist 00;90
-.ucf-new 00;90
-.ucf-old 00;90
-.rpmnew 00;90
-.rpmorig 00;90
-.rpmsave 00;90
-# Subsequent TERM or COLORTERM entries, can be used to add / override
-# config specific to those matching environment variables."#;
diff --git a/src/uu/dircolors/src/dircolors.rs b/src/uu/dircolors/src/dircolors.rs
index dcd79a7a9d394fef3fbf037e2592b0aca3ffd306..d581fc5ce2f6d75d098c414171e0705f0442c763 100644
--- a/src/uu/dircolors/src/dircolors.rs
+++ b/src/uu/dircolors/src/dircolors.rs
@@ -1,8 +1,5 @@
// This file is part of the uutils coreutils package.
//
-// (c) Jian Zeng <anonymousknight96@gmail.com>
-// (c) Mitchell Mebane <mitchell.mebane@gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
@@ -11,11 +8,15 @@
use std::borrow::Borrow;
use std::env;
use std::fs::File;
+//use std::io::IsTerminal;
use std::io::{BufRead, BufReader};
+use std::path::Path;
use clap::{crate_version, Arg, ArgAction, Command};
+use uucore::colors::{FILE_ATTRIBUTE_CODES, FILE_COLORS, FILE_TYPES, TERMS};
use uucore::display::Quotable;
use uucore::error::{UResult, USimpleError, UUsageError};
+use uucore::{help_about, help_section, help_usage};
mod options {
pub const BOURNE_SHELL: &str = "bourne-shell";
@@ -25,16 +26,9 @@ mod options {
pub const FILE: &str = "FILE";
}
-static USAGE: &str = "{} [OPTION]... [FILE]";
-static ABOUT: &str = "Output commands to set the LS_COLORS environment variable.";
-static LONG_HELP: &str = "
- If FILE is specified, read it to determine which colors to use for which
- file types and extensions. Otherwise, a precompiled database is used.
- For details on the format of these files, run 'dircolors --print-database'
-";
-
-mod colors;
-use self::colors::INTERNAL_DB;
+const USAGE: &str = help_usage!("dircolors.md");
+const ABOUT: &str = help_about!("dircolors.md");
+const AFTER_HELP: &str = help_section!("after help", "dircolors.md");
#[derive(PartialEq, Eq, Debug)]
pub enum OutputFmt {
@@ -45,7 +39,6 @@ pub enum OutputFmt {
}
pub fn guess_syntax() -> OutputFmt {
- use std::path::Path;
match env::var("SHELL") {
Ok(ref s) if !s.is_empty() => {
let shell_path: &Path = s.as_ref();
@@ -63,10 +56,79 @@ pub fn guess_syntax() -> OutputFmt {
}
}
+fn get_colors_format_strings(fmt: &OutputFmt) -> (String, String) {
+ let prefix = match fmt {
+ OutputFmt::Shell => "LS_COLORS='".to_string(),
+ OutputFmt::CShell => "setenv LS_COLORS '".to_string(),
+ OutputFmt::Display => String::new(),
+ OutputFmt::Unknown => unreachable!(),
+ };
+
+ let suffix = match fmt {
+ OutputFmt::Shell => "';\nexport LS_COLORS".to_string(),
+ OutputFmt::CShell => "'".to_string(),
+ OutputFmt::Display => String::new(),
+ OutputFmt::Unknown => unreachable!(),
+ };
+
+ (prefix, suffix)
+}
+
+pub fn generate_type_output(fmt: &OutputFmt) -> String {
+ match fmt {
+ OutputFmt::Display => FILE_TYPES
+ .iter()
+ .map(|&(_, key, val)| format!("\x1b[{}m{}\t{}\x1b[0m", val, key, val))
+ .collect::<Vec<String>>()
+ .join("\n"),
+ _ => {
+ // Existing logic for other formats
+ FILE_TYPES
+ .iter()
+ .map(|&(_, v1, v2)| format!("{}={}", v1, v2))
+ .collect::<Vec<String>>()
+ .join(":")
+ }
+ }
+}
+
+fn generate_ls_colors(fmt: &OutputFmt, sep: &str) -> String {
+ match fmt {
+ OutputFmt::Display => {
+ let mut display_parts = vec![];
+ let type_output = generate_type_output(fmt);
+ display_parts.push(type_output);
+ for &(extension, code) in FILE_COLORS {
+ let prefix = if extension.starts_with('*') { "" } else { "*" };
+ let formatted_extension =
+ format!("\x1b[{}m{}{}\t{}\x1b[0m", code, prefix, extension, code);
+ display_parts.push(formatted_extension);
+ }
+ display_parts.join("\n")
+ }
+ _ => {
+ // existing logic for other formats
+ let mut parts = vec![];
+ for &(extension, code) in FILE_COLORS {
+ let prefix = if extension.starts_with('*') { "" } else { "*" };
+ let formatted_extension = format!("{}{}", prefix, extension);
+ parts.push(format!("{}={}", formatted_extension, code));
+ }
+ let (prefix, suffix) = get_colors_format_strings(fmt);
+ let ls_colors = parts.join(sep);
+ format!(
+ "{}{}:{}:{}",
+ prefix,
+ generate_type_output(fmt),
+ ls_colors,
+ suffix
+ )
+ }
+ }
+}
+
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_ignore();
-
let matches = uu_app().try_get_matches_from(args)?;
let files = matches
@@ -103,7 +165,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
),
));
}
- println!("{}", INTERNAL_DB);
+
+ println!("{}", generate_dircolors_config());
return Ok(());
}
@@ -131,7 +194,20 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let result;
if files.is_empty() {
- result = parse(INTERNAL_DB.lines(), &out_format, "");
+ println!("{}", generate_ls_colors(&out_format, ":"));
+ return Ok(());
+ /*
+ // Check if data is being piped into the program
+ if std::io::stdin().is_terminal() {
+ // No data piped, use default behavior
+ println!("{}", generate_ls_colors(&out_format, ":"));
+ return Ok(());
+ } else {
+ // Data is piped, process the input from stdin
+ let fin = BufReader::new(std::io::stdin());
+ result = parse(fin.lines().map_while(Result::ok), &out_format, "-");
+ }
+ */
} else if files.len() > 1 {
return Err(UUsageError::new(
1,
@@ -139,17 +215,29 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
));
} else if files[0].eq("-") {
let fin = BufReader::new(std::io::stdin());
- result = parse(fin.lines().filter_map(Result::ok), &out_format, files[0]);
+ // For example, for echo "owt 40;33"|dircolors -b -
+ result = parse(fin.lines().map_while(Result::ok), &out_format, files[0]);
} else {
- match File::open(files[0]) {
+ let path = Path::new(files[0]);
+ if path.is_dir() {
+ return Err(USimpleError::new(
+ 2,
+ format!("expected file, got directory {}", path.quote()),
+ ));
+ }
+ match File::open(path) {
Ok(f) => {
let fin = BufReader::new(f);
- result = parse(fin.lines().filter_map(Result::ok), &out_format, files[0]);
+ result = parse(
+ fin.lines().map_while(Result::ok),
+ &out_format,
+ &path.to_string_lossy(),
+ );
}
Err(e) => {
return Err(USimpleError::new(
1,
- format!("{}: {}", files[0].maybe_quote(), e),
+ format!("{}: {}", path.maybe_quote(), e),
));
}
}
@@ -157,12 +245,10 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
match result {
Ok(s) => {
- println!("{}", s);
+ println!("{s}");
Ok(())
}
- Err(s) => {
- return Err(USimpleError::new(1, s));
- }
+ Err(s) => Err(USimpleError::new(1, s)),
}
}
@@ -170,8 +256,9 @@ pub fn uu_app() -> Command {
Command::new(uucore::util_name())
.version(crate_version!())
.about(ABOUT)
- .after_help(LONG_HELP)
+ .after_help(AFTER_HELP)
.override_usage(format_usage(USAGE))
+ .args_override_self(true)
.infer_long_args(true)
.arg(
Arg::new(options::BOURNE_SHELL)
@@ -273,68 +360,25 @@ enum ParseState {
Pass,
}
-use std::collections::HashMap;
use uucore::{format_usage, parse_glob};
-fn parse<T>(lines: T, fmt: &OutputFmt, fp: &str) -> Result<String, String>
+#[allow(clippy::cognitive_complexity)]
+fn parse<T>(user_input: T, fmt: &OutputFmt, fp: &str) -> Result<String, String>
where
T: IntoIterator,
T::Item: Borrow<str>,
{
- // 1790 > $(dircolors | wc -m)
let mut result = String::with_capacity(1790);
- match fmt {
- OutputFmt::Shell => result.push_str("LS_COLORS='"),
- OutputFmt::CShell => result.push_str("setenv LS_COLORS '"),
- OutputFmt::Display => (),
- OutputFmt::Unknown => unreachable!(),
- }
+ let (prefix, suffix) = get_colors_format_strings(fmt);
- let mut table: HashMap<&str, &str> = HashMap::with_capacity(48);
- table.insert("normal", "no");
- table.insert("norm", "no");
- table.insert("file", "fi");
- table.insert("reset", "rs");
- table.insert("dir", "di");
- table.insert("lnk", "ln");
- table.insert("link", "ln");
- table.insert("symlink", "ln");
- table.insert("orphan", "or");
- table.insert("missing", "mi");
- table.insert("fifo", "pi");
- table.insert("pipe", "pi");
- table.insert("sock", "so");
- table.insert("blk", "bd");
- table.insert("block", "bd");
- table.insert("chr", "cd");
- table.insert("char", "cd");
- table.insert("door", "do");
- table.insert("exec", "ex");
- table.insert("left", "lc");
- table.insert("leftcode", "lc");
- table.insert("right", "rc");
- table.insert("rightcode", "rc");
- table.insert("end", "ec");
- table.insert("endcode", "ec");
- table.insert("suid", "su");
- table.insert("setuid", "su");
- table.insert("sgid", "sg");
- table.insert("setgid", "sg");
- table.insert("sticky", "st");
- table.insert("other_writable", "ow");
- table.insert("owr", "ow");
- table.insert("sticky_other_writable", "tw");
- table.insert("owt", "tw");
- table.insert("capability", "ca");
- table.insert("multihardlink", "mh");
- table.insert("clrtoeol", "cl");
+ result.push_str(&prefix);
let term = env::var("TERM").unwrap_or_else(|_| "none".to_owned());
let term = term.as_str();
let mut state = ParseState::Global;
- for (num, line) in lines.into_iter().enumerate() {
+ for (num, line) in user_input.into_iter().enumerate() {
let num = num + 1;
let line = line.borrow().purify();
if line.is_empty() {
@@ -346,13 +390,13 @@ where
let (key, val) = line.split_two();
if val.is_empty() {
return Err(format!(
+ // The double space is what GNU is doing
"{}:{}: invalid line; missing second token",
fp.maybe_quote(),
num
));
}
let lower = key.to_lowercase();
-
if lower == "term" || lower == "colorterm" {
if term.fnmatch(val) {
state = ParseState::Matched;
@@ -366,25 +410,30 @@ where
state = ParseState::Continue;
}
if state != ParseState::Pass {
+ let search_key = lower.as_str();
+
if key.starts_with('.') {
if *fmt == OutputFmt::Display {
- result.push_str(format!("\x1b[{1}m*{0}\t{1}\x1b[0m\n", key, val).as_str());
+ result.push_str(format!("\x1b[{val}m*{key}\t{val}\x1b[0m\n").as_str());
} else {
- result.push_str(format!("*{}={}:", key, val).as_str());
+ result.push_str(format!("*{key}={val}:").as_str());
}
} else if key.starts_with('*') {
if *fmt == OutputFmt::Display {
- result.push_str(format!("\x1b[{1}m{0}\t{1}\x1b[0m\n", key, val).as_str());
+ result.push_str(format!("\x1b[{val}m{key}\t{val}\x1b[0m\n").as_str());
} else {
- result.push_str(format!("{}={}:", key, val).as_str());
+ result.push_str(format!("{key}={val}:").as_str());
}
} else if lower == "options" || lower == "color" || lower == "eightbit" {
// Slackware only. Ignore
- } else if let Some(s) = table.get(lower.as_str()) {
+ } else if let Some((_, s)) = FILE_ATTRIBUTE_CODES
+ .iter()
+ .find(|&&(key, _)| key == search_key)
+ {
if *fmt == OutputFmt::Display {
- result.push_str(format!("\x1b[{1}m{0}\t{1}\x1b[0m\n", s, val).as_str());
+ result.push_str(format!("\x1b[{val}m{s}\t{val}\x1b[0m\n").as_str());
} else {
- result.push_str(format!("{}={}:", s, val).as_str());
+ result.push_str(format!("{s}={val}:").as_str());
}
} else {
return Err(format!(
@@ -398,15 +447,11 @@ where
}
}
- match fmt {
- OutputFmt::Shell => result.push_str("';\nexport LS_COLORS"),
- OutputFmt::CShell => result.push('\''),
- OutputFmt::Display => {
- // remove latest "\n"
- result.pop();
- }
- OutputFmt::Unknown => unreachable!(),
+ if fmt == &OutputFmt::Display {
+ // remove latest "\n"
+ result.pop();
}
+ result.push_str(&suffix);
Ok(result)
}
@@ -432,6 +477,58 @@ fn escape(s: &str) -> String {
result
}
+pub fn generate_dircolors_config() -> String {
+ let mut config = String::new();
+
+ config.push_str(
+ "\
+ # Configuration file for dircolors, a utility to help you set the\n\
+ # LS_COLORS environment variable used by GNU ls with the --color option.\n\
+ # The keywords COLOR, OPTIONS, and EIGHTBIT (honored by the\n\
+ # slackware version of dircolors) are recognized but ignored.\n\
+ # Global config options can be specified before TERM or COLORTERM entries\n\
+ # Below are TERM or COLORTERM entries, which can be glob patterns, which\n\
+ # restrict following config to systems with matching environment variables.\n\
+ ",
+ );
+ config.push_str("COLORTERM ?*\n");
+ for term in TERMS {
+ config.push_str(&format!("TERM {}\n", term));
+ }
+
+ config.push_str(
+ "\
+ # Below are the color init strings for the basic file types.\n\
+ # One can use codes for 256 or more colors supported by modern terminals.\n\
+ # The default color codes use the capabilities of an 8 color terminal\n\
+ # with some additional attributes as per the following codes:\n\
+ # Attribute codes:\n\
+ # 00=none 01=bold 04=underscore 05=blink 07=reverse 08=concealed\n\
+ # Text color codes:\n\
+ # 30=black 31=red 32=green 33=yellow 34=blue 35=magenta 36=cyan 37=white\n\
+ # Background color codes:\n\
+ # 40=black 41=red 42=green 43=yellow 44=blue 45=magenta 46=cyan 47=white\n\
+ #NORMAL 00 # no color code at all\n\
+ #FILE 00 # regular file: use no color at all\n\
+ ",
+ );
+
+ for (name, _, code) in FILE_TYPES {
+ config.push_str(&format!("{} {}\n", name, code));
+ }
+
+ config.push_str("# List any file extensions like '.gz' or '.tar' that you would like ls\n");
+ config.push_str("# to color below. Put the extension, a space, and the color init string.\n");
+
+ for (ext, color) in FILE_COLORS {
+ config.push_str(&format!("{} {}\n", ext, color));
+ }
+ config.push_str("# Subsequent TERM or COLORTERM entries, can be used to add / override\n");
+ config.push_str("# config specific to those matching environment variables.");
+
+ config
+}
+
#[cfg(test)]
mod tests {
use super::escape;
diff --git a/src/uu/dirname/Cargo.toml b/src/uu/dirname/Cargo.toml
index 9a23d50b9fdb34bb420b6f7b13ca35cd455614bc..7244ea7965e3a10cfda5d36bf0e463e62d31bd89 100644
--- a/src/uu/dirname/Cargo.toml
+++ b/src/uu/dirname/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_dirname"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "dirname ~ (uutils) display parent directory of PATHNAME"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/dirname.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "dirname"
diff --git a/src/uu/dirname/dirname.md b/src/uu/dirname/dirname.md
new file mode 100644
index 0000000000000000000000000000000000000000..f08c1c4c9ad5f82f875750a7e85d85d7c0890252
--- /dev/null
+++ b/src/uu/dirname/dirname.md
@@ -0,0 +1,12 @@
+# dirname
+
+```
+dirname [OPTION] NAME...
+```
+
+Strip last component from file name
+
+## After Help
+
+Output each NAME with its last non-slash component and trailing slashes
+removed; if NAME contains no /'s, output '.' (meaning the current directory).
diff --git a/src/uu/dirname/src/dirname.rs b/src/uu/dirname/src/dirname.rs
index 1f15ccdca7f195e3a11b5d018ab5717affc56440..25daa3a36c82694c30fcfdb929f3b26ccc0ae178 100644
--- a/src/uu/dirname/src/dirname.rs
+++ b/src/uu/dirname/src/dirname.rs
@@ -1,7 +1,5 @@
// This file is part of the uutils coreutils package.
//
-// (c) Derek Chiang <derekchiang93@gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
@@ -9,42 +7,33 @@ use clap::{crate_version, Arg, ArgAction, Command};
use std::path::Path;
use uucore::display::print_verbatim;
use uucore::error::{UResult, UUsageError};
-use uucore::format_usage;
+use uucore::line_ending::LineEnding;
+use uucore::{format_usage, help_about, help_section, help_usage};
-static ABOUT: &str = "strip last component from file name";
-const USAGE: &str = "{} [OPTION] NAME...";
+const ABOUT: &str = help_about!("dirname.md");
+const USAGE: &str = help_usage!("dirname.md");
+const AFTER_HELP: &str = help_section!("after help", "dirname.md");
mod options {
pub const ZERO: &str = "zero";
pub const DIR: &str = "dir";
}
-fn get_long_usage() -> &'static str {
- "Output each NAME with its last non-slash component and trailing slashes \n\
- removed; if NAME contains no /'s, output '.' (meaning the current directory)."
-}
-
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_lossy();
+ let matches = uu_app().after_help(AFTER_HELP).try_get_matches_from(args)?;
- let matches = uu_app()
- .after_help(get_long_usage())
- .try_get_matches_from(args)?;
-
- let separator = if matches.get_flag(options::ZERO) {
- "\0"
- } else {
- "\n"
- };
+ let line_ending = LineEnding::from_zero_flag(matches.get_flag(options::ZERO));
let dirnames: Vec<String> = matches
.get_many::<String>(options::DIR)
.unwrap_or_default()
- .map(|s| s.to_owned())
+ .cloned()
.collect();
- if !dirnames.is_empty() {
+ if dirnames.is_empty() {
+ return Err(UUsageError::new(1, "missing operand"));
+ } else {
for path in &dirnames {
let p = Path::new(path);
match p.parent() {
@@ -63,10 +52,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
}
}
}
- print!("{}", separator);
+ print!("{line_ending}");
}
- } else {
- return Err(UUsageError::new(1, "missing operand"));
}
Ok(())
@@ -77,6 +64,7 @@ pub fn uu_app() -> Command {
.about(ABOUT)
.version(crate_version!())
.override_usage(format_usage(USAGE))
+ .args_override_self(true)
.infer_long_args(true)
.arg(
Arg::new(options::ZERO)
diff --git a/src/uu/du/Cargo.toml b/src/uu/du/Cargo.toml
index 57855b8861a21bb7dd937f48324a2e11302d8f4e..8f18dbd824920bfb9a56bc52096520e4c0cc13f1 100644
--- a/src/uu/du/Cargo.toml
+++ b/src/uu/du/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_du"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "du ~ (uutils) display disk usage"
@@ -15,14 +15,17 @@ edition = "2021"
path = "src/du.rs"
[dependencies]
-chrono = { version="^0.4.23", default-features=false, features=["std", "alloc", "clock"]}
+chrono = { workspace = true }
# For the --exclude & --exclude-from options
-glob = "0.3.0"
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+glob = { workspace = true }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["format"] }
[target.'cfg(target_os = "windows")'.dependencies]
-windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_Storage_FileSystem", "Win32_Foundation"] }
+windows-sys = { workspace = true, features = [
+ "Win32_Storage_FileSystem",
+ "Win32_Foundation",
+] }
[[bin]]
name = "du"
diff --git a/src/uu/du/du.md b/src/uu/du/du.md
new file mode 100644
index 0000000000000000000000000000000000000000..ae3319ad6b6ba41b59ff1bed0f1910fca5f02479
--- /dev/null
+++ b/src/uu/du/du.md
@@ -0,0 +1,24 @@
+# du
+
+```
+du [OPTION]... [FILE]...
+du [OPTION]... --files0-from=F
+```
+
+Estimate file space usage
+
+## After Help
+
+Display values are in units of the first available SIZE from --block-size,
+and the DU_BLOCK_SIZE, BLOCK_SIZE and BLOCKSIZE environment variables.
+Otherwise, units default to 1024 bytes (or 512 if POSIXLY_CORRECT is set).
+
+SIZE is an integer and optional unit (example: 10M is 10*1024*1024).
+Units are K, M, G, T, P, E, Z, Y (powers of 1024) or KB, MB,... (powers
+of 1000).
+
+PATTERN allows some advanced exclusions. For example, the following syntaxes
+are supported:
+`?` will match only one character
+`*` will match zero or more characters
+`{a,b}` will match a or b
diff --git a/src/uu/du/src/du.rs b/src/uu/du/src/du.rs
index f65afa32f885fa813a2972773c63369defe14e77..74fa4154db531e1e84730177c3aa51bbf6c2f4db 100644
--- a/src/uu/du/src/du.rs
+++ b/src/uu/du/src/du.rs
@@ -1,42 +1,37 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Derek Chiang <derekchiang93@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
-
-use chrono::prelude::DateTime;
-use chrono::Local;
-use clap::ArgAction;
-use clap::{crate_version, Arg, ArgMatches, Command};
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use chrono::{DateTime, Local};
+use clap::{builder::PossibleValue, crate_version, Arg, ArgAction, ArgMatches, Command};
use glob::Pattern;
use std::collections::HashSet;
use std::env;
-use std::fs;
-use std::fs::File;
+use std::error::Error;
+use std::fmt::Display;
#[cfg(not(windows))]
use std::fs::Metadata;
-use std::io::BufRead;
-use std::io::BufReader;
-use std::io::Result;
-use std::iter;
+use std::fs::{self, File};
+use std::io::{BufRead, BufReader};
#[cfg(not(windows))]
use std::os::unix::fs::MetadataExt;
#[cfg(windows)]
use std::os::windows::fs::MetadataExt;
#[cfg(windows)]
use std::os::windows::io::AsRawHandle;
-use std::path::Path;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
use std::str::FromStr;
+use std::sync::mpsc;
+use std::thread;
use std::time::{Duration, UNIX_EPOCH};
-use std::{error::Error, fmt::Display};
use uucore::display::{print_verbatim, Quotable};
-use uucore::error::FromIo;
-use uucore::error::{UError, UResult};
+use uucore::error::{set_exit_code, FromIo, UError, UResult, USimpleError};
+use uucore::line_ending::LineEnding;
use uucore::parse_glob;
-use uucore::parse_size::{parse_size, ParseSizeError};
-use uucore::{crash, format_usage, show, show_error, show_warning};
+use uucore::parse_size::{parse_size_u64, ParseSizeError};
+use uucore::shortcut_value_parser::ShortcutValueParser;
+use uucore::{format_usage, help_about, help_section, help_usage, show, show_error, show_warning};
#[cfg(windows)]
use windows_sys::Win32::Foundation::HANDLE;
#[cfg(windows)]
@@ -66,45 +61,62 @@ mod options {
pub const TIME_STYLE: &str = "time-style";
pub const ONE_FILE_SYSTEM: &str = "one-file-system";
pub const DEREFERENCE: &str = "dereference";
+ pub const DEREFERENCE_ARGS: &str = "dereference-args";
+ pub const NO_DEREFERENCE: &str = "no-dereference";
pub const INODES: &str = "inodes";
pub const EXCLUDE: &str = "exclude";
pub const EXCLUDE_FROM: &str = "exclude-from";
+ pub const FILES0_FROM: &str = "files0-from";
pub const VERBOSE: &str = "verbose";
pub const FILE: &str = "FILE";
}
-const ABOUT: &str = "estimate file space usage";
-const LONG_HELP: &str = "
-Display values are in units of the first available SIZE from --block-size,
-and the DU_BLOCK_SIZE, BLOCK_SIZE and BLOCKSIZE environment variables.
-Otherwise, units default to 1024 bytes (or 512 if POSIXLY_CORRECT is set).
-
-SIZE is an integer and optional unit (example: 10M is 10*1024*1024).
-Units are K, M, G, T, P, E, Z, Y (powers of 1024) or KB, MB,... (powers
-of 1000).
-
-PATTERN allows some advanced exclusions. For example, the following syntaxes
-are supported:
-? will match only one character
-* will match zero or more characters
-{a,b} will match a or b
-";
-const USAGE: &str = "\
- {} [OPTION]... [FILE]...
- {} [OPTION]... --files0-from=F";
+const ABOUT: &str = help_about!("du.md");
+const AFTER_HELP: &str = help_section!("after help", "du.md");
+const USAGE: &str = help_usage!("du.md");
-// TODO: Support Z & Y (currently limited by size of u64)
-const UNITS: [(char, u32); 6] = [('E', 6), ('P', 5), ('T', 4), ('G', 3), ('M', 2), ('K', 1)];
-
-struct Options {
+struct TraversalOptions {
all: bool,
- max_depth: Option<usize>,
- total: bool,
separate_dirs: bool,
one_file_system: bool,
- dereference: bool,
- inodes: bool,
+ dereference: Deref,
+ count_links: bool,
verbose: bool,
+ excludes: Vec<Pattern>,
+}
+
+struct StatPrinter {
+ total: bool,
+ inodes: bool,
+ max_depth: Option<usize>,
+ threshold: Option<Threshold>,
+ apparent_size: bool,
+ size_format: SizeFormat,
+ time: Option<Time>,
+ time_format: String,
+ line_ending: LineEnding,
+ summarize: bool,
+}
+
+#[derive(PartialEq, Clone)]
+enum Deref {
+ All,
+ Args(Vec<PathBuf>),
+ None,
+}
+
+#[derive(Clone, Copy)]
+enum Time {
+ Accessed,
+ Modified,
+ Created,
+}
+
+#[derive(Clone)]
+enum SizeFormat {
+ HumanDecimal,
+ HumanBinary,
+ BlockSize(u64),
}
#[derive(PartialEq, Eq, Hash, Clone, Copy)]
@@ -126,47 +138,59 @@ struct Stat {
}
impl Stat {
- fn new(path: PathBuf, options: &Options) -> Result<Self> {
- let metadata = if options.dereference {
- fs::metadata(&path)?
- } else {
- fs::symlink_metadata(&path)?
+ fn new(path: &Path, options: &TraversalOptions) -> std::io::Result<Self> {
+ // Determine whether to dereference (follow) the symbolic link
+ let should_dereference = match &options.dereference {
+ Deref::All => true,
+ Deref::Args(paths) => paths.contains(&path.to_path_buf()),
+ Deref::None => false,
};
+ let metadata = if should_dereference {
+ // Get metadata, following symbolic links if necessary
+ fs::metadata(path)
+ } else {
+ // Get metadata without following symbolic links
+ fs::symlink_metadata(path)
+ }?;
+
#[cfg(not(windows))]
- let file_info = FileInfo {
- file_id: metadata.ino() as u128,
- dev_id: metadata.dev(),
- };
- #[cfg(not(windows))]
- return Ok(Self {
- path,
- is_dir: metadata.is_dir(),
- size: metadata.len(),
- blocks: metadata.blocks(),
- inodes: 1,
- inode: Some(file_info),
- created: birth_u64(&metadata),
- accessed: metadata.atime() as u64,
- modified: metadata.mtime() as u64,
- });
+ {
+ let file_info = FileInfo {
+ file_id: metadata.ino() as u128,
+ dev_id: metadata.dev(),
+ };
+
+ Ok(Self {
+ path: path.to_path_buf(),
+ is_dir: metadata.is_dir(),
+ size: if path.is_dir() { 0 } else { metadata.len() },
+ blocks: metadata.blocks(),
+ inodes: 1,
+ inode: Some(file_info),
+ created: birth_u64(&metadata),
+ accessed: metadata.atime() as u64,
+ modified: metadata.mtime() as u64,
+ })
+ }
#[cfg(windows)]
- let size_on_disk = get_size_on_disk(&path);
- #[cfg(windows)]
- let file_info = get_file_info(&path);
- #[cfg(windows)]
- Ok(Self {
- path,
- is_dir: metadata.is_dir(),
- size: metadata.len(),
- blocks: size_on_disk / 1024 * 2,
- inode: file_info,
- inodes: 1,
- created: windows_creation_time_to_unix_time(metadata.creation_time()),
- accessed: windows_time_to_unix_time(metadata.last_access_time()),
- modified: windows_time_to_unix_time(metadata.last_write_time()),
- })
+ {
+ let size_on_disk = get_size_on_disk(path);
+ let file_info = get_file_info(path);
+
+ Ok(Self {
+ path: path.to_path_buf(),
+ is_dir: metadata.is_dir(),
+ size: if path.is_dir() { 0 } else { metadata.len() },
+ blocks: size_on_disk / 1024 * 2,
+ inodes: 1,
+ inode: file_info,
+ created: windows_creation_time_to_unix_time(metadata.creation_time()),
+ accessed: windows_time_to_unix_time(metadata.last_access_time()),
+ modified: windows_time_to_unix_time(metadata.last_write_time()),
+ })
+ }
}
}
@@ -252,68 +276,53 @@ fn get_file_info(path: &Path) -> Option<FileInfo> {
result
}
-fn read_block_size(s: Option<&str>) -> u64 {
+fn read_block_size(s: Option<&str>) -> UResult<u64> {
if let Some(s) = s {
- parse_size(s)
- .unwrap_or_else(|e| crash!(1, "{}", format_error_message(&e, s, options::BLOCK_SIZE)))
+ parse_size_u64(s)
+ .map_err(|e| USimpleError::new(1, format_error_message(&e, s, options::BLOCK_SIZE)))
} else {
for env_var in ["DU_BLOCK_SIZE", "BLOCK_SIZE", "BLOCKSIZE"] {
if let Ok(env_size) = env::var(env_var) {
- if let Ok(v) = parse_size(&env_size) {
- return v;
+ if let Ok(v) = parse_size_u64(&env_size) {
+ return Ok(v);
}
}
}
if env::var("POSIXLY_CORRECT").is_ok() {
- 512
+ Ok(512)
} else {
- 1024
+ Ok(1024)
}
}
}
-fn choose_size(matches: &ArgMatches, stat: &Stat) -> u64 {
- if matches.get_flag(options::INODES) {
- stat.inodes
- } else if matches.get_flag(options::APPARENT_SIZE) || matches.get_flag(options::BYTES) {
- stat.size
- } else {
- // The st_blocks field indicates the number of blocks allocated to the file, 512-byte units.
- // See: http://linux.die.net/man/2/stat
- stat.blocks * 512
- }
-}
-
// this takes `my_stat` to avoid having to stat files multiple times.
-// XXX: this should use the impl Trait return type when it is stabilized
+#[allow(clippy::cognitive_complexity)]
fn du(
mut my_stat: Stat,
- options: &Options,
+ options: &TraversalOptions,
depth: usize,
- inodes: &mut HashSet<FileInfo>,
- exclude: &[Pattern],
-) -> Box<dyn DoubleEndedIterator<Item = Stat>> {
- let mut stats = vec![];
- let mut futures = vec![];
-
+ seen_inodes: &mut HashSet<FileInfo>,
+ print_tx: &mpsc::Sender<UResult<StatPrintInfo>>,
+) -> Result<Stat, Box<mpsc::SendError<UResult<StatPrintInfo>>>> {
if my_stat.is_dir {
let read = match fs::read_dir(&my_stat.path) {
Ok(read) => read,
Err(e) => {
- show!(
- e.map_err_context(|| format!("cannot read directory {}", my_stat.path.quote()))
- );
- return Box::new(iter::once(my_stat));
+ print_tx.send(Err(e.map_err_context(|| {
+ format!("cannot read directory {}", my_stat.path.quote())
+ })))?;
+ return Ok(my_stat);
}
};
'file_loop: for f in read {
match f {
Ok(entry) => {
- match Stat::new(entry.path(), options) {
+ match Stat::new(&entry.path(), options) {
Ok(this_stat) => {
// We have an exclude list
- for pattern in exclude {
+ for pattern in &options.excludes {
// Look at all patterns with both short and long paths
// if we have 'du foo' but search to exclude 'foo/bar'
// we need the full path
@@ -330,10 +339,13 @@ fn du(
}
if let Some(inode) = this_stat.inode {
- if inodes.contains(&inode) {
+ if seen_inodes.contains(&inode) {
+ if options.count_links {
+ my_stat.inodes += 1;
+ }
continue;
}
- inodes.insert(inode);
+ seen_inodes.insert(inode);
}
if this_stat.is_dir {
if options.one_file_system {
@@ -345,70 +357,42 @@ fn du(
}
}
}
- futures.push(du(this_stat, options, depth + 1, inodes, exclude));
+
+ let this_stat =
+ du(this_stat, options, depth + 1, seen_inodes, print_tx)?;
+
+ if !options.separate_dirs {
+ my_stat.size += this_stat.size;
+ my_stat.blocks += this_stat.blocks;
+ my_stat.inodes += this_stat.inodes;
+ }
+ print_tx.send(Ok(StatPrintInfo {
+ stat: this_stat,
+ depth: depth + 1,
+ }))?;
} else {
my_stat.size += this_stat.size;
my_stat.blocks += this_stat.blocks;
my_stat.inodes += 1;
if options.all {
- stats.push(this_stat);
+ print_tx.send(Ok(StatPrintInfo {
+ stat: this_stat,
+ depth: depth + 1,
+ }))?;
}
}
}
- Err(e) => show!(
- e.map_err_context(|| format!("cannot access {}", entry.path().quote()))
- ),
+ Err(e) => print_tx.send(Err(e.map_err_context(|| {
+ format!("cannot access {}", entry.path().quote())
+ })))?,
}
}
- Err(error) => show_error!("{}", error),
+ Err(error) => print_tx.send(Err(error.into()))?,
}
}
}
- stats.extend(futures.into_iter().flatten().filter(|stat| {
- if !options.separate_dirs && stat.path.parent().unwrap() == my_stat.path {
- my_stat.size += stat.size;
- my_stat.blocks += stat.blocks;
- my_stat.inodes += stat.inodes;
- }
- options
- .max_depth
- .map_or(true, |max_depth| depth < max_depth)
- }));
- stats.push(my_stat);
- Box::new(stats.into_iter())
-}
-
-fn convert_size_human(size: u64, multiplier: u64, _block_size: u64) -> String {
- for &(unit, power) in &UNITS {
- let limit = multiplier.pow(power);
- if size >= limit {
- return format!("{:.1}{}", (size as f64) / (limit as f64), unit);
- }
- }
- if size == 0 {
- return "0".to_string();
- }
- format!("{}B", size)
-}
-
-fn convert_size_b(size: u64, _multiplier: u64, _block_size: u64) -> String {
- format!("{}", ((size as f64) / (1_f64)).ceil())
-}
-
-fn convert_size_k(size: u64, multiplier: u64, _block_size: u64) -> String {
- format!("{}", ((size as f64) / (multiplier as f64)).ceil())
-}
-
-fn convert_size_m(size: u64, multiplier: u64, _block_size: u64) -> String {
- format!(
- "{}",
- ((size as f64) / ((multiplier * multiplier) as f64)).ceil()
- )
-}
-
-fn convert_size_other(size: u64, _multiplier: u64, block_size: u64) -> String {
- format!("{}", ((size as f64) / (block_size as f64)).ceil())
+ Ok(my_stat)
}
#[derive(Debug)]
@@ -416,7 +400,7 @@ enum DuError {
InvalidMaxDepthArg(String),
SummarizeDepthConflict(String),
InvalidTimeStyleArg(String),
- InvalidTimeArg(String),
+ InvalidTimeArg,
InvalidGlob(String),
}
@@ -442,13 +426,11 @@ Try '{} --help' for more information.",
s.quote(),
uucore::execution_phrase()
),
- Self::InvalidTimeArg(s) => write!(
+ Self::InvalidTimeArg => write!(
f,
- "Invalid argument {} for --time.
-'birth' and 'creation' arguments are not supported on this platform.",
- s.quote()
+ "'birth' and 'creation' arguments for --time are not supported on this platform.",
),
- Self::InvalidGlob(s) => write!(f, "Invalid exclude syntax: {}", s),
+ Self::InvalidGlob(s) => write!(f, "Invalid exclude syntax: {s}"),
}
}
}
@@ -461,7 +443,7 @@ impl UError for DuError {
Self::InvalidMaxDepthArg(_)
| Self::SummarizeDepthConflict(_)
| Self::InvalidTimeStyleArg(_)
- | Self::InvalidTimeArg(_)
+ | Self::InvalidTimeArg
| Self::InvalidGlob(_) => 1,
}
}
@@ -488,7 +470,7 @@ fn build_exclude_patterns(matches: &ArgMatches) -> UResult<Vec<Pattern>> {
let excludes_iterator = matches
.get_many::<String>(options::EXCLUDE)
.unwrap_or_default()
- .map(|v| v.to_owned());
+ .cloned();
let mut exclude_patterns = Vec::new();
for f in excludes_iterator.chain(exclude_from_iterator) {
@@ -503,11 +485,158 @@ fn build_exclude_patterns(matches: &ArgMatches) -> UResult<Vec<Pattern>> {
Ok(exclude_patterns)
}
+struct StatPrintInfo {
+ stat: Stat,
+ depth: usize,
+}
+
+impl StatPrinter {
+ fn choose_size(&self, stat: &Stat) -> u64 {
+ if self.inodes {
+ stat.inodes
+ } else if self.apparent_size {
+ stat.size
+ } else {
+ // The st_blocks field indicates the number of blocks allocated to the file, 512-byte units.
+ // See: http://linux.die.net/man/2/stat
+ stat.blocks * 512
+ }
+ }
+
+ fn print_stats(&self, rx: &mpsc::Receiver<UResult<StatPrintInfo>>) -> UResult<()> {
+ let mut grand_total = 0;
+ loop {
+ let received = rx.recv();
+
+ match received {
+ Ok(message) => match message {
+ Ok(stat_info) => {
+ let size = self.choose_size(&stat_info.stat);
+
+ if stat_info.depth == 0 {
+ grand_total += size;
+ }
+
+ if !self
+ .threshold
+ .map_or(false, |threshold| threshold.should_exclude(size))
+ && self
+ .max_depth
+ .map_or(true, |max_depth| stat_info.depth <= max_depth)
+ && (!self.summarize || stat_info.depth == 0)
+ {
+ self.print_stat(&stat_info.stat, size)?;
+ }
+ }
+ Err(e) => show!(e),
+ },
+ Err(_) => break,
+ }
+ }
+
+ if self.total {
+ print!("{}\ttotal", self.convert_size(grand_total));
+ print!("{}", self.line_ending);
+ }
+
+ Ok(())
+ }
+
+ fn convert_size(&self, size: u64) -> String {
+ if self.inodes {
+ return size.to_string();
+ }
+ match self.size_format {
+ SizeFormat::HumanDecimal => uucore::format::human::human_readable(
+ size,
+ uucore::format::human::SizeFormat::Decimal,
+ ),
+ SizeFormat::HumanBinary => uucore::format::human::human_readable(
+ size,
+ uucore::format::human::SizeFormat::Binary,
+ ),
+ SizeFormat::BlockSize(block_size) => div_ceil(size, block_size).to_string(),
+ }
+ }
+
+ fn print_stat(&self, stat: &Stat, size: u64) -> UResult<()> {
+ if let Some(time) = self.time {
+ let secs = get_time_secs(time, stat)?;
+ let tm = DateTime::<Local>::from(UNIX_EPOCH + Duration::from_secs(secs));
+ let time_str = tm.format(&self.time_format).to_string();
+ print!("{}\t{}\t", self.convert_size(size), time_str);
+ } else {
+ print!("{}\t", self.convert_size(size));
+ }
+
+ print_verbatim(&stat.path).unwrap();
+ print!("{}", self.line_ending);
+
+ Ok(())
+ }
+}
+
+// This can be replaced with u64::div_ceil once it is stabilized.
+// This implementation approach is optimized for when `b` is a constant,
+// particularly a power of two.
+pub fn div_ceil(a: u64, b: u64) -> u64 {
+ (a + b - 1) / b
+}
+
+// Read file paths from the specified file, separated by null characters
+fn read_files_from(file_name: &str) -> Result<Vec<PathBuf>, std::io::Error> {
+ let reader: Box<dyn BufRead> = if file_name == "-" {
+ // Read from standard input
+ Box::new(BufReader::new(std::io::stdin()))
+ } else {
+ // First, check if the file_name is a directory
+ let path = PathBuf::from(file_name);
+ if path.is_dir() {
+ return Err(std::io::Error::new(
+ std::io::ErrorKind::Other,
+ format!("{}: read error: Is a directory", file_name),
+ ));
+ }
+
+ // Attempt to open the file and handle the error if it does not exist
+ match File::open(file_name) {
+ Ok(file) => Box::new(BufReader::new(file)),
+ Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
+ return Err(std::io::Error::new(
+ std::io::ErrorKind::Other,
+ format!(
+ "cannot open '{}' for reading: No such file or directory",
+ file_name
+ ),
+ ))
+ }
+ Err(e) => return Err(e),
+ }
+ };
+
+ let mut paths = Vec::new();
+
+ for (i, line) in reader.split(b'\0').enumerate() {
+ let path = line?;
+
+ if path.is_empty() {
+ let line_number = i + 1;
+ show_error!("{file_name}:{line_number}: invalid zero-length file name");
+ set_exit_code(1);
+ } else {
+ let p = PathBuf::from(String::from_utf8_lossy(&path).to_string());
+ if !paths.contains(&p) {
+ paths.push(p);
+ }
+ }
+ }
+
+ Ok(paths)
+}
+
#[uucore::main]
#[allow(clippy::cognitive_complexity)]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_ignore();
-
let matches = uu_app().try_get_matches_from(args)?;
let summarize = matches.get_flag(options::SUMMARIZE);
@@ -519,88 +648,118 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
summarize,
)?;
- let options = Options {
- all: matches.get_flag(options::ALL),
- max_depth,
- total: matches.get_flag(options::TOTAL),
- separate_dirs: matches.get_flag(options::SEPARATE_DIRS),
- one_file_system: matches.get_flag(options::ONE_FILE_SYSTEM),
- dereference: matches.get_flag(options::DEREFERENCE),
- inodes: matches.get_flag(options::INODES),
- verbose: matches.get_flag(options::VERBOSE),
- };
+ let files = if let Some(file_from) = matches.get_one::<String>(options::FILES0_FROM) {
+ if file_from == "-" && matches.get_one::<String>(options::FILE).is_some() {
+ return Err(std::io::Error::new(
+ std::io::ErrorKind::Other,
+ format!(
+ "extra operand {}\nfile operands cannot be combined with --files0-from",
+ matches.get_one::<String>(options::FILE).unwrap().quote()
+ ),
+ )
+ .into());
+ }
- let files = match matches.get_one::<String>(options::FILE) {
- Some(_) => matches
- .get_many::<String>(options::FILE)
- .unwrap()
- .map(|s| s.as_str())
- .collect(),
- None => vec!["."],
+ read_files_from(file_from)?
+ } else {
+ match matches.get_one::<String>(options::FILE) {
+ Some(_) => matches
+ .get_many::<String>(options::FILE)
+ .unwrap()
+ .map(PathBuf::from)
+ .collect(),
+ None => vec![PathBuf::from(".")],
+ }
};
- if options.inodes
- && (matches.get_flag(options::APPARENT_SIZE) || matches.get_flag(options::BYTES))
- {
- show_warning!("options --apparent-size and -b are ineffective with --inodes");
- }
-
- let block_size = read_block_size(
- matches
- .get_one::<String>(options::BLOCK_SIZE)
- .map(|s| s.as_str()),
- );
-
- let threshold = matches.get_one::<String>(options::THRESHOLD).map(|s| {
- Threshold::from_str(s)
- .unwrap_or_else(|e| crash!(1, "{}", format_error_message(&e, s, options::THRESHOLD)))
+ let time = matches.contains_id(options::TIME).then(|| {
+ match matches.get_one::<String>(options::TIME).map(AsRef::as_ref) {
+ None | Some("ctime" | "status") => Time::Modified,
+ Some("access" | "atime" | "use") => Time::Accessed,
+ Some("birth" | "creation") => Time::Created,
+ _ => unreachable!("should be caught by clap"),
+ }
});
- let multiplier: u64 = if matches.get_flag(options::SI) {
- 1000
+ let size_format = if matches.get_flag(options::HUMAN_READABLE) {
+ SizeFormat::HumanBinary
+ } else if matches.get_flag(options::SI) {
+ SizeFormat::HumanDecimal
+ } else if matches.get_flag(options::BYTES) {
+ SizeFormat::BlockSize(1)
+ } else if matches.get_flag(options::BLOCK_SIZE_1K) {
+ SizeFormat::BlockSize(1024)
+ } else if matches.get_flag(options::BLOCK_SIZE_1M) {
+ SizeFormat::BlockSize(1024 * 1024)
} else {
- 1024
- };
- let convert_size_fn = {
- if matches.get_flag(options::HUMAN_READABLE) || matches.get_flag(options::SI) {
- convert_size_human
- } else if matches.get_flag(options::BYTES) {
- convert_size_b
- } else if matches.get_flag(options::BLOCK_SIZE_1K) {
- convert_size_k
- } else if matches.get_flag(options::BLOCK_SIZE_1M) {
- convert_size_m
- } else {
- convert_size_other
- }
+ SizeFormat::BlockSize(read_block_size(
+ matches
+ .get_one::<String>(options::BLOCK_SIZE)
+ .map(AsRef::as_ref),
+ )?)
};
- let convert_size = |size: u64| {
- if options.inodes {
- size.to_string()
+
+ let traversal_options = TraversalOptions {
+ all: matches.get_flag(options::ALL),
+ separate_dirs: matches.get_flag(options::SEPARATE_DIRS),
+ one_file_system: matches.get_flag(options::ONE_FILE_SYSTEM),
+ dereference: if matches.get_flag(options::DEREFERENCE) {
+ Deref::All
+ } else if matches.get_flag(options::DEREFERENCE_ARGS) {
+ // We don't care about the cost of cloning as it is rarely used
+ Deref::Args(files.clone())
} else {
- convert_size_fn(size, multiplier, block_size)
- }
+ Deref::None
+ },
+ count_links: matches.get_flag(options::COUNT_LINKS),
+ verbose: matches.get_flag(options::VERBOSE),
+ excludes: build_exclude_patterns(&matches)?,
};
- let time_format_str =
- parse_time_style(matches.get_one::<String>("time-style").map(|s| s.as_str()))?;
-
- let line_separator = if matches.get_flag(options::NULL) {
- "\0"
+ let time_format = if time.is_some() {
+ parse_time_style(matches.get_one::<String>("time-style").map(|s| s.as_str()))?.to_string()
} else {
- "\n"
+ "%Y-%m-%d %H:%M".to_string()
};
- let excludes = build_exclude_patterns(&matches)?;
+ let stat_printer = StatPrinter {
+ max_depth,
+ size_format,
+ summarize,
+ total: matches.get_flag(options::TOTAL),
+ inodes: matches.get_flag(options::INODES),
+ threshold: matches
+ .get_one::<String>(options::THRESHOLD)
+ .map(|s| {
+ Threshold::from_str(s).map_err(|e| {
+ USimpleError::new(1, format_error_message(&e, s, options::THRESHOLD))
+ })
+ })
+ .transpose()?,
+ apparent_size: matches.get_flag(options::APPARENT_SIZE) || matches.get_flag(options::BYTES),
+ time,
+ time_format,
+ line_ending: LineEnding::from_zero_flag(matches.get_flag(options::NULL)),
+ };
+
+ if stat_printer.inodes
+ && (matches.get_flag(options::APPARENT_SIZE) || matches.get_flag(options::BYTES))
+ {
+ show_warning!("options --apparent-size and -b are ineffective with --inodes");
+ }
+
+ // Use separate thread to print output, so we can print finished results while computation is still running
+ let (print_tx, rx) = mpsc::channel::<UResult<StatPrintInfo>>();
+ let printing_thread = thread::spawn(move || stat_printer.print_stats(&rx));
- let mut grand_total = 0;
- 'loop_file: for path_string in files {
+ 'loop_file: for path in files {
// Skip if we don't want to ignore anything
- if !&excludes.is_empty() {
- for pattern in &excludes {
- if pattern.matches(path_string) {
+ if !&traversal_options.excludes.is_empty() {
+ let path_string = path.to_string_lossy();
+ for pattern in &traversal_options.excludes {
+ if pattern.matches(&path_string) {
// if the directory is ignored, leave early
- if options.verbose {
+ if traversal_options.verbose {
println!("{} ignored", path_string.quote());
}
continue 'loop_file;
@@ -608,78 +767,49 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
}
}
- let path = PathBuf::from(&path_string);
// Check existence of path provided in argument
- if let Ok(stat) = Stat::new(path, &options) {
+ if let Ok(stat) = Stat::new(&path, &traversal_options) {
// Kick off the computation of disk usage from the initial path
- let mut inodes: HashSet<FileInfo> = HashSet::new();
+ let mut seen_inodes: HashSet<FileInfo> = HashSet::new();
if let Some(inode) = stat.inode {
- inodes.insert(inode);
+ seen_inodes.insert(inode);
}
- let iter = du(stat, &options, 0, &mut inodes, &excludes);
+ let stat = du(stat, &traversal_options, 0, &mut seen_inodes, &print_tx)
+ .map_err(|e| USimpleError::new(1, e.to_string()))?;
- // Sum up all the returned `Stat`s and display results
- let (_, len) = iter.size_hint();
- let len = len.unwrap();
- for (index, stat) in iter.enumerate() {
- let size = choose_size(&matches, &stat);
-
- if threshold.map_or(false, |threshold| threshold.should_exclude(size)) {
- continue;
- }
-
- if matches.contains_id(options::TIME) {
- let tm = {
- let secs = {
- match matches.get_one::<String>(options::TIME) {
- Some(s) => match s.as_str() {
- "ctime" | "status" => stat.modified,
- "access" | "atime" | "use" => stat.accessed,
- "birth" | "creation" => stat
- .created
- .ok_or_else(|| DuError::InvalidTimeArg(s.into()))?,
- // below should never happen as clap already restricts the values.
- _ => unreachable!("Invalid field for --time"),
- },
- None => stat.modified,
- }
- };
- DateTime::<Local>::from(UNIX_EPOCH + Duration::from_secs(secs))
- };
- if !summarize || index == len - 1 {
- let time_str = tm.format(time_format_str).to_string();
- print!("{}\t{}\t", convert_size(size), time_str);
- print_verbatim(stat.path).unwrap();
- print!("{}", line_separator);
- }
- } else if !summarize || index == len - 1 {
- print!("{}\t", convert_size(size));
- print_verbatim(stat.path).unwrap();
- print!("{}", line_separator);
- }
- if options.total && index == (len - 1) {
- // The last element will be the total size of the the path under
- // path_string. We add it to the grand total.
- grand_total += size;
- }
- }
+ print_tx
+ .send(Ok(StatPrintInfo { stat, depth: 0 }))
+ .map_err(|e| USimpleError::new(1, e.to_string()))?;
} else {
- show_error!(
- "{}: {}",
- path_string.maybe_quote(),
- "No such file or directory"
- );
+ print_tx
+ .send(Err(USimpleError::new(
+ 1,
+ format!(
+ "cannot access {}: No such file or directory",
+ path.to_string_lossy().quote()
+ ),
+ )))
+ .map_err(|e| USimpleError::new(1, e.to_string()))?;
}
}
- if options.total {
- print!("{}\ttotal", convert_size(grand_total));
- print!("{}", line_separator);
- }
+ drop(print_tx);
+
+ printing_thread
+ .join()
+ .map_err(|_| USimpleError::new(1, "Printing thread panicked."))??;
Ok(())
}
+fn get_time_secs(time: Time, stat: &Stat) -> Result<u64, DuError> {
+ match time {
+ Time::Modified => Ok(stat.modified),
+ Time::Accessed => Ok(stat.accessed),
+ Time::Created => stat.created.ok_or(DuError::InvalidTimeArg),
+ }
+}
+
fn parse_time_style(s: Option<&str>) -> UResult<&str> {
match s {
Some(s) => match s {
@@ -705,7 +835,7 @@ pub fn uu_app() -> Command {
Command::new(uucore::util_name())
.version(crate_version!())
.about(ABOUT)
- .after_help(LONG_HELP)
+ .after_help(AFTER_HELP)
.override_usage(format_usage(USAGE))
.infer_long_args(true)
.disable_help_flag(true)
@@ -799,16 +929,25 @@ pub fn uu_app() -> Command {
Arg::new(options::DEREFERENCE)
.short('L')
.long(options::DEREFERENCE)
- .help("dereference all symbolic links")
+ .help("follow all symbolic links")
.action(ArgAction::SetTrue)
)
- // .arg(
- // Arg::new("no-dereference")
- // .short('P')
- // .long("no-dereference")
- // .help("don't follow any symbolic links (this is the default)")
- // .action(ArgAction::SetTrue),
- // )
+ .arg(
+ Arg::new(options::DEREFERENCE_ARGS)
+ .short('D')
+ .visible_short_alias('H')
+ .long(options::DEREFERENCE_ARGS)
+ .help("follow only symlinks that are listed on the command line")
+ .action(ArgAction::SetTrue)
+ )
+ .arg(
+ Arg::new(options::NO_DEREFERENCE)
+ .short('P')
+ .long(options::NO_DEREFERENCE)
+ .help("don't follow any symbolic links (this is the default)")
+ .overrides_with(options::DEREFERENCE)
+ .action(ArgAction::SetTrue),
+ )
.arg(
Arg::new(options::BLOCK_SIZE_1M)
.short('m')
@@ -882,13 +1021,25 @@ pub fn uu_app() -> Command {
.help("exclude files that match any pattern in FILE")
.action(ArgAction::Append)
)
+ .arg(
+ Arg::new(options::FILES0_FROM)
+ .long("files0-from")
+ .value_name("FILE")
+ .value_hint(clap::ValueHint::FilePath)
+ .help("summarize device usage of the NUL-terminated file names specified in file F; if F is -, then read names from standard input")
+ .action(ArgAction::Append)
+ )
.arg(
Arg::new(options::TIME)
.long(options::TIME)
.value_name("WORD")
.require_equals(true)
.num_args(0..)
- .value_parser(["atime", "access", "use", "ctime", "status", "birth", "creation"])
+ .value_parser(ShortcutValueParser::new([
+ PossibleValue::new("atime").alias("access").alias("use"),
+ PossibleValue::new("ctime").alias("status"),
+ PossibleValue::new("creation").alias("birth"),
+ ]))
.help(
"show time of the last modification of any file in the \
directory, or any of its subdirectories. If WORD is given, show time as WORD instead \
@@ -921,12 +1072,17 @@ enum Threshold {
impl FromStr for Threshold {
type Err = ParseSizeError;
- fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
let offset = usize::from(s.starts_with(&['-', '+'][..]));
- let size = parse_size(&s[offset..])?;
+ let size = parse_size_u64(&s[offset..])?;
if s.starts_with('-') {
+ // Threshold of '-0' excludes everything besides 0 sized entries
+ // GNU's du treats '-0' as an invalid argument
+ if size == 0 {
+ return Err(ParseSizeError::ParseFailure(s.to_string()));
+ }
Ok(Self::Upper(size))
} else {
Ok(Self::Lower(size))
@@ -962,13 +1118,9 @@ mod test_du {
#[test]
fn test_read_block_size() {
- let test_data = [
- (Some("1024".to_string()), 1024),
- (Some("K".to_string()), 1024),
- (None, 1024),
- ];
+ let test_data = [Some("1024".to_string()), Some("K".to_string()), None];
for it in &test_data {
- assert_eq!(read_block_size(it.0.as_deref()), it.1);
+ assert!(matches!(read_block_size(it.as_deref()), Ok(1024)));
}
}
}
diff --git a/src/uu/echo/Cargo.toml b/src/uu/echo/Cargo.toml
index a241c1427c0d9a3abeaf5ff58b98955bedb42c23..d38845fc5cddfbc780e27d353b4cb374a4a14e28 100644
--- a/src/uu/echo/Cargo.toml
+++ b/src/uu/echo/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_echo"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "echo ~ (uutils) display TEXT"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/echo.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "echo"
diff --git a/src/uu/echo/echo.md b/src/uu/echo/echo.md
new file mode 100644
index 0000000000000000000000000000000000000000..f6f6f37ffcd148f2740cdf7c197ee9c2b09f00b3
--- /dev/null
+++ b/src/uu/echo/echo.md
@@ -0,0 +1,26 @@
+# echo
+
+```
+echo [OPTIONS]... [STRING]...
+```
+
+Display a line of text
+
+## After Help
+
+Echo the STRING(s) to standard output.
+
+If -e is in effect, the following sequences are recognized:
+
+- `\` backslash
+- `\a` alert (BEL)
+- `\b` backspace
+- `\c` produce no further output
+- `\e` escape
+- `\f` form feed
+- `\n` new line
+- `\r` carriage return
+- `\t` horizontal tab
+- `\v` vertical tab
+- `\0NNN` byte with octal value NNN (1 to 3 digits)
+- `\xHH` byte with hexadecimal value HH (1 to 2 digits)
diff --git a/src/uu/echo/src/echo.rs b/src/uu/echo/src/echo.rs
index cae9e6225e060a7bbe72050100db9f3a1a9eee27..c94443822e0b6e39702285201839453f80bb43a0 100644
--- a/src/uu/echo/src/echo.rs
+++ b/src/uu/echo/src/echo.rs
@@ -1,38 +1,19 @@
// This file is part of the uutils coreutils package.
//
-// (c) Derek Chiang <derekchiang93@gmail.com>
-// (c) Christopher Brown <ccbrown112@gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
use clap::{crate_version, Arg, ArgAction, Command};
use std::io::{self, Write};
use std::iter::Peekable;
+use std::ops::ControlFlow;
use std::str::Chars;
use uucore::error::{FromIo, UResult};
-use uucore::format_usage;
-
-const ABOUT: &str = "display a line of text";
-const USAGE: &str = "{} [OPTIONS]... [STRING]...";
-const AFTER_HELP: &str = r#"
- Echo the STRING(s) to standard output.
-
- If -e is in effect, the following sequences are recognized:
-
- \\\\ backslash
- \\a alert (BEL)
- \\b backspace
- \\c produce no further output
- \\e escape
- \\f form feed
- \\n new line
- \\r carriage return
- \\t horizontal tab
- \\v vertical tab
- \\0NNN byte with octal value NNN (1 to 3 digits)
- \\xHH byte with hexadecimal value HH (1 to 2 digits)
-"#;
+use uucore::{format_usage, help_about, help_section, help_usage};
+
+const ABOUT: &str = help_about!("echo.md");
+const USAGE: &str = help_usage!("echo.md");
+const AFTER_HELP: &str = help_section!("after help", "echo.md");
mod options {
pub const STRING: &str = "STRING";
@@ -41,78 +22,102 @@ mod options {
pub const DISABLE_BACKSLASH_ESCAPE: &str = "disable_backslash_escape";
}
-fn parse_code(
- input: &mut Peekable<Chars>,
- base: u32,
- max_digits: u32,
- bits_per_digit: u32,
-) -> Option<char> {
- let mut ret = 0x8000_0000;
- for _ in 0..max_digits {
- match input.peek().and_then(|c| c.to_digit(base)) {
- Some(n) => ret = (ret << bits_per_digit) | n,
- None => break,
+#[repr(u8)]
+#[derive(Clone, Copy)]
+enum Base {
+ Oct = 8,
+ Hex = 16,
+}
+
+impl Base {
+ fn max_digits(&self) -> u8 {
+ match self {
+ Self::Oct => 3,
+ Self::Hex => 2,
}
- input.next();
}
- std::char::from_u32(ret)
}
-fn print_escaped(input: &str, mut output: impl Write) -> io::Result<bool> {
- let mut should_stop = false;
+/// Parse the numeric part of the `\xHHH` and `\0NNN` escape sequences
+fn parse_code(input: &mut Peekable<Chars>, base: Base) -> Option<char> {
+ // All arithmetic on `ret` needs to be wrapping, because octal input can
+ // take 3 digits, which is 9 bits, and therefore more than what fits in a
+ // `u8`. GNU just seems to wrap these values.
+ // Note that if we instead make `ret` a `u32` and use `char::from_u32` will
+ // yield incorrect results because it will interpret values larger than
+ // `u8::MAX` as unicode.
+ let mut ret = input.peek().and_then(|c| c.to_digit(base as u32))? as u8;
+
+ // We can safely ignore the None case because we just peeked it.
+ let _ = input.next();
+
+ for _ in 1..base.max_digits() {
+ match input.peek().and_then(|c| c.to_digit(base as u32)) {
+ Some(n) => ret = ret.wrapping_mul(base as u8).wrapping_add(n as u8),
+ None => break,
+ }
+ // We can safely ignore the None case because we just peeked it.
+ let _ = input.next();
+ }
- let mut buffer = ['\\'; 2];
+ Some(ret.into())
+}
- // TODO `cargo +nightly clippy` complains that `.peek()` is never
- // called on `iter`. However, `peek()` is called inside the
- // `parse_code()` function that borrows `iter`.
+fn print_escaped(input: &str, mut output: impl Write) -> io::Result<ControlFlow<()>> {
let mut iter = input.chars().peekable();
- while let Some(mut c) = iter.next() {
- let mut start = 1;
-
- if c == '\\' {
- if let Some(next) = iter.next() {
- c = match next {
- '\\' => '\\',
- 'a' => '\x07',
- 'b' => '\x08',
- 'c' => {
- should_stop = true;
- break;
- }
- 'e' => '\x1b',
- 'f' => '\x0c',
- 'n' => '\n',
- 'r' => '\r',
- 't' => '\t',
- 'v' => '\x0b',
- 'x' => parse_code(&mut iter, 16, 2, 4).unwrap_or_else(|| {
- start = 0;
- next
- }),
- '0' => parse_code(&mut iter, 8, 3, 3).unwrap_or('\0'),
- _ => {
- start = 0;
- next
- }
- };
- }
+ while let Some(c) = iter.next() {
+ if c != '\\' {
+ write!(output, "{c}")?;
+ continue;
}
- buffer[1] = c;
+ // This is for the \NNN syntax for octal sequences.
+ // Note that '0' is intentionally omitted because that
+ // would be the \0NNN syntax.
+ if let Some('1'..='8') = iter.peek() {
+ if let Some(parsed) = parse_code(&mut iter, Base::Oct) {
+ write!(output, "{parsed}")?;
+ continue;
+ }
+ }
- // because printing char slices is apparently not available in the standard library
- for ch in &buffer[start..] {
- write!(output, "{}", ch)?;
+ if let Some(next) = iter.next() {
+ let unescaped = match next {
+ '\\' => '\\',
+ 'a' => '\x07',
+ 'b' => '\x08',
+ 'c' => return Ok(ControlFlow::Break(())),
+ 'e' => '\x1b',
+ 'f' => '\x0c',
+ 'n' => '\n',
+ 'r' => '\r',
+ 't' => '\t',
+ 'v' => '\x0b',
+ 'x' => {
+ if let Some(c) = parse_code(&mut iter, Base::Hex) {
+ c
+ } else {
+ write!(output, "\\")?;
+ 'x'
+ }
+ }
+ '0' => parse_code(&mut iter, Base::Oct).unwrap_or('\0'),
+ c => {
+ write!(output, "\\")?;
+ c
+ }
+ };
+ write!(output, "{unescaped}")?;
+ } else {
+ write!(output, "\\")?;
}
}
- Ok(should_stop)
+ Ok(ControlFlow::Continue(()))
}
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_lossy();
let matches = uu_app().get_matches_from(args);
let no_newline = matches.get_flag(options::NO_NEWLINE);
@@ -127,13 +132,15 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
}
pub fn uu_app() -> Command {
+ // Note: echo is different from the other utils in that it should **not**
+ // have `infer_long_args(true)`, because, for example, `--ver` should be
+ // printed as `--ver` and not show the version text.
Command::new(uucore::util_name())
// TrailingVarArg specifies the final positional argument is a VarArg
// and it doesn't attempts the parse any further args.
// Final argument must have multiple(true) or the usage string equivalent.
.trailing_var_arg(true)
.allow_hyphen_values(true)
- .infer_long_args(true)
.version(crate_version!())
.about(ABOUT)
.after_help(AFTER_HELP)
@@ -148,13 +155,15 @@ pub fn uu_app() -> Command {
Arg::new(options::ENABLE_BACKSLASH_ESCAPE)
.short('e')
.help("enable interpretation of backslash escapes")
- .action(ArgAction::SetTrue),
+ .action(ArgAction::SetTrue)
+ .overrides_with(options::DISABLE_BACKSLASH_ESCAPE),
)
.arg(
Arg::new(options::DISABLE_BACKSLASH_ESCAPE)
.short('E')
.help("disable interpretation of backslash escapes (default)")
- .action(ArgAction::SetTrue),
+ .action(ArgAction::SetTrue)
+ .overrides_with(options::ENABLE_BACKSLASH_ESCAPE),
)
.arg(Arg::new(options::STRING).action(ArgAction::Append))
}
@@ -168,12 +177,11 @@ fn execute(no_newline: bool, escaped: bool, free: &[String]) -> io::Result<()> {
write!(output, " ")?;
}
if escaped {
- let should_stop = print_escaped(input, &mut output)?;
- if should_stop {
- break;
+ if print_escaped(input, &mut output)?.is_break() {
+ return Ok(());
}
} else {
- write!(output, "{}", input)?;
+ write!(output, "{input}")?;
}
}
diff --git a/src/uu/env/Cargo.toml b/src/uu/env/Cargo.toml
index 311d34c0606cf493e92fc24381ff6b60c58546d9..9101c4268eed93bf6df53fbbeaf05d583d261202 100644
--- a/src/uu/env/Cargo.toml
+++ b/src/uu/env/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_env"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "env ~ (uutils) set each NAME to VALUE in the environment and run COMMAND"
@@ -15,12 +15,12 @@ edition = "2021"
path = "src/env.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-rust-ini = "0.18.0"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["signals"]}
+clap = { workspace = true }
+rust-ini = { workspace = true }
+uucore = { workspace = true, features = ["signals"] }
[target.'cfg(unix)'.dependencies]
-nix = { version = "0.25", default-features = false, features = ["signal"] }
+nix = { workspace = true, features = ["signal"] }
[[bin]]
diff --git a/src/uu/env/env.md b/src/uu/env/env.md
new file mode 100644
index 0000000000000000000000000000000000000000..fc3341a61f7bcc911999b44dc5618cec9c51b7d4
--- /dev/null
+++ b/src/uu/env/env.md
@@ -0,0 +1,13 @@
+# env
+
+```
+env [OPTION]... [-] [NAME=VALUE]... [COMMAND [ARG]...]
+```
+
+
+Set each NAME to VALUE in the environment and run COMMAND
+
+
+## After Help
+
+A mere - implies -i. If no COMMAND, print the resulting environment.
diff --git a/src/uu/env/src/env.rs b/src/uu/env/src/env.rs
index 0776a6b120f3a4b08a9f62892d3d185cc9094af4..229488cfb5158fcc89b4af4b5fba18a6951927fd 100644
--- a/src/uu/env/src/env.rs
+++ b/src/uu/env/src/env.rs
@@ -1,63 +1,81 @@
// This file is part of the uutils coreutils package.
//
-// (c) Jordi Boggiano <j.boggiano@seld.be>
-// (c) Thomas Queiroz <thomasqueirozb@gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
-/* last synced with: env (GNU coreutils) 8.13 */
-
// spell-checker:ignore (ToDO) chdir execvp progname subcommand subcommands unsets setenv putenv spawnp SIGSEGV SIGBUS sigaction
+pub mod native_int_str;
+pub mod parse_error;
+pub mod split_iterator;
+pub mod string_expander;
+pub mod string_parser;
+pub mod variable_parser;
+
+use clap::builder::ValueParser;
use clap::{crate_name, crate_version, Arg, ArgAction, Command};
use ini::Ini;
+use native_int_str::{
+ from_native_int_representation_owned, Convert, NCvt, NativeIntStr, NativeIntString, NativeStr,
+};
#[cfg(unix)]
-use nix::sys::signal::{raise, sigaction, SaFlags, SigAction, SigHandler, SigSet, Signal};
+use nix::sys::signal::{
+ raise, sigaction, signal, SaFlags, SigAction, SigHandler, SigHandler::SigIgn, SigSet, Signal,
+};
use std::borrow::Cow;
use std::env;
+use std::ffi::{OsStr, OsString};
use std::io::{self, Write};
-use std::iter::Iterator;
+use std::ops::Deref;
+
#[cfg(unix)]
-use std::os::unix::process::ExitStatusExt;
-use std::process;
+use std::os::unix::ffi::OsStrExt;
+#[cfg(unix)]
+use std::os::unix::process::{CommandExt, ExitStatusExt};
+use std::process::{self};
use uucore::display::Quotable;
-use uucore::error::{UClapError, UResult, USimpleError, UUsageError};
-use uucore::{format_usage, show_warning};
+use uucore::error::{ExitCode, UError, UResult, USimpleError, UUsageError};
+use uucore::line_ending::LineEnding;
+#[cfg(unix)]
+use uucore::signals::signal_by_name_or_value;
+use uucore::{format_usage, help_about, help_section, help_usage, show_warning};
-const ABOUT: &str = "set each NAME to VALUE in the environment and run COMMAND";
-const USAGE: &str = "{} [OPTION]... [-] [NAME=VALUE]... [COMMAND [ARG]...]";
-const AFTER_HELP: &str = "\
-A mere - implies -i. If no COMMAND, print the resulting environment.
-";
+const ABOUT: &str = help_about!("env.md");
+const USAGE: &str = help_usage!("env.md");
+const AFTER_HELP: &str = help_section!("after help", "env.md");
+
+const ERROR_MSG_S_SHEBANG: &str = "use -[v]S to pass options in shebang lines";
struct Options<'a> {
ignore_env: bool,
- null: bool,
- running_directory: Option<&'a str>,
- files: Vec<&'a str>,
- unsets: Vec<&'a str>,
- sets: Vec<(&'a str, &'a str)>,
- program: Vec<&'a str>,
+ line_ending: LineEnding,
+ running_directory: Option<&'a OsStr>,
+ files: Vec<&'a OsStr>,
+ unsets: Vec<&'a OsStr>,
+ sets: Vec<(Cow<'a, OsStr>, Cow<'a, OsStr>)>,
+ program: Vec<&'a OsStr>,
+ argv0: Option<&'a OsStr>,
+ #[cfg(unix)]
+ ignore_signal: Vec<usize>,
}
// print name=value env pairs on screen
// if null is true, separate pairs with a \0, \n otherwise
-fn print_env(null: bool) {
+fn print_env(line_ending: LineEnding) {
let stdout_raw = io::stdout();
let mut stdout = stdout_raw.lock();
for (n, v) in env::vars() {
- write!(stdout, "{}={}{}", n, v, if null { '\0' } else { '\n' }).unwrap();
+ write!(stdout, "{}={}{}", n, v, line_ending).unwrap();
}
}
-fn parse_name_value_opt<'a>(opts: &mut Options<'a>, opt: &'a str) -> UResult<bool> {
+fn parse_name_value_opt<'a>(opts: &mut Options<'a>, opt: &'a OsStr) -> UResult<bool> {
// is it a NAME=VALUE like opt ?
- if let Some(idx) = opt.find('=') {
+ let wrap = NativeStr::<'a>::new(opt);
+ let split_o = wrap.split_once(&'=');
+ if let Some((name, value)) = split_o {
// yes, so push name, value pair
- let (name, value) = opt.split_at(idx);
- opts.sets.push((name, &value['='.len_utf8()..]));
-
+ opts.sets.push((name, value));
Ok(false)
} else {
// no, it's a program-like opt
@@ -65,8 +83,8 @@ fn parse_name_value_opt<'a>(opts: &mut Options<'a>, opt: &'a str) -> UResult<boo
}
}
-fn parse_program_opt<'a>(opts: &mut Options<'a>, opt: &'a str) -> UResult<()> {
- if opts.null {
+fn parse_program_opt<'a>(opts: &mut Options<'a>, opt: &'a OsStr) -> UResult<()> {
+ if opts.line_ending == LineEnding::Nul {
Err(UUsageError::new(
125,
"cannot specify --null (-0) with command".to_string(),
@@ -77,6 +95,59 @@ fn parse_program_opt<'a>(opts: &mut Options<'a>, opt: &'a str) -> UResult<()> {
}
}
+#[cfg(unix)]
+fn parse_signal_value(signal_name: &str) -> UResult<usize> {
+ let signal_name_upcase = signal_name.to_uppercase();
+ let optional_signal_value = signal_by_name_or_value(&signal_name_upcase);
+ let error = USimpleError::new(125, format!("{}: invalid signal", signal_name.quote()));
+ match optional_signal_value {
+ Some(sig_val) => {
+ if sig_val == 0 {
+ Err(error)
+ } else {
+ Ok(sig_val)
+ }
+ }
+ None => Err(error),
+ }
+}
+
+#[cfg(unix)]
+fn parse_signal_opt<'a>(opts: &mut Options<'a>, opt: &'a OsStr) -> UResult<()> {
+ if opt.is_empty() {
+ return Ok(());
+ }
+ let signals: Vec<&'a OsStr> = opt
+ .as_bytes()
+ .split(|&b| b == b',')
+ .map(OsStr::from_bytes)
+ .collect();
+
+ let mut sig_vec = Vec::with_capacity(signals.len());
+ signals.into_iter().for_each(|sig| {
+ if !(sig.is_empty()) {
+ sig_vec.push(sig);
+ }
+ });
+ for sig in sig_vec {
+ let sig_str = match sig.to_str() {
+ Some(s) => s,
+ None => {
+ return Err(USimpleError::new(
+ 1,
+ format!("{}: invalid signal", sig.quote()),
+ ))
+ }
+ };
+ let sig_val = parse_signal_value(sig_str)?;
+ if !opts.ignore_signal.contains(&sig_val) {
+ opts.ignore_signal.push(sig_val);
+ }
+ }
+
+ Ok(())
+}
+
fn load_config_file(opts: &mut Options) -> UResult<()> {
// NOTE: config files are parsed using an INI parser b/c it's available and compatible with ".env"-style files
// ... * but support for actual INI files, although working, is not intended, nor claimed
@@ -94,7 +165,7 @@ fn load_config_file(opts: &mut Options) -> UResult<()> {
for (_, prop) in &conf {
// ignore all INI section lines (treat them as comments)
- for (key, value) in prop.iter() {
+ for (key, value) in prop {
env::set_var(key, value);
}
}
@@ -103,23 +174,6 @@ fn load_config_file(opts: &mut Options) -> UResult<()> {
Ok(())
}
-#[cfg(not(windows))]
-#[allow(clippy::ptr_arg)]
-fn build_command<'a, 'b>(args: &'a mut Vec<&'b str>) -> (Cow<'b, str>, &'a [&'b str]) {
- let progname = Cow::from(args[0]);
- (progname, &args[1..])
-}
-
-#[cfg(windows)]
-fn build_command<'a, 'b>(args: &'a mut Vec<&'b str>) -> (Cow<'b, str>, &'a [&'b str]) {
- args.insert(0, "/d/c");
- let progname = env::var("ComSpec")
- .map(Cow::from)
- .unwrap_or_else(|_| Cow::from("cmd"));
-
- (progname, &args[..])
-}
-
pub fn uu_app() -> Command {
Command::new(crate_name!())
.version(crate_version!())
@@ -141,6 +195,7 @@ pub fn uu_app() -> Command {
.long("chdir")
.number_of_values(1)
.value_name("DIR")
+ .value_parser(ValueParser::os_string())
.value_hint(clap::ValueHint::DirPath)
.help("change working directory to DIR"),
)
@@ -160,6 +215,7 @@ pub fn uu_app() -> Command {
.long("file")
.value_name("PATH")
.value_hint(clap::ValueHint::FilePath)
+ .value_parser(ValueParser::os_string())
.action(ArgAction::Append)
.help(
"read and set variables from a \".env\"-style configuration file \
@@ -172,52 +228,365 @@ pub fn uu_app() -> Command {
.long("unset")
.value_name("NAME")
.action(ArgAction::Append)
+ .value_parser(ValueParser::os_string())
.help("remove variable from the environment"),
)
- .arg(Arg::new("vars").action(ArgAction::Append))
+ .arg(
+ Arg::new("debug")
+ .short('v')
+ .long("debug")
+ .action(ArgAction::Count)
+ .help("print verbose information for each processing step"),
+ )
+ .arg(
+ Arg::new("split-string") // split string handling is implemented directly, not using CLAP. But this entry here is needed for the help information output.
+ .short('S')
+ .long("split-string")
+ .value_name("S")
+ .action(ArgAction::Set)
+ .value_parser(ValueParser::os_string())
+ .help("process and split S into separate arguments; used to pass multiple arguments on shebang lines")
+ ).arg(
+ Arg::new("argv0")
+ .overrides_with("argv0")
+ .short('a')
+ .long("argv0")
+ .value_name("a")
+ .action(ArgAction::Set)
+ .value_parser(ValueParser::os_string())
+ .help("Override the zeroth argument passed to the command being executed. \
+ Without this option a default value of `command` is used.")
+ )
+ .arg(
+ Arg::new("vars")
+ .action(ArgAction::Append)
+ .value_parser(ValueParser::os_string())
+ )
+ .arg(
+ Arg::new("ignore-signal")
+ .long("ignore-signal")
+ .value_name("SIG")
+ .action(ArgAction::Append)
+ .value_parser(ValueParser::os_string())
+ .help("set handling of SIG signal(s) to do nothing")
+ )
+}
+
+pub fn parse_args_from_str(text: &NativeIntStr) -> UResult<Vec<NativeIntString>> {
+ split_iterator::split(text).map_err(|e| match e {
+ parse_error::ParseError::BackslashCNotAllowedInDoubleQuotes { pos: _ } => {
+ USimpleError::new(125, "'\\c' must not appear in double-quoted -S string")
+ }
+ parse_error::ParseError::InvalidBackslashAtEndOfStringInMinusS { pos: _, quoting: _ } => {
+ USimpleError::new(125, "invalid backslash at end of string in -S")
+ }
+ parse_error::ParseError::InvalidSequenceBackslashXInMinusS { pos: _, c } => {
+ USimpleError::new(125, format!("invalid sequence '\\{}' in -S", c))
+ }
+ parse_error::ParseError::MissingClosingQuote { pos: _, c: _ } => {
+ USimpleError::new(125, "no terminating quote in -S string")
+ }
+ parse_error::ParseError::ParsingOfVariableNameFailed { pos, msg } => {
+ USimpleError::new(125, format!("variable name issue (at {}): {}", pos, msg,))
+ }
+ _ => USimpleError::new(125, format!("Error: {:?}", e)),
+ })
+}
+
+fn debug_print_args(args: &[OsString]) {
+ eprintln!("input args:");
+ for (i, arg) in args.iter().enumerate() {
+ eprintln!("arg[{}]: {}", i, arg.quote());
+ }
+}
+
+fn check_and_handle_string_args(
+ arg: &OsString,
+ prefix_to_test: &str,
+ all_args: &mut Vec<std::ffi::OsString>,
+ do_debug_print_args: Option<&Vec<OsString>>,
+) -> UResult<bool> {
+ let native_arg = NCvt::convert(arg);
+ if let Some(remaining_arg) = native_arg.strip_prefix(&*NCvt::convert(prefix_to_test)) {
+ if let Some(input_args) = do_debug_print_args {
+ debug_print_args(input_args); // do it here, such that its also printed when we get an error/panic during parsing
+ }
+
+ let arg_strings = parse_args_from_str(remaining_arg)?;
+ all_args.extend(
+ arg_strings
+ .into_iter()
+ .map(from_native_int_representation_owned),
+ );
+
+ Ok(true)
+ } else {
+ Ok(false)
+ }
+}
+
+#[derive(Default)]
+struct EnvAppData {
+ do_debug_printing: bool,
+ do_input_debug_printing: Option<bool>,
+ had_string_argument: bool,
+}
+
+impl EnvAppData {
+ fn make_error_no_such_file_or_dir(&self, prog: &OsStr) -> Box<dyn UError> {
+ uucore::show_error!("{}: No such file or directory", prog.quote());
+ if !self.had_string_argument {
+ uucore::show_error!("{}", ERROR_MSG_S_SHEBANG);
+ }
+ ExitCode::new(127)
+ }
+
+ fn process_all_string_arguments(
+ &mut self,
+ original_args: &Vec<OsString>,
+ ) -> UResult<Vec<std::ffi::OsString>> {
+ let mut all_args: Vec<std::ffi::OsString> = Vec::new();
+ for arg in original_args {
+ match arg {
+ b if check_and_handle_string_args(b, "--split-string", &mut all_args, None)? => {
+ self.had_string_argument = true;
+ }
+ b if check_and_handle_string_args(b, "-S", &mut all_args, None)? => {
+ self.had_string_argument = true;
+ }
+ b if check_and_handle_string_args(b, "-vS", &mut all_args, None)? => {
+ self.do_debug_printing = true;
+ self.had_string_argument = true;
+ }
+ b if check_and_handle_string_args(
+ b,
+ "-vvS",
+ &mut all_args,
+ Some(original_args),
+ )? =>
+ {
+ self.do_debug_printing = true;
+ self.do_input_debug_printing = Some(false); // already done
+ self.had_string_argument = true;
+ }
+ _ => {
+ all_args.push(arg.clone());
+ }
+ }
+ }
+
+ Ok(all_args)
+ }
+
+ fn parse_arguments(
+ &mut self,
+ original_args: impl uucore::Args,
+ ) -> Result<(Vec<OsString>, clap::ArgMatches), Box<dyn UError>> {
+ let original_args: Vec<OsString> = original_args.collect();
+ let args = self.process_all_string_arguments(&original_args)?;
+ let app = uu_app();
+ let matches = app
+ .try_get_matches_from(args)
+ .map_err(|e| -> Box<dyn UError> {
+ match e.kind() {
+ clap::error::ErrorKind::DisplayHelp
+ | clap::error::ErrorKind::DisplayVersion => e.into(),
+ _ => {
+ // extent any real issue with parameter parsing by the ERROR_MSG_S_SHEBANG
+ let s = format!("{}", e);
+ if !s.is_empty() {
+ let s = s.trim_end();
+ uucore::show_error!("{}", s);
+ }
+ uucore::show_error!("{}", ERROR_MSG_S_SHEBANG);
+ uucore::error::ExitCode::new(125)
+ }
+ }
+ })?;
+ Ok((original_args, matches))
+ }
+
+ fn run_env(&mut self, original_args: impl uucore::Args) -> UResult<()> {
+ let (original_args, matches) = self.parse_arguments(original_args)?;
+
+ self.do_debug_printing = self.do_debug_printing || (0 != matches.get_count("debug"));
+ self.do_input_debug_printing = self
+ .do_input_debug_printing
+ .or(Some(matches.get_count("debug") >= 2));
+ if let Some(value) = self.do_input_debug_printing {
+ if value {
+ debug_print_args(&original_args);
+ self.do_input_debug_printing = Some(false);
+ }
+ }
+
+ let mut opts = make_options(&matches)?;
+
+ apply_change_directory(&opts)?;
+
+ // NOTE: we manually set and unset the env vars below rather than using Command::env() to more
+ // easily handle the case where no command is given
+
+ apply_removal_of_all_env_vars(&opts);
+
+ // load .env-style config file prior to those given on the command-line
+ load_config_file(&mut opts)?;
+
+ apply_unset_env_vars(&opts)?;
+
+ apply_specified_env_vars(&opts);
+
+ #[cfg(unix)]
+ apply_ignore_signal(&opts)?;
+
+ if opts.program.is_empty() {
+ // no program provided, so just dump all env vars to stdout
+ print_env(opts.line_ending);
+ } else {
+ return self.run_program(&opts, self.do_debug_printing);
+ }
+
+ Ok(())
+ }
+
+ fn run_program(
+ &mut self,
+ opts: &Options<'_>,
+ do_debug_printing: bool,
+ ) -> Result<(), Box<dyn UError>> {
+ let prog = Cow::from(opts.program[0]);
+ #[cfg(unix)]
+ let mut arg0 = prog.clone();
+ #[cfg(not(unix))]
+ let arg0 = prog.clone();
+ let args = &opts.program[1..];
+
+ /*
+ * On Unix-like systems Command::status either ends up calling either fork or posix_spawnp
+ * (which ends up calling clone). Keep using the current process would be ideal, but the
+ * standard library contains many checks and fail-safes to ensure the process ends up being
+ * created. This is much simpler than dealing with the hassles of calling execvp directly.
+ */
+ let mut cmd = process::Command::new(&*prog);
+ cmd.args(args);
+
+ if let Some(_argv0) = opts.argv0 {
+ #[cfg(unix)]
+ {
+ cmd.arg0(_argv0);
+ arg0 = Cow::Borrowed(_argv0);
+ if do_debug_printing {
+ eprintln!("argv0: {}", arg0.quote());
+ }
+ }
+
+ #[cfg(not(unix))]
+ return Err(USimpleError::new(
+ 2,
+ "--argv0 is currently not supported on this platform",
+ ));
+ }
+
+ if do_debug_printing {
+ eprintln!("executing: {}", prog.maybe_quote());
+ let arg_prefix = " arg";
+ eprintln!("{}[{}]= {}", arg_prefix, 0, arg0.quote());
+ for (i, arg) in args.iter().enumerate() {
+ eprintln!("{}[{}]= {}", arg_prefix, i + 1, arg.quote());
+ }
+ }
+
+ match cmd.status() {
+ Ok(exit) if !exit.success() => {
+ #[cfg(unix)]
+ if let Some(exit_code) = exit.code() {
+ return Err(exit_code.into());
+ } else {
+ // `exit.code()` returns `None` on Unix when the process is terminated by a signal.
+ // See std::os::unix::process::ExitStatusExt for more information. This prints out
+ // the interrupted process and the signal it received.
+ let signal_code = exit.signal().unwrap();
+ let signal = Signal::try_from(signal_code).unwrap();
+
+ // We have to disable any handler that's installed by default.
+ // This ensures that we exit on this signal.
+ // For example, `SIGSEGV` and `SIGBUS` have default handlers installed in Rust.
+ // We ignore the errors because there is not much we can do if that fails anyway.
+ // SAFETY: The function is unsafe because installing functions is unsafe, but we are
+ // just defaulting to default behavior and not installing a function. Hence, the call
+ // is safe.
+ let _ = unsafe {
+ sigaction(
+ signal,
+ &SigAction::new(SigHandler::SigDfl, SaFlags::empty(), SigSet::all()),
+ )
+ };
+
+ let _ = raise(signal);
+ }
+ return Err(exit.code().unwrap().into());
+ }
+ Err(ref err)
+ if (err.kind() == io::ErrorKind::NotFound)
+ || (err.kind() == io::ErrorKind::InvalidInput) =>
+ {
+ return Err(self.make_error_no_such_file_or_dir(prog.deref()));
+ }
+ Err(e) => {
+ uucore::show_error!("unknown error: {:?}", e);
+ return Err(126.into());
+ }
+ Ok(_) => (),
+ }
+ Ok(())
+ }
}
-fn run_env(args: impl uucore::Args) -> UResult<()> {
- let app = uu_app();
- let matches = app.try_get_matches_from(args).with_exit_code(125)?;
+fn apply_removal_of_all_env_vars(opts: &Options<'_>) {
+ // remove all env vars if told to ignore presets
+ if opts.ignore_env {
+ for (ref name, _) in env::vars_os() {
+ env::remove_var(name);
+ }
+ }
+}
+fn make_options(matches: &clap::ArgMatches) -> UResult<Options<'_>> {
let ignore_env = matches.get_flag("ignore-environment");
- let null = matches.get_flag("null");
- let running_directory = matches.get_one::<String>("chdir").map(|s| s.as_str());
- let files = match matches.get_many::<String>("file") {
- Some(v) => v.map(|s| s.as_str()).collect(),
+ let line_ending = LineEnding::from_zero_flag(matches.get_flag("null"));
+ let running_directory = matches.get_one::<OsString>("chdir").map(|s| s.as_os_str());
+ let files = match matches.get_many::<OsString>("file") {
+ Some(v) => v.map(|s| s.as_os_str()).collect(),
None => Vec::with_capacity(0),
};
- let unsets = match matches.get_many::<String>("unset") {
- Some(v) => v.map(|s| s.as_str()).collect(),
+ let unsets = match matches.get_many::<OsString>("unset") {
+ Some(v) => v.map(|s| s.as_os_str()).collect(),
None => Vec::with_capacity(0),
};
+ let argv0 = matches.get_one::<OsString>("argv0").map(|s| s.as_os_str());
let mut opts = Options {
ignore_env,
- null,
+ line_ending,
running_directory,
files,
unsets,
sets: vec![],
program: vec![],
+ argv0,
+ #[cfg(unix)]
+ ignore_signal: vec![],
};
- // change directory
- if let Some(d) = opts.running_directory {
- match env::set_current_dir(d) {
- Ok(()) => d,
- Err(error) => {
- return Err(USimpleError::new(
- 125,
- format!("cannot change directory to \"{}\": {}", d, error),
- ));
- }
- };
+ #[cfg(unix)]
+ if let Some(iter) = matches.get_many::<OsString>("ignore-signal") {
+ for opt in iter {
+ parse_signal_opt(&mut opts, opt)?;
+ }
}
let mut begin_prog_opts = false;
- if let Some(mut iter) = matches.get_many::<String>("vars") {
+ if let Some(mut iter) = matches.get_many::<OsString>("vars") {
// read NAME=VALUE arguments (and up to a single program argument)
while !begin_prog_opts {
if let Some(opt) = iter.next() {
@@ -237,30 +606,16 @@ fn run_env(args: impl uucore::Args) -> UResult<()> {
}
}
- // GNU env tests this behavior
- if opts.program.is_empty() && running_directory.is_some() {
- return Err(UUsageError::new(
- 125,
- "must specify command with --chdir (-C)".to_string(),
- ));
- }
-
- // NOTE: we manually set and unset the env vars below rather than using Command::env() to more
- // easily handle the case where no command is given
-
- // remove all env vars if told to ignore presets
- if opts.ignore_env {
- for (ref name, _) in env::vars() {
- env::remove_var(name);
- }
- }
-
- // load .env-style config file prior to those given on the command-line
- load_config_file(&mut opts)?;
+ Ok(opts)
+}
- // unset specified env vars
+fn apply_unset_env_vars(opts: &Options<'_>) -> Result<(), Box<dyn UError>> {
for name in &opts.unsets {
- if name.is_empty() || name.contains(0 as char) || name.contains('=') {
+ let native_name = NativeStr::new(name);
+ if name.is_empty()
+ || native_name.contains(&'\0').unwrap()
+ || native_name.contains(&'=').unwrap()
+ {
return Err(USimpleError::new(
125,
format!("cannot unset {}: Invalid argument", name.quote()),
@@ -269,9 +624,35 @@ fn run_env(args: impl uucore::Args) -> UResult<()> {
env::remove_var(name);
}
+ Ok(())
+}
+
+fn apply_change_directory(opts: &Options<'_>) -> Result<(), Box<dyn UError>> {
+ // GNU env tests this behavior
+ if opts.program.is_empty() && opts.running_directory.is_some() {
+ return Err(UUsageError::new(
+ 125,
+ "must specify command with --chdir (-C)".to_string(),
+ ));
+ }
+ if let Some(d) = opts.running_directory {
+ match env::set_current_dir(d) {
+ Ok(()) => d,
+ Err(error) => {
+ return Err(USimpleError::new(
+ 125,
+ format!("cannot change directory to {}: {error}", d.quote()),
+ ));
+ }
+ };
+ }
+ Ok(())
+}
+
+fn apply_specified_env_vars(opts: &Options<'_>) {
// set specified env vars
- for &(name, val) in &opts.sets {
+ for (name, val) in &opts.sets {
/*
* set_var panics if name is an empty string
* set_var internally calls setenv (on unix at least), while GNU env calls putenv instead.
@@ -300,61 +681,74 @@ fn run_env(args: impl uucore::Args) -> UResult<()> {
}
env::set_var(name, val);
}
+}
- if !opts.program.is_empty() {
- // we need to execute a command
- let (prog, args) = build_command(&mut opts.program);
-
- /*
- * On Unix-like systems Command::status either ends up calling either fork or posix_spawnp
- * (which ends up calling clone). Keep using the current process would be ideal, but the
- * standard library contains many checks and fail-safes to ensure the process ends up being
- * created. This is much simpler than dealing with the hassles of calling execvp directly.
- */
- match process::Command::new(&*prog).args(args).status() {
- Ok(exit) if !exit.success() => {
- #[cfg(unix)]
- if let Some(exit_code) = exit.code() {
- return Err(exit_code.into());
- } else {
- // `exit.code()` returns `None` on Unix when the process is terminated by a signal.
- // See std::os::unix::process::ExitStatusExt for more information. This prints out
- // the interrupted process and the signal it received.
- let signal_code = exit.signal().unwrap();
- let signal = Signal::try_from(signal_code).unwrap();
-
- // We have to disable any handler that's installed by default.
- // This ensures that we exit on this signal.
- // For example, `SIGSEGV` and `SIGBUS` have default handlers installed in Rust.
- // We ignore the errors because there is not much we can do if that fails anyway.
- // SAFETY: The function is unsafe because installing functions is unsafe, but we are
- // just defaulting to default behavior and not installing a function. Hence, the call
- // is safe.
- let _ = unsafe {
- sigaction(
- signal,
- &SigAction::new(SigHandler::SigDfl, SaFlags::empty(), SigSet::all()),
- )
- };
+#[cfg(unix)]
+fn apply_ignore_signal(opts: &Options<'_>) -> UResult<()> {
+ for &sig_value in &opts.ignore_signal {
+ let sig: Signal = (sig_value as i32)
+ .try_into()
+ .map_err(|e| std::io::Error::from_raw_os_error(e as i32))?;
- let _ = raise(signal);
- }
- #[cfg(not(unix))]
- return Err(exit.code().unwrap().into());
- }
- Err(ref err) if err.kind() == io::ErrorKind::NotFound => return Err(127.into()),
- Err(_) => return Err(126.into()),
- Ok(_) => (),
- }
- } else {
- // no program provided, so just dump all env vars to stdout
- print_env(opts.null);
+ ignore_signal(sig)?;
}
+ Ok(())
+}
+#[cfg(unix)]
+fn ignore_signal(sig: Signal) -> UResult<()> {
+ // SAFETY: This is safe because we write the handler for each signal only once, and therefore "the current handler is the default", as the documentation requires it.
+ let result = unsafe { signal(sig, SigIgn) };
+ if let Err(err) = result {
+ return Err(USimpleError::new(
+ 125,
+ format!(
+ "failed to set signal action for signal {}: {}",
+ sig as i32,
+ err.desc()
+ ),
+ ));
+ }
Ok(())
}
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- run_env(args)
+ EnvAppData::default().run_env(args)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_split_string_environment_vars_test() {
+ std::env::set_var("FOO", "BAR");
+ assert_eq!(
+ NCvt::convert(vec!["FOO=bar", "sh", "-c", "echo xBARx =$FOO="]),
+ parse_args_from_str(&NCvt::convert(r#"FOO=bar sh -c "echo x${FOO}x =\$FOO=""#))
+ .unwrap(),
+ );
+ }
+
+ #[test]
+ fn test_split_string_misc() {
+ assert_eq!(
+ NCvt::convert(vec!["A=B", "FOO=AR", "sh", "-c", "echo $A$FOO"]),
+ parse_args_from_str(&NCvt::convert(r#"A=B FOO=AR sh -c "echo \$A\$FOO""#)).unwrap(),
+ );
+ assert_eq!(
+ NCvt::convert(vec!["A=B", "FOO=AR", "sh", "-c", "echo $A$FOO"]),
+ parse_args_from_str(&NCvt::convert(r#"A=B FOO=AR sh -c 'echo $A$FOO'"#)).unwrap()
+ );
+ assert_eq!(
+ NCvt::convert(vec!["A=B", "FOO=AR", "sh", "-c", "echo $A$FOO"]),
+ parse_args_from_str(&NCvt::convert(r#"A=B FOO=AR sh -c 'echo $A$FOO'"#)).unwrap()
+ );
+
+ assert_eq!(
+ NCvt::convert(vec!["-i", "A=B ' C"]),
+ parse_args_from_str(&NCvt::convert(r#"-i A='B \' C'"#)).unwrap()
+ );
+ }
}
diff --git a/src/uu/env/src/native_int_str.rs b/src/uu/env/src/native_int_str.rs
new file mode 100644
index 0000000000000000000000000000000000000000..dc1e741e1e13de59ea1b6ae0f53565594355a4a9
--- /dev/null
+++ b/src/uu/env/src/native_int_str.rs
@@ -0,0 +1,325 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// This module contains classes and functions for dealing with the differences
+// between operating systems regarding the lossless processing of OsStr/OsString.
+// In contrast to existing crates with similar purpose, this module does not use any
+// `unsafe` features or functions.
+// Due to a suboptimal design aspect of OsStr/OsString on windows, we need to
+// encode/decode to wide chars on windows operating system.
+// This prevents borrowing from OsStr on windows. Anyway, if optimally used,#
+// this conversion needs to be done only once in the beginning and at the end.
+
+use std::ffi::OsString;
+#[cfg(not(target_os = "windows"))]
+use std::os::unix::ffi::{OsStrExt, OsStringExt};
+#[cfg(target_os = "windows")]
+use std::os::windows::prelude::*;
+use std::{borrow::Cow, ffi::OsStr};
+
+#[cfg(target_os = "windows")]
+use u16 as NativeIntCharU;
+#[cfg(not(target_os = "windows"))]
+use u8 as NativeIntCharU;
+
+pub type NativeCharInt = NativeIntCharU;
+pub type NativeIntStr = [NativeCharInt];
+pub type NativeIntString = Vec<NativeCharInt>;
+
+pub struct NCvt;
+
+pub trait Convert<From, To> {
+ fn convert(f: From) -> To;
+}
+
+// ================ str/String =================
+
+impl<'a> Convert<&'a str, Cow<'a, NativeIntStr>> for NCvt {
+ fn convert(f: &'a str) -> Cow<'a, NativeIntStr> {
+ #[cfg(target_os = "windows")]
+ {
+ Cow::Owned(f.encode_utf16().collect())
+ }
+
+ #[cfg(not(target_os = "windows"))]
+ {
+ Cow::Borrowed(f.as_bytes())
+ }
+ }
+}
+
+impl<'a> Convert<&'a String, Cow<'a, NativeIntStr>> for NCvt {
+ fn convert(f: &'a String) -> Cow<'a, NativeIntStr> {
+ #[cfg(target_os = "windows")]
+ {
+ Cow::Owned(f.encode_utf16().collect())
+ }
+
+ #[cfg(not(target_os = "windows"))]
+ {
+ Cow::Borrowed(f.as_bytes())
+ }
+ }
+}
+
+impl<'a> Convert<String, Cow<'a, NativeIntStr>> for NCvt {
+ fn convert(f: String) -> Cow<'a, NativeIntStr> {
+ #[cfg(target_os = "windows")]
+ {
+ Cow::Owned(f.encode_utf16().collect())
+ }
+
+ #[cfg(not(target_os = "windows"))]
+ {
+ Cow::Owned(f.into_bytes())
+ }
+ }
+}
+
+// ================ OsStr/OsString =================
+
+impl<'a> Convert<&'a OsStr, Cow<'a, NativeIntStr>> for NCvt {
+ fn convert(f: &'a OsStr) -> Cow<'a, NativeIntStr> {
+ to_native_int_representation(f)
+ }
+}
+
+impl<'a> Convert<&'a OsString, Cow<'a, NativeIntStr>> for NCvt {
+ fn convert(f: &'a OsString) -> Cow<'a, NativeIntStr> {
+ to_native_int_representation(f)
+ }
+}
+
+impl<'a> Convert<OsString, Cow<'a, NativeIntStr>> for NCvt {
+ fn convert(f: OsString) -> Cow<'a, NativeIntStr> {
+ #[cfg(target_os = "windows")]
+ {
+ Cow::Owned(f.encode_wide().collect())
+ }
+
+ #[cfg(not(target_os = "windows"))]
+ {
+ Cow::Owned(f.into_vec())
+ }
+ }
+}
+
+// ================ Vec<Str/String> =================
+
+impl<'a> Convert<&'a Vec<&'a str>, Vec<Cow<'a, NativeIntStr>>> for NCvt {
+ fn convert(f: &'a Vec<&'a str>) -> Vec<Cow<'a, NativeIntStr>> {
+ f.iter().map(|x| Self::convert(*x)).collect()
+ }
+}
+
+impl<'a> Convert<Vec<&'a str>, Vec<Cow<'a, NativeIntStr>>> for NCvt {
+ fn convert(f: Vec<&'a str>) -> Vec<Cow<'a, NativeIntStr>> {
+ f.iter().map(|x| Self::convert(*x)).collect()
+ }
+}
+
+impl<'a> Convert<&'a Vec<String>, Vec<Cow<'a, NativeIntStr>>> for NCvt {
+ fn convert(f: &'a Vec<String>) -> Vec<Cow<'a, NativeIntStr>> {
+ f.iter().map(Self::convert).collect()
+ }
+}
+
+impl<'a> Convert<Vec<String>, Vec<Cow<'a, NativeIntStr>>> for NCvt {
+ fn convert(f: Vec<String>) -> Vec<Cow<'a, NativeIntStr>> {
+ f.into_iter().map(Self::convert).collect()
+ }
+}
+
+pub fn to_native_int_representation(input: &OsStr) -> Cow<'_, NativeIntStr> {
+ #[cfg(target_os = "windows")]
+ {
+ Cow::Owned(input.encode_wide().collect())
+ }
+
+ #[cfg(not(target_os = "windows"))]
+ {
+ Cow::Borrowed(input.as_bytes())
+ }
+}
+
+#[allow(clippy::needless_pass_by_value)] // needed on windows
+pub fn from_native_int_representation(input: Cow<'_, NativeIntStr>) -> Cow<'_, OsStr> {
+ #[cfg(target_os = "windows")]
+ {
+ Cow::Owned(OsString::from_wide(&input))
+ }
+
+ #[cfg(not(target_os = "windows"))]
+ {
+ match input {
+ Cow::Borrowed(borrow) => Cow::Borrowed(OsStr::from_bytes(borrow)),
+ Cow::Owned(own) => Cow::Owned(OsString::from_vec(own)),
+ }
+ }
+}
+
+#[allow(clippy::needless_pass_by_value)] // needed on windows
+pub fn from_native_int_representation_owned(input: NativeIntString) -> OsString {
+ #[cfg(target_os = "windows")]
+ {
+ OsString::from_wide(&input)
+ }
+
+ #[cfg(not(target_os = "windows"))]
+ {
+ OsString::from_vec(input)
+ }
+}
+
+pub fn get_single_native_int_value(c: &char) -> Option<NativeCharInt> {
+ #[cfg(target_os = "windows")]
+ {
+ let mut buf = [0u16, 0];
+ let s = c.encode_utf16(&mut buf);
+ if s.len() == 1 {
+ Some(buf[0])
+ } else {
+ None
+ }
+ }
+
+ #[cfg(not(target_os = "windows"))]
+ {
+ let mut buf = [0u8, 0, 0, 0];
+ let s = c.encode_utf8(&mut buf);
+ if s.len() == 1 {
+ Some(buf[0])
+ } else {
+ None
+ }
+ }
+}
+
+pub fn get_char_from_native_int(ni: NativeCharInt) -> Option<(char, NativeCharInt)> {
+ let c_opt;
+ #[cfg(target_os = "windows")]
+ {
+ c_opt = char::decode_utf16([ni; 1]).next().unwrap().ok();
+ };
+
+ #[cfg(not(target_os = "windows"))]
+ {
+ c_opt = std::str::from_utf8(&[ni; 1])
+ .ok()
+ .map(|x| x.chars().next().unwrap());
+ };
+
+ if let Some(c) = c_opt {
+ return Some((c, ni));
+ }
+
+ None
+}
+
+pub struct NativeStr<'a> {
+ native: Cow<'a, NativeIntStr>,
+}
+
+impl<'a> NativeStr<'a> {
+ pub fn new(str: &'a OsStr) -> Self {
+ Self {
+ native: to_native_int_representation(str),
+ }
+ }
+
+ pub fn native(&self) -> Cow<'a, NativeIntStr> {
+ self.native.clone()
+ }
+
+ pub fn into_native(self) -> Cow<'a, NativeIntStr> {
+ self.native
+ }
+
+ pub fn contains(&self, x: &char) -> Option<bool> {
+ let n_c = get_single_native_int_value(x)?;
+ Some(self.native.contains(&n_c))
+ }
+
+ pub fn slice(&self, from: usize, to: usize) -> Cow<'a, OsStr> {
+ let result = self.match_cow(|b| Ok::<_, ()>(&b[from..to]), |o| Ok(o[from..to].to_vec()));
+ result.unwrap()
+ }
+
+ pub fn split_once(&self, pred: &char) -> Option<(Cow<'a, OsStr>, Cow<'a, OsStr>)> {
+ let n_c = get_single_native_int_value(pred)?;
+ let p = self.native.iter().position(|&x| x == n_c)?;
+ let before = self.slice(0, p);
+ let after = self.slice(p + 1, self.native.len());
+ Some((before, after))
+ }
+
+ pub fn split_at(&self, pos: usize) -> (Cow<'a, OsStr>, Cow<'a, OsStr>) {
+ let before = self.slice(0, pos);
+ let after = self.slice(pos, self.native.len());
+ (before, after)
+ }
+
+ pub fn strip_prefix(&self, prefix: &OsStr) -> Option<Cow<'a, OsStr>> {
+ let n_prefix = to_native_int_representation(prefix);
+ let result = self.match_cow(
+ |b| b.strip_prefix(&*n_prefix).ok_or(()),
+ |o| o.strip_prefix(&*n_prefix).map(|x| x.to_vec()).ok_or(()),
+ );
+ result.ok()
+ }
+
+ pub fn strip_prefix_native(&self, prefix: &OsStr) -> Option<Cow<'a, NativeIntStr>> {
+ let n_prefix = to_native_int_representation(prefix);
+ let result = self.match_cow_native(
+ |b| b.strip_prefix(&*n_prefix).ok_or(()),
+ |o| o.strip_prefix(&*n_prefix).map(|x| x.to_vec()).ok_or(()),
+ );
+ result.ok()
+ }
+
+ fn match_cow<FnBorrow, FnOwned, Err>(
+ &self,
+ f_borrow: FnBorrow,
+ f_owned: FnOwned,
+ ) -> Result<Cow<'a, OsStr>, Err>
+ where
+ FnBorrow: FnOnce(&'a [NativeCharInt]) -> Result<&'a [NativeCharInt], Err>,
+ FnOwned: FnOnce(&Vec<NativeCharInt>) -> Result<Vec<NativeCharInt>, Err>,
+ {
+ match &self.native {
+ Cow::Borrowed(b) => {
+ let slice = f_borrow(b);
+ let os_str = slice.map(|x| from_native_int_representation(Cow::Borrowed(x)));
+ os_str
+ }
+ Cow::Owned(o) => {
+ let slice = f_owned(o);
+ let os_str = slice.map(from_native_int_representation_owned);
+ os_str.map(Cow::Owned)
+ }
+ }
+ }
+
+ fn match_cow_native<FnBorrow, FnOwned, Err>(
+ &self,
+ f_borrow: FnBorrow,
+ f_owned: FnOwned,
+ ) -> Result<Cow<'a, NativeIntStr>, Err>
+ where
+ FnBorrow: FnOnce(&'a [NativeCharInt]) -> Result<&'a [NativeCharInt], Err>,
+ FnOwned: FnOnce(&Vec<NativeCharInt>) -> Result<Vec<NativeCharInt>, Err>,
+ {
+ match &self.native {
+ Cow::Borrowed(b) => {
+ let slice = f_borrow(b);
+ slice.map(Cow::Borrowed)
+ }
+ Cow::Owned(o) => {
+ let slice = f_owned(o);
+ slice.map(Cow::Owned)
+ }
+ }
+ }
+}
diff --git a/src/uu/env/src/parse_error.rs b/src/uu/env/src/parse_error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cbdba99ed90cddc47d001dc8b455bd5df0f18fc4
--- /dev/null
+++ b/src/uu/env/src/parse_error.rs
@@ -0,0 +1,55 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use std::fmt;
+
+use crate::string_parser;
+
+/// An error returned when string arg splitting fails.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ParseError {
+ MissingClosingQuote {
+ pos: usize,
+ c: char,
+ },
+ InvalidBackslashAtEndOfStringInMinusS {
+ pos: usize,
+ quoting: String,
+ },
+ BackslashCNotAllowedInDoubleQuotes {
+ pos: usize,
+ },
+ InvalidSequenceBackslashXInMinusS {
+ pos: usize,
+ c: char,
+ },
+ ParsingOfVariableNameFailed {
+ pos: usize,
+ msg: String,
+ },
+ InternalError {
+ pos: usize,
+ sub_err: string_parser::Error,
+ },
+ ReachedEnd,
+ ContinueWithDelimiter,
+}
+
+impl fmt::Display for ParseError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.write_str(format!("{:?}", self).as_str())
+ }
+}
+
+impl std::error::Error for ParseError {}
+
+impl From<string_parser::Error> for ParseError {
+ fn from(value: string_parser::Error) -> Self {
+ Self::InternalError {
+ pos: value.peek_position,
+ sub_err: value,
+ }
+ }
+}
diff --git a/src/uu/env/src/split_iterator.rs b/src/uu/env/src/split_iterator.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0af7a78ad8aade141db607aca7e21f5d721298f5
--- /dev/null
+++ b/src/uu/env/src/split_iterator.rs
@@ -0,0 +1,375 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+//
+// This file is based on work from Tomasz MiÄ…sko who published it as "shell_words" crate,
+// licensed under the Apache License, Version 2.0 <LICENSE-APACHE>
+// or the MIT license <LICENSE-MIT>, at your option.
+//
+//! Process command line according to parsing rules of original GNU env.
+//! Even though it looks quite like a POSIX syntax, the original
+//! "shell_words" implementation had to be adapted significantly.
+//!
+//! Apart from the grammar differences, there is a new feature integrated: $VARIABLE expansion.
+//!
+//! [GNU env] <https://www.gnu.org/software/coreutils/manual/html_node/env-invocation.html#g_t_002dS_002f_002d_002dsplit_002dstring-syntax>
+// spell-checker:ignore (words) Tomasz MiÄ…sko rntfv FFFD varname
+
+#![forbid(unsafe_code)]
+
+use std::borrow::Cow;
+
+use crate::native_int_str::from_native_int_representation;
+use crate::native_int_str::NativeCharInt;
+use crate::native_int_str::NativeIntStr;
+use crate::native_int_str::NativeIntString;
+use crate::parse_error::ParseError;
+use crate::string_expander::StringExpander;
+use crate::string_parser::StringParser;
+use crate::variable_parser::VariableParser;
+
+const BACKSLASH: char = '\\';
+const DOUBLE_QUOTES: char = '\"';
+const SINGLE_QUOTES: char = '\'';
+const NEW_LINE: char = '\n';
+const DOLLAR: char = '$';
+
+const REPLACEMENTS: [(char, char); 9] = [
+ ('r', '\r'),
+ ('n', '\n'),
+ ('t', '\t'),
+ ('f', '\x0C'),
+ ('v', '\x0B'),
+ ('_', ' '),
+ ('#', '#'),
+ ('$', '$'),
+ ('"', '"'),
+];
+
+const ASCII_WHITESPACE_CHARS: [char; 6] = [' ', '\t', '\r', '\n', '\x0B', '\x0C'];
+
+pub struct SplitIterator<'a> {
+ expander: StringExpander<'a>,
+ words: Vec<Vec<NativeCharInt>>,
+}
+
+impl<'a> SplitIterator<'a> {
+ pub fn new(s: &'a NativeIntStr) -> Self {
+ Self {
+ expander: StringExpander::new(s),
+ words: Vec::new(),
+ }
+ }
+
+ fn skip_one(&mut self) -> Result<(), ParseError> {
+ self.expander
+ .get_parser_mut()
+ .consume_one_ascii_or_all_non_ascii()?;
+ Ok(())
+ }
+
+ fn take_one(&mut self) -> Result<(), ParseError> {
+ Ok(self.expander.take_one()?)
+ }
+
+ fn get_current_char(&self) -> Option<char> {
+ self.expander.peek().ok()
+ }
+
+ fn push_char_to_word(&mut self, c: char) {
+ self.expander.put_one_char(c);
+ }
+
+ fn push_word_to_words(&mut self) {
+ let word = self.expander.take_collected_output();
+ self.words.push(word);
+ }
+
+ fn get_parser(&self) -> &StringParser<'a> {
+ self.expander.get_parser()
+ }
+
+ fn get_parser_mut(&mut self) -> &mut StringParser<'a> {
+ self.expander.get_parser_mut()
+ }
+
+ fn substitute_variable<'x>(&'x mut self) -> Result<(), ParseError> {
+ let mut var_parse = VariableParser::<'a, '_> {
+ parser: self.get_parser_mut(),
+ };
+
+ let (name, default) = var_parse.parse_variable()?;
+
+ let varname_os_str_cow = from_native_int_representation(Cow::Borrowed(name));
+ let value = std::env::var_os(varname_os_str_cow);
+ match (&value, default) {
+ (None, None) => {} // do nothing, just replace it with ""
+ (Some(value), _) => {
+ self.expander.put_string(value);
+ }
+ (None, Some(default)) => {
+ self.expander.put_native_string(default);
+ }
+ };
+
+ Ok(())
+ }
+
+ fn check_and_replace_ascii_escape_code(&mut self, c: char) -> Result<bool, ParseError> {
+ if let Some(replace) = REPLACEMENTS.iter().find(|&x| x.0 == c) {
+ self.skip_one()?;
+ self.push_char_to_word(replace.1);
+ return Ok(true);
+ }
+
+ Ok(false)
+ }
+
+ fn make_invalid_sequence_backslash_xin_minus_s(&self, c: char) -> ParseError {
+ ParseError::InvalidSequenceBackslashXInMinusS {
+ pos: self.expander.get_parser().get_peek_position(),
+ c,
+ }
+ }
+
+ fn state_root(&mut self) -> Result<(), ParseError> {
+ loop {
+ match self.state_delimiter() {
+ Err(ParseError::ContinueWithDelimiter) => {}
+ Err(ParseError::ReachedEnd) => return Ok(()),
+ result => return result,
+ }
+ }
+ }
+
+ fn state_delimiter(&mut self) -> Result<(), ParseError> {
+ loop {
+ match self.get_current_char() {
+ None => return Ok(()),
+ Some('#') => {
+ self.skip_one()?;
+ self.state_comment()?;
+ }
+ Some(BACKSLASH) => {
+ self.skip_one()?;
+ self.state_delimiter_backslash()?;
+ }
+ Some(c) if ASCII_WHITESPACE_CHARS.contains(&c) => {
+ self.skip_one()?;
+ }
+ Some(_) => {
+ // Don't consume char. Will be done in unquoted state.
+ self.state_unquoted()?;
+ }
+ }
+ }
+ }
+
+ fn state_delimiter_backslash(&mut self) -> Result<(), ParseError> {
+ match self.get_current_char() {
+ None => Err(ParseError::InvalidBackslashAtEndOfStringInMinusS {
+ pos: self.get_parser().get_peek_position(),
+ quoting: "Delimiter".into(),
+ }),
+ Some('_') | Some(NEW_LINE) => {
+ self.skip_one()?;
+ Ok(())
+ }
+ Some(DOLLAR) | Some(BACKSLASH) | Some('#') | Some(SINGLE_QUOTES)
+ | Some(DOUBLE_QUOTES) => {
+ self.take_one()?;
+ self.state_unquoted()
+ }
+ Some('c') => Err(ParseError::ReachedEnd),
+ Some(c) if self.check_and_replace_ascii_escape_code(c)? => self.state_unquoted(),
+ Some(c) => Err(self.make_invalid_sequence_backslash_xin_minus_s(c)),
+ }
+ }
+
+ fn state_unquoted(&mut self) -> Result<(), ParseError> {
+ loop {
+ match self.get_current_char() {
+ None => {
+ self.push_word_to_words();
+ return Err(ParseError::ReachedEnd);
+ }
+ Some(DOLLAR) => {
+ self.substitute_variable()?;
+ }
+ Some(SINGLE_QUOTES) => {
+ self.skip_one()?;
+ self.state_single_quoted()?;
+ }
+ Some(DOUBLE_QUOTES) => {
+ self.skip_one()?;
+ self.state_double_quoted()?;
+ }
+ Some(BACKSLASH) => {
+ self.skip_one()?;
+ self.state_unquoted_backslash()?;
+ }
+ Some(c) if ASCII_WHITESPACE_CHARS.contains(&c) => {
+ self.push_word_to_words();
+ self.skip_one()?;
+ return Ok(());
+ }
+ Some(_) => {
+ self.take_one()?;
+ }
+ }
+ }
+ }
+
+ fn state_unquoted_backslash(&mut self) -> Result<(), ParseError> {
+ match self.get_current_char() {
+ None => Err(ParseError::InvalidBackslashAtEndOfStringInMinusS {
+ pos: self.get_parser().get_peek_position(),
+ quoting: "Unquoted".into(),
+ }),
+ Some(NEW_LINE) => {
+ self.skip_one()?;
+ Ok(())
+ }
+ Some('_') => {
+ self.skip_one()?;
+ self.push_word_to_words();
+ Err(ParseError::ContinueWithDelimiter)
+ }
+ Some('c') => {
+ self.push_word_to_words();
+ Err(ParseError::ReachedEnd)
+ }
+ Some(DOLLAR) | Some(BACKSLASH) | Some(SINGLE_QUOTES) | Some(DOUBLE_QUOTES) => {
+ self.take_one()?;
+ Ok(())
+ }
+ Some(c) if self.check_and_replace_ascii_escape_code(c)? => Ok(()),
+ Some(c) => Err(self.make_invalid_sequence_backslash_xin_minus_s(c)),
+ }
+ }
+
+ fn state_single_quoted(&mut self) -> Result<(), ParseError> {
+ loop {
+ match self.get_current_char() {
+ None => {
+ return Err(ParseError::MissingClosingQuote {
+ pos: self.get_parser().get_peek_position(),
+ c: '\'',
+ })
+ }
+ Some(SINGLE_QUOTES) => {
+ self.skip_one()?;
+ return Ok(());
+ }
+ Some(BACKSLASH) => {
+ self.skip_one()?;
+ self.split_single_quoted_backslash()?;
+ }
+ Some(_) => {
+ self.take_one()?;
+ }
+ }
+ }
+ }
+
+ fn split_single_quoted_backslash(&mut self) -> Result<(), ParseError> {
+ match self.get_current_char() {
+ None => Err(ParseError::MissingClosingQuote {
+ pos: self.get_parser().get_peek_position(),
+ c: '\'',
+ }),
+ Some(NEW_LINE) => {
+ self.skip_one()?;
+ Ok(())
+ }
+ Some(SINGLE_QUOTES) | Some(BACKSLASH) => {
+ self.take_one()?;
+ Ok(())
+ }
+ Some(c) if REPLACEMENTS.iter().any(|&x| x.0 == c) => {
+ // See GNU test-suite e11: In single quotes, \t remains as it is.
+ // Comparing with GNU behavior: \a is not accepted and issues an error.
+ // So apparently only known sequences are allowed, even though they are not expanded.... bug of GNU?
+ self.push_char_to_word(BACKSLASH);
+ self.take_one()?;
+ Ok(())
+ }
+ Some(c) => Err(self.make_invalid_sequence_backslash_xin_minus_s(c)),
+ }
+ }
+
+ fn state_double_quoted(&mut self) -> Result<(), ParseError> {
+ loop {
+ match self.get_current_char() {
+ None => {
+ return Err(ParseError::MissingClosingQuote {
+ pos: self.get_parser().get_peek_position(),
+ c: '"',
+ })
+ }
+ Some(DOLLAR) => {
+ self.substitute_variable()?;
+ }
+ Some(DOUBLE_QUOTES) => {
+ self.skip_one()?;
+ return Ok(());
+ }
+ Some(BACKSLASH) => {
+ self.skip_one()?;
+ self.state_double_quoted_backslash()?;
+ }
+ Some(_) => {
+ self.take_one()?;
+ }
+ }
+ }
+ }
+
+ fn state_double_quoted_backslash(&mut self) -> Result<(), ParseError> {
+ match self.get_current_char() {
+ None => Err(ParseError::MissingClosingQuote {
+ pos: self.get_parser().get_peek_position(),
+ c: '"',
+ }),
+ Some(NEW_LINE) => {
+ self.skip_one()?;
+ Ok(())
+ }
+ Some(DOUBLE_QUOTES) | Some(DOLLAR) | Some(BACKSLASH) => {
+ self.take_one()?;
+ Ok(())
+ }
+ Some('c') => Err(ParseError::BackslashCNotAllowedInDoubleQuotes {
+ pos: self.get_parser().get_peek_position(),
+ }),
+ Some(c) if self.check_and_replace_ascii_escape_code(c)? => Ok(()),
+ Some(c) => Err(self.make_invalid_sequence_backslash_xin_minus_s(c)),
+ }
+ }
+
+ fn state_comment(&mut self) -> Result<(), ParseError> {
+ loop {
+ match self.get_current_char() {
+ None => return Err(ParseError::ReachedEnd),
+ Some(NEW_LINE) => {
+ self.skip_one()?;
+ return Ok(());
+ }
+ Some(_) => {
+ self.get_parser_mut().skip_until_char_or_end(NEW_LINE);
+ }
+ }
+ }
+ }
+
+ pub fn split(mut self) -> Result<Vec<NativeIntString>, ParseError> {
+ self.state_root()?;
+ Ok(self.words)
+ }
+}
+
+pub fn split(s: &NativeIntStr) -> Result<Vec<NativeIntString>, ParseError> {
+ let splitted_args = SplitIterator::new(s).split()?;
+ Ok(splitted_args)
+}
diff --git a/src/uu/env/src/string_expander.rs b/src/uu/env/src/string_expander.rs
new file mode 100644
index 0000000000000000000000000000000000000000..06e4699269f8427def6ef56ad1dece73e085b7d6
--- /dev/null
+++ b/src/uu/env/src/string_expander.rs
@@ -0,0 +1,92 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use std::{
+ ffi::{OsStr, OsString},
+ mem,
+ ops::Deref,
+};
+
+use crate::{
+ native_int_str::{to_native_int_representation, NativeCharInt, NativeIntStr},
+ string_parser::{Chunk, Error, StringParser},
+};
+
+/// This class makes parsing and word collection more convenient.
+///
+/// It manages an "output" buffer that is automatically filled.
+/// It provides "skip_one" and "take_one" that focus on
+/// working with ASCII separators. Thus they will skip or take
+/// all consecutive non-ascii char sequences at once.
+pub struct StringExpander<'a> {
+ parser: StringParser<'a>,
+ output: Vec<NativeCharInt>,
+}
+
+impl<'a> StringExpander<'a> {
+ pub fn new(input: &'a NativeIntStr) -> Self {
+ Self {
+ parser: StringParser::new(input),
+ output: Vec::default(),
+ }
+ }
+
+ pub fn new_at(input: &'a NativeIntStr, pos: usize) -> Self {
+ Self {
+ parser: StringParser::new_at(input, pos),
+ output: Vec::default(),
+ }
+ }
+
+ pub fn get_parser(&self) -> &StringParser<'a> {
+ &self.parser
+ }
+
+ pub fn get_parser_mut(&mut self) -> &mut StringParser<'a> {
+ &mut self.parser
+ }
+
+ pub fn peek(&self) -> Result<char, Error> {
+ self.parser.peek()
+ }
+
+ pub fn skip_one(&mut self) -> Result<(), Error> {
+ self.get_parser_mut().consume_one_ascii_or_all_non_ascii()?;
+ Ok(())
+ }
+
+ pub fn get_peek_position(&self) -> usize {
+ self.get_parser().get_peek_position()
+ }
+
+ pub fn take_one(&mut self) -> Result<(), Error> {
+ let chunks = self.parser.consume_one_ascii_or_all_non_ascii()?;
+ for chunk in chunks {
+ match chunk {
+ Chunk::InvalidEncoding(invalid) => self.output.extend(invalid),
+ Chunk::ValidSingleIntChar((_c, ni)) => self.output.push(ni),
+ }
+ }
+ Ok(())
+ }
+
+ pub fn put_one_char(&mut self, c: char) {
+ let os_str = OsString::from(c.to_string());
+ self.put_string(os_str);
+ }
+
+ pub fn put_string<S: AsRef<OsStr>>(&mut self, os_str: S) {
+ let native = to_native_int_representation(os_str.as_ref());
+ self.output.extend(native.deref());
+ }
+
+ pub fn put_native_string(&mut self, n_str: &NativeIntStr) {
+ self.output.extend(n_str);
+ }
+
+ pub fn take_collected_output(&mut self) -> Vec<NativeCharInt> {
+ mem::take(&mut self.output)
+ }
+}
diff --git a/src/uu/env/src/string_parser.rs b/src/uu/env/src/string_parser.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6f8d550883b32fc24b2b8ca7230f6e75e2726fca
--- /dev/null
+++ b/src/uu/env/src/string_parser.rs
@@ -0,0 +1,182 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+//
+// spell-checker:ignore (words) splitted FFFD
+#![forbid(unsafe_code)]
+
+use std::{borrow::Cow, ffi::OsStr};
+
+use crate::native_int_str::{
+ from_native_int_representation, get_char_from_native_int, get_single_native_int_value,
+ NativeCharInt, NativeIntStr,
+};
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Error {
+ pub peek_position: usize,
+ pub err_type: ErrorType,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ErrorType {
+ EndOfInput,
+ InternalError,
+}
+
+/// Provides a valid char or a invalid sequence of bytes.
+///
+/// Invalid byte sequences can't be splitted in any meaningful way.
+/// Thus, they need to be consumed as one piece.
+pub enum Chunk<'a> {
+ InvalidEncoding(&'a NativeIntStr),
+ ValidSingleIntChar((char, NativeCharInt)),
+}
+
+/// This class makes parsing a OsString char by char more convenient.
+///
+/// It also allows to capturing of intermediate positions for later splitting.
+pub struct StringParser<'a> {
+ input: &'a NativeIntStr,
+ pointer: usize,
+ remaining: &'a NativeIntStr,
+}
+
+impl<'a> StringParser<'a> {
+ pub fn new(input: &'a NativeIntStr) -> Self {
+ let mut instance = Self {
+ input,
+ pointer: 0,
+ remaining: input,
+ };
+ instance.set_pointer(0);
+ instance
+ }
+
+ pub fn new_at(input: &'a NativeIntStr, pos: usize) -> Self {
+ let mut instance = Self::new(input);
+ instance.set_pointer(pos);
+ instance
+ }
+
+ pub fn get_input(&self) -> &'a NativeIntStr {
+ self.input
+ }
+
+ pub fn get_peek_position(&self) -> usize {
+ self.pointer
+ }
+
+ pub fn peek(&self) -> Result<char, Error> {
+ self.peek_char_at_pointer(self.pointer)
+ }
+
+ fn make_err(&self, err_type: ErrorType) -> Error {
+ Error {
+ peek_position: self.get_peek_position(),
+ err_type,
+ }
+ }
+
+ pub fn peek_char_at_pointer(&self, at_pointer: usize) -> Result<char, Error> {
+ let split = self.input.split_at(at_pointer).1;
+ if split.is_empty() {
+ return Err(self.make_err(ErrorType::EndOfInput));
+ }
+ if let Some((c, _ni)) = get_char_from_native_int(split[0]) {
+ Ok(c)
+ } else {
+ Ok('\u{FFFD}')
+ }
+ }
+
+ fn get_chunk_with_length_at(&self, pointer: usize) -> Result<(Chunk<'a>, usize), Error> {
+ let (_before, after) = self.input.split_at(pointer);
+ if after.is_empty() {
+ return Err(self.make_err(ErrorType::EndOfInput));
+ }
+
+ if let Some(c_ni) = get_char_from_native_int(after[0]) {
+ Ok((Chunk::ValidSingleIntChar(c_ni), 1))
+ } else {
+ let mut i = 1;
+ while i < after.len() {
+ if let Some(_c) = get_char_from_native_int(after[i]) {
+ break;
+ }
+ i += 1;
+ }
+
+ let chunk = &after[0..i];
+ Ok((Chunk::InvalidEncoding(chunk), chunk.len()))
+ }
+ }
+
+ pub fn peek_chunk(&self) -> Option<Chunk<'a>> {
+ return self
+ .get_chunk_with_length_at(self.pointer)
+ .ok()
+ .map(|(chunk, _)| chunk);
+ }
+
+ pub fn consume_chunk(&mut self) -> Result<Chunk<'a>, Error> {
+ let (chunk, len) = self.get_chunk_with_length_at(self.pointer)?;
+ self.set_pointer(self.pointer + len);
+ Ok(chunk)
+ }
+
+ pub fn consume_one_ascii_or_all_non_ascii(&mut self) -> Result<Vec<Chunk<'a>>, Error> {
+ let mut result = Vec::<Chunk<'a>>::new();
+ loop {
+ let data = self.consume_chunk()?;
+ let was_ascii = if let Chunk::ValidSingleIntChar((c, _ni)) = &data {
+ c.is_ascii()
+ } else {
+ false
+ };
+ result.push(data);
+ if was_ascii {
+ return Ok(result);
+ }
+
+ match self.peek_chunk() {
+ Some(Chunk::ValidSingleIntChar((c, _ni))) if c.is_ascii() => return Ok(result),
+ None => return Ok(result),
+ _ => {}
+ }
+ }
+ }
+
+ pub fn skip_multiple(&mut self, skip_byte_count: usize) {
+ let end_ptr = self.pointer + skip_byte_count;
+ self.set_pointer(end_ptr);
+ }
+
+ pub fn skip_until_char_or_end(&mut self, c: char) {
+ let native_rep = get_single_native_int_value(&c).unwrap();
+ let pos = self.remaining.iter().position(|x| *x == native_rep);
+
+ if let Some(pos) = pos {
+ self.set_pointer(self.pointer + pos);
+ } else {
+ self.set_pointer(self.input.len());
+ }
+ }
+
+ pub fn substring(&self, range: &std::ops::Range<usize>) -> &'a NativeIntStr {
+ let (_before1, after1) = self.input.split_at(range.start);
+ let (middle, _after2) = after1.split_at(range.end - range.start);
+ middle
+ }
+
+ pub fn peek_remaining(&self) -> Cow<'a, OsStr> {
+ from_native_int_representation(Cow::Borrowed(self.remaining))
+ }
+
+ pub fn set_pointer(&mut self, new_pointer: usize) {
+ self.pointer = new_pointer;
+ let (_before, after) = self.input.split_at(self.pointer);
+ self.remaining = after;
+ }
+}
diff --git a/src/uu/env/src/variable_parser.rs b/src/uu/env/src/variable_parser.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ef80ff801a66c99784f463f0ba63b8d29744857b
--- /dev/null
+++ b/src/uu/env/src/variable_parser.rs
@@ -0,0 +1,158 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use std::ops::Range;
+
+use crate::{native_int_str::NativeIntStr, parse_error::ParseError, string_parser::StringParser};
+
+pub struct VariableParser<'a, 'b> {
+ pub parser: &'b mut StringParser<'a>,
+}
+
+impl<'a, 'b> VariableParser<'a, 'b> {
+ fn get_current_char(&self) -> Option<char> {
+ self.parser.peek().ok()
+ }
+
+ fn check_variable_name_start(&self) -> Result<(), ParseError> {
+ if let Some(c) = self.get_current_char() {
+ if c.is_ascii_digit() {
+ return Err(ParseError::ParsingOfVariableNameFailed {
+ pos: self.parser.get_peek_position(),
+ msg: format!("Unexpected character: '{}', expected variable name must not start with 0..9", c) });
+ }
+ }
+ Ok(())
+ }
+
+ fn skip_one(&mut self) -> Result<(), ParseError> {
+ self.parser.consume_chunk()?;
+ Ok(())
+ }
+
+ fn parse_braced_variable_name(
+ &mut self,
+ ) -> Result<(&'a NativeIntStr, Option<&'a NativeIntStr>), ParseError> {
+ let pos_start = self.parser.get_peek_position();
+
+ self.check_variable_name_start()?;
+
+ let (varname_end, default_end);
+ loop {
+ match self.get_current_char() {
+ None => {
+ return Err(ParseError::ParsingOfVariableNameFailed {
+ pos: self.parser.get_peek_position(), msg: "Missing closing brace".into() })
+ },
+ Some(c) if !c.is_ascii() || c.is_ascii_alphanumeric() || c == '_' => {
+ self.skip_one()?;
+ }
+ Some(':') => {
+ varname_end = self.parser.get_peek_position();
+ loop {
+ match self.get_current_char() {
+ None => {
+ return Err(ParseError::ParsingOfVariableNameFailed {
+ pos: self.parser.get_peek_position(),
+ msg: "Missing closing brace after default value".into() })
+ },
+ Some('}') => {
+ default_end = Some(self.parser.get_peek_position());
+ self.skip_one()?;
+ break
+ },
+ Some(_) => {
+ self.skip_one()?;
+ },
+ }
+ }
+ break;
+ },
+ Some('}') => {
+ varname_end = self.parser.get_peek_position();
+ default_end = None;
+ self.skip_one()?;
+ break;
+ },
+ Some(c) => {
+ return Err(ParseError::ParsingOfVariableNameFailed {
+ pos: self.parser.get_peek_position(),
+ msg: format!("Unexpected character: '{}', expected a closing brace ('}}') or colon (':')", c)
+ })
+ },
+ };
+ }
+
+ let default_opt = if let Some(default_end) = default_end {
+ Some(self.parser.substring(&Range {
+ start: varname_end + 1,
+ end: default_end,
+ }))
+ } else {
+ None
+ };
+
+ let varname = self.parser.substring(&Range {
+ start: pos_start,
+ end: varname_end,
+ });
+
+ Ok((varname, default_opt))
+ }
+
+ fn parse_unbraced_variable_name(&mut self) -> Result<&'a NativeIntStr, ParseError> {
+ let pos_start = self.parser.get_peek_position();
+
+ self.check_variable_name_start()?;
+
+ loop {
+ match self.get_current_char() {
+ None => break,
+ Some(c) if c.is_ascii_alphanumeric() || c == '_' => {
+ self.skip_one()?;
+ }
+ Some(_) => break,
+ };
+ }
+
+ let pos_end = self.parser.get_peek_position();
+
+ if pos_end == pos_start {
+ return Err(ParseError::ParsingOfVariableNameFailed {
+ pos: pos_start,
+ msg: "Missing variable name".into(),
+ });
+ }
+
+ let varname = self.parser.substring(&Range {
+ start: pos_start,
+ end: pos_end,
+ });
+
+ Ok(varname)
+ }
+
+ pub fn parse_variable(
+ &mut self,
+ ) -> Result<(&'a NativeIntStr, Option<&'a NativeIntStr>), ParseError> {
+ self.skip_one()?;
+
+ let (name, default) = match self.get_current_char() {
+ None => {
+ return Err(ParseError::ParsingOfVariableNameFailed {
+ pos: self.parser.get_peek_position(),
+ msg: "missing variable name".into(),
+ })
+ }
+ Some('{') => {
+ self.skip_one()?;
+ self.parse_braced_variable_name()?
+ }
+ Some(_) => (self.parse_unbraced_variable_name()?, None),
+ };
+
+ Ok((name, default))
+ }
+}
diff --git a/src/uu/expand/Cargo.toml b/src/uu/expand/Cargo.toml
index cac1f173f792d57cfb309abd2345acc14c21d37c..87976a6b57aff1e19212e6c012ca10e0a54aba16 100644
--- a/src/uu/expand/Cargo.toml
+++ b/src/uu/expand/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_expand"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "expand ~ (uutils) convert input tabs to spaces"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/expand.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-unicode-width = "0.1.5"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+unicode-width = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "expand"
diff --git a/src/uu/expand/expand.md b/src/uu/expand/expand.md
new file mode 100644
index 0000000000000000000000000000000000000000..df7294c30d2b5b6005b084dd52116c8d2eefc42e
--- /dev/null
+++ b/src/uu/expand/expand.md
@@ -0,0 +1,8 @@
+# expand
+
+```
+expand [OPTION]... [FILE]...
+```
+
+Convert tabs in each `FILE` to spaces, writing to standard output.
+With no `FILE`, or when `FILE` is `-`, read standard input.
diff --git a/src/uu/expand/src/expand.rs b/src/uu/expand/src/expand.rs
index 63de76fbd811ed121dbaf5f7078f559461ec4342..6df282de23a98bac4b45497250478be88bc42575 100644
--- a/src/uu/expand/src/expand.rs
+++ b/src/uu/expand/src/expand.rs
@@ -1,9 +1,5 @@
// This file is part of the uutils coreutils package.
//
-// (c) Virgile Andreani <virgile.andreani@anbuco.fr>
-// (c) kwantam <kwantam@gmail.com>
-// * 2015-04-28 ~ updated to work with both UTF-8 and non-UTF-8 encodings
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
@@ -11,19 +7,20 @@
use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
use std::error::Error;
+use std::ffi::OsString;
use std::fmt;
use std::fs::File;
use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Write};
use std::num::IntErrorKind;
+use std::path::Path;
use std::str::from_utf8;
use unicode_width::UnicodeWidthChar;
use uucore::display::Quotable;
-use uucore::error::{FromIo, UError, UResult};
-use uucore::{crash, format_usage};
+use uucore::error::{set_exit_code, FromIo, UError, UResult};
+use uucore::{format_usage, help_about, help_usage, show_error};
-static ABOUT: &str = "Convert tabs in each FILE to spaces, writing to standard output.
- With no FILE, or when FILE is -, read standard input.";
-const USAGE: &str = "{} [OPTION]... [FILE]...";
+const ABOUT: &str = help_about!("expand.md");
+const USAGE: &str = help_usage!("expand.md");
pub mod options {
pub static TABS: &str = "tabs";
@@ -126,12 +123,8 @@ fn tabstops_parse(s: &str) -> Result<(RemainingMode, Vec<usize>), ParseError> {
let bytes = word.as_bytes();
for i in 0..bytes.len() {
match bytes[i] {
- b'+' => {
- remaining_mode = RemainingMode::Plus;
- }
- b'/' => {
- remaining_mode = RemainingMode::Slash;
- }
+ b'+' => remaining_mode = RemainingMode::Plus,
+ b'/' => remaining_mode = RemainingMode::Slash,
_ => {
// Parse a number from the byte sequence.
let s = from_utf8(&bytes[i..]).unwrap();
@@ -191,6 +184,10 @@ fn tabstops_parse(s: &str) -> Result<(RemainingMode, Vec<usize>), ParseError> {
if nums.is_empty() {
nums = vec![DEFAULT_TABSTOP];
}
+
+ if nums.len() < 2 {
+ remaining_mode = RemainingMode::None;
+ }
Ok((remaining_mode, nums))
}
@@ -247,18 +244,20 @@ impl Options {
/// Preprocess command line arguments and expand shortcuts. For example, "-7" is expanded to
/// "--tabs=7" and "-1,3" to "--tabs=1 --tabs=3".
-fn expand_shortcuts(args: &[String]) -> Vec<String> {
+fn expand_shortcuts(args: Vec<OsString>) -> Vec<OsString> {
let mut processed_args = Vec::with_capacity(args.len());
for arg in args {
- if arg.starts_with('-') && arg[1..].chars().all(is_digit_or_comma) {
- arg[1..]
- .split(',')
- .filter(|s| !s.is_empty())
- .for_each(|s| processed_args.push(format!("--tabs={}", s)));
- } else {
- processed_args.push(arg.to_string());
+ if let Some(arg) = arg.to_str() {
+ if arg.starts_with('-') && arg[1..].chars().all(is_digit_or_comma) {
+ arg[1..]
+ .split(',')
+ .filter(|s| !s.is_empty())
+ .for_each(|s| processed_args.push(OsString::from(format!("--tabs={s}"))));
+ continue;
+ }
}
+ processed_args.push(arg);
}
processed_args
@@ -266,11 +265,9 @@ fn expand_shortcuts(args: &[String]) -> Vec<String> {
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_ignore();
+ let matches = uu_app().try_get_matches_from(expand_shortcuts(args.collect()))?;
- let matches = uu_app().try_get_matches_from(expand_shortcuts(&args))?;
-
- expand(&Options::new(&matches)?).map_err_context(|| "failed to write output".to_string())
+ expand(&Options::new(&matches)?)
}
pub fn uu_app() -> Command {
@@ -280,6 +277,7 @@ pub fn uu_app() -> Command {
.after_help(LONG_HELP)
.override_usage(format_usage(USAGE))
.infer_long_args(true)
+ .args_override_self(true)
.arg(
Arg::new(options::INITIAL)
.long(options::INITIAL)
@@ -313,16 +311,13 @@ pub fn uu_app() -> Command {
)
}
-fn open(path: &str) -> BufReader<Box<dyn Read + 'static>> {
+fn open(path: &str) -> UResult<BufReader<Box<dyn Read + 'static>>> {
let file_buf;
if path == "-" {
- BufReader::new(Box::new(stdin()) as Box<dyn Read>)
+ Ok(BufReader::new(Box::new(stdin()) as Box<dyn Read>))
} else {
- file_buf = match File::open(path) {
- Ok(a) => a,
- Err(e) => crash!(1, "{}: {}\n", path.maybe_quote(), e),
- };
- BufReader::new(Box::new(file_buf) as Box<dyn Read>)
+ file_buf = File::open(path).map_err_context(|| path.to_string())?;
+ Ok(BufReader::new(Box::new(file_buf) as Box<dyn Read>))
}
}
@@ -336,17 +331,19 @@ fn open(path: &str) -> BufReader<Box<dyn Read + 'static>> {
/// in the `tabstops` slice is interpreted as a relative number of
/// spaces, which this function will return for every input value of
/// `col` beyond the end of the second-to-last element of `tabstops`.
-///
-/// If `remaining_mode` is [`RemainingMode::Plus`], then the last entry
-/// in the `tabstops` slice is interpreted as a relative number of
-/// spaces, which this function will return for every input value of
-/// `col` beyond the end of the second-to-last element of `tabstops`.
fn next_tabstop(tabstops: &[usize], col: usize, remaining_mode: &RemainingMode) -> usize {
let num_tabstops = tabstops.len();
match remaining_mode {
RemainingMode::Plus => match tabstops[0..num_tabstops - 1].iter().find(|&&t| t > col) {
Some(t) => t - col,
- None => tabstops[num_tabstops - 1] - 1,
+ None => {
+ let step_size = tabstops[num_tabstops - 1];
+ let last_fixed_tabstop = tabstops[num_tabstops - 2];
+ let characters_since_last_tabstop = col - last_fixed_tabstop;
+
+ let steps_required = 1 + characters_since_last_tabstop / step_size;
+ steps_required * step_size - characters_since_last_tabstop
+ }
},
RemainingMode::Slash => match tabstops[0..num_tabstops - 1].iter().find(|&&t| t > col) {
Some(t) => t - col,
@@ -372,99 +369,124 @@ enum CharType {
Other,
}
-fn expand(options: &Options) -> std::io::Result<()> {
+#[allow(clippy::cognitive_complexity)]
+fn expand_line(
+ buf: &mut Vec<u8>,
+ output: &mut BufWriter<std::io::Stdout>,
+ tabstops: &[usize],
+ options: &Options,
+) -> std::io::Result<()> {
use self::CharType::*;
- let mut output = BufWriter::new(stdout());
- let ts = options.tabstops.as_ref();
- let mut buf = Vec::new();
-
- for file in &options.files {
- let mut fh = open(file);
-
- while match fh.read_until(b'\n', &mut buf) {
- Ok(s) => s > 0,
- Err(_) => buf.is_empty(),
- } {
- let mut col = 0;
- let mut byte = 0;
- let mut init = true;
-
- while byte < buf.len() {
- let (ctype, cwidth, nbytes) = if options.uflag {
- let nbytes = char::from(buf[byte]).len_utf8();
-
- if byte + nbytes > buf.len() {
- // don't overrun buffer because of invalid UTF-8
+ let mut col = 0;
+ let mut byte = 0;
+ let mut init = true;
+
+ while byte < buf.len() {
+ let (ctype, cwidth, nbytes) = if options.uflag {
+ let nbytes = char::from(buf[byte]).len_utf8();
+
+ if byte + nbytes > buf.len() {
+ // don't overrun buffer because of invalid UTF-8
+ (Other, 1, 1)
+ } else if let Ok(t) = from_utf8(&buf[byte..byte + nbytes]) {
+ match t.chars().next() {
+ Some('\t') => (Tab, 0, nbytes),
+ Some('\x08') => (Backspace, 0, nbytes),
+ Some(c) => (Other, UnicodeWidthChar::width(c).unwrap_or(0), nbytes),
+ None => {
+ // no valid char at start of t, so take 1 byte
(Other, 1, 1)
- } else if let Ok(t) = from_utf8(&buf[byte..byte + nbytes]) {
- match t.chars().next() {
- Some('\t') => (Tab, 0, nbytes),
- Some('\x08') => (Backspace, 0, nbytes),
- Some(c) => (Other, UnicodeWidthChar::width(c).unwrap_or(0), nbytes),
- None => {
- // no valid char at start of t, so take 1 byte
- (Other, 1, 1)
- }
- }
- } else {
- (Other, 1, 1) // implicit assumption: non-UTF-8 char is 1 col wide
}
+ }
+ } else {
+ (Other, 1, 1) // implicit assumption: non-UTF-8 char is 1 col wide
+ }
+ } else {
+ (
+ match buf[byte] {
+ // always take exactly 1 byte in strict ASCII mode
+ 0x09 => Tab,
+ 0x08 => Backspace,
+ _ => Other,
+ },
+ 1,
+ 1,
+ )
+ };
+
+ // figure out how many columns this char takes up
+ match ctype {
+ Tab => {
+ // figure out how many spaces to the next tabstop
+ let nts = next_tabstop(tabstops, col, &options.remaining_mode);
+ col += nts;
+
+ // now dump out either spaces if we're expanding, or a literal tab if we're not
+ if init || !options.iflag {
+ if nts <= options.tspaces.len() {
+ output.write_all(options.tspaces[..nts].as_bytes())?;
+ } else {
+ output.write_all(" ".repeat(nts).as_bytes())?;
+ };
} else {
- (
- match buf[byte] {
- // always take exactly 1 byte in strict ASCII mode
- 0x09 => Tab,
- 0x08 => Backspace,
- _ => Other,
- },
- 1,
- 1,
- )
+ output.write_all(&buf[byte..byte + nbytes])?;
+ }
+ }
+ _ => {
+ col = if ctype == Other {
+ col + cwidth
+ } else if col > 0 {
+ col - 1
+ } else {
+ 0
};
- // figure out how many columns this char takes up
- match ctype {
- Tab => {
- // figure out how many spaces to the next tabstop
- let nts = next_tabstop(ts, col, &options.remaining_mode);
- col += nts;
-
- // now dump out either spaces if we're expanding, or a literal tab if we're not
- if init || !options.iflag {
- if nts <= options.tspaces.len() {
- output.write_all(options.tspaces[..nts].as_bytes())?;
- } else {
- output.write_all(" ".repeat(nts).as_bytes())?;
- };
- } else {
- output.write_all(&buf[byte..byte + nbytes])?;
- }
- }
- _ => {
- col = if ctype == Other {
- col + cwidth
- } else if col > 0 {
- col - 1
- } else {
- 0
- };
-
- // if we're writing anything other than a space, then we're
- // done with the line's leading spaces
- if buf[byte] != 0x20 {
- init = false;
- }
-
- output.write_all(&buf[byte..byte + nbytes])?;
- }
+ // if we're writing anything other than a space, then we're
+ // done with the line's leading spaces
+ if buf[byte] != 0x20 {
+ init = false;
}
- byte += nbytes; // advance the pointer
+ output.write_all(&buf[byte..byte + nbytes])?;
}
+ }
+
+ byte += nbytes; // advance the pointer
+ }
+
+ output.flush()?;
+ buf.truncate(0); // clear the buffer
+
+ Ok(())
+}
+
+fn expand(options: &Options) -> UResult<()> {
+ let mut output = BufWriter::new(stdout());
+ let ts = options.tabstops.as_ref();
+ let mut buf = Vec::new();
- output.flush()?;
- buf.truncate(0); // clear the buffer
+ for file in &options.files {
+ if Path::new(file).is_dir() {
+ show_error!("{}: Is a directory", file);
+ set_exit_code(1);
+ continue;
+ }
+ match open(file) {
+ Ok(mut fh) => {
+ while match fh.read_until(b'\n', &mut buf) {
+ Ok(s) => s > 0,
+ Err(_) => buf.is_empty(),
+ } {
+ expand_line(&mut buf, &mut output, ts, options)
+ .map_err_context(|| "failed to write output".to_string())?;
+ }
+ }
+ Err(e) => {
+ show_error!("{}", e);
+ set_exit_code(1);
+ continue;
+ }
}
}
Ok(())
@@ -487,8 +509,8 @@ mod tests {
#[test]
fn test_next_tabstop_remaining_mode_plus() {
assert_eq!(next_tabstop(&[1, 5], 0, &RemainingMode::Plus), 1);
- assert_eq!(next_tabstop(&[1, 5], 3, &RemainingMode::Plus), 4);
- assert_eq!(next_tabstop(&[1, 5], 6, &RemainingMode::Plus), 4);
+ assert_eq!(next_tabstop(&[1, 5], 3, &RemainingMode::Plus), 3);
+ assert_eq!(next_tabstop(&[1, 5], 6, &RemainingMode::Plus), 5);
}
#[test]
diff --git a/src/uu/expr/Cargo.toml b/src/uu/expr/Cargo.toml
index 18de38a7c0d525eae70880a7964d0720aaffa047..06d623e326b29e0686474454bd09ad6f129c5ee2 100644
--- a/src/uu/expr/Cargo.toml
+++ b/src/uu/expr/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_expr"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "expr ~ (uutils) display the value of EXPRESSION"
@@ -15,11 +15,11 @@ edition = "2021"
path = "src/expr.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-num-bigint = "0.4.0"
-num-traits = "0.2.15"
-onig = { version = "~6.4", default-features = false }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+num-bigint = { workspace = true }
+num-traits = { workspace = true }
+onig = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "expr"
diff --git a/src/uu/expr/expr.md b/src/uu/expr/expr.md
index 6c881eb3557b76bd297c38ac98830edbf48d4395..ab0824651492b096db1ca33f64af33f917e858e8 100644
--- a/src/uu/expr/expr.md
+++ b/src/uu/expr/expr.md
@@ -1,61 +1,53 @@
# expr
-## About
-
-Print the value of `EXPRESSION` to standard output
-
-## Usage
```
expr [EXPRESSION]
expr [OPTIONS]
```
+Print the value of `EXPRESSION` to standard output
+
## After help
Print the value of `EXPRESSION` to standard output. A blank line below
-separates increasing precedence groups.
+separates increasing precedence groups.
`EXPRESSION` may be:
- ARG1 | ARG2 ARG1 if it is neither null nor 0, otherwise ARG2
-
- ARG1 & ARG2 ARG1 if neither argument is null or 0, otherwise 0
-
- ARG1 < ARG2 ARG1 is less than ARG2
- ARG1 <= ARG2 ARG1 is less than or equal to ARG2
- ARG1 = ARG2 ARG1 is equal to ARG2
- ARG1 != ARG2 ARG1 is unequal to ARG2
- ARG1 >= ARG2 ARG1 is greater than or equal to ARG2
- ARG1 > ARG2 ARG1 is greater than ARG2
-
- ARG1 + ARG2 arithmetic sum of ARG1 and ARG2
- ARG1 - ARG2 arithmetic difference of ARG1 and ARG2
-
- ARG1 * ARG2 arithmetic product of ARG1 and ARG2
- ARG1 / ARG2 arithmetic quotient of ARG1 divided by ARG2
- ARG1 % ARG2 arithmetic remainder of ARG1 divided by ARG2
-
- STRING : REGEXP anchored pattern match of REGEXP in STRING
-
- match STRING REGEXP same as STRING : REGEXP
- substr STRING POS LENGTH substring of STRING, POS counted from 1
- index STRING CHARS index in STRING where any CHARS is found, or 0
- length STRING length of STRING
- + TOKEN interpret TOKEN as a string, even if it is a
- keyword like 'match' or an operator like '/'
-
- ( EXPRESSION ) value of EXPRESSION
+- `ARG1 | ARG2`: `ARG1` if it is neither null nor 0, otherwise `ARG2`
+- `ARG1 & ARG2`: `ARG1` if neither argument is null or 0, otherwise 0
+- `ARG1 < ARG2`: `ARG1` is less than `ARG2`
+- `ARG1 <= ARG2`: `ARG1` is less than or equal to `ARG2`
+- `ARG1 = ARG2`: `ARG1` is equal to `ARG2`
+- `ARG1 != ARG2`: `ARG1` is unequal to `ARG2`
+- `ARG1 >= ARG2`: `ARG1` is greater than or equal to `ARG2`
+- `ARG1 > ARG2`: `ARG1` is greater than `ARG2`
+- `ARG1 + ARG2`: arithmetic sum of `ARG1` and `ARG2`
+- `ARG1 - ARG2`: arithmetic difference of `ARG1` and `ARG2`
+- `ARG1 * ARG2`: arithmetic product of `ARG1` and `ARG2`
+- `ARG1 / ARG2`: arithmetic quotient of `ARG1` divided by `ARG2`
+- `ARG1 % ARG2`: arithmetic remainder of `ARG1` divided by `ARG2`
+- `STRING : REGEXP`: anchored pattern match of `REGEXP` in `STRING`
+- `match STRING REGEXP`: same as `STRING : REGEXP`
+- `substr STRING POS LENGTH`: substring of `STRING`, `POS` counted from 1
+- `index STRING CHARS`: index in `STRING` where any `CHARS` is found, or 0
+- `length STRING`: length of `STRING`
+- `+ TOKEN`: interpret `TOKEN` as a string, even if it is a keyword like `match`
+ or an operator like `/`
+- `( EXPRESSION )`: value of `EXPRESSION`
Beware that many operators need to be escaped or quoted for shells.
Comparisons are arithmetic if both ARGs are numbers, else lexicographical.
Pattern matches return the string matched between \( and \) or null; if
\( and \) are not used, they return the number of characters matched or 0.
-Exit status is `0` if `EXPRESSION` is neither null nor `0`, `1` if `EXPRESSION` is null
-or `0`, `2` if `EXPRESSION` is syntactically invalid, and `3` if an error occurred.
+Exit status is `0` if `EXPRESSION` is neither null nor `0`, `1` if `EXPRESSION`
+is null or `0`, `2` if `EXPRESSION` is syntactically invalid, and `3` if an
+error occurred.
Environment variables:
- - `EXPR_DEBUG_TOKENS=1`: dump expression's tokens
- - `EXPR_DEBUG_RPN=1`: dump expression represented in reverse polish notation
- - `EXPR_DEBUG_SYA_STEP=1`: dump each parser step
- - `EXPR_DEBUG_AST=1`: dump expression represented abstract syntax tree
\ No newline at end of file
+
+- `EXPR_DEBUG_TOKENS=1`: dump expression's tokens
+- `EXPR_DEBUG_RPN=1`: dump expression represented in reverse polish notation
+- `EXPR_DEBUG_SYA_STEP=1`: dump each parser step
+- `EXPR_DEBUG_AST=1`: dump expression represented abstract syntax tree
diff --git a/src/uu/expr/src/expr.rs b/src/uu/expr/src/expr.rs
index 7c262da877709f77ed55bae1ffb3a420875b06e7..4e41a6929e6cf57fcaeb0fdeae42cbdf361f2c33 100644
--- a/src/uu/expr/src/expr.rs
+++ b/src/uu/expr/src/expr.rs
@@ -1,18 +1,21 @@
-//* This file is part of the uutils coreutils package.
-//*
-//* (c) Roman Gafiyatullin <r.gafiyatullin@me.com>
-//*
-//* For the full copyright and license information, please view the LICENSE
-//* file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use std::fmt::Display;
use clap::{crate_version, Arg, ArgAction, Command};
+use syntax_tree::AstNode;
use uucore::{
- error::{UResult, USimpleError},
- format_usage, help_section, help_usage,
+ display::Quotable,
+ error::{UError, UResult},
+ format_usage, help_about, help_section, help_usage,
};
+use crate::syntax_tree::is_truthy;
+
mod syntax_tree;
-mod tokens;
mod options {
pub const VERSION: &str = "version";
@@ -20,10 +23,55 @@ mod options {
pub const EXPRESSION: &str = "expression";
}
+pub type ExprResult<T> = Result<T, ExprError>;
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum ExprError {
+ UnexpectedArgument(String),
+ MissingArgument(String),
+ NonIntegerArgument,
+ MissingOperand,
+ DivisionByZero,
+ InvalidRegexExpression,
+ ExpectedClosingBraceAfter(String),
+}
+
+impl Display for ExprError {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ Self::UnexpectedArgument(s) => {
+ write!(f, "syntax error: unexpected argument {}", s.quote())
+ }
+ Self::MissingArgument(s) => {
+ write!(f, "syntax error: missing argument after {}", s.quote())
+ }
+ Self::NonIntegerArgument => write!(f, "non-integer argument"),
+ Self::MissingOperand => write!(f, "missing operand"),
+ Self::DivisionByZero => write!(f, "division by zero"),
+ Self::InvalidRegexExpression => write!(f, "Invalid regex expression"),
+ Self::ExpectedClosingBraceAfter(s) => {
+ write!(f, "expected ')' after {}", s.quote())
+ }
+ }
+ }
+}
+
+impl std::error::Error for ExprError {}
+
+impl UError for ExprError {
+ fn code(&self) -> i32 {
+ 2
+ }
+
+ fn usage(&self) -> bool {
+ *self == Self::MissingOperand
+ }
+}
+
pub fn uu_app() -> Command {
Command::new(uucore::util_name())
.version(crate_version!())
- .about(help_section!("about", "expr.md"))
+ .about(help_about!("expr.md"))
.override_usage(format_usage(help_usage!("expr.md")))
.after_help(help_section!("after help", "expr.md"))
.infer_long_args(true)
@@ -50,37 +98,18 @@ pub fn uu_app() -> Command {
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_lossy();
-
// For expr utility we do not want getopts.
// The following usage should work without escaping hyphens: `expr -15 = 1 + 2 \* \( 3 - -4 \)`
let matches = uu_app().try_get_matches_from(args)?;
- let token_strings = matches
+ let token_strings: Vec<&str> = matches
.get_many::<String>(options::EXPRESSION)
.map(|v| v.into_iter().map(|s| s.as_ref()).collect::<Vec<_>>())
.unwrap_or_default();
- match process_expr(&token_strings[..]) {
- Ok(expr_result) => print_expr_ok(&expr_result),
- Err(expr_error) => Err(USimpleError::new(2, &expr_error)),
+ let res: String = AstNode::parse(&token_strings)?.eval()?.eval_as_string();
+ println!("{res}");
+ if !is_truthy(&res.into()) {
+ return Err(1.into());
}
-}
-
-fn process_expr(token_strings: &[&str]) -> Result<String, String> {
- let maybe_tokens = tokens::strings_to_tokens(token_strings);
- let maybe_ast = syntax_tree::tokens_to_ast(maybe_tokens);
- evaluate_ast(maybe_ast)
-}
-
-fn print_expr_ok(expr_result: &str) -> UResult<()> {
- println!("{}", expr_result);
- if expr_result.parse::<i32>() == Ok(0) || expr_result.is_empty() {
- Err(1.into())
- } else {
- Ok(())
- }
-}
-
-fn evaluate_ast(maybe_ast: Result<Box<syntax_tree::AstNode>, String>) -> Result<String, String> {
- maybe_ast.and_then(|ast| ast.evaluate())
+ Ok(())
}
diff --git a/src/uu/expr/src/syntax_tree.rs b/src/uu/expr/src/syntax_tree.rs
index 6a112df757bfa01edb6e4ca1873e1da059ddc313..5aa9c93986b7c0eb4c82ea02f07d42deaf94e70f 100644
--- a/src/uu/expr/src/syntax_tree.rs
+++ b/src/uu/expr/src/syntax_tree.rs
@@ -1,525 +1,590 @@
-//* This file is part of the uutils coreutils package.
-//*
-//* (c) Roman Gafiyatullin <r.gafiyatullin@me.com>
-//*
-//* For the full copyright and license information, please view the LICENSE
-//* file that was distributed with this source code.
-
-//!
-//! Here we employ shunting-yard algorithm for building AST from tokens according to operators' precedence and associative-ness.
-//! * `<https://en.wikipedia.org/wiki/Shunting-yard_algorithm>`
-//!
-
-// spell-checker:ignore (ToDO) binop binops ints paren prec multibytes
-
-use num_bigint::BigInt;
-use num_traits::{One, Zero};
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore (ToDO) ints paren prec multibytes
+
+use num_bigint::{BigInt, ParseBigIntError};
+use num_traits::ToPrimitive;
use onig::{Regex, RegexOptions, Syntax};
-use crate::tokens::Token;
+use crate::{ExprError, ExprResult};
-type TokenStack = Vec<(usize, Token)>;
-pub type OperandsList = Vec<Box<AstNode>>;
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BinOp {
+ Relation(RelationOp),
+ Numeric(NumericOp),
+ String(StringOp),
+}
-#[derive(Debug)]
-pub enum AstNode {
- Leaf {
- token_idx: usize,
- value: String,
- },
- Node {
- token_idx: usize,
- op_type: String,
- operands: OperandsList,
- },
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RelationOp {
+ Lt,
+ Leq,
+ Eq,
+ Neq,
+ Gt,
+ Geq,
}
-impl AstNode {
- fn debug_dump(&self) {
- self.debug_dump_impl(1);
- }
- fn debug_dump_impl(&self, depth: usize) {
- for _ in 0..depth {
- print!("\t",);
- }
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum NumericOp {
+ Add,
+ Sub,
+ Mul,
+ Div,
+ Mod,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum StringOp {
+ Match,
+ Index,
+ And,
+ Or,
+}
+
+impl BinOp {
+ fn eval(&self, left: &AstNode, right: &AstNode) -> ExprResult<NumOrStr> {
match self {
- Self::Leaf { token_idx, value } => println!(
- "Leaf( {} ) at #{} ( evaluate -> {:?} )",
- value,
- token_idx,
- self.evaluate()
- ),
- Self::Node {
- token_idx,
- op_type,
- operands,
- } => {
- println!(
- "Node( {} ) at #{} (evaluate -> {:?})",
- op_type,
- token_idx,
- self.evaluate()
- );
- for operand in operands {
- operand.debug_dump_impl(depth + 1);
- }
- }
+ Self::Relation(op) => op.eval(left, right),
+ Self::Numeric(op) => op.eval(left, right),
+ Self::String(op) => op.eval(left, right),
}
}
+}
- fn new_node(token_idx: usize, op_type: &str, operands: OperandsList) -> Box<Self> {
- Box::new(Self::Node {
- token_idx,
- op_type: op_type.into(),
- operands,
- })
+impl RelationOp {
+ fn eval(&self, a: &AstNode, b: &AstNode) -> ExprResult<NumOrStr> {
+ let a = a.eval()?;
+ let b = b.eval()?;
+ let b = if let (Ok(a), Ok(b)) = (&a.to_bigint(), &b.to_bigint()) {
+ match self {
+ Self::Lt => a < b,
+ Self::Leq => a <= b,
+ Self::Eq => a == b,
+ Self::Neq => a != b,
+ Self::Gt => a > b,
+ Self::Geq => a >= b,
+ }
+ } else {
+ // These comparisons should be using locale settings
+ let a = a.eval_as_string();
+ let b = b.eval_as_string();
+ match self {
+ Self::Lt => a < b,
+ Self::Leq => a <= b,
+ Self::Eq => a == b,
+ Self::Neq => a != b,
+ Self::Gt => a > b,
+ Self::Geq => a >= b,
+ }
+ };
+ if b {
+ Ok(1.into())
+ } else {
+ Ok(0.into())
+ }
}
- fn new_leaf(token_idx: usize, value: &str) -> Box<Self> {
- Box::new(Self::Leaf {
- token_idx,
- value: value.into(),
- })
+}
+
+impl NumericOp {
+ fn eval(&self, left: &AstNode, right: &AstNode) -> ExprResult<NumOrStr> {
+ let a = left.eval()?.eval_as_bigint()?;
+ let b = right.eval()?.eval_as_bigint()?;
+ Ok(NumOrStr::Num(match self {
+ Self::Add => a + b,
+ Self::Sub => a - b,
+ Self::Mul => a * b,
+ Self::Div => match a.checked_div(&b) {
+ Some(x) => x,
+ None => return Err(ExprError::DivisionByZero),
+ },
+ Self::Mod => {
+ if a.checked_div(&b).is_none() {
+ return Err(ExprError::DivisionByZero);
+ };
+ a % b
+ }
+ }))
}
- pub fn evaluate(&self) -> Result<String, String> {
+}
+
+impl StringOp {
+ fn eval(&self, left: &AstNode, right: &AstNode) -> ExprResult<NumOrStr> {
match self {
- Self::Leaf { value, .. } => Ok(value.clone()),
- Self::Node { op_type, .. } => match self.operand_values() {
- Err(reason) => Err(reason),
- Ok(operand_values) => match op_type.as_ref() {
- "+" => {
- infix_operator_two_ints(|a: BigInt, b: BigInt| Ok(a + b), &operand_values)
- }
- "-" => {
- infix_operator_two_ints(|a: BigInt, b: BigInt| Ok(a - b), &operand_values)
- }
- "*" => {
- infix_operator_two_ints(|a: BigInt, b: BigInt| Ok(a * b), &operand_values)
+ Self::Or => {
+ let left = left.eval()?;
+ if is_truthy(&left) {
+ return Ok(left);
+ }
+ let right = right.eval()?;
+ if is_truthy(&right) {
+ return Ok(right);
+ }
+ Ok(0.into())
+ }
+ Self::And => {
+ let left = left.eval()?;
+ if !is_truthy(&left) {
+ return Ok(0.into());
+ }
+ let right = right.eval()?;
+ if !is_truthy(&right) {
+ return Ok(0.into());
+ }
+ Ok(left)
+ }
+ Self::Match => {
+ let left = left.eval()?.eval_as_string();
+ let right = right.eval()?.eval_as_string();
+ let re_string = format!("^{}", right);
+ let re = Regex::with_options(
+ &re_string,
+ RegexOptions::REGEX_OPTION_NONE,
+ Syntax::grep(),
+ )
+ .map_err(|_| ExprError::InvalidRegexExpression)?;
+ Ok(if re.captures_len() > 0 {
+ re.captures(&left)
+ .map(|captures| captures.at(1).unwrap())
+ .unwrap_or("")
+ .to_string()
+ } else {
+ re.find(&left)
+ .map_or("0".to_string(), |(start, end)| (end - start).to_string())
+ }
+ .into())
+ }
+ Self::Index => {
+ let left = left.eval()?.eval_as_string();
+ let right = right.eval()?.eval_as_string();
+ for (current_idx, ch_h) in left.chars().enumerate() {
+ for ch_n in right.to_string().chars() {
+ if ch_n == ch_h {
+ return Ok((current_idx + 1).into());
+ }
}
- "/" => infix_operator_two_ints(
- |a: BigInt, b: BigInt| {
- if b.is_zero() {
- Err("division by zero".to_owned())
- } else {
- Ok(a / b)
- }
- },
- &operand_values,
- ),
- "%" => infix_operator_two_ints(
- |a: BigInt, b: BigInt| {
- if b.is_zero() {
- Err("division by zero".to_owned())
- } else {
- Ok(a % b)
- }
- },
- &operand_values,
- ),
- "=" => infix_operator_two_ints_or_two_strings(
- |a: BigInt, b: BigInt| Ok(bool_as_int(a == b)),
- |a: &String, b: &String| Ok(bool_as_string(a == b)),
- &operand_values,
- ),
- "!=" => infix_operator_two_ints_or_two_strings(
- |a: BigInt, b: BigInt| Ok(bool_as_int(a != b)),
- |a: &String, b: &String| Ok(bool_as_string(a != b)),
- &operand_values,
- ),
- "<" => infix_operator_two_ints_or_two_strings(
- |a: BigInt, b: BigInt| Ok(bool_as_int(a < b)),
- |a: &String, b: &String| Ok(bool_as_string(a < b)),
- &operand_values,
- ),
- ">" => infix_operator_two_ints_or_two_strings(
- |a: BigInt, b: BigInt| Ok(bool_as_int(a > b)),
- |a: &String, b: &String| Ok(bool_as_string(a > b)),
- &operand_values,
- ),
- "<=" => infix_operator_two_ints_or_two_strings(
- |a: BigInt, b: BigInt| Ok(bool_as_int(a <= b)),
- |a: &String, b: &String| Ok(bool_as_string(a <= b)),
- &operand_values,
- ),
- ">=" => infix_operator_two_ints_or_two_strings(
- |a: BigInt, b: BigInt| Ok(bool_as_int(a >= b)),
- |a: &String, b: &String| Ok(bool_as_string(a >= b)),
- &operand_values,
- ),
- "|" => Ok(infix_operator_or(&operand_values)),
- "&" => Ok(infix_operator_and(&operand_values)),
- ":" | "match" => operator_match(&operand_values),
- "length" => Ok(prefix_operator_length(&operand_values)),
- "index" => Ok(prefix_operator_index(&operand_values)),
- "substr" => Ok(prefix_operator_substr(&operand_values)),
-
- _ => Err(format!("operation not implemented: {}", op_type)),
- },
- },
- }
- }
- pub fn operand_values(&self) -> Result<Vec<String>, String> {
- if let Self::Node { operands, .. } = self {
- let mut out = Vec::with_capacity(operands.len());
- for operand in operands {
- let value = operand.evaluate()?;
- out.push(value);
+ }
+ Ok(0.into())
}
- Ok(out)
- } else {
- panic!("Invoked .operand_values(&self) not with ASTNode::Node")
}
}
}
-pub fn tokens_to_ast(
- maybe_tokens: Result<Vec<(usize, Token)>, String>,
-) -> Result<Box<AstNode>, String> {
- maybe_tokens.and_then(|tokens| {
- let mut out_stack: TokenStack = Vec::new();
- let mut op_stack: TokenStack = Vec::new();
+/// Precedence for infix binary operators
+const PRECEDENCE: &[&[(&str, BinOp)]] = &[
+ &[("|", BinOp::String(StringOp::Or))],
+ &[("&", BinOp::String(StringOp::And))],
+ &[
+ ("<", BinOp::Relation(RelationOp::Lt)),
+ ("<=", BinOp::Relation(RelationOp::Leq)),
+ ("=", BinOp::Relation(RelationOp::Eq)),
+ ("!=", BinOp::Relation(RelationOp::Neq)),
+ (">=", BinOp::Relation(RelationOp::Geq)),
+ (">", BinOp::Relation(RelationOp::Gt)),
+ ],
+ &[
+ ("+", BinOp::Numeric(NumericOp::Add)),
+ ("-", BinOp::Numeric(NumericOp::Sub)),
+ ],
+ &[
+ ("*", BinOp::Numeric(NumericOp::Mul)),
+ ("/", BinOp::Numeric(NumericOp::Div)),
+ ("%", BinOp::Numeric(NumericOp::Mod)),
+ ],
+ &[(":", BinOp::String(StringOp::Match))],
+];
- for (token_idx, token) in tokens {
- push_token_to_either_stack(token_idx, &token, &mut out_stack, &mut op_stack)?;
- }
- move_rest_of_ops_to_out(&mut out_stack, &mut op_stack)?;
- assert!(op_stack.is_empty());
-
- maybe_dump_rpn(&out_stack);
- let result = ast_from_rpn(&mut out_stack);
- if !out_stack.is_empty() {
- Err(
- "syntax error (first RPN token does not represent the root of the expression AST)"
- .to_owned(),
- )
- } else {
- maybe_dump_ast(&result);
- result
- }
- })
+#[derive(Debug)]
+pub enum NumOrStr {
+ Num(BigInt),
+ Str(String),
}
-fn maybe_dump_ast(result: &Result<Box<AstNode>, String>) {
- use std::env;
- if let Ok(debug_var) = env::var("EXPR_DEBUG_AST") {
- if debug_var == "1" {
- println!("EXPR_DEBUG_AST");
- match result {
- Ok(ast) => ast.debug_dump(),
- Err(reason) => println!("\terr: {:?}", reason),
- }
- }
+impl From<usize> for NumOrStr {
+ fn from(num: usize) -> Self {
+ Self::Num(BigInt::from(num))
}
}
-#[allow(clippy::ptr_arg)]
-fn maybe_dump_rpn(rpn: &TokenStack) {
- use std::env;
- if let Ok(debug_var) = env::var("EXPR_DEBUG_RPN") {
- if debug_var == "1" {
- println!("EXPR_DEBUG_RPN");
- for token in rpn {
- println!("\t{:?}", token);
- }
- }
+impl From<BigInt> for NumOrStr {
+ fn from(num: BigInt) -> Self {
+ Self::Num(num)
}
}
-fn ast_from_rpn(rpn: &mut TokenStack) -> Result<Box<AstNode>, String> {
- match rpn.pop() {
- None => Err("syntax error (premature end of expression)".to_owned()),
-
- Some((token_idx, Token::Value { value })) => Ok(AstNode::new_leaf(token_idx, &value)),
+impl From<String> for NumOrStr {
+ fn from(str: String) -> Self {
+ Self::Str(str)
+ }
+}
- Some((token_idx, Token::InfixOp { value, .. })) => {
- maybe_ast_node(token_idx, &value, 2, rpn)
+impl NumOrStr {
+ pub fn to_bigint(&self) -> Result<BigInt, ParseBigIntError> {
+ match self {
+ Self::Num(num) => Ok(num.clone()),
+ Self::Str(str) => str.parse::<BigInt>(),
}
+ }
- Some((token_idx, Token::PrefixOp { value, arity })) => {
- maybe_ast_node(token_idx, &value, arity, rpn)
+ pub fn eval_as_bigint(self) -> ExprResult<BigInt> {
+ match self {
+ Self::Num(num) => Ok(num),
+ Self::Str(str) => str
+ .parse::<BigInt>()
+ .map_err(|_| ExprError::NonIntegerArgument),
}
+ }
- Some((token_idx, unexpected_token)) => {
- panic!("unexpected token at #{} {:?}", token_idx, unexpected_token)
+ pub fn eval_as_string(self) -> String {
+ match self {
+ Self::Num(num) => num.to_string(),
+ Self::Str(str) => str,
}
}
}
-fn maybe_ast_node(
- token_idx: usize,
- op_type: &str,
- arity: usize,
- rpn: &mut TokenStack,
-) -> Result<Box<AstNode>, String> {
- let mut operands = Vec::with_capacity(arity);
- for _ in 0..arity {
- let operand = ast_from_rpn(rpn)?;
- operands.push(operand);
- }
- operands.reverse();
- Ok(AstNode::new_node(token_idx, op_type, operands))
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum AstNode {
+ Leaf {
+ value: String,
+ },
+ BinOp {
+ op_type: BinOp,
+ left: Box<AstNode>,
+ right: Box<AstNode>,
+ },
+ Substr {
+ string: Box<AstNode>,
+ pos: Box<AstNode>,
+ length: Box<AstNode>,
+ },
+ Length {
+ string: Box<AstNode>,
+ },
}
-fn move_rest_of_ops_to_out(
- out_stack: &mut TokenStack,
- op_stack: &mut TokenStack,
-) -> Result<(), String> {
- loop {
- match op_stack.pop() {
- None => return Ok(()),
- Some((token_idx, Token::ParOpen)) => {
- return Err(format!(
- "syntax error (Mismatched open-parenthesis at #{})",
- token_idx
- ))
- }
- Some((token_idx, Token::ParClose)) => {
- return Err(format!(
- "syntax error (Mismatched close-parenthesis at #{})",
- token_idx
- ))
+impl AstNode {
+ pub fn parse(input: &[&str]) -> ExprResult<Self> {
+ Parser::new(input).parse()
+ }
+
+ pub fn eval(&self) -> ExprResult<NumOrStr> {
+ match self {
+ Self::Leaf { value } => Ok(value.to_string().into()),
+ Self::BinOp {
+ op_type,
+ left,
+ right,
+ } => op_type.eval(left, right),
+ Self::Substr {
+ string,
+ pos,
+ length,
+ } => {
+ let string: String = string.eval()?.eval_as_string();
+
+ // The GNU docs say:
+ //
+ // > If either position or length is negative, zero, or
+ // > non-numeric, returns the null string.
+ //
+ // So we coerce errors into 0 to make that the only case we
+ // have to care about.
+ let pos = pos
+ .eval()?
+ .eval_as_bigint()
+ .ok()
+ .and_then(|n| n.to_usize())
+ .unwrap_or(0);
+ let length = length
+ .eval()?
+ .eval_as_bigint()
+ .ok()
+ .and_then(|n| n.to_usize())
+ .unwrap_or(0);
+
+ let (Some(pos), Some(_)) = (pos.checked_sub(1), length.checked_sub(1)) else {
+ return Ok(String::new().into());
+ };
+
+ Ok(string
+ .chars()
+ .skip(pos)
+ .take(length)
+ .collect::<String>()
+ .into())
}
- Some(other) => out_stack.push(other),
+ Self::Length { string } => Ok(string.eval()?.eval_as_string().chars().count().into()),
}
}
}
-fn push_token_to_either_stack(
- token_idx: usize,
- token: &Token,
- out_stack: &mut TokenStack,
- op_stack: &mut TokenStack,
-) -> Result<(), String> {
- let result = match token {
- Token::Value { .. } => {
- out_stack.push((token_idx, token.clone()));
- Ok(())
+struct Parser<'a> {
+ input: &'a [&'a str],
+ index: usize,
+}
+
+impl<'a> Parser<'a> {
+ fn new(input: &'a [&'a str]) -> Self {
+ Self { input, index: 0 }
+ }
+
+ fn next(&mut self) -> ExprResult<&'a str> {
+ let next = self.input.get(self.index);
+ if let Some(next) = next {
+ self.index += 1;
+ Ok(next)
+ } else {
+ // The indexing won't panic, because we know that the input size
+ // is greater than zero.
+ Err(ExprError::MissingArgument(
+ self.input[self.index - 1].into(),
+ ))
}
+ }
- Token::InfixOp { .. } => {
- if op_stack.is_empty() {
- op_stack.push((token_idx, token.clone()));
- Ok(())
- } else {
- push_op_to_stack(token_idx, token, out_stack, op_stack)
- }
+ fn accept<T>(&mut self, f: impl Fn(&str) -> Option<T>) -> Option<T> {
+ let next = self.input.get(self.index)?;
+ let tok = f(next);
+ if let Some(tok) = tok {
+ self.index += 1;
+ Some(tok)
+ } else {
+ None
}
+ }
- Token::PrefixOp { .. } | Token::ParOpen => {
- op_stack.push((token_idx, token.clone()));
- Ok(())
+ fn parse(&mut self) -> ExprResult<AstNode> {
+ if self.input.is_empty() {
+ return Err(ExprError::MissingOperand);
+ }
+ let res = self.parse_expression()?;
+ if let Some(arg) = self.input.get(self.index) {
+ return Err(ExprError::UnexpectedArgument(arg.to_string()));
}
+ Ok(res)
+ }
- Token::ParClose => move_till_match_paren(out_stack, op_stack),
- };
- maybe_dump_shunting_yard_step(token_idx, token, out_stack, op_stack, &result);
- result
-}
+ fn parse_expression(&mut self) -> ExprResult<AstNode> {
+ self.parse_precedence(0)
+ }
-#[allow(clippy::ptr_arg)]
-fn maybe_dump_shunting_yard_step(
- token_idx: usize,
- token: &Token,
- out_stack: &TokenStack,
- op_stack: &TokenStack,
- result: &Result<(), String>,
-) {
- use std::env;
- if let Ok(debug_var) = env::var("EXPR_DEBUG_SYA_STEP") {
- if debug_var == "1" {
- println!("EXPR_DEBUG_SYA_STEP");
- println!("\t{} => {:?}", token_idx, token);
- println!("\t\tout: {:?}", out_stack);
- println!("\t\top : {:?}", op_stack);
- println!("\t\tresult: {:?}", result);
+ fn parse_op(&mut self, precedence: usize) -> Option<BinOp> {
+ self.accept(|s| {
+ for (op_string, op) in PRECEDENCE[precedence] {
+ if s == *op_string {
+ return Some(*op);
+ }
+ }
+ None
+ })
+ }
+
+ fn parse_precedence(&mut self, precedence: usize) -> ExprResult<AstNode> {
+ if precedence >= PRECEDENCE.len() {
+ return self.parse_simple_expression();
+ }
+
+ let mut left = self.parse_precedence(precedence + 1)?;
+ while let Some(op) = self.parse_op(precedence) {
+ let right = self.parse_precedence(precedence + 1)?;
+ left = AstNode::BinOp {
+ op_type: op,
+ left: Box::new(left),
+ right: Box::new(right),
+ };
}
+ Ok(left)
}
-}
-fn push_op_to_stack(
- token_idx: usize,
- token: &Token,
- out_stack: &mut TokenStack,
- op_stack: &mut TokenStack,
-) -> Result<(), String> {
- if let Token::InfixOp {
- precedence: prec,
- left_assoc: la,
- ..
- } = *token
- {
- loop {
- match op_stack.last() {
- None | Some(&(_, Token::ParOpen)) => {
- op_stack.push((token_idx, token.clone()));
- return Ok(());
+ fn parse_simple_expression(&mut self) -> ExprResult<AstNode> {
+ let first = self.next()?;
+ Ok(match first {
+ "match" => {
+ let left = self.parse_expression()?;
+ let right = self.parse_expression()?;
+ AstNode::BinOp {
+ op_type: BinOp::String(StringOp::Match),
+ left: Box::new(left),
+ right: Box::new(right),
}
-
- Some(&(
- _,
- Token::InfixOp {
- precedence: prev_prec,
- ..
- },
- )) => {
- if la && prev_prec >= prec || !la && prev_prec > prec {
- out_stack.push(op_stack.pop().unwrap());
- } else {
- op_stack.push((token_idx, token.clone()));
- return Ok(());
- }
+ }
+ "substr" => {
+ let string = self.parse_expression()?;
+ let pos = self.parse_expression()?;
+ let length = self.parse_expression()?;
+ AstNode::Substr {
+ string: Box::new(string),
+ pos: Box::new(pos),
+ length: Box::new(length),
}
-
- Some(&(_, Token::PrefixOp { .. })) => {
- op_stack.push((token_idx, token.clone()));
- return Ok(());
+ }
+ "index" => {
+ let left = self.parse_expression()?;
+ let right = self.parse_expression()?;
+ AstNode::BinOp {
+ op_type: BinOp::String(StringOp::Index),
+ left: Box::new(left),
+ right: Box::new(right),
}
-
- Some(_) => panic!("Non-operator on op_stack"),
}
- }
- } else {
- panic!("Expected infix-op")
+ "length" => {
+ let string = self.parse_expression()?;
+ AstNode::Length {
+ string: Box::new(string),
+ }
+ }
+ "+" => AstNode::Leaf {
+ value: self.next()?.into(),
+ },
+ "(" => {
+ let s = self.parse_expression()?;
+ let close_paren = self.next()?;
+ if close_paren != ")" {
+ // Since we have parsed at least a '(', there will be a token
+ // at `self.index - 1`. So this indexing won't panic.
+ return Err(ExprError::ExpectedClosingBraceAfter(
+ self.input[self.index - 1].into(),
+ ));
+ }
+ s
+ }
+ s => AstNode::Leaf { value: s.into() },
+ })
}
}
-fn move_till_match_paren(
- out_stack: &mut TokenStack,
- op_stack: &mut TokenStack,
-) -> Result<(), String> {
- loop {
- let op = op_stack
- .pop()
- .ok_or_else(|| "syntax error (Mismatched close-parenthesis)".to_string())?;
- match op {
- (_, Token::ParOpen) => return Ok(()),
- other => out_stack.push(other),
+/// Determine whether `expr` should evaluate the string as "truthy"
+///
+/// Truthy strings are either empty or match the regex "-?0+".
+pub fn is_truthy(s: &NumOrStr) -> bool {
+ match s {
+ NumOrStr::Num(num) => num != &BigInt::from(0),
+ NumOrStr::Str(str) => {
+ // Edge case: `-` followed by nothing is truthy
+ if str == "-" {
+ return true;
+ }
+
+ let mut bytes = str.bytes();
+
+ // Empty string is falsy
+ let Some(first) = bytes.next() else {
+ return false;
+ };
+
+ let is_zero = (first == b'-' || first == b'0') && bytes.all(|b| b == b'0');
+ !is_zero
}
}
}
-fn infix_operator_two_ints<F>(f: F, values: &[String]) -> Result<String, String>
-where
- F: Fn(BigInt, BigInt) -> Result<BigInt, String>,
-{
- assert!(values.len() == 2);
- if let Ok(left) = values[0].parse::<BigInt>() {
- if let Ok(right) = values[1].parse::<BigInt>() {
- return f(left, right).map(|big_int| big_int.to_string());
+#[cfg(test)]
+mod test {
+ use super::{AstNode, BinOp, NumericOp, RelationOp, StringOp};
+
+ impl From<&str> for AstNode {
+ fn from(value: &str) -> Self {
+ Self::Leaf {
+ value: value.into(),
+ }
}
}
- Err("Expected an integer operand".to_string())
-}
-fn infix_operator_two_ints_or_two_strings<FI, FS>(
- fi: FI,
- fs: FS,
- values: &[String],
-) -> Result<String, String>
-where
- FI: Fn(BigInt, BigInt) -> Result<u8, String>,
- FS: Fn(&String, &String) -> Result<String, String>,
-{
- assert!(values.len() == 2);
- if let (Some(a_int), Some(b_int)) = (
- values[0].parse::<BigInt>().ok(),
- values[1].parse::<BigInt>().ok(),
- ) {
- match fi(a_int, b_int) {
- Ok(result) => Ok(result.to_string()),
- Err(reason) => Err(reason),
+ fn op(op_type: BinOp, left: impl Into<AstNode>, right: impl Into<AstNode>) -> AstNode {
+ AstNode::BinOp {
+ op_type,
+ left: Box::new(left.into()),
+ right: Box::new(right.into()),
}
- } else {
- fs(&values[0], &values[1])
}
-}
-fn infix_operator_or(values: &[String]) -> String {
- assert!(values.len() == 2);
- if value_as_bool(&values[0]) {
- values[0].clone()
- } else {
- values[1].clone()
+ fn length(string: impl Into<AstNode>) -> AstNode {
+ AstNode::Length {
+ string: Box::new(string.into()),
+ }
}
-}
-fn infix_operator_and(values: &[String]) -> String {
- if value_as_bool(&values[0]) && value_as_bool(&values[1]) {
- values[0].clone()
- } else {
- 0.to_string()
+ fn substr(
+ string: impl Into<AstNode>,
+ pos: impl Into<AstNode>,
+ length: impl Into<AstNode>,
+ ) -> AstNode {
+ AstNode::Substr {
+ string: Box::new(string.into()),
+ pos: Box::new(pos.into()),
+ length: Box::new(length.into()),
+ }
}
-}
-
-fn operator_match(values: &[String]) -> Result<String, String> {
- assert!(values.len() == 2);
- let re = Regex::with_options(&values[1], RegexOptions::REGEX_OPTION_NONE, Syntax::grep())
- .map_err(|err| err.description().to_string())?;
- Ok(if re.captures_len() > 0 {
- re.captures(&values[0])
- .map(|captures| captures.at(1).unwrap())
- .unwrap_or("")
- .to_string()
- } else {
- re.find(&values[0])
- .map_or("0".to_string(), |(start, end)| (end - start).to_string())
- })
-}
-
-fn prefix_operator_length(values: &[String]) -> String {
- assert!(values.len() == 1);
- // Use chars().count() as we can have some multibytes chars
- // See https://github.com/uutils/coreutils/issues/3132
- values[0].chars().count().to_string()
-}
-
-fn prefix_operator_index(values: &[String]) -> String {
- assert!(values.len() == 2);
- let haystack = &values[0];
- let needles = &values[1];
- for (current_idx, ch_h) in haystack.chars().enumerate() {
- for ch_n in needles.chars() {
- if ch_n == ch_h {
- return (current_idx + 1).to_string();
- }
+ #[test]
+ fn infix_operators() {
+ let cases = [
+ ("|", BinOp::String(StringOp::Or)),
+ ("&", BinOp::String(StringOp::And)),
+ ("<", BinOp::Relation(RelationOp::Lt)),
+ ("<=", BinOp::Relation(RelationOp::Leq)),
+ ("=", BinOp::Relation(RelationOp::Eq)),
+ ("!=", BinOp::Relation(RelationOp::Neq)),
+ (">=", BinOp::Relation(RelationOp::Geq)),
+ (">", BinOp::Relation(RelationOp::Gt)),
+ ("+", BinOp::Numeric(NumericOp::Add)),
+ ("-", BinOp::Numeric(NumericOp::Sub)),
+ ("*", BinOp::Numeric(NumericOp::Mul)),
+ ("/", BinOp::Numeric(NumericOp::Div)),
+ ("%", BinOp::Numeric(NumericOp::Mod)),
+ (":", BinOp::String(StringOp::Match)),
+ ];
+ for (string, value) in cases {
+ assert_eq!(AstNode::parse(&["1", string, "2"]), Ok(op(value, "1", "2")));
}
}
- "0".to_string()
-}
-
-fn prefix_operator_substr(values: &[String]) -> String {
- assert!(values.len() == 3);
- let subj = &values[0];
- let idx = match values[1]
- .parse::<usize>()
- .ok()
- .and_then(|v| v.checked_sub(1))
- {
- Some(i) => i,
- None => return String::new(),
- };
- let len = match values[2].parse::<usize>() {
- Ok(i) => i,
- Err(_) => return String::new(),
- };
-
- subj.chars().skip(idx).take(len).collect()
-}
-fn bool_as_int(b: bool) -> u8 {
- u8::from(b)
-}
-fn bool_as_string(b: bool) -> String {
- if b {
- "1".to_string()
- } else {
- "0".to_string()
- }
-}
-fn value_as_bool(s: &str) -> bool {
- if s.is_empty() {
- return false;
+ #[test]
+ fn other_operators() {
+ assert_eq!(
+ AstNode::parse(&["match", "1", "2"]),
+ Ok(op(BinOp::String(StringOp::Match), "1", "2")),
+ );
+ assert_eq!(
+ AstNode::parse(&["index", "1", "2"]),
+ Ok(op(BinOp::String(StringOp::Index), "1", "2")),
+ );
+ assert_eq!(AstNode::parse(&["length", "1"]), Ok(length("1")),);
+ assert_eq!(
+ AstNode::parse(&["substr", "1", "2", "3"]),
+ Ok(substr("1", "2", "3")),
+ );
}
- match s.parse::<BigInt>() {
- Ok(n) => n.is_one(),
- Err(_) => true,
+
+ #[test]
+ fn precedence() {
+ assert_eq!(
+ AstNode::parse(&["1", "+", "2", "*", "3"]),
+ Ok(op(
+ BinOp::Numeric(NumericOp::Add),
+ "1",
+ op(BinOp::Numeric(NumericOp::Mul), "2", "3")
+ ))
+ );
+ assert_eq!(
+ AstNode::parse(&["(", "1", "+", "2", ")", "*", "3"]),
+ Ok(op(
+ BinOp::Numeric(NumericOp::Mul),
+ op(BinOp::Numeric(NumericOp::Add), "1", "2"),
+ "3"
+ ))
+ );
+ assert_eq!(
+ AstNode::parse(&["1", "*", "2", "+", "3"]),
+ Ok(op(
+ BinOp::Numeric(NumericOp::Add),
+ op(BinOp::Numeric(NumericOp::Mul), "1", "2"),
+ "3"
+ )),
+ );
}
}
diff --git a/src/uu/expr/src/tokens.rs b/src/uu/expr/src/tokens.rs
deleted file mode 100644
index 6ff930f81ea1fca880ccb8d314e5e2bde8b7b4af..0000000000000000000000000000000000000000
--- a/src/uu/expr/src/tokens.rs
+++ /dev/null
@@ -1,150 +0,0 @@
-//* This file is part of the uutils coreutils package.
-//*
-//* (c) Roman Gafiyatullin <r.gafiyatullin@me.com>
-//*
-//* For the full copyright and license information, please view the LICENSE
-//* file that was distributed with this source code.
-
-//!
-//! The following tokens are present in the expr grammar:
-//! * integer literal;
-//! * string literal;
-//! * infix binary operators;
-//! * prefix operators.
-//!
-//! According to the man-page of expr we have expression split into tokens (each token -- separate CLI-argument).
-//! Hence all we need is to map the strings into the Token structures, except for some ugly fiddling with +-escaping.
-//!
-
-// spell-checker:ignore (ToDO) paren
-
-use num_bigint::BigInt;
-
-#[derive(Debug, Clone)]
-pub enum Token {
- Value {
- value: String,
- },
-
- ParOpen,
- ParClose,
-
- InfixOp {
- precedence: u8,
- left_assoc: bool,
- value: String,
- },
-
- PrefixOp {
- arity: usize,
- value: String,
- },
-}
-impl Token {
- fn new_infix_op(v: &str, left_assoc: bool, precedence: u8) -> Self {
- Self::InfixOp {
- left_assoc,
- precedence,
- value: v.into(),
- }
- }
- fn new_value(v: &str) -> Self {
- Self::Value { value: v.into() }
- }
-
- fn is_infix_plus(&self) -> bool {
- match self {
- Self::InfixOp { value, .. } => value == "+",
- _ => false,
- }
- }
- fn is_a_number(&self) -> bool {
- match self {
- Self::Value { value, .. } => value.parse::<BigInt>().is_ok(),
- _ => false,
- }
- }
- fn is_a_close_paren(&self) -> bool {
- matches!(*self, Self::ParClose)
- }
-}
-
-pub fn strings_to_tokens(strings: &[&str]) -> Result<Vec<(usize, Token)>, String> {
- let mut tokens_acc = Vec::with_capacity(strings.len());
- let mut tok_idx = 1;
-
- for s in strings {
- let token_if_not_escaped = match *s {
- "(" => Token::ParOpen,
- ")" => Token::ParClose,
-
- "^" => Token::new_infix_op(s, false, 7),
-
- ":" => Token::new_infix_op(s, true, 6),
-
- "*" | "/" | "%" => Token::new_infix_op(s, true, 5),
-
- "+" | "-" => Token::new_infix_op(s, true, 4),
-
- "=" | "!=" | "<" | ">" | "<=" | ">=" => Token::new_infix_op(s, true, 3),
-
- "&" => Token::new_infix_op(s, true, 2),
-
- "|" => Token::new_infix_op(s, true, 1),
-
- "match" | "index" => Token::PrefixOp {
- arity: 2,
- value: s.to_string(),
- },
- "substr" => Token::PrefixOp {
- arity: 3,
- value: s.to_string(),
- },
- "length" => Token::PrefixOp {
- arity: 1,
- value: s.to_string(),
- },
-
- _ => Token::new_value(s),
- };
- push_token_if_not_escaped(&mut tokens_acc, tok_idx, token_if_not_escaped, s);
- tok_idx += 1;
- }
- maybe_dump_tokens_acc(&tokens_acc);
-
- Ok(tokens_acc)
-}
-
-fn maybe_dump_tokens_acc(tokens_acc: &[(usize, Token)]) {
- use std::env;
-
- if let Ok(debug_var) = env::var("EXPR_DEBUG_TOKENS") {
- if debug_var == "1" {
- println!("EXPR_DEBUG_TOKENS");
- for token in tokens_acc {
- println!("\t{:?}", token);
- }
- }
- }
-}
-
-fn push_token_if_not_escaped(acc: &mut Vec<(usize, Token)>, tok_idx: usize, token: Token, s: &str) {
- // Smells heuristics... :(
- let prev_is_plus = match acc.last() {
- None => false,
- Some(t) => t.1.is_infix_plus(),
- };
- let should_use_as_escaped = if prev_is_plus && acc.len() >= 2 {
- let pre_prev = &acc[acc.len() - 2];
- !(pre_prev.1.is_a_number() || pre_prev.1.is_a_close_paren())
- } else {
- prev_is_plus
- };
-
- if should_use_as_escaped {
- acc.pop();
- acc.push((tok_idx, Token::new_value(s)));
- } else {
- acc.push((tok_idx, token));
- }
-}
diff --git a/src/uu/factor/BENCHMARKING.md b/src/uu/factor/BENCHMARKING.md
index 0f9afaff0e4dcc95c4ed92839a7e3c46cf07215b..d5fdb47d68d3ced43123740e64c02e45a05eb1b1 100644
--- a/src/uu/factor/BENCHMARKING.md
+++ b/src/uu/factor/BENCHMARKING.md
@@ -53,19 +53,19 @@ which I recommend reading if you want to add benchmarks to `factor`.
so each sample takes a very short time, minimizing variability and
maximizing the numbers of samples we can take in a given time.
-2. Benchmarks are immutable (once merged in `uutils`)
+1. Benchmarks are immutable (once merged in `uutils`)
Modifying a benchmark means previously-collected values cannot meaningfully
be compared, silently giving nonsensical results. If you must modify an
existing benchmark, rename it.
-3. Test common cases
+1. Test common cases
We are interested in overall performance, rather than specific edge-cases;
use **reproducibly-randomized inputs**, sampling from either all possible
input values or some subset of interest.
-4. Use [`criterion`], `criterion::black_box`, ...
+1. Use [`criterion`], `criterion::black_box`, ...
`criterion` isn't perfect, but it is also much better than ad-hoc
solutions in each benchmark.
@@ -103,7 +103,7 @@ characteristics:
1. integer factoring algorithms are randomized, with large variance in
execution time ;
-2. various inputs also have large differences in factoring time, that
+1. various inputs also have large differences in factoring time, that
corresponds to no natural, linear ordering of the inputs.
If (1) was untrue (i.e. if execution time wasn't random), we could faithfully
diff --git a/src/uu/factor/Cargo.toml b/src/uu/factor/Cargo.toml
index 06175a5150e59abfb9674b954a459395f4678e7a..f5202fd255b9470a11b93a5cc8268c8cb537dfcf 100644
--- a/src/uu/factor/Cargo.toml
+++ b/src/uu/factor/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_factor"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "factor ~ (uutils) display the prime factors of each NUMBER"
@@ -12,18 +12,19 @@ categories = ["command-line-utilities"]
edition = "2021"
[build-dependencies]
-num-traits = "0.2.15" # used in src/numerics.rs, which is included by build.rs
+num-traits = { workspace = true } # used in src/numerics.rs, which is included by build.rs
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-coz = { version = "0.1.3", optional = true }
-num-traits = "0.2.15" # Needs at least version 0.2.15 for "OverflowingAdd"
-rand = { version = "0.8", features = ["small_rng"] }
-smallvec = { version = "1.10", features = ["union"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+coz = { workspace = true, optional = true }
+num-traits = { workspace = true }
+rand = { workspace = true }
+smallvec = { workspace = true }
+uucore = { workspace = true }
+num-bigint = { workspace = true }
+num-prime = { workspace = true }
[dev-dependencies]
-paste = "1.0.6"
quickcheck = "1.0.3"
[[bin]]
@@ -31,4 +32,4 @@ name = "factor"
path = "src/main.rs"
[lib]
-path = "src/cli.rs"
+path = "src/factor.rs"
diff --git a/src/uu/factor/build.rs b/src/uu/factor/build.rs
deleted file mode 100644
index aad2aac77033c58153a1046a1f2a42bbff4a8899..0000000000000000000000000000000000000000
--- a/src/uu/factor/build.rs
+++ /dev/null
@@ -1,108 +0,0 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) kwantam <kwantam@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
-
-//! Generate a table of the multiplicative inverses of p_i mod 2^64
-//! for the first 1027 odd primes (all 13 bit and smaller primes).
-//! You can supply a command line argument to override the default
-//! value of 1027 for the number of entries in the table.
-//!
-//! 2 has no multiplicative inverse mode 2^64 because 2 | 2^64,
-//! and in any case divisibility by two is trivial by checking the LSB.
-
-#![cfg_attr(test, allow(dead_code))]
-
-use std::env::{self, args};
-use std::fs::File;
-use std::io::Write;
-use std::path::Path;
-
-use self::sieve::Sieve;
-
-#[cfg(test)]
-use miller_rabin::is_prime;
-
-#[path = "src/numeric/modular_inverse.rs"]
-mod modular_inverse;
-#[allow(unused_imports)] // imports there are used, but invisible from build.rs
-#[path = "src/numeric/traits.rs"]
-mod traits;
-use modular_inverse::modular_inverse;
-
-mod sieve;
-
-#[cfg_attr(test, allow(dead_code))]
-fn main() {
- let out_dir = env::var("OUT_DIR").unwrap();
- let mut file = File::create(Path::new(&out_dir).join("prime_table.rs")).unwrap();
-
- // By default, we print the multiplicative inverses mod 2^64 of the first 1k primes
- const DEFAULT_SIZE: usize = 320;
- let n = args()
- .nth(1)
- .and_then(|s| s.parse::<usize>().ok())
- .unwrap_or(DEFAULT_SIZE);
-
- write!(file, "{}", PREAMBLE).unwrap();
- let mut cols = 3;
-
- // we want a total of n + 1 values
- let mut primes = Sieve::odd_primes().take(n + 1);
-
- // in each iteration of the for loop, we use the value yielded
- // by the previous iteration. This leaves one value left at the
- // end, which we call NEXT_PRIME.
- let mut x = primes.next().unwrap();
- for next in primes {
- // format the table
- let output = format!("({}, {}, {}),", x, modular_inverse(x), std::u64::MAX / x);
- if cols + output.len() > MAX_WIDTH {
- write!(file, "\n {}", output).unwrap();
- cols = 4 + output.len();
- } else {
- write!(file, " {}", output).unwrap();
- cols += 1 + output.len();
- }
-
- x = next;
- }
-
- write!(
- file,
- "\n];\n\n#[allow(dead_code)]\npub const NEXT_PRIME: u64 = {};\n",
- x
- )
- .unwrap();
-}
-
-#[test]
-fn test_generator_is_prime() {
- assert_eq!(Sieve::odd_primes.take(10_000).all(is_prime));
-}
-
-#[test]
-fn test_generator_10001() {
- let prime_10001 = Sieve::primes().skip(10_000).next();
- assert_eq!(prime_10001, Some(104_743));
-}
-
-const MAX_WIDTH: usize = 102;
-const PREAMBLE: &str = r##"/*
-* This file is part of the uutils coreutils package.
-*
-* (c) kwantam <kwantam@gmail.com>
-*
-* For the full copyright and license information, please view the LICENSE file
-* that was distributed with this source code.
-*/
-
-// *** NOTE: this file was automatically generated.
-// Please do not edit by hand. Instead, modify and
-// re-run src/factor/gen_tables.rs.
-
-#[allow(clippy::unreadable_literal)]
-pub const PRIME_INVERSIONS_U64: &[(u64, u64, u64)] = &[
- "##;
diff --git a/src/uu/factor/factor.md b/src/uu/factor/factor.md
new file mode 100644
index 0000000000000000000000000000000000000000..ccce4f2529c96b3fcc5bf7e9a22f697c0bb44b30
--- /dev/null
+++ b/src/uu/factor/factor.md
@@ -0,0 +1,8 @@
+# factor
+
+```
+factor [OPTION]... [NUMBER]...
+```
+
+Print the prime factors of the given NUMBER(s).
+If none are specified, read from standard input.
diff --git a/src/uu/factor/sieve.rs b/src/uu/factor/sieve.rs
deleted file mode 100644
index 2c637fad1170e8036ecaaf460a29ea1364c348fe..0000000000000000000000000000000000000000
--- a/src/uu/factor/sieve.rs
+++ /dev/null
@@ -1,217 +0,0 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) kwantam <kwantam@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
-
-// spell-checker:ignore (ToDO) filts, minidx, minkey paridx
-
-use std::iter::{Chain, Copied, Cycle};
-use std::slice::Iter;
-
-/// A lazy Sieve of Eratosthenes.
-///
-/// This is a reasonably efficient implementation based on
-/// O'Neill, M. E. "[The Genuine Sieve of Eratosthenes.](http://dx.doi.org/10.1017%2FS0956796808007004)"
-/// Journal of Functional Programming, Volume 19, Issue 1, 2009, pp. 95--106.
-#[derive(Default)]
-pub struct Sieve {
- inner: Wheel,
- filts: PrimeHeap,
-}
-
-impl Iterator for Sieve {
- type Item = u64;
-
- #[inline]
- fn size_hint(&self) -> (usize, Option<usize>) {
- self.inner.size_hint()
- }
-
- #[inline]
- fn next(&mut self) -> Option<u64> {
- for n in &mut self.inner {
- let mut prime = true;
- while let Some((next, inc)) = self.filts.peek() {
- // need to keep checking the min element of the heap
- // until we've found an element that's greater than n
- if next > n {
- break; // next heap element is bigger than n
- }
-
- if next == n {
- // n == next, and is composite.
- prime = false;
- }
- // Increment the element in the prime heap.
- self.filts.replace((next + inc, inc));
- }
-
- if prime {
- // this is a prime; add it to the heap
- self.filts.insert(n);
- return Some(n);
- }
- }
- None
- }
-}
-
-impl Sieve {
- fn new() -> Self {
- Self::default()
- }
-
- #[allow(dead_code)]
- #[inline]
- pub fn primes() -> PrimeSieve {
- INIT_PRIMES.iter().copied().chain(Self::new())
- }
-
- #[allow(dead_code)]
- #[inline]
- pub fn odd_primes() -> PrimeSieve {
- INIT_PRIMES[1..].iter().copied().chain(Self::new())
- }
-}
-
-pub type PrimeSieve = Chain<Copied<Iter<'static, u64>>, Sieve>;
-
-/// An iterator that generates an infinite list of numbers that are
-/// not divisible by any of 2, 3, 5, or 7.
-struct Wheel {
- next: u64,
- increment: Cycle<Iter<'static, u64>>,
-}
-
-impl Iterator for Wheel {
- type Item = u64;
-
- #[inline]
- fn size_hint(&self) -> (usize, Option<usize>) {
- (1, None)
- }
-
- #[inline]
- fn next(&mut self) -> Option<u64> {
- let increment = self.increment.next().unwrap(); // infinite iterator, no check necessary
- let ret = self.next;
- self.next = ret + increment;
- Some(ret)
- }
-}
-
-impl Wheel {
- #[inline]
- fn new() -> Self {
- Self {
- next: 11u64,
- increment: WHEEL_INCS.iter().cycle(),
- }
- }
-}
-
-impl Default for Wheel {
- fn default() -> Self {
- Self::new()
- }
-}
-
-/// The increments of a wheel of circumference 210
-/// (i.e., a wheel that skips all multiples of 2, 3, 5, 7)
-const WHEEL_INCS: &[u64] = &[
- 2, 4, 2, 4, 6, 2, 6, 4, 2, 4, 6, 6, 2, 6, 4, 2, 6, 4, 6, 8, 4, 2, 4, 2, 4, 8, 6, 4, 6, 2, 4, 6,
- 2, 6, 6, 4, 2, 4, 6, 2, 6, 4, 2, 4, 2, 10, 2, 10,
-];
-const INIT_PRIMES: &[u64] = &[2, 3, 5, 7];
-
-/// A min-heap of "infinite lists" of prime multiples, where a list is
-/// represented as (head, increment).
-#[derive(Debug, Default)]
-struct PrimeHeap {
- data: Vec<(u64, u64)>,
-}
-
-impl PrimeHeap {
- fn peek(&self) -> Option<(u64, u64)> {
- if let Some(&(x, y)) = self.data.first() {
- Some((x, y))
- } else {
- None
- }
- }
-
- fn insert(&mut self, next: u64) {
- let mut idx = self.data.len();
- let key = next * next;
-
- let item = (key, next);
- self.data.push(item);
- loop {
- // break if we've bubbled to the top
- if idx == 0 {
- break;
- }
-
- let paridx = (idx - 1) / 2;
- let (k, _) = self.data[paridx];
- if key < k {
- // bubble up, found a smaller key
- self.data.swap(idx, paridx);
- idx = paridx;
- } else {
- // otherwise, parent is smaller, so we're done
- break;
- }
- }
- }
-
- fn remove(&mut self) -> (u64, u64) {
- let ret = self.data.swap_remove(0);
-
- let mut idx = 0;
- let len = self.data.len();
- let (key, _) = self.data[0];
- loop {
- let child1 = 2 * idx + 1;
- let child2 = 2 * idx + 2;
-
- // no more children
- if child1 >= len {
- break;
- }
-
- // find lesser child
- let (c1key, _) = self.data[child1];
- let (minidx, minkey) = if child2 >= len {
- (child1, c1key)
- } else {
- let (c2key, _) = self.data[child2];
- if c1key < c2key {
- (child1, c1key)
- } else {
- (child2, c2key)
- }
- };
-
- if minkey < key {
- self.data.swap(minidx, idx);
- idx = minidx;
- continue;
- }
-
- // smaller than both children, so done
- break;
- }
-
- ret
- }
-
- /// More efficient than inserting and removing in two steps
- /// because we save one traversal of the heap.
- fn replace(&mut self, next: (u64, u64)) -> (u64, u64) {
- self.data.push(next);
- self.remove()
- }
-}
diff --git a/src/uu/factor/src/cli.rs b/src/uu/factor/src/cli.rs
deleted file mode 100644
index 0b50599aef7235999ad4cc0e28be72e64ac23259..0000000000000000000000000000000000000000
--- a/src/uu/factor/src/cli.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) 2014 T. Jameson Little <t.jameson.little@gmail.com>
-// * (c) 2020 nicoo <nicoo@debian.org>
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
-
-use std::error::Error;
-use std::fmt::Write as FmtWrite;
-use std::io::BufRead;
-use std::io::{self, stdin, stdout, Write};
-
-mod factor;
-use clap::{crate_version, Arg, ArgAction, Command};
-pub use factor::*;
-use uucore::display::Quotable;
-use uucore::error::UResult;
-use uucore::{show_error, show_warning};
-
-mod miller_rabin;
-pub mod numeric;
-mod rho;
-pub mod table;
-
-static ABOUT: &str = r#"Print the prime factors of the given NUMBER(s).
-If none are specified, read from standard input."#;
-
-mod options {
- pub static NUMBER: &str = "NUMBER";
-}
-
-fn print_factors_str(
- num_str: &str,
- w: &mut io::BufWriter<impl io::Write>,
- factors_buffer: &mut String,
-) -> Result<(), Box<dyn Error>> {
- num_str
- .trim()
- .parse::<u64>()
- .map_err(|e| e.into())
- .and_then(|x| {
- factors_buffer.clear();
- writeln!(factors_buffer, "{}:{}", x, factor(x))?;
- w.write_all(factors_buffer.as_bytes())?;
- Ok(())
- })
-}
-
-#[uucore::main]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let matches = uu_app().try_get_matches_from(args)?;
- let stdout = stdout();
- // We use a smaller buffer here to pass a gnu test. 4KiB appears to be the default pipe size for bash.
- let mut w = io::BufWriter::with_capacity(4 * 1024, stdout.lock());
- let mut factors_buffer = String::new();
-
- if let Some(values) = matches.get_many::<String>(options::NUMBER) {
- for number in values {
- if let Err(e) = print_factors_str(number, &mut w, &mut factors_buffer) {
- show_warning!("{}: {}", number.maybe_quote(), e);
- }
- }
- } else {
- let stdin = stdin();
- let lines = stdin.lock().lines();
- for line in lines {
- for number in line.unwrap().split_whitespace() {
- if let Err(e) = print_factors_str(number, &mut w, &mut factors_buffer) {
- show_warning!("{}: {}", number.maybe_quote(), e);
- }
- }
- }
- }
-
- if let Err(e) = w.flush() {
- show_error!("{}", e);
- }
-
- Ok(())
-}
-
-pub fn uu_app() -> Command {
- Command::new(uucore::util_name())
- .version(crate_version!())
- .about(ABOUT)
- .infer_long_args(true)
- .arg(Arg::new(options::NUMBER).action(ArgAction::Append))
-}
diff --git a/src/uu/factor/src/factor.rs b/src/uu/factor/src/factor.rs
index c776f95ea35f23340cc3d0eac131874e8b48028e..41fd860b3cea220f5094f21fe79772addfd851f8 100644
--- a/src/uu/factor/src/factor.rs
+++ b/src/uu/factor/src/factor.rs
@@ -1,299 +1,144 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) 2020 nicoo <nicoo@debian.org>
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
-
-use smallvec::SmallVec;
-use std::cell::RefCell;
-use std::fmt;
-
-use crate::numeric::{Arithmetic, Montgomery};
-use crate::{miller_rabin, rho, table};
-
-type Exponent = u8;
-
-#[derive(Clone, Debug, Default)]
-struct Decomposition(SmallVec<[(u64, Exponent); NUM_FACTORS_INLINE]>);
-
-// spell-checker:ignore (names) Erdős–Kac * Erdős Kac
-// The number of factors to inline directly into a `Decomposition` object.
-// As a consequence of the Erdős–Kac theorem, the average number of prime factors
-// of integers < 10²ⵠ≃ 2â¸Â³ is 4, so we can use a slightly higher value.
-const NUM_FACTORS_INLINE: usize = 5;
-
-impl Decomposition {
- fn one() -> Self {
- Self::default()
- }
-
- fn add(&mut self, factor: u64, exp: Exponent) {
- debug_assert!(exp > 0);
-
- if let Some((_, e)) = self.0.iter_mut().find(|(f, _)| *f == factor) {
- *e += exp;
- } else {
- self.0.push((factor, exp));
- }
- }
-
- #[cfg(test)]
- fn product(&self) -> u64 {
- self.0
- .iter()
- .fold(1, |acc, (p, exp)| acc * p.pow(*exp as u32))
- }
-
- fn get(&self, p: u64) -> Option<&(u64, u8)> {
- self.0.iter().find(|(q, _)| *q == p)
- }
-}
-
-impl PartialEq for Decomposition {
- fn eq(&self, other: &Self) -> bool {
- for p in &self.0 {
- if other.get(p.0) != Some(p) {
- return false;
- }
- }
-
- for p in &other.0 {
- if self.get(p.0) != Some(p) {
- return false;
- }
- }
-
- true
- }
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore funcs
+
+use std::collections::BTreeMap;
+use std::io::BufRead;
+use std::io::{self, stdin, stdout, Write};
+
+use clap::{crate_version, Arg, ArgAction, Command};
+use num_bigint::BigUint;
+use num_traits::FromPrimitive;
+use uucore::display::Quotable;
+use uucore::error::{set_exit_code, FromIo, UResult, USimpleError};
+use uucore::{format_usage, help_about, help_usage, show_error, show_warning};
+
+const ABOUT: &str = help_about!("factor.md");
+const USAGE: &str = help_usage!("factor.md");
+
+mod options {
+ pub static EXPONENTS: &str = "exponents";
+ pub static HELP: &str = "help";
+ pub static NUMBER: &str = "NUMBER";
}
-impl Eq for Decomposition {}
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct Factors(RefCell<Decomposition>);
+fn print_factors_str(
+ num_str: &str,
+ w: &mut io::BufWriter<impl io::Write>,
+ print_exponents: bool,
+) -> UResult<()> {
+ let rx = num_str.trim().parse::<num_bigint::BigUint>();
+ let Ok(x) = rx else {
+ // return Ok(). it's non-fatal and we should try the next number.
+ show_warning!("{}: {}", num_str.maybe_quote(), rx.unwrap_err());
+ set_exit_code(1);
+ return Ok(());
+ };
-impl Factors {
- pub fn one() -> Self {
- Self(RefCell::new(Decomposition::one()))
- }
+ let (factorization, remaining) = if x > BigUint::from_u32(1).unwrap() {
+ num_prime::nt_funcs::factors(x.clone(), None)
+ } else {
+ (BTreeMap::new(), None)
+ };
- pub fn add(&mut self, prime: u64, exp: Exponent) {
- debug_assert!(miller_rabin::is_prime(prime));
- self.0.borrow_mut().add(prime, exp);
+ if let Some(_remaining) = remaining {
+ return Err(USimpleError::new(
+ 1,
+ "Factorization incomplete. Remainders exists.",
+ ));
}
- pub fn push(&mut self, prime: u64) {
- self.add(prime, 1);
- }
+ write_result(w, &x, factorization, print_exponents).map_err_context(|| "write error".into())?;
- #[cfg(test)]
- fn product(&self) -> u64 {
- self.0.borrow().product()
- }
+ Ok(())
}
-impl fmt::Display for Factors {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- let v = &mut (self.0).borrow_mut().0;
- v.sort_unstable();
-
- for (p, exp) in v.iter() {
- for _ in 0..*exp {
- write!(f, " {}", p)?;
+fn write_result(
+ w: &mut io::BufWriter<impl Write>,
+ x: &BigUint,
+ factorization: BTreeMap<BigUint, usize>,
+ print_exponents: bool,
+) -> io::Result<()> {
+ write!(w, "{x}:")?;
+ for (factor, n) in factorization {
+ if print_exponents {
+ if n > 1 {
+ write!(w, " {}^{}", factor, n)?;
+ } else {
+ write!(w, " {}", factor)?;
}
- }
-
- Ok(())
- }
-}
-
-fn _factor<A: Arithmetic + miller_rabin::Basis>(num: u64, f: Factors) -> Factors {
- use miller_rabin::Result::*;
-
- // Shadow the name, so the recursion automatically goes from “Big†arithmetic to small.
- let _factor = |n, f| {
- if n < (1 << 32) {
- _factor::<Montgomery<u32>>(n, f)
} else {
- _factor::<A>(n, f)
- }
- };
-
- if num == 1 {
- return f;
- }
-
- let n = A::new(num);
- let divisor = match miller_rabin::test::<A>(n) {
- Prime => {
- #[cfg(feature = "coz")]
- coz::progress!("factor found");
- let mut r = f;
- r.push(num);
- return r;
+ w.write_all(format!(" {}", factor).repeat(n).as_bytes())?;
}
-
- Composite(d) => d,
- Pseudoprime => rho::find_divisor::<A>(n),
- };
-
- let f = _factor(divisor, f);
- _factor(num / divisor, f)
-}
-
-pub fn factor(mut n: u64) -> Factors {
- #[cfg(feature = "coz")]
- coz::begin!("factorization");
- let mut factors = Factors::one();
-
- if n < 2 {
- return factors;
- }
-
- let n_zeros = n.trailing_zeros();
- if n_zeros > 0 {
- factors.add(2, n_zeros as Exponent);
- n >>= n_zeros;
- }
-
- if n == 1 {
- #[cfg(feature = "coz")]
- coz::end!("factorization");
- return factors;
}
-
- table::factor(&mut n, &mut factors);
-
- #[allow(clippy::let_and_return)]
- let r = if n < (1 << 32) {
- _factor::<Montgomery<u32>>(n, factors)
- } else {
- _factor::<Montgomery<u64>>(n, factors)
- };
-
- #[cfg(feature = "coz")]
- coz::end!("factorization");
-
- r
+ writeln!(w)?;
+ w.flush()
}
-#[cfg(test)]
-mod tests {
- use super::{factor, Decomposition, Exponent, Factors};
- use quickcheck::quickcheck;
- use smallvec::smallvec;
- use std::cell::RefCell;
-
- #[test]
- fn factor_2044854919485649() {
- let f = Factors(RefCell::new(Decomposition(smallvec![
- (503, 1),
- (2423, 1),
- (40961, 2)
- ])));
- assert_eq!(factor(f.product()), f);
- }
-
- #[test]
- fn factor_recombines_small() {
- assert!((1..10_000)
- .map(|i| 2 * i + 1)
- .all(|i| factor(i).product() == i));
- }
-
- #[test]
- fn factor_recombines_overflowing() {
- assert!((0..250)
- .map(|i| 2 * i + 2u64.pow(32) + 1)
- .all(|i| factor(i).product() == i));
- }
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+ let matches = uu_app().try_get_matches_from(args)?;
- #[test]
- fn factor_recombines_strong_pseudoprime() {
- // This is a strong pseudoprime (wrt. miller_rabin::BASIS)
- // and triggered a bug in rho::factor's code path handling
- // miller_rabbin::Result::Composite
- let pseudoprime = 17179869183;
- for _ in 0..20 {
- // Repeat the test 20 times, as it only fails some fraction
- // of the time.
- assert!(factor(pseudoprime).product() == pseudoprime);
- }
- }
+ // If matches find --exponents flag than variable print_exponents is true and p^e output format will be used.
+ let print_exponents = matches.get_flag(options::EXPONENTS);
- quickcheck! {
- fn factor_recombines(i: u64) -> bool {
- i == 0 || factor(i).product() == i
- }
+ let stdout = stdout();
+ // We use a smaller buffer here to pass a gnu test. 4KiB appears to be the default pipe size for bash.
+ let mut w = io::BufWriter::with_capacity(4 * 1024, stdout.lock());
- fn recombines_factors(f: Factors) -> () {
- assert_eq!(factor(f.product()), f);
+ if let Some(values) = matches.get_many::<String>(options::NUMBER) {
+ for number in values {
+ print_factors_str(number, &mut w, print_exponents)?;
}
-
- fn exponentiate_factors(f: Factors, e: Exponent) -> () {
- if e == 0 { return; }
- if let Some(fe) = f.product().checked_pow(e.into()) {
- assert_eq!(factor(fe), f ^ e);
- }
- }
- }
-}
-
-#[cfg(test)]
-use rand::{
- distributions::{Distribution, Standard},
- Rng,
-};
-#[cfg(test)]
-impl Distribution<Factors> for Standard {
- fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Factors {
- let mut f = Factors::one();
- let mut g = 1u64;
- let mut n = u64::MAX;
-
- // spell-checker:ignore (names) Adam Kalai * Kalai's
- // Adam Kalai's algorithm for generating uniformly-distributed
- // integers and their factorization.
- //
- // See Generating Random Factored Numbers, Easily, J. Cryptology (2003)
- 'attempt: loop {
- while n > 1 {
- n = rng.gen_range(1..n);
- if miller_rabin::is_prime(n) {
- if let Some(h) = g.checked_mul(n) {
- f.push(n);
- g = h;
- } else {
- // We are overflowing u64, retry
- continue 'attempt;
+ } else {
+ let stdin = stdin();
+ let lines = stdin.lock().lines();
+ for line in lines {
+ match line {
+ Ok(line) => {
+ for number in line.split_whitespace() {
+ print_factors_str(number, &mut w, print_exponents)?;
}
}
+ Err(e) => {
+ set_exit_code(1);
+ show_error!("error reading input: {}", e);
+ return Ok(());
+ }
}
-
- return f;
}
}
-}
-#[cfg(test)]
-impl quickcheck::Arbitrary for Factors {
- fn arbitrary(g: &mut quickcheck::Gen) -> Self {
- factor(u64::arbitrary(g))
+ if let Err(e) = w.flush() {
+ show_error!("{}", e);
}
-}
-
-#[cfg(test)]
-impl std::ops::BitXor<Exponent> for Factors {
- type Output = Self;
- fn bitxor(self, rhs: Exponent) -> Self {
- debug_assert_ne!(rhs, 0);
- let mut r = Self::one();
- for (p, e) in self.0.borrow().0.iter() {
- r.add(*p, rhs * e);
- }
+ Ok(())
+}
- debug_assert_eq!(r.product(), self.product().pow(rhs.into()));
- r
- }
+pub fn uu_app() -> Command {
+ Command::new(uucore::util_name())
+ .version(crate_version!())
+ .about(ABOUT)
+ .override_usage(format_usage(USAGE))
+ .infer_long_args(true)
+ .disable_help_flag(true)
+ .args_override_self(true)
+ .arg(Arg::new(options::NUMBER).action(ArgAction::Append))
+ .arg(
+ Arg::new(options::EXPONENTS)
+ .short('h')
+ .long(options::EXPONENTS)
+ .help("Print factors in the form p^e")
+ .action(ArgAction::SetTrue),
+ )
+ .arg(
+ Arg::new(options::HELP)
+ .long(options::HELP)
+ .help("Print help information.")
+ .action(ArgAction::Help),
+ )
}
diff --git a/src/uu/factor/src/miller_rabin.rs b/src/uu/factor/src/miller_rabin.rs
deleted file mode 100644
index 8906abf59f0a1cbe4be2068e73b65a500bca1407..0000000000000000000000000000000000000000
--- a/src/uu/factor/src/miller_rabin.rs
+++ /dev/null
@@ -1,210 +0,0 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) 2020 nicoo <nicoo@debian.org>
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
-
-// spell-checker:ignore (URL) appspot
-
-use crate::numeric::*;
-
-pub(crate) trait Basis {
- const BASIS: &'static [u64];
-}
-
-impl Basis for Montgomery<u64> {
- // Small set of bases for the Miller-Rabin prime test, valid for all 64b integers;
- // discovered by Jim Sinclair on 2011-04-20, see miller-rabin.appspot.com
- #[allow(clippy::unreadable_literal)]
- const BASIS: &'static [u64] = &[2, 325, 9375, 28178, 450775, 9780504, 1795265022];
-}
-
-impl Basis for Montgomery<u32> {
- // spell-checker:ignore (names) Steve Worley
- // Small set of bases for the Miller-Rabin prime test, valid for all 32b integers;
- // discovered by Steve Worley on 2013-05-27, see miller-rabin.appspot.com
- #[allow(clippy::unreadable_literal)]
- const BASIS: &'static [u64] = &[
- 4230279247111683200,
- 14694767155120705706,
- 16641139526367750375,
- ];
-}
-
-#[derive(Eq, PartialEq)]
-#[must_use = "Ignoring the output of a primality test."]
-pub(crate) enum Result {
- Prime,
- Pseudoprime,
- Composite(u64),
-}
-
-impl Result {
- pub(crate) fn is_prime(&self) -> bool {
- *self == Self::Prime
- }
-}
-
-// Deterministic Miller-Rabin primality-checking algorithm, adapted to extract
-// (some) dividers; it will fail to factor strong pseudoprimes.
-#[allow(clippy::many_single_char_names)]
-pub(crate) fn test<A: Arithmetic + Basis>(m: A) -> Result {
- use self::Result::*;
-
- let n = m.modulus();
- debug_assert!(n > 1);
- debug_assert!(n % 2 != 0);
-
- // n-1 = r 2â±
- let i = (n - 1).trailing_zeros();
- let r = (n - 1) >> i;
-
- let one = m.one();
- let minus_one = m.minus_one();
-
- 'witness: for _a in A::BASIS.iter() {
- let _a = _a % n;
- if _a == 0 {
- continue;
- }
-
- let a = m.to_mod(_a);
-
- // x = a^r mod n
- let mut x = m.pow(a, r);
-
- if x == one || x == minus_one {
- continue;
- }
-
- for _ in 1..i {
- let y = m.mul(x, x);
- if y == one {
- return Composite(gcd(m.to_u64(x) - 1, m.modulus()));
- } else if y == minus_one {
- // This basis element is not a witness of `n` being composite.
- // Keep looking.
- continue 'witness;
- }
- x = y;
- }
-
- return Pseudoprime;
- }
-
- Prime
-}
-
-// Used by build.rs' tests and debug assertions
-#[allow(dead_code)]
-pub(crate) fn is_prime(n: u64) -> bool {
- if n < 2 {
- false
- } else if n % 2 == 0 {
- n == 2
- } else {
- test::<Montgomery<u64>>(Montgomery::new(n)).is_prime()
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use crate::numeric::{traits::DoubleInt, Arithmetic, Montgomery};
- use crate::parametrized_check;
- use quickcheck::quickcheck;
- use std::iter;
- const LARGEST_U64_PRIME: u64 = 0xFFFFFFFFFFFFFFC5;
-
- fn primes() -> impl Iterator<Item = u64> {
- iter::once(2).chain(odd_primes())
- }
-
- fn odd_primes() -> impl Iterator<Item = u64> {
- use crate::table::{NEXT_PRIME, PRIME_INVERSIONS_U64};
- PRIME_INVERSIONS_U64
- .iter()
- .map(|(p, _, _)| *p)
- .chain(iter::once(NEXT_PRIME))
- }
-
- #[test]
- fn largest_prime() {
- assert!(is_prime(LARGEST_U64_PRIME));
- }
-
- #[test]
- fn largest_composites() {
- for i in LARGEST_U64_PRIME + 1..=u64::MAX {
- assert!(!is_prime(i), "2â¶â´ - {} reported prime", u64::MAX - i + 1);
- }
- }
-
- #[test]
- fn two() {
- assert!(is_prime(2));
- }
-
- fn first_primes<A: DoubleInt>()
- where
- Montgomery<A>: Basis,
- {
- for p in odd_primes() {
- assert!(
- test(Montgomery::<A>::new(p)).is_prime(),
- "{} reported composite",
- p
- );
- }
- }
- parametrized_check!(first_primes);
-
- #[test]
- fn one() {
- assert!(!is_prime(1));
- }
- #[test]
- fn zero() {
- assert!(!is_prime(0));
- }
-
- #[test]
- fn first_composites() {
- for (p, q) in primes().zip(odd_primes()) {
- for i in p + 1..q {
- assert!(!is_prime(i), "{} reported prime", i);
- }
- }
- }
-
- #[test]
- fn issue_1556() {
- // 10 425 511 = 2441 × 4271
- assert!(!is_prime(10_425_511));
- }
-
- fn small_semiprimes<A: DoubleInt>()
- where
- Montgomery<A>: Basis,
- {
- for p in odd_primes() {
- for q in odd_primes().take_while(|q| *q <= p) {
- let n = p * q;
- let m = Montgomery::<A>::new(n);
- assert!(!test(m).is_prime(), "{} = {} × {} reported prime", n, p, q);
- }
- }
- }
- parametrized_check!(small_semiprimes);
-
- quickcheck! {
- fn composites(i: u64, j: u64) -> bool {
- // TODO: #1559 factor n > 2^64 - 1
- match i.checked_mul(j) {
- Some(n) => i < 2 || j < 2 || !is_prime(n),
- _ => true,
- }
- }
- }
-}
diff --git a/src/uu/factor/src/numeric/gcd.rs b/src/uu/factor/src/numeric/gcd.rs
deleted file mode 100644
index 089318f480e01bc60625b426b780b9daa783daab..0000000000000000000000000000000000000000
--- a/src/uu/factor/src/numeric/gcd.rs
+++ /dev/null
@@ -1,129 +0,0 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) 2015 Wiktor Kuropatwa <wiktor.kuropatwa@gmail.com>
-// * (c) 2020 nicoo <nicoo@debian.org>
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
-
-// spell-checker:ignore (vars) kgcdab gcdac gcdbc
-
-use std::cmp::min;
-use std::mem::swap;
-
-pub fn gcd(mut u: u64, mut v: u64) -> u64 {
- // Stein's binary GCD algorithm
- // Base cases: gcd(n, 0) = gcd(0, n) = n
- if u == 0 {
- return v;
- } else if v == 0 {
- return u;
- }
-
- // gcd(2Ⱡu, 2ʲ v) = 2ᵠgcd(u, v) with u, v odd and k = min(i, j)
- // 2áµ is the greatest power of two that divides both u and v
- let k = {
- let i = u.trailing_zeros();
- let j = v.trailing_zeros();
- u >>= i;
- v >>= j;
- min(i, j)
- };
-
- loop {
- // Loop invariant: u and v are odd
- debug_assert!(u % 2 == 1, "u = {} is even", u);
- debug_assert!(v % 2 == 1, "v = {} is even", v);
-
- // gcd(u, v) = gcd(|u - v|, min(u, v))
- if u > v {
- swap(&mut u, &mut v);
- }
- v -= u;
-
- if v == 0 {
- // Reached the base case; gcd is 2áµ u
- return u << k;
- }
-
- // gcd(u, 2ʲ v) = gcd(u, v) as u is odd
- v >>= v.trailing_zeros();
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use quickcheck::{quickcheck, TestResult};
-
- quickcheck! {
- fn euclidean(a: u64, b: u64) -> bool {
- // Test against the Euclidean algorithm
- let g = {
- let (mut a, mut b) = (a, b);
- while b > 0 {
- a %= b;
- swap(&mut a, &mut b);
- }
- a
- };
- gcd(a, b) == g
- }
-
- fn one(a: u64) -> bool {
- gcd(1, a) == 1
- }
-
- fn zero(a: u64) -> bool {
- gcd(0, a) == a
- }
-
- fn divisor(a: u64, b: u64) -> TestResult {
- // Test that gcd(a, b) divides a and b, unless a == b == 0
- if a == 0 && b == 0 { return TestResult::discard(); } // restrict test domain to !(a == b == 0)
-
- let g = gcd(a, b);
- TestResult::from_bool( g != 0 && a % g == 0 && b % g == 0 )
- }
-
- fn commutative(a: u64, b: u64) -> bool {
- gcd(a, b) == gcd(b, a)
- }
-
- fn associative(a: u64, b: u64, c: u64) -> bool {
- gcd(a, gcd(b, c)) == gcd(gcd(a, b), c)
- }
-
- fn scalar_multiplication(a: u64, b: u64, k: u64) -> bool {
- // TODO: #1559 factor n > 2^64 - 1
- match (k.checked_mul(a), k.checked_mul(b), k.checked_mul(gcd(a, b))) {
- (Some(ka), Some(kb), Some(kgcdab)) => gcd(ka, kb) == kgcdab,
- _ => true
- }
- }
-
- fn multiplicative(a: u64, b: u64, c: u64) -> bool {
- // TODO: #1559 factor n > 2^64 - 1
- match (a.checked_mul(b), gcd(a, c).checked_mul(gcd(b, c))) {
- (Some(ab), Some(gcdac_gcdbc)) => {
- // gcd(ab, c) = gcd(a, c) gcd(b, c) when a and b coprime
- gcd(a, b) != 1 || gcd(ab, c) == gcdac_gcdbc
- },
- _ => true,
- }
- }
-
- fn linearity(a: u64, b: u64, k: u64) -> bool {
- // TODO: #1559 factor n > 2^64 - 1
- match k.checked_mul(b) {
- Some(kb) => {
- match a.checked_add(kb) {
- Some(a_plus_kb) => gcd(a_plus_kb, b) == gcd(a, b),
- _ => true,
- }
- }
- _ => true,
- }
- }
- }
-}
diff --git a/src/uu/factor/src/numeric/mod.rs b/src/uu/factor/src/numeric/mod.rs
deleted file mode 100644
index d086027b8209af7bd7edc9d3b5fff8eb3ac39d18..0000000000000000000000000000000000000000
--- a/src/uu/factor/src/numeric/mod.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) 2020 nicoo <nicoo@debian.org>
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
-
-mod gcd;
-pub use gcd::gcd;
-
-pub(crate) mod traits;
-
-mod modular_inverse;
-pub(crate) use modular_inverse::modular_inverse;
-
-mod montgomery;
-pub(crate) use montgomery::{Arithmetic, Montgomery};
diff --git a/src/uu/factor/src/numeric/modular_inverse.rs b/src/uu/factor/src/numeric/modular_inverse.rs
deleted file mode 100644
index 5b37a9782111dd16d63114ea7939409b16b3ea2f..0000000000000000000000000000000000000000
--- a/src/uu/factor/src/numeric/modular_inverse.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) 2015 Wiktor Kuropatwa <wiktor.kuropatwa@gmail.com>
-// * (c) 2020 nicoo <nicoo@debian.org>
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
-
-use super::traits::Int;
-
-// extended Euclid algorithm
-// precondition: a is odd
-pub(crate) fn modular_inverse<T: Int>(a: T) -> T {
- let zero = T::zero();
- let one = T::one();
- debug_assert!(a % (one + one) == one, "{:?} is not odd", a);
-
- let mut t = zero;
- let mut new_t = one;
- let mut r = zero;
- let mut new_r = a;
-
- while new_r != zero {
- let quot = if r == zero {
- // special case when we're just starting out
- // This works because we know that
- // a does not divide 2^64, so floor(2^64 / a) == floor((2^64-1) / a);
- T::max_value()
- } else {
- r
- } / new_r;
-
- let new_tp = t.wrapping_sub(".wrapping_mul(&new_t));
- t = new_t;
- new_t = new_tp;
-
- let new_rp = r.wrapping_sub(".wrapping_mul(&new_r));
- r = new_r;
- new_r = new_rp;
- }
-
- debug_assert_eq!(r, one);
- t
-}
-
-#[cfg(test)]
-mod tests {
- use super::{super::traits::Int, *};
- use crate::parametrized_check;
- use quickcheck::quickcheck;
-
- fn small_values<T: Int>() {
- // All odd integers from 1 to 20 000
- let one = T::from(1).unwrap();
- let two = T::from(2).unwrap();
- let mut test_values = (0..10_000)
- .map(|i| T::from(i).unwrap())
- .map(|i| two * i + one);
-
- assert!(test_values.all(|x| x.wrapping_mul(&modular_inverse(x)) == one));
- }
- parametrized_check!(small_values);
-
- quickcheck! {
- fn random_values_u32(n: u32) -> bool {
- match 2_u32.checked_mul(n) {
- Some(n) => modular_inverse(n + 1).wrapping_mul(n + 1) == 1,
- _ => true,
- }
- }
-
- fn random_values_u64(n: u64) -> bool {
- match 2_u64.checked_mul(n) {
- Some(n) => modular_inverse(n + 1).wrapping_mul(n + 1) == 1,
- _ => true,
- }
- }
- }
-}
diff --git a/src/uu/factor/src/numeric/montgomery.rs b/src/uu/factor/src/numeric/montgomery.rs
deleted file mode 100644
index 368a711822fe8047d5a379ac5fbb325ed011d771..0000000000000000000000000000000000000000
--- a/src/uu/factor/src/numeric/montgomery.rs
+++ /dev/null
@@ -1,229 +0,0 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) 2020 Alex Lyon <arcterus@mail.com>
-// * (c) 2020 nicoo <nicoo@debian.org>
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
-
-use super::*;
-
-use traits::{DoubleInt, Int, One, OverflowingAdd, Zero};
-
-pub(crate) trait Arithmetic: Copy + Sized {
- // The type of integers mod m, in some opaque representation
- type ModInt: Copy + Sized + Eq;
-
- fn new(m: u64) -> Self;
- fn modulus(&self) -> u64;
- fn to_mod(&self, n: u64) -> Self::ModInt;
- fn to_u64(&self, n: Self::ModInt) -> u64;
- fn add(&self, a: Self::ModInt, b: Self::ModInt) -> Self::ModInt;
- fn mul(&self, a: Self::ModInt, b: Self::ModInt) -> Self::ModInt;
-
- fn pow(&self, mut a: Self::ModInt, mut b: u64) -> Self::ModInt {
- let (_a, _b) = (a, b);
- let mut result = self.one();
- while b > 0 {
- if b & 1 != 0 {
- result = self.mul(result, a);
- }
- a = self.mul(a, a);
- b >>= 1;
- }
-
- // Check that r (reduced back to the usual representation) equals
- // a^b % n, unless the latter computation overflows
- // Temporarily commented-out, as there u64::checked_pow is not available
- // on the minimum supported Rust version, nor is an appropriate method
- // for compiling the check conditionally.
- //debug_assert!(self
- // .to_u64(_a)
- // .checked_pow(_b as u32)
- // .map(|r| r % self.modulus() == self.to_u64(result))
- // .unwrap_or(true));
-
- result
- }
-
- fn one(&self) -> Self::ModInt {
- self.to_mod(1)
- }
- fn minus_one(&self) -> Self::ModInt {
- self.to_mod(self.modulus() - 1)
- }
- fn zero(&self) -> Self::ModInt {
- self.to_mod(0)
- }
-}
-
-#[derive(Clone, Copy, Debug)]
-pub(crate) struct Montgomery<T: DoubleInt> {
- a: T,
- n: T,
-}
-
-impl<T: DoubleInt> Montgomery<T> {
- /// computes x/R mod n efficiently
- fn reduce(&self, x: T::DoubleWidth) -> T {
- let t_bits = T::zero().count_zeros() as usize;
-
- debug_assert!(x < (self.n.as_double_width()) << t_bits);
- // TODO: optimize
- let Self { a, n } = self;
- let m = T::from_double_width(x).wrapping_mul(a);
- let nm = (n.as_double_width()) * (m.as_double_width());
- let (xnm, overflow) = x.overflowing_add(&nm); // x + n*m
- debug_assert_eq!(
- xnm % (T::DoubleWidth::one() << T::zero().count_zeros() as usize),
- T::DoubleWidth::zero()
- );
-
- // (x + n*m) / R
- // in case of overflow, this is (2¹²⸠+ xnm)/2â¶â´ - n = xnm/2â¶â´ + (2â¶â´ - n)
- let y = T::from_double_width(xnm >> t_bits)
- + if !overflow {
- T::zero()
- } else {
- n.wrapping_neg()
- };
-
- if y >= *n {
- y - *n
- } else {
- y
- }
- }
-}
-
-impl<T: DoubleInt> Arithmetic for Montgomery<T> {
- // Montgomery transform, R=2â¶â´
- // Provides fast arithmetic mod n (n odd, u64)
- type ModInt = T;
-
- fn new(n: u64) -> Self {
- debug_assert!(T::zero().count_zeros() >= 64 || n < (1 << T::zero().count_zeros() as usize));
- let n = T::from_u64(n);
- let a = modular_inverse(n).wrapping_neg();
- debug_assert_eq!(n.wrapping_mul(&a), T::one().wrapping_neg());
- Self { a, n }
- }
-
- fn modulus(&self) -> u64 {
- self.n.as_u64()
- }
-
- fn to_mod(&self, x: u64) -> Self::ModInt {
- // TODO: optimise!
- debug_assert!(x < self.n.as_u64());
- let r = T::from_double_width(
- ((T::DoubleWidth::from_u64(x)) << T::zero().count_zeros() as usize)
- % self.n.as_double_width(),
- );
- debug_assert_eq!(x, self.to_u64(r));
- r
- }
-
- fn to_u64(&self, n: Self::ModInt) -> u64 {
- self.reduce(n.as_double_width()).as_u64()
- }
-
- fn add(&self, a: Self::ModInt, b: Self::ModInt) -> Self::ModInt {
- let (r, overflow) = a.overflowing_add(&b);
-
- // In case of overflow, a+b = 2â¶â´ + r = (2â¶â´ - n) + r (working mod n)
- let r = if !overflow {
- r
- } else {
- r + self.n.wrapping_neg()
- };
-
- // Normalize to [0; n[
- let r = if r < self.n { r } else { r - self.n };
-
- // Check that r (reduced back to the usual representation) equals
- // a+b % n
- #[cfg(debug_assertions)]
- {
- let a_r = self.to_u64(a) as u128;
- let b_r = self.to_u64(b) as u128;
- let r_r = self.to_u64(r);
- let r_2 = ((a_r + b_r) % self.n.as_u128()) as u64;
- debug_assert_eq!(
- r_r, r_2,
- "[{}] = {} ≠{} = {} + {} = [{}] + [{}] mod {}; a = {}",
- r, r_r, r_2, a_r, b_r, a, b, self.n, self.a
- );
- }
- r
- }
-
- fn mul(&self, a: Self::ModInt, b: Self::ModInt) -> Self::ModInt {
- let r = self.reduce(a.as_double_width() * b.as_double_width());
-
- // Check that r (reduced back to the usual representation) equals
- // a*b % n
- #[cfg(debug_assertions)]
- {
- let a_r = self.to_u64(a) as u128;
- let b_r = self.to_u64(b) as u128;
- let r_r = self.to_u64(r);
- let r_2: u64 = ((a_r * b_r) % self.n.as_u128()) as u64;
- debug_assert_eq!(
- r_r, r_2,
- "[{}] = {} ≠{} = {} * {} = [{}] * [{}] mod {}; a = {}",
- r, r_r, r_2, a_r, b_r, a, b, self.n, self.a
- );
- }
- r
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use crate::parametrized_check;
-
- fn test_add<A: DoubleInt>() {
- for n in 0..100 {
- let n = 2 * n + 1;
- let m = Montgomery::<A>::new(n);
- for x in 0..n {
- let m_x = m.to_mod(x);
- for y in 0..=x {
- let m_y = m.to_mod(y);
- println!("{n:?}, {x:?}, {y:?}", n = n, x = x, y = y);
- assert_eq!((x + y) % n, m.to_u64(m.add(m_x, m_y)));
- }
- }
- }
- }
- parametrized_check!(test_add);
-
- fn test_multiplication<A: DoubleInt>() {
- for n in 0..100 {
- let n = 2 * n + 1;
- let m = Montgomery::<A>::new(n);
- for x in 0..n {
- let m_x = m.to_mod(x);
- for y in 0..=x {
- let m_y = m.to_mod(y);
- assert_eq!((x * y) % n, m.to_u64(m.mul(m_x, m_y)));
- }
- }
- }
- }
- parametrized_check!(test_multiplication);
-
- fn test_roundtrip<A: DoubleInt>() {
- for n in 0..100 {
- let n = 2 * n + 1;
- let m = Montgomery::<A>::new(n);
- for x in 0..n {
- let x_ = m.to_mod(x);
- assert_eq!(x, m.to_u64(x_));
- }
- }
- }
- parametrized_check!(test_roundtrip);
-}
diff --git a/src/uu/factor/src/numeric/traits.rs b/src/uu/factor/src/numeric/traits.rs
deleted file mode 100644
index 1dc681976389c9052c6dc1a9ec909422ea451e9a..0000000000000000000000000000000000000000
--- a/src/uu/factor/src/numeric/traits.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) 2020 Alex Lyon <arcterus@mail.com>
-// * (c) 2020 nicoo <nicoo@debian.org>
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
-
-pub(crate) use num_traits::{
- identities::{One, Zero},
- ops::overflowing::OverflowingAdd,
-};
-use num_traits::{
- int::PrimInt,
- ops::wrapping::{WrappingMul, WrappingNeg, WrappingSub},
-};
-use std::fmt::{Debug, Display};
-
-pub(crate) trait Int:
- Display + Debug + PrimInt + OverflowingAdd + WrappingNeg + WrappingSub + WrappingMul
-{
- fn as_u64(&self) -> u64;
- fn from_u64(n: u64) -> Self;
-
- #[cfg(debug_assertions)]
- fn as_u128(&self) -> u128;
-}
-
-pub(crate) trait DoubleInt: Int {
- /// An integer type with twice the width of `Self`.
- /// In particular, multiplications (of `Int` values) can be performed in
- /// `Self::DoubleWidth` without possibility of overflow.
- type DoubleWidth: Int;
-
- fn as_double_width(self) -> Self::DoubleWidth;
- fn from_double_width(n: Self::DoubleWidth) -> Self;
-}
-
-macro_rules! int {
- ( $x:ty ) => {
- impl Int for $x {
- fn as_u64(&self) -> u64 {
- *self as u64
- }
- fn from_u64(n: u64) -> Self {
- n as _
- }
- #[cfg(debug_assertions)]
- fn as_u128(&self) -> u128 {
- *self as u128
- }
- }
- };
-}
-macro_rules! double_int {
- ( $x:ty, $y:ty ) => {
- int!($x);
- impl DoubleInt for $x {
- type DoubleWidth = $y;
-
- fn as_double_width(self) -> $y {
- self as _
- }
- fn from_double_width(n: $y) -> Self {
- n as _
- }
- }
- };
-}
-double_int!(u32, u64);
-double_int!(u64, u128);
-int!(u128);
-
-/// Helper macro for instantiating tests over u32 and u64
-#[cfg(test)]
-#[macro_export]
-macro_rules! parametrized_check {
- ( $f:ident ) => {
- paste::item! {
- #[test]
- fn [< $f _ u32 >]() {
- $f::<u32>()
- }
- #[test]
- fn [< $f _ u64 >]() {
- $f::<u64>()
- }
- }
- };
-}
diff --git a/src/uu/factor/src/rho.rs b/src/uu/factor/src/rho.rs
deleted file mode 100644
index e7aa00b4d9fede3dcee4b0a30be537e88f7211d7..0000000000000000000000000000000000000000
--- a/src/uu/factor/src/rho.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) 2015 Wiktor Kuropatwa <wiktor.kuropatwa@gmail.com>
-// * (c) 2020 nicoo <nicoo@debian.org>
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
-
-use rand::distributions::{Distribution, Uniform};
-use rand::rngs::SmallRng;
-use rand::{thread_rng, SeedableRng};
-use std::cmp::{max, min};
-
-use crate::numeric::*;
-
-pub(crate) fn find_divisor<A: Arithmetic>(n: A) -> u64 {
- #![allow(clippy::many_single_char_names)]
- let mut rand = {
- let range = Uniform::new(1, n.modulus());
- let mut rng = SmallRng::from_rng(&mut thread_rng()).unwrap();
- move || n.to_mod(range.sample(&mut rng))
- };
-
- let quadratic = |a, b| move |x| n.add(n.mul(a, n.mul(x, x)), b);
-
- loop {
- let f = quadratic(rand(), rand());
- let mut x = rand();
- let mut y = x;
-
- loop {
- x = f(x);
- y = f(f(y));
- let d = {
- let _x = n.to_u64(x);
- let _y = n.to_u64(y);
- gcd(n.modulus(), max(_x, _y) - min(_x, _y))
- };
- if d == n.modulus() {
- // Failure, retry with a different quadratic
- break;
- } else if d > 1 {
- return d;
- }
- }
- }
-}
diff --git a/src/uu/factor/src/table.rs b/src/uu/factor/src/table.rs
deleted file mode 100644
index 0fb338d9d7ee8171a10e221e121c62d10182ff4f..0000000000000000000000000000000000000000
--- a/src/uu/factor/src/table.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) 2015 kwantam <kwantam@gmail.com>
-// * (c) 2020 nicoo <nicoo@debian.org>
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
-
-// spell-checker: ignore (ToDO) INVS
-
-use crate::Factors;
-
-include!(concat!(env!("OUT_DIR"), "/prime_table.rs"));
-
-pub fn factor(num: &mut u64, factors: &mut Factors) {
- for &(prime, inv, ceil) in PRIME_INVERSIONS_U64 {
- if *num == 1 {
- break;
- }
-
- // inv = prime^-1 mod 2^64
- // ceil = floor((2^64-1) / prime)
- // if (num * inv) mod 2^64 <= ceil, then prime divides num
- // See https://math.stackexchange.com/questions/1251327/
- // for a nice explanation.
- let mut k = 0;
- loop {
- let x = num.wrapping_mul(inv);
-
- // While prime divides num
- if x <= ceil {
- *num = x;
- k += 1;
- #[cfg(feature = "coz")]
- coz::progress!("factor found");
- } else {
- if k > 0 {
- factors.add(prime, k);
- }
- break;
- }
- }
- }
-}
-
-pub const CHUNK_SIZE: usize = 8;
-pub fn factor_chunk(n_s: &mut [u64; CHUNK_SIZE], f_s: &mut [Factors; CHUNK_SIZE]) {
- for &(prime, inv, ceil) in PRIME_INVERSIONS_U64 {
- if n_s[0] == 1 && n_s[1] == 1 && n_s[2] == 1 && n_s[3] == 1 {
- break;
- }
-
- for (num, factors) in n_s.iter_mut().zip(f_s.iter_mut()) {
- if *num == 1 {
- continue;
- }
- let mut k = 0;
- loop {
- let x = num.wrapping_mul(inv);
-
- // While prime divides num
- if x <= ceil {
- *num = x;
- k += 1;
- } else {
- if k > 0 {
- factors.add(prime, k);
- }
- break;
- }
- }
- }
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use crate::Factors;
- use quickcheck::quickcheck;
- use rand::{rngs::SmallRng, Rng, SeedableRng};
-
- quickcheck! {
- fn chunk_vs_iter(seed: u64) -> () {
- let mut rng = SmallRng::seed_from_u64(seed);
- let mut n_c: [u64; CHUNK_SIZE] = rng.gen();
- let mut f_c: [Factors; CHUNK_SIZE] = rng.gen();
-
- let mut n_i = n_c;
- let mut f_i = f_c.clone();
- for (n, f) in n_i.iter_mut().zip(f_i.iter_mut()) {
- factor(n, f);
- }
-
- factor_chunk(&mut n_c, &mut f_c);
-
- assert_eq!(n_i, n_c);
- assert_eq!(f_i, f_c);
- }
- }
-}
diff --git a/src/uu/false/Cargo.toml b/src/uu/false/Cargo.toml
index 848d872aaa55b1e01cfdacfabc7332172d157a84..37f13ec7a3f42a3dae7dde8895ba63344b0d30a5 100644
--- a/src/uu/false/Cargo.toml
+++ b/src/uu/false/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_false"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "false ~ (uutils) do nothing and fail"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/false.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "false"
diff --git a/src/uu/false/false.md b/src/uu/false/false.md
new file mode 100644
index 0000000000000000000000000000000000000000..3f0594767f2b3f309f4a14173b5f56763d8ac614
--- /dev/null
+++ b/src/uu/false/false.md
@@ -0,0 +1,11 @@
+# false
+
+```
+false
+```
+
+Returns false, an unsuccessful exit status.
+
+Immediately returns with the exit status `1`. When invoked with one of the recognized options it
+will try to write the help or version text. Any IO error during this operation is diagnosed, yet
+the program will also return `1`.
diff --git a/src/uu/false/src/false.rs b/src/uu/false/src/false.rs
index 3a74142e0e597fa93b4955937baf4777224714d3..3ae25e5696d5803e8ca73d163d02bf2584388600 100644
--- a/src/uu/false/src/false.rs
+++ b/src/uu/false/src/false.rs
@@ -1,20 +1,13 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Jordi Boggiano <j.boggiano@seld.be>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use clap::{Arg, ArgAction, Command};
use std::{ffi::OsString, io::Write};
use uucore::error::{set_exit_code, UResult};
+use uucore::help_about;
-static ABOUT: &str = "\
-Returns false, an unsuccessful exit status.
-
-Immediately returns with the exit status `1`. When invoked with one of the recognized options it
-will try to write the help or version text. Any IO error during this operation is diagnosed, yet
-the program will also return `1`.
-";
+const ABOUT: &str = help_about!("false.md");
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
diff --git a/src/uu/fmt/Cargo.toml b/src/uu/fmt/Cargo.toml
index 5f644950819e04c16fdf55ad078a647cc9307291..8d6dea64e2f2f2d3283472a384239538717e1810 100644
--- a/src/uu/fmt/Cargo.toml
+++ b/src/uu/fmt/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_fmt"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "fmt ~ (uutils) reformat each paragraph of input"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/fmt.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-unicode-width = "0.1.5"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+unicode-width = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "fmt"
diff --git a/src/uu/fmt/fmt.md b/src/uu/fmt/fmt.md
new file mode 100644
index 0000000000000000000000000000000000000000..6ed7d3048a5db91f60d87fea66db229787147147
--- /dev/null
+++ b/src/uu/fmt/fmt.md
@@ -0,0 +1,7 @@
+# fmt
+
+```
+fmt [-WIDTH] [OPTION]... [FILE]...
+```
+
+Reformat paragraphs from input files (or stdin) to stdout.
diff --git a/src/uu/fmt/src/fmt.rs b/src/uu/fmt/src/fmt.rs
index a97f6494531c8174fb5222b24db230a459666259..77858b041ebb17a1281ac5e1d1c9965622a1dc4a 100644
--- a/src/uu/fmt/src/fmt.rs
+++ b/src/uu/fmt/src/fmt.rs
@@ -1,58 +1,58 @@
-// * This file is part of `fmt` from the uutils coreutils package.
-// *
-// * (c) kwantam <kwantam@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) PSKIP linebreak ostream parasplit tabwidth xanti xprefix
-use clap::{crate_version, Arg, ArgAction, Command};
-use std::cmp;
+use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
use std::fs::File;
-use std::io::{stdin, stdout, Write};
-use std::io::{BufReader, BufWriter, Read};
+use std::io::{stdin, stdout, BufReader, BufWriter, Read, Stdout, Write};
use uucore::display::Quotable;
-use uucore::error::{FromIo, UResult, USimpleError};
-use uucore::{format_usage, show_warning};
+use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
+use uucore::{format_usage, help_about, help_usage};
-use self::linebreak::break_lines;
-use self::parasplit::ParagraphStream;
+use linebreak::break_lines;
+use parasplit::ParagraphStream;
mod linebreak;
mod parasplit;
-static ABOUT: &str = "Reformat paragraphs from input files (or stdin) to stdout.";
-const USAGE: &str = "{} [OPTION]... [FILE]...";
-static MAX_WIDTH: usize = 2500;
-
-static OPT_CROWN_MARGIN: &str = "crown-margin";
-static OPT_TAGGED_PARAGRAPH: &str = "tagged-paragraph";
-static OPT_PRESERVE_HEADERS: &str = "preserve-headers";
-static OPT_SPLIT_ONLY: &str = "split-only";
-static OPT_UNIFORM_SPACING: &str = "uniform-spacing";
-static OPT_PREFIX: &str = "prefix";
-static OPT_SKIP_PREFIX: &str = "skip-prefix";
-static OPT_EXACT_PREFIX: &str = "exact-prefix";
-static OPT_EXACT_SKIP_PREFIX: &str = "exact-skip-prefix";
-static OPT_WIDTH: &str = "width";
-static OPT_GOAL: &str = "goal";
-static OPT_QUICK: &str = "quick";
-static OPT_TAB_WIDTH: &str = "tab-width";
-
-static ARG_FILES: &str = "files";
+const ABOUT: &str = help_about!("fmt.md");
+const USAGE: &str = help_usage!("fmt.md");
+const MAX_WIDTH: usize = 2500;
+const DEFAULT_GOAL: usize = 70;
+const DEFAULT_WIDTH: usize = 75;
+// by default, goal is 93% of width
+const DEFAULT_GOAL_TO_WIDTH_RATIO: usize = 93;
+
+mod options {
+ pub const CROWN_MARGIN: &str = "crown-margin";
+ pub const TAGGED_PARAGRAPH: &str = "tagged-paragraph";
+ pub const PRESERVE_HEADERS: &str = "preserve-headers";
+ pub const SPLIT_ONLY: &str = "split-only";
+ pub const UNIFORM_SPACING: &str = "uniform-spacing";
+ pub const PREFIX: &str = "prefix";
+ pub const SKIP_PREFIX: &str = "skip-prefix";
+ pub const EXACT_PREFIX: &str = "exact-prefix";
+ pub const EXACT_SKIP_PREFIX: &str = "exact-skip-prefix";
+ pub const WIDTH: &str = "width";
+ pub const GOAL: &str = "goal";
+ pub const QUICK: &str = "quick";
+ pub const TAB_WIDTH: &str = "tab-width";
+ pub const FILES_OR_WIDTH: &str = "files";
+}
pub type FileOrStdReader = BufReader<Box<dyn Read + 'static>>;
+
pub struct FmtOptions {
crown: bool,
tagged: bool,
mail: bool,
split_only: bool,
- use_prefix: bool,
- prefix: String,
+ prefix: Option<String>,
xprefix: bool,
- use_anti_prefix: bool,
- anti_prefix: String,
+ anti_prefix: Option<String>,
xanti_prefix: bool,
uniform: bool,
quick: bool,
@@ -61,155 +61,260 @@ pub struct FmtOptions {
tabwidth: usize,
}
-#[uucore::main]
-#[allow(clippy::cognitive_complexity)]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let matches = uu_app().try_get_matches_from(args)?;
-
- let mut files: Vec<String> = matches
- .get_many::<String>(ARG_FILES)
- .map(|v| v.map(ToString::to_string).collect())
- .unwrap_or_default();
-
- let mut fmt_opts = FmtOptions {
- crown: false,
- tagged: false,
- mail: false,
- uniform: false,
- quick: false,
- split_only: false,
- use_prefix: false,
- prefix: String::new(),
- xprefix: false,
- use_anti_prefix: false,
- anti_prefix: String::new(),
- xanti_prefix: false,
- width: 79,
- goal: 74,
- tabwidth: 8,
- };
-
- fmt_opts.tagged = matches.get_flag(OPT_TAGGED_PARAGRAPH);
- if matches.get_flag(OPT_CROWN_MARGIN) {
- fmt_opts.crown = true;
- fmt_opts.tagged = false;
- }
- fmt_opts.mail = matches.get_flag(OPT_PRESERVE_HEADERS);
- fmt_opts.uniform = matches.get_flag(OPT_UNIFORM_SPACING);
- fmt_opts.quick = matches.get_flag(OPT_QUICK);
- if matches.get_flag(OPT_SPLIT_ONLY) {
- fmt_opts.split_only = true;
- fmt_opts.crown = false;
- fmt_opts.tagged = false;
- }
- fmt_opts.xprefix = matches.contains_id(OPT_EXACT_PREFIX);
- fmt_opts.xanti_prefix = matches.contains_id(OPT_SKIP_PREFIX);
-
- if let Some(s) = matches.get_one::<String>(OPT_PREFIX).map(String::from) {
- fmt_opts.prefix = s;
- fmt_opts.use_prefix = true;
- };
-
- if let Some(s) = matches.get_one::<String>(OPT_SKIP_PREFIX).map(String::from) {
- fmt_opts.anti_prefix = s;
- fmt_opts.use_anti_prefix = true;
- };
-
- if let Some(s) = matches.get_one::<String>(OPT_WIDTH) {
- fmt_opts.width = match s.parse::<usize>() {
- Ok(t) => t,
- Err(e) => {
- return Err(USimpleError::new(
- 1,
- format!("Invalid WIDTH specification: {}: {}", s.quote(), e),
- ));
+impl FmtOptions {
+ fn from_matches(matches: &ArgMatches) -> UResult<Self> {
+ let mut tagged = matches.get_flag(options::TAGGED_PARAGRAPH);
+ let mut crown = matches.get_flag(options::CROWN_MARGIN);
+
+ let mail = matches.get_flag(options::PRESERVE_HEADERS);
+ let uniform = matches.get_flag(options::UNIFORM_SPACING);
+ let quick = matches.get_flag(options::QUICK);
+ let split_only = matches.get_flag(options::SPLIT_ONLY);
+
+ if crown {
+ tagged = false;
+ }
+ if split_only {
+ crown = false;
+ tagged = false;
+ }
+
+ let xprefix = matches.contains_id(options::EXACT_PREFIX);
+ let xanti_prefix = matches.contains_id(options::SKIP_PREFIX);
+
+ let prefix = matches.get_one::<String>(options::PREFIX).map(String::from);
+ let anti_prefix = matches
+ .get_one::<String>(options::SKIP_PREFIX)
+ .map(String::from);
+
+ let width_opt = extract_width(matches)?;
+ let goal_opt_str = matches.get_one::<String>(options::GOAL);
+ let goal_opt = if let Some(goal_str) = goal_opt_str {
+ match goal_str.parse::<usize>() {
+ Ok(goal) => Some(goal),
+ Err(_) => {
+ return Err(USimpleError::new(
+ 1,
+ format!("invalid goal: {}", goal_str.quote()),
+ ));
+ }
}
+ } else {
+ None
};
- if fmt_opts.width > MAX_WIDTH {
+
+ let (width, goal) = match (width_opt, goal_opt) {
+ (Some(w), Some(g)) => {
+ if g > w {
+ return Err(USimpleError::new(1, "GOAL cannot be greater than WIDTH."));
+ }
+ (w, g)
+ }
+ (Some(w), None) => {
+ // Only allow a goal of zero if the width is set to be zero
+ let g = (w * DEFAULT_GOAL_TO_WIDTH_RATIO / 100).max(if w == 0 { 0 } else { 1 });
+ (w, g)
+ }
+ (None, Some(g)) => {
+ if g > DEFAULT_WIDTH {
+ return Err(USimpleError::new(1, "GOAL cannot be greater than WIDTH."));
+ }
+ let w = (g * 100 / DEFAULT_GOAL_TO_WIDTH_RATIO).max(g + 3);
+ (w, g)
+ }
+ (None, None) => (DEFAULT_WIDTH, DEFAULT_GOAL),
+ };
+ debug_assert!(width >= goal, "GOAL {goal} should not be greater than WIDTH {width} when given {width_opt:?} and {goal_opt:?}.");
+
+ if width > MAX_WIDTH {
return Err(USimpleError::new(
1,
- format!(
- "invalid width: '{}': Numerical result out of range",
- fmt_opts.width,
- ),
+ format!("invalid width: '{}': Numerical result out of range", width),
));
}
- fmt_opts.goal = cmp::min(fmt_opts.width * 94 / 100, fmt_opts.width - 3);
- };
-
- if let Some(s) = matches.get_one::<String>(OPT_GOAL) {
- fmt_opts.goal = match s.parse::<usize>() {
- Ok(t) => t,
- Err(e) => {
- return Err(USimpleError::new(
- 1,
- format!("Invalid GOAL specification: {}: {}", s.quote(), e),
- ));
- }
+
+ let mut tabwidth = 8;
+ if let Some(s) = matches.get_one::<String>(options::TAB_WIDTH) {
+ tabwidth = match s.parse::<usize>() {
+ Ok(t) => t,
+ Err(e) => {
+ return Err(USimpleError::new(
+ 1,
+ format!("Invalid TABWIDTH specification: {}: {}", s.quote(), e),
+ ));
+ }
+ };
};
- if !matches.get_flag(OPT_WIDTH) {
- fmt_opts.width = cmp::max(fmt_opts.goal * 100 / 94, fmt_opts.goal + 3);
- } else if fmt_opts.goal > fmt_opts.width {
- return Err(USimpleError::new(1, "GOAL cannot be greater than WIDTH."));
+
+ if tabwidth < 1 {
+ tabwidth = 1;
}
- };
-
- if let Some(s) = matches.get_one::<String>(OPT_TAB_WIDTH) {
- fmt_opts.tabwidth = match s.parse::<usize>() {
- Ok(t) => t,
- Err(e) => {
- return Err(USimpleError::new(
- 1,
- format!("Invalid TABWIDTH specification: {}: {}", s.quote(), e),
- ));
- }
- };
- };
- if fmt_opts.tabwidth < 1 {
- fmt_opts.tabwidth = 1;
+ Ok(Self {
+ crown,
+ tagged,
+ mail,
+ uniform,
+ quick,
+ split_only,
+ prefix,
+ xprefix,
+ anti_prefix,
+ xanti_prefix,
+ width,
+ goal,
+ tabwidth,
+ })
}
+}
- // immutable now
- let fmt_opts = fmt_opts;
+/// Process the content of a file and format it according to the provided options.
+///
+/// # Arguments
+///
+/// * `file_name` - The name of the file to process. A value of "-" represents the standard input.
+/// * `fmt_opts` - A reference to a `FmtOptions` struct containing the formatting options.
+/// * `ostream` - A mutable reference to a `BufWriter` wrapping the standard output.
+///
+/// # Returns
+///
+/// A `UResult<()>` indicating success or failure.
+fn process_file(
+ file_name: &str,
+ fmt_opts: &FmtOptions,
+ ostream: &mut BufWriter<Stdout>,
+) -> UResult<()> {
+ let mut fp = BufReader::new(match file_name {
+ "-" => Box::new(stdin()) as Box<dyn Read + 'static>,
+ _ => {
+ let f = File::open(file_name)
+ .map_err_context(|| format!("cannot open {} for reading", file_name.quote()))?;
+ Box::new(f) as Box<dyn Read + 'static>
+ }
+ });
- if files.is_empty() {
- files.push("-".to_owned());
+ let p_stream = ParagraphStream::new(fmt_opts, &mut fp);
+ for para_result in p_stream {
+ match para_result {
+ Err(s) => {
+ ostream
+ .write_all(s.as_bytes())
+ .map_err_context(|| "failed to write output".to_string())?;
+ ostream
+ .write_all(b"\n")
+ .map_err_context(|| "failed to write output".to_string())?;
+ }
+ Ok(para) => break_lines(¶, fmt_opts, ostream)
+ .map_err_context(|| "failed to write output".to_string())?,
+ }
}
- let mut ostream = BufWriter::new(stdout());
+ // flush the output after each file
+ ostream
+ .flush()
+ .map_err_context(|| "failed to write output".to_string())?;
- for i in files.iter().map(|x| &x[..]) {
- let mut fp = match i {
- "-" => BufReader::new(Box::new(stdin()) as Box<dyn Read + 'static>),
- _ => match File::open(i) {
- Ok(f) => BufReader::new(Box::new(f) as Box<dyn Read + 'static>),
- Err(e) => {
- show_warning!("{}: {}", i.maybe_quote(), e);
- continue;
- }
- },
- };
- let p_stream = ParagraphStream::new(&fmt_opts, &mut fp);
- for para_result in p_stream {
- match para_result {
- Err(s) => {
- ostream
- .write_all(s.as_bytes())
- .map_err_context(|| "failed to write output".to_string())?;
- ostream
- .write_all(b"\n")
- .map_err_context(|| "failed to write output".to_string())?;
+ Ok(())
+}
+
+/// Extract the file names from the positional arguments, ignoring any negative width in the first
+/// position.
+///
+/// # Returns
+/// A `UResult<()>` with the file names, or an error if one of the file names could not be parsed
+/// (e.g., it is given as a negative number not in the first argument and not after a --
+fn extract_files(matches: &ArgMatches) -> UResult<Vec<String>> {
+ let in_first_pos = matches
+ .index_of(options::FILES_OR_WIDTH)
+ .is_some_and(|x| x == 1);
+ let is_neg = |s: &str| s.parse::<isize>().is_ok_and(|w| w < 0);
+
+ let files: UResult<Vec<String>> = matches
+ .get_many::<String>(options::FILES_OR_WIDTH)
+ .into_iter()
+ .flatten()
+ .enumerate()
+ .filter_map(|(i, x)| {
+ if is_neg(x) {
+ if in_first_pos && i == 0 {
+ None
+ } else {
+ let first_num = x.chars().nth(1).expect("a negative number should be at least two characters long");
+ Some(Err(
+ UUsageError::new(1, format!("invalid option -- {}; -WIDTH is recognized only when it is the first\noption; use -w N instead", first_num))
+ ))
}
- Ok(para) => break_lines(¶, &fmt_opts, &mut ostream)
- .map_err_context(|| "failed to write output".to_string())?,
+ } else {
+ Some(Ok(x.clone()))
}
+ })
+ .collect();
+
+ if files.as_ref().is_ok_and(|f| f.is_empty()) {
+ Ok(vec!["-".into()])
+ } else {
+ files
+ }
+}
+
+fn extract_width(matches: &ArgMatches) -> UResult<Option<usize>> {
+ let width_opt = matches.get_one::<String>(options::WIDTH);
+ if let Some(width_str) = width_opt {
+ if let Ok(width) = width_str.parse::<usize>() {
+ return Ok(Some(width));
+ } else {
+ return Err(USimpleError::new(
+ 1,
+ format!("invalid width: {}", width_str.quote()),
+ ));
+ }
+ }
+
+ if let Some(1) = matches.index_of(options::FILES_OR_WIDTH) {
+ let width_arg = matches.get_one::<String>(options::FILES_OR_WIDTH).unwrap();
+ if let Some(num) = width_arg.strip_prefix('-') {
+ Ok(num.parse::<usize>().ok())
+ } else {
+ // will be treated as a file name
+ Ok(None)
+ }
+ } else {
+ Ok(None)
+ }
+}
+
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+ let args: Vec<_> = args.collect();
+
+ // Warn the user if it looks like we're trying to pass a number in the first
+ // argument with non-numeric characters
+ if let Some(first_arg) = args.get(1) {
+ let first_arg = first_arg.to_string_lossy();
+ let malformed_number = first_arg.starts_with('-')
+ && first_arg.chars().nth(1).is_some_and(|c| c.is_ascii_digit())
+ && first_arg.chars().skip(2).any(|c| !c.is_ascii_digit());
+ if malformed_number {
+ return Err(USimpleError::new(
+ 1,
+ format!(
+ "invalid width: {}",
+ first_arg.strip_prefix('-').unwrap().quote()
+ ),
+ ));
}
+ }
- // flush the output after each file
- ostream
- .flush()
- .map_err_context(|| "failed to write output".to_string())?;
+ let matches = uu_app().try_get_matches_from(&args)?;
+
+ let files = extract_files(&matches)?;
+
+ let fmt_opts = FmtOptions::from_matches(&matches)?;
+
+ let mut ostream = BufWriter::new(stdout());
+
+ for file_name in &files {
+ process_file(file_name, &fmt_opts, &mut ostream)?;
}
Ok(())
@@ -221,10 +326,11 @@ pub fn uu_app() -> Command {
.about(ABOUT)
.override_usage(format_usage(USAGE))
.infer_long_args(true)
+ .args_override_self(true)
.arg(
- Arg::new(OPT_CROWN_MARGIN)
+ Arg::new(options::CROWN_MARGIN)
.short('c')
- .long(OPT_CROWN_MARGIN)
+ .long(options::CROWN_MARGIN)
.help(
"First and second line of paragraph \
may have different indentations, in which \
@@ -234,7 +340,7 @@ pub fn uu_app() -> Command {
.action(ArgAction::SetTrue),
)
.arg(
- Arg::new(OPT_TAGGED_PARAGRAPH)
+ Arg::new(options::TAGGED_PARAGRAPH)
.short('t')
.long("tagged-paragraph")
.help(
@@ -244,7 +350,7 @@ pub fn uu_app() -> Command {
.action(ArgAction::SetTrue),
)
.arg(
- Arg::new(OPT_PRESERVE_HEADERS)
+ Arg::new(options::PRESERVE_HEADERS)
.short('m')
.long("preserve-headers")
.help(
@@ -254,14 +360,14 @@ pub fn uu_app() -> Command {
.action(ArgAction::SetTrue),
)
.arg(
- Arg::new(OPT_SPLIT_ONLY)
+ Arg::new(options::SPLIT_ONLY)
.short('s')
.long("split-only")
.help("Split lines only, do not reflow.")
.action(ArgAction::SetTrue),
)
.arg(
- Arg::new(OPT_UNIFORM_SPACING)
+ Arg::new(options::UNIFORM_SPACING)
.short('u')
.long("uniform-spacing")
.help(
@@ -274,7 +380,7 @@ pub fn uu_app() -> Command {
.action(ArgAction::SetTrue),
)
.arg(
- Arg::new(OPT_PREFIX)
+ Arg::new(options::PREFIX)
.short('p')
.long("prefix")
.help(
@@ -286,7 +392,7 @@ pub fn uu_app() -> Command {
.value_name("PREFIX"),
)
.arg(
- Arg::new(OPT_SKIP_PREFIX)
+ Arg::new(options::SKIP_PREFIX)
.short('P')
.long("skip-prefix")
.help(
@@ -297,7 +403,7 @@ pub fn uu_app() -> Command {
.value_name("PSKIP"),
)
.arg(
- Arg::new(OPT_EXACT_PREFIX)
+ Arg::new(options::EXACT_PREFIX)
.short('x')
.long("exact-prefix")
.help(
@@ -307,7 +413,7 @@ pub fn uu_app() -> Command {
.action(ArgAction::SetTrue),
)
.arg(
- Arg::new(OPT_EXACT_SKIP_PREFIX)
+ Arg::new(options::EXACT_SKIP_PREFIX)
.short('X')
.long("exact-skip-prefix")
.help(
@@ -317,21 +423,23 @@ pub fn uu_app() -> Command {
.action(ArgAction::SetTrue),
)
.arg(
- Arg::new(OPT_WIDTH)
+ Arg::new(options::WIDTH)
.short('w')
.long("width")
- .help("Fill output lines up to a maximum of WIDTH columns, default 79.")
+ .help("Fill output lines up to a maximum of WIDTH columns, default 75. This can be specified as a negative number in the first argument.")
+ // We must accept invalid values if they are overridden later. This is not supported by clap, so accept all strings instead.
.value_name("WIDTH"),
)
.arg(
- Arg::new(OPT_GOAL)
+ Arg::new(options::GOAL)
.short('g')
.long("goal")
- .help("Goal width, default ~0.94*WIDTH. Must be less than WIDTH.")
+ .help("Goal width, default of 93% of WIDTH. Must be less than or equal to WIDTH.")
+ // We must accept invalid values if they are overridden later. This is not supported by clap, so accept all strings instead.
.value_name("GOAL"),
)
.arg(
- Arg::new(OPT_QUICK)
+ Arg::new(options::QUICK)
.short('q')
.long("quick")
.help(
@@ -341,7 +449,7 @@ pub fn uu_app() -> Command {
.action(ArgAction::SetTrue),
)
.arg(
- Arg::new(OPT_TAB_WIDTH)
+ Arg::new(options::TAB_WIDTH)
.short('T')
.long("tab-width")
.help(
@@ -352,8 +460,64 @@ pub fn uu_app() -> Command {
.value_name("TABWIDTH"),
)
.arg(
- Arg::new(ARG_FILES)
+ Arg::new(options::FILES_OR_WIDTH)
.action(ArgAction::Append)
- .value_hint(clap::ValueHint::FilePath),
+ .value_name("FILES")
+ .value_hint(clap::ValueHint::FilePath)
+ .allow_negative_numbers(true),
)
}
+
+#[cfg(test)]
+mod tests {
+ use crate::uu_app;
+ use crate::{extract_files, extract_width};
+
+ #[test]
+ fn parse_negative_width() {
+ let matches = uu_app()
+ .try_get_matches_from(vec!["fmt", "-3", "some-file"])
+ .unwrap();
+
+ assert_eq!(extract_files(&matches).unwrap(), vec!["some-file"]);
+ assert_eq!(extract_width(&matches).ok(), Some(Some(3)));
+ }
+
+ #[test]
+ fn parse_width_as_arg() {
+ let matches = uu_app()
+ .try_get_matches_from(vec!["fmt", "-w3", "some-file"])
+ .unwrap();
+
+ assert_eq!(extract_files(&matches).unwrap(), vec!["some-file"]);
+ assert_eq!(extract_width(&matches).ok(), Some(Some(3)));
+ }
+
+ #[test]
+ fn parse_no_args() {
+ let matches = uu_app().try_get_matches_from(vec!["fmt"]).unwrap();
+
+ assert_eq!(extract_files(&matches).unwrap(), vec!["-"]);
+ assert_eq!(extract_width(&matches).ok(), Some(None));
+ }
+
+ #[test]
+ fn parse_just_file_name() {
+ let matches = uu_app()
+ .try_get_matches_from(vec!["fmt", "some-file"])
+ .unwrap();
+
+ assert_eq!(extract_files(&matches).unwrap(), vec!["some-file"]);
+ assert_eq!(extract_width(&matches).ok(), Some(None));
+ }
+
+ #[test]
+ fn parse_with_both_widths_positional_first() {
+ let matches = uu_app()
+ .try_get_matches_from(vec!["fmt", "-10", "-w3", "some-file"])
+ .unwrap();
+
+ assert_eq!(extract_files(&matches).unwrap(), vec!["some-file"]);
+ assert_eq!(extract_width(&matches).ok(), Some(Some(3)));
+ }
+}
diff --git a/src/uu/fmt/src/linebreak.rs b/src/uu/fmt/src/linebreak.rs
index 75a5f81ac7738dc060a50e3b6187b7b5b6d8565e..aa1477ebac05ac92d763b865ce34780dbf1bf3f4 100644
--- a/src/uu/fmt/src/linebreak.rs
+++ b/src/uu/fmt/src/linebreak.rs
@@ -1,18 +1,12 @@
-// * This file is part of `fmt` from the uutils coreutils package.
-// *
-// * (c) kwantam <kwantam@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) INFTY MULT accum breakwords linebreak linebreaking linebreaks linelen maxlength minlength nchars ostream overlen parasplit plass posn powf punct signum slen sstart tabwidth tlen underlen winfo wlen wordlen
-use std::cmp;
-use std::i64;
use std::io::{BufWriter, Stdout, Write};
-use std::mem;
-
-use uucore::crash;
+use std::{cmp, mem};
use crate::parasplit::{ParaWords, Paragraph, WordInfo};
use crate::FmtOptions;
@@ -27,7 +21,7 @@ struct BreakArgs<'a> {
}
impl<'a> BreakArgs<'a> {
- fn compute_width<'b>(&self, winfo: &WordInfo<'b>, posn: usize, fresh: bool) -> usize {
+ fn compute_width(&self, winfo: &WordInfo, posn: usize, fresh: bool) -> usize {
if fresh {
0
} else {
@@ -48,7 +42,7 @@ pub fn break_lines(
ostream: &mut BufWriter<Stdout>,
) -> std::io::Result<()> {
// indent
- let p_indent = ¶.indent_str[..];
+ let p_indent = ¶.indent_str;
let p_indent_len = para.indent_len;
// words
@@ -57,14 +51,12 @@ pub fn break_lines(
// the first word will *always* appear on the first line
// make sure of this here
- let (w, w_len) = match p_words_words.next() {
- Some(winfo) => (winfo.word, winfo.word_nchars),
- None => {
- return ostream.write_all(b"\n");
- }
+ let Some(winfo) = p_words_words.next() else {
+ return ostream.write_all(b"\n");
};
+
// print the init, if it exists, and get its length
- let p_init_len = w_len
+ let p_init_len = winfo.word_nchars
+ if opts.crown || opts.tagged {
// handle "init" portion
ostream.write_all(para.init_str.as_bytes())?;
@@ -77,8 +69,9 @@ pub fn break_lines(
// except that mail headers get no indent at all
0
};
+
// write first word after writing init
- ostream.write_all(w.as_bytes())?;
+ ostream.write_all(winfo.word.as_bytes())?;
// does this paragraph require uniform spacing?
let uniform = para.mail_header || opts.uniform;
@@ -105,15 +98,16 @@ fn break_simple<'a, T: Iterator<Item = &'a WordInfo<'a>>>(
mut iter: T,
args: &mut BreakArgs<'a>,
) -> std::io::Result<()> {
- iter.try_fold((args.init_len, false), |l, winfo| {
- accum_words_simple(args, l, winfo)
+ iter.try_fold((args.init_len, false), |(l, prev_punct), winfo| {
+ accum_words_simple(args, l, prev_punct, winfo)
})?;
args.ostream.write_all(b"\n")
}
fn accum_words_simple<'a>(
args: &mut BreakArgs<'a>,
- (l, prev_punct): (usize, bool),
+ l: usize,
+ prev_punct: bool,
winfo: &'a WordInfo<'a>,
) -> std::io::Result<(usize, bool)> {
// compute the length of this word, considering how tabs will expand at this position on the line
@@ -223,6 +217,7 @@ struct LineBreak<'a> {
fresh: bool,
}
+#[allow(clippy::cognitive_complexity)]
fn find_kp_breakpoints<'a, T: Iterator<Item = &'a WordInfo<'a>>>(
iter: T,
args: &BreakArgs<'a>,
@@ -234,25 +229,22 @@ fn find_kp_breakpoints<'a, T: Iterator<Item = &'a WordInfo<'a>>>(
linebreak: None,
break_before: false,
demerits: 0,
- prev_rat: 0.0f32,
+ prev_rat: 0.0,
length: args.init_len,
fresh: false,
}];
// this vec holds the current active linebreaks; next_ holds the breaks that will be active for
// the next word
- let active_breaks = &mut vec![0];
- let next_active_breaks = &mut vec![];
+ let mut active_breaks = vec![0];
+ let mut next_active_breaks = vec![];
- let stretch = (args.opts.width - args.opts.goal) as isize;
- let minlength = args.opts.goal - stretch as usize;
+ let stretch = args.opts.width - args.opts.goal;
+ let minlength = args.opts.goal.max(stretch + 1) - stretch;
let mut new_linebreaks = vec![];
let mut is_sentence_start = false;
let mut least_demerits = 0;
loop {
- let w = match iter.next() {
- None => break,
- Some(w) => w,
- };
+ let Some(w) = iter.next() else { break };
// if this is the last word, we don't add additional demerits for this break
let (is_last_word, is_sentence_end) = match iter.peek() {
@@ -274,6 +266,7 @@ fn find_kp_breakpoints<'a, T: Iterator<Item = &'a WordInfo<'a>>>(
next_active_breaks.clear();
// go through each active break, extending it and possibly adding a new active
// break if we are above the minimum required length
+ #[allow(clippy::explicit_iter_loop)]
for &i in active_breaks.iter() {
let active = &mut linebreaks[i];
// normalize demerits to avoid overflow, and record if this is the least
@@ -307,7 +300,7 @@ fn find_kp_breakpoints<'a, T: Iterator<Item = &'a WordInfo<'a>>>(
compute_demerits(
args.opts.goal as isize - tlen as isize,
stretch,
- w.word_nchars as isize,
+ w.word_nchars,
active.prev_rat,
)
};
@@ -358,38 +351,36 @@ fn find_kp_breakpoints<'a, T: Iterator<Item = &'a WordInfo<'a>>>(
least_demerits = cmp::max(ld_next, 0);
}
// swap in new list of active breaks
- mem::swap(active_breaks, next_active_breaks);
+ mem::swap(&mut active_breaks, &mut next_active_breaks);
// If this was the last word in a sentence, the next one must be the first in the next.
is_sentence_start = is_sentence_end;
}
// return the best path
- build_best_path(&linebreaks, active_breaks)
+ build_best_path(&linebreaks, &active_breaks)
}
fn build_best_path<'a>(paths: &[LineBreak<'a>], active: &[usize]) -> Vec<(&'a WordInfo<'a>, bool)> {
- let mut breakwords = vec![];
// of the active paths, we select the one with the fewest demerits
- let mut best_idx = match active.iter().min_by_key(|&&a| paths[a].demerits) {
- None => crash!(
- 1,
- "Failed to find a k-p linebreak solution. This should never happen."
- ),
- Some(&s) => s,
- };
-
- // now, chase the pointers back through the break list, recording
- // the words at which we should break
- loop {
- let next_best = &paths[best_idx];
- match next_best.linebreak {
- None => return breakwords,
- Some(prev) => {
- breakwords.push((prev, next_best.break_before));
- best_idx = next_best.prev;
+ active
+ .iter()
+ .min_by_key(|&&a| paths[a].demerits)
+ .map(|&(mut best_idx)| {
+ let mut breakwords = vec![];
+ // now, chase the pointers back through the break list, recording
+ // the words at which we should break
+ loop {
+ let next_best = &paths[best_idx];
+ match next_best.linebreak {
+ None => return breakwords,
+ Some(prev) => {
+ breakwords.push((prev, next_best.break_before));
+ best_idx = next_best.prev;
+ }
+ }
}
- }
- }
+ })
+ .unwrap_or_default()
}
// "infinite" badness is more like (1+BAD_INFTY)^2 because of how demerits are computed
@@ -402,7 +393,7 @@ const DR_MULT: f32 = 600.0;
// DL_MULT is penalty multiplier for short words at end of line
const DL_MULT: f32 = 300.0;
-fn compute_demerits(delta_len: isize, stretch: isize, wlen: isize, prev_rat: f32) -> (i64, f32) {
+fn compute_demerits(delta_len: isize, stretch: usize, wlen: usize, prev_rat: f32) -> (i64, f32) {
// how much stretch are we using?
let ratio = if delta_len == 0 {
0.0f32
@@ -428,7 +419,7 @@ fn compute_demerits(delta_len: isize, stretch: isize, wlen: isize, prev_rat: f32
};
// we penalize lines that have very different ratios from previous lines
- let bad_delta_r = (DR_MULT * (((ratio - prev_rat) / 2.0).powi(3)).abs()) as i64;
+ let bad_delta_r = (DR_MULT * ((ratio - prev_rat) / 2.0).powi(3).abs()) as i64;
let demerits = i64::pow(1 + bad_linelen + bad_wordlen + bad_delta_r, 2);
@@ -449,8 +440,8 @@ fn restart_active_breaks<'a>(
} else {
// choose the lesser evil: breaking too early, or breaking too late
let wlen = w.word_nchars + args.compute_width(w, active.length, active.fresh);
- let underlen = (min - active.length) as isize;
- let overlen = ((wlen + slen + active.length) - args.opts.width) as isize;
+ let underlen = min as isize - active.length as isize;
+ let overlen = (wlen + slen + active.length) as isize - args.opts.width as isize;
if overlen > underlen {
// break early, put this word on the next line
(true, args.indent_len + w.word_nchars)
diff --git a/src/uu/fmt/src/parasplit.rs b/src/uu/fmt/src/parasplit.rs
index c60be0a47dfbc4496ba9abfe97defd30fb300c2e..1ae8ea34f425da8c79186383b10225b45592edcb 100644
--- a/src/uu/fmt/src/parasplit.rs
+++ b/src/uu/fmt/src/parasplit.rs
@@ -1,11 +1,9 @@
-// * This file is part of `fmt` from the uutils coreutils package.
-// *
-// * (c) kwantam <kwantam@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-// spell-checker:ignore (ToDO) INFTY MULT PSKIP accum aftertab beforetab breakwords fmt's formatline linebreak linebreaking linebreaks linelen maxlength minlength nchars noformat noformatline ostream overlen parasplit pfxind plass pmatch poffset posn powf prefixindent punct signum slen sstart tabwidth tlen underlen winfo wlen wordlen wordsplits xanti xprefix
+// spell-checker:ignore (ToDO) INFTY MULT PSKIP accum aftertab beforetab breakwords fmt's formatline linebreak linebreaking linebreaks linelen maxlength minlength nchars noformat noformatline ostream overlen parasplit plass pmatch poffset posn powf prefixindent punct signum slen sstart tabwidth tlen underlen winfo wlen wordlen wordsplits xanti xprefix
use std::io::{BufRead, Lines};
use std::iter::Peekable;
@@ -54,18 +52,22 @@ impl Line {
}
}
-// each line's prefix has to be considered to know whether to merge it with
-// the next line or not
+/// Each line's prefix has to be considered to know whether to merge it with
+/// the next line or not
#[derive(Debug)]
pub struct FileLine {
line: String,
- indent_end: usize, // the end of the indent, always the start of the text
- pfxind_end: usize, // the end of the PREFIX's indent, that is, the spaces before the prefix
- indent_len: usize, // display length of indent taking into account tabs
- prefix_len: usize, // PREFIX indent length taking into account tabs
+ /// The end of the indent, always the start of the text
+ indent_end: usize,
+ /// The end of the PREFIX's indent, that is, the spaces before the prefix
+ prefix_indent_end: usize,
+ /// Display length of indent taking into account tabs
+ indent_len: usize,
+ /// PREFIX indent length taking into account tabs
+ prefix_len: usize,
}
-// iterator that produces a stream of Lines from a file
+/// Iterator that produces a stream of Lines from a file
pub struct FileLines<'a> {
opts: &'a FmtOptions,
lines: Lines<&'a mut FileOrStdReader>,
@@ -76,26 +78,22 @@ impl<'a> FileLines<'a> {
FileLines { opts, lines }
}
- // returns true if this line should be formatted
+ /// returns true if this line should be formatted
fn match_prefix(&self, line: &str) -> (bool, usize) {
- if !self.opts.use_prefix {
+ let Some(prefix) = &self.opts.prefix else {
return (true, 0);
- }
+ };
- FileLines::match_prefix_generic(&self.opts.prefix[..], line, self.opts.xprefix)
+ FileLines::match_prefix_generic(prefix, line, self.opts.xprefix)
}
- // returns true if this line should be formatted
+ /// returns true if this line should be formatted
fn match_anti_prefix(&self, line: &str) -> bool {
- if !self.opts.use_anti_prefix {
+ let Some(anti_prefix) = &self.opts.anti_prefix else {
return true;
- }
+ };
- match FileLines::match_prefix_generic(
- &self.opts.anti_prefix[..],
- line,
- self.opts.xanti_prefix,
- ) {
+ match FileLines::match_prefix_generic(anti_prefix, line, self.opts.xanti_prefix) {
(true, _) => false,
(_, _) => true,
}
@@ -150,13 +148,7 @@ impl<'a> Iterator for FileLines<'a> {
type Item = Line;
fn next(&mut self) -> Option<Line> {
- let n = match self.lines.next() {
- Some(t) => match t {
- Ok(tt) => tt,
- Err(_) => return None,
- },
- None => return None,
- };
+ let n = self.lines.next()?.ok()?;
// if this line is entirely whitespace,
// emit a blank line
@@ -180,7 +172,7 @@ impl<'a> Iterator for FileLines<'a> {
// not truly blank we will not allow mail headers on the
// following line)
if pmatch
- && n[poffset + self.opts.prefix.len()..]
+ && n[poffset + self.opts.prefix.as_ref().map_or(0, |s| s.len())..]
.chars()
.all(char::is_whitespace)
{
@@ -194,37 +186,46 @@ impl<'a> Iterator for FileLines<'a> {
}
// figure out the indent, prefix, and prefixindent ending points
- let prefix_end = poffset + self.opts.prefix.len();
+ let prefix_end = poffset + self.opts.prefix.as_ref().map_or(0, |s| s.len());
let (indent_end, prefix_len, indent_len) = self.compute_indent(&n[..], prefix_end);
Some(Line::FormatLine(FileLine {
line: n,
indent_end,
- pfxind_end: poffset,
+ prefix_indent_end: poffset,
indent_len,
prefix_len,
}))
}
}
-// a paragraph : a collection of FileLines that are to be formatted
-// plus info about the paragraph's indentation
-// (but we only retain the String from the FileLine; the other info
-// is only there to help us in deciding how to merge lines into Paragraphs
+/// A paragraph : a collection of FileLines that are to be formatted
+/// plus info about the paragraph's indentation
+///
+/// We only retain the String from the FileLine; the other info
+/// is only there to help us in deciding how to merge lines into Paragraphs
#[derive(Debug)]
pub struct Paragraph {
- lines: Vec<String>, // the lines of the file
- pub init_str: String, // string representing the init, that is, the first line's indent
- pub init_len: usize, // printable length of the init string considering TABWIDTH
- init_end: usize, // byte location of end of init in first line String
- pub indent_str: String, // string representing indent
- pub indent_len: usize, // length of above
- indent_end: usize, // byte location of end of indent (in crown and tagged mode, only applies to 2nd line and onward)
- pub mail_header: bool, // we need to know if this is a mail header because we do word splitting differently in that case
+ /// the lines of the file
+ lines: Vec<String>,
+ /// string representing the init, that is, the first line's indent
+ pub init_str: String,
+ /// printable length of the init string considering TABWIDTH
+ pub init_len: usize,
+ /// byte location of end of init in first line String
+ init_end: usize,
+ /// string representing indent
+ pub indent_str: String,
+ /// length of above
+ pub indent_len: usize,
+ /// byte location of end of indent (in crown and tagged mode, only applies to 2nd line and onward)
+ indent_end: usize,
+ /// we need to know if this is a mail header because we do word splitting differently in that case
+ pub mail_header: bool,
}
-// an iterator producing a stream of paragraphs from a stream of lines
-// given a set of options.
+/// An iterator producing a stream of paragraphs from a stream of lines
+/// given a set of options.
pub struct ParagraphStream<'a> {
lines: Peekable<FileLines<'a>>,
next_mail: bool,
@@ -242,7 +243,7 @@ impl<'a> ParagraphStream<'a> {
}
}
- // detect RFC822 mail header
+ /// Detect RFC822 mail header
fn is_mail_header(line: &FileLine) -> bool {
// a mail header begins with either "From " (envelope sender line)
// or with a sequence of printable ASCII chars (33 to 126, inclusive,
@@ -275,14 +276,12 @@ impl<'a> ParagraphStream<'a> {
impl<'a> Iterator for ParagraphStream<'a> {
type Item = Result<Paragraph, String>;
+ #[allow(clippy::cognitive_complexity)]
fn next(&mut self) -> Option<Result<Paragraph, String>> {
// return a NoFormatLine in an Err; it should immediately be output
- let noformat = match self.lines.peek() {
- None => return None,
- Some(l) => match *l {
- Line::FormatLine(_) => false,
- Line::NoFormatLine(_, _) => true,
- },
+ let noformat = match self.lines.peek()? {
+ Line::FormatLine(_) => false,
+ Line::NoFormatLine(_, _) => true,
};
// found a NoFormatLine, immediately dump it out
@@ -300,101 +299,95 @@ impl<'a> Iterator for ParagraphStream<'a> {
let mut indent_end = 0;
let mut indent_len = 0;
let mut prefix_len = 0;
- let mut pfxind_end = 0;
+ let mut prefix_indent_end = 0;
let mut p_lines = Vec::new();
let mut in_mail = false;
let mut second_done = false; // for when we use crown or tagged mode
loop {
- {
- // peek ahead
- // need to explicitly force fl out of scope before we can call self.lines.next()
- let fl = match self.lines.peek() {
- None => break,
- Some(l) => match *l {
- Line::FormatLine(ref x) => x,
- Line::NoFormatLine(..) => break,
- },
- };
+ // peek ahead
+ // need to explicitly force fl out of scope before we can call self.lines.next()
+ let Some(Line::FormatLine(fl)) = self.lines.peek() else {
+ break;
+ };
- if p_lines.is_empty() {
- // first time through the loop, get things set up
- // detect mail header
- if self.opts.mail && self.next_mail && ParagraphStream::is_mail_header(fl) {
- in_mail = true;
- // there can't be any indent or pfxind because otherwise is_mail_header
- // would fail since there cannot be any whitespace before the colon in a
- // valid header field
- indent_str.push_str(" ");
- indent_len = 2;
+ if p_lines.is_empty() {
+ // first time through the loop, get things set up
+ // detect mail header
+ if self.opts.mail && self.next_mail && ParagraphStream::is_mail_header(fl) {
+ in_mail = true;
+ // there can't be any indent or prefixindent because otherwise is_mail_header
+ // would fail since there cannot be any whitespace before the colon in a
+ // valid header field
+ indent_str.push_str(" ");
+ indent_len = 2;
+ } else {
+ if self.opts.crown || self.opts.tagged {
+ init_str.push_str(&fl.line[..fl.indent_end]);
+ init_len = fl.indent_len;
+ init_end = fl.indent_end;
} else {
- if self.opts.crown || self.opts.tagged {
- init_str.push_str(&fl.line[..fl.indent_end]);
- init_len = fl.indent_len;
- init_end = fl.indent_end;
- } else {
- second_done = true;
- }
-
- // these will be overwritten in the 2nd line of crown or tagged mode, but
- // we are not guaranteed to get to the 2nd line, e.g., if the next line
- // is a NoFormatLine or None. Thus, we set sane defaults the 1st time around
- indent_str.push_str(&fl.line[..fl.indent_end]);
- indent_len = fl.indent_len;
- indent_end = fl.indent_end;
-
- // save these to check for matching lines
- prefix_len = fl.prefix_len;
- pfxind_end = fl.pfxind_end;
-
- // in tagged mode, add 4 spaces of additional indenting by default
- // (gnu fmt's behavior is different: it seems to find the closest column to
- // indent_end that is divisible by 3. But honestly that behavior seems
- // pretty arbitrary.
- // Perhaps a better default would be 1 TABWIDTH? But ugh that's so big.
- if self.opts.tagged {
- indent_str.push_str(" ");
- indent_len += 4;
- }
- }
- } else if in_mail {
- // lines following mail headers must begin with spaces
- if fl.indent_end == 0 || (self.opts.use_prefix && fl.pfxind_end == 0) {
- break; // this line does not begin with spaces
- }
- } else if !second_done {
- // now we have enough info to handle crown margin and tagged mode
-
- // in both crown and tagged modes we require that prefix_len is the same
- if prefix_len != fl.prefix_len || pfxind_end != fl.pfxind_end {
- break;
+ second_done = true;
}
- // in tagged mode, indent has to be *different* on following lines
- if self.opts.tagged
- && indent_len - 4 == fl.indent_len
- && indent_end == fl.indent_end
- {
- break;
- }
-
- // this is part of the same paragraph, get the indent info from this line
- indent_str.clear();
+ // these will be overwritten in the 2nd line of crown or tagged mode, but
+ // we are not guaranteed to get to the 2nd line, e.g., if the next line
+ // is a NoFormatLine or None. Thus, we set sane defaults the 1st time around
indent_str.push_str(&fl.line[..fl.indent_end]);
indent_len = fl.indent_len;
indent_end = fl.indent_end;
- second_done = true;
- } else {
- // detect mismatch
- if indent_end != fl.indent_end
- || pfxind_end != fl.pfxind_end
- || indent_len != fl.indent_len
- || prefix_len != fl.prefix_len
- {
- break;
+ // save these to check for matching lines
+ prefix_len = fl.prefix_len;
+ prefix_indent_end = fl.prefix_indent_end;
+
+ // in tagged mode, add 4 spaces of additional indenting by default
+ // (gnu fmt's behavior is different: it seems to find the closest column to
+ // indent_end that is divisible by 3. But honestly that behavior seems
+ // pretty arbitrary.
+ // Perhaps a better default would be 1 TABWIDTH? But ugh that's so big.
+ if self.opts.tagged {
+ indent_str.push_str(" ");
+ indent_len += 4;
}
}
+ } else if in_mail {
+ // lines following mail headers must begin with spaces
+ if fl.indent_end == 0 || (self.opts.prefix.is_some() && fl.prefix_indent_end == 0) {
+ break; // this line does not begin with spaces
+ }
+ } else if !second_done {
+ // now we have enough info to handle crown margin and tagged mode
+
+ // in both crown and tagged modes we require that prefix_len is the same
+ if prefix_len != fl.prefix_len || prefix_indent_end != fl.prefix_indent_end {
+ break;
+ }
+
+ // in tagged mode, indent has to be *different* on following lines
+ if self.opts.tagged
+ && indent_len - 4 == fl.indent_len
+ && indent_end == fl.indent_end
+ {
+ break;
+ }
+
+ // this is part of the same paragraph, get the indent info from this line
+ indent_str.clear();
+ indent_str.push_str(&fl.line[..fl.indent_end]);
+ indent_len = fl.indent_len;
+ indent_end = fl.indent_end;
+
+ second_done = true;
+ } else {
+ // detect mismatch
+ if indent_end != fl.indent_end
+ || prefix_indent_end != fl.prefix_indent_end
+ || indent_len != fl.indent_len
+ || prefix_len != fl.prefix_len
+ {
+ break;
+ }
}
p_lines.push(self.lines.next().unwrap().get_formatline().line);
@@ -430,7 +423,7 @@ pub struct ParaWords<'a> {
}
impl<'a> ParaWords<'a> {
- pub fn new<'b>(opts: &'b FmtOptions, para: &'b Paragraph) -> ParaWords<'b> {
+ pub fn new(opts: &'a FmtOptions, para: &'a Paragraph) -> Self {
let mut pw = ParaWords {
opts,
para,
@@ -580,11 +573,11 @@ impl<'a> Iterator for WordSplit<'a> {
// points to whitespace character OR end of string
let mut word_nchars = 0;
self.position = match self.string[word_start..].find(|x: char| {
- if !x.is_whitespace() {
+ if x.is_whitespace() {
+ true
+ } else {
word_nchars += char_width(x);
false
- } else {
- true
}
}) {
None => self.length,
@@ -597,7 +590,7 @@ impl<'a> Iterator for WordSplit<'a> {
self.prev_punct && (before_tab.is_some() || word_start_relative > 1);
// now record whether this word ends in punctuation
- self.prev_punct = match self.string[..self.position].chars().rev().next() {
+ self.prev_punct = match self.string[..self.position].chars().next_back() {
Some(ch) => WordSplit::is_punctuation(ch),
_ => panic!("fatal: expected word not to be empty"),
};
diff --git a/src/uu/fold/Cargo.toml b/src/uu/fold/Cargo.toml
index 44fe202f9daee1b42db8dc33fab8515c9fd35437..3176c27161d78951a74b834d7b59e90f2b978324 100644
--- a/src/uu/fold/Cargo.toml
+++ b/src/uu/fold/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_fold"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "fold ~ (uutils) wrap each line of input"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/fold.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "fold"
diff --git a/src/uu/fold/fold.md b/src/uu/fold/fold.md
new file mode 100644
index 0000000000000000000000000000000000000000..13062c8587d83cf8dd97e8c7d97b4fa555c310df
--- /dev/null
+++ b/src/uu/fold/fold.md
@@ -0,0 +1,8 @@
+# fold
+
+```
+fold [OPTION]... [FILE]...
+```
+
+Writes each file (or standard input if no files are given)
+to standard output whilst breaking long lines
diff --git a/src/uu/fold/src/fold.rs b/src/uu/fold/src/fold.rs
index 3b27549b1aca30e2fa7b6304f1b003b18dc9521d..0223248be27357c9804678901f93a0c6fefc2e98 100644
--- a/src/uu/fold/src/fold.rs
+++ b/src/uu/fold/src/fold.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Alex Lyon <arcterus@mail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDOs) ncount routput
@@ -13,13 +11,12 @@ use std::io::{stdin, BufRead, BufReader, Read};
use std::path::Path;
use uucore::display::Quotable;
use uucore::error::{FromIo, UResult, USimpleError};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
const TAB_WIDTH: usize = 8;
-static USAGE: &str = "{} [OPTION]... [FILE]...";
-static ABOUT: &str = "Writes each file (or standard input if no files are given)
- to standard output whilst breaking long lines";
+const USAGE: &str = help_usage!("fold.md");
+const ABOUT: &str = help_about!("fold.md");
mod options {
pub const BYTES: &str = "bytes";
@@ -38,7 +35,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let bytes = matches.get_flag(options::BYTES);
let spaces = matches.get_flag(options::SPACES);
let poss_width = match matches.get_one::<String>(options::WIDTH) {
- Some(v) => Some(v.to_owned()),
+ Some(v) => Some(v.clone()),
None => obs_width,
};
@@ -53,7 +50,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
};
let files = match matches.get_many::<String>(options::FILE) {
- Some(v) => v.map(|v| v.to_owned()).collect(),
+ Some(v) => v.cloned().collect(),
None => vec!["-".to_owned()],
};
@@ -188,9 +185,9 @@ fn fold_file_bytewise<T: Read>(mut file: BufReader<T>, spaces: bool, width: usiz
let at_eol = i >= len;
if at_eol {
- print!("{}", slice);
+ print!("{slice}");
} else {
- println!("{}", slice);
+ println!("{slice}");
}
}
@@ -208,6 +205,7 @@ fn fold_file_bytewise<T: Read>(mut file: BufReader<T>, spaces: bool, width: usiz
///
/// If `spaces` is `true`, attempt to break lines at whitespace boundaries.
#[allow(unused_assignments)]
+#[allow(clippy::cognitive_complexity)]
fn fold_file<T: Read>(mut file: BufReader<T>, spaces: bool, width: usize) -> UResult<()> {
let mut line = String::new();
let mut output = String::new();
@@ -285,7 +283,7 @@ fn fold_file<T: Read>(mut file: BufReader<T>, spaces: bool, width: usize) -> URe
}
if !output.is_empty() {
- print!("{}", output);
+ print!("{output}");
output.truncate(0);
}
diff --git a/src/uu/groups/Cargo.toml b/src/uu/groups/Cargo.toml
index 3dec2ca9ad2ac3cc3086b9c8f62dd38df787aec0..fa4c6313a70562a5aa867cbc85b988be0f51704d 100644
--- a/src/uu/groups/Cargo.toml
+++ b/src/uu/groups/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_groups"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "groups ~ (uutils) display group memberships for USERNAME"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/groups.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["entries", "process"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["entries", "process"] }
[[bin]]
name = "groups"
diff --git a/src/uu/groups/groups.md b/src/uu/groups/groups.md
new file mode 100644
index 0000000000000000000000000000000000000000..1d11d5e46bb6c68c3c5a648207acdf346833e330
--- /dev/null
+++ b/src/uu/groups/groups.md
@@ -0,0 +1,8 @@
+# groups
+
+```
+groups [OPTION]... [USERNAME]...
+```
+
+Print group memberships for each `USERNAME` or, if no `USERNAME` is specified, for
+the current process (which may differ if the groups dataâ€base has changed).
diff --git a/src/uu/groups/src/groups.rs b/src/uu/groups/src/groups.rs
index 4fa53a232ec3d38b1dc8dd7e793dc091ce6bb555..0f0dfce804a638cc499117c162a8e9c2ca098e07 100644
--- a/src/uu/groups/src/groups.rs
+++ b/src/uu/groups/src/groups.rs
@@ -1,8 +1,5 @@
// This file is part of the uutils coreutils package.
//
-// (c) Alan Andrade <alan.andradec@gmail.com>
-// (c) Jian Zeng <anonymousknight96 AT gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
//
@@ -21,7 +18,7 @@ use uucore::{
display::Quotable,
entries::{get_groups_gnu, gid2grp, Locate, Passwd},
error::{UError, UResult},
- format_usage, show,
+ format_usage, help_about, help_usage, show,
};
use clap::{crate_version, Arg, ArgAction, Command};
@@ -29,11 +26,8 @@ use clap::{crate_version, Arg, ArgAction, Command};
mod options {
pub const USERS: &str = "USERNAME";
}
-static ABOUT: &str = "Print group memberships for each USERNAME or, \
- if no USERNAME is specified, for\nthe current process \
- (which may differ if the groups dataâ€base has changed).";
-
-const USAGE: &str = "{} [OPTION]... [USERNAME]...";
+const ABOUT: &str = help_about!("groups.md");
+const USAGE: &str = help_usage!("groups.md");
#[derive(Debug)]
enum GroupsError {
@@ -49,7 +43,7 @@ impl Display for GroupsError {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
Self::GetGroupsFailed => write!(f, "failed to fetch groups"),
- Self::GroupNotFound(gid) => write!(f, "cannot find name for group ID {}", gid),
+ Self::GroupNotFound(gid) => write!(f, "cannot find name for group ID {gid}"),
Self::UserNotFound(user) => write!(f, "{}: no such user", user.quote()),
}
}
diff --git a/src/uu/hashsum/BENCHMARKING.md b/src/uu/hashsum/BENCHMARKING.md
index cef710a1972db00f7323d0f32c696a170ff4c4a8..9508cae1b6600a8bef77444463a2c6182a888abb 100644
--- a/src/uu/hashsum/BENCHMARKING.md
+++ b/src/uu/hashsum/BENCHMARKING.md
@@ -1,9 +1,11 @@
-## Benchmarking hashsum
+# Benchmarking hashsum
-### To bench blake2
+## To bench blake2
-Taken from: https://github.com/uutils/coreutils/pull/2296
+Taken from: <https://github.com/uutils/coreutils/pull/2296>
With a large file:
-$ hyperfine "./target/release/coreutils hashsum --b2sum large-file" "b2sum large-file"
+```shell
+hyperfine "./target/release/coreutils hashsum --b2sum large-file" "b2sum large-file"
+```
diff --git a/src/uu/hashsum/Cargo.toml b/src/uu/hashsum/Cargo.toml
index a57e26c46d1d8f2db4b1cfb34ef7a7996f13cf75..0ea16225b7990782cdace32518bcf91a054bc9b1 100644
--- a/src/uu/hashsum/Cargo.toml
+++ b/src/uu/hashsum/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_hashsum"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "hashsum ~ (uutils) display or check input digests"
@@ -15,18 +15,11 @@ edition = "2021"
path = "src/hashsum.rs"
[dependencies]
-digest = "0.10.6"
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-hex = "0.4.3"
-memchr = "2"
-md-5 = "0.10.5"
-regex = "1.7.0"
-sha1 = "0.10.1"
-sha2 = "0.10.2"
-sha3 = "0.10.6"
-blake2b_simd = "1.0.0"
-blake3 = "1.3.1"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["checksum", "sum"] }
+memchr = { workspace = true }
+regex = { workspace = true }
+hex = { workspace = true }
[[bin]]
name = "hashsum"
diff --git a/src/uu/hashsum/hashsum.md b/src/uu/hashsum/hashsum.md
new file mode 100644
index 0000000000000000000000000000000000000000..a632eedf3d91c9d036c71fbc86a28ed818bdb68b
--- /dev/null
+++ b/src/uu/hashsum/hashsum.md
@@ -0,0 +1,7 @@
+# hashsum
+
+```
+hashsum [OPTIONS] [FILE]...
+```
+
+Compute and check message digests.
diff --git a/src/uu/hashsum/src/digest.rs b/src/uu/hashsum/src/digest.rs
deleted file mode 100644
index df3bfc16616dd23f81c394545da614b0916ca898..0000000000000000000000000000000000000000
--- a/src/uu/hashsum/src/digest.rs
+++ /dev/null
@@ -1,287 +0,0 @@
-// spell-checker:ignore memmem
-//! Implementations of digest functions, like md5 and sha1.
-//!
-//! The [`Digest`] trait represents the interface for providing inputs
-//! to these digest functions and accessing the resulting hash. The
-//! [`DigestWriter`] struct provides a wrapper around [`Digest`] that
-//! implements the [`Write`] trait, for use in situations where calling
-//! [`write`] would be useful.
-use std::io::Write;
-
-use hex::encode;
-#[cfg(windows)]
-use memchr::memmem;
-
-pub trait Digest {
- fn new() -> Self
- where
- Self: Sized;
- fn input(&mut self, input: &[u8]);
- fn result(&mut self, out: &mut [u8]);
- fn reset(&mut self);
- fn output_bits(&self) -> usize;
- fn output_bytes(&self) -> usize {
- (self.output_bits() + 7) / 8
- }
- fn result_str(&mut self) -> String {
- let mut buf: Vec<u8> = vec![0; self.output_bytes()];
- self.result(&mut buf);
- encode(buf)
- }
-}
-
-impl Digest for blake2b_simd::State {
- fn new() -> Self {
- Self::new()
- }
-
- fn input(&mut self, input: &[u8]) {
- self.update(input);
- }
-
- fn result(&mut self, out: &mut [u8]) {
- let hash_result = &self.finalize();
- out.copy_from_slice(hash_result.as_bytes());
- }
-
- fn reset(&mut self) {
- *self = Self::new();
- }
-
- fn output_bits(&self) -> usize {
- 512
- }
-}
-
-impl Digest for blake3::Hasher {
- fn new() -> Self {
- Self::new()
- }
-
- fn input(&mut self, input: &[u8]) {
- self.update(input);
- }
-
- fn result(&mut self, out: &mut [u8]) {
- let hash_result = &self.finalize();
- out.copy_from_slice(hash_result.as_bytes());
- }
-
- fn reset(&mut self) {
- *self = Self::new();
- }
-
- fn output_bits(&self) -> usize {
- 256
- }
-}
-
-// Implements the Digest trait for sha2 / sha3 algorithms with fixed output
-macro_rules! impl_digest_common {
- ($type: ty, $size: expr) => {
- impl Digest for $type {
- fn new() -> Self {
- Self::default()
- }
-
- fn input(&mut self, input: &[u8]) {
- digest::Digest::update(self, input);
- }
-
- fn result(&mut self, out: &mut [u8]) {
- digest::Digest::finalize_into_reset(self, out.into());
- }
-
- fn reset(&mut self) {
- *self = Self::new();
- }
-
- fn output_bits(&self) -> usize {
- $size
- }
- }
- };
-}
-
-// Implements the Digest trait for sha2 / sha3 algorithms with variable output
-macro_rules! impl_digest_shake {
- ($type: ty) => {
- impl Digest for $type {
- fn new() -> Self {
- Self::default()
- }
-
- fn input(&mut self, input: &[u8]) {
- digest::Update::update(self, input);
- }
-
- fn result(&mut self, out: &mut [u8]) {
- digest::ExtendableOutputReset::finalize_xof_reset_into(self, out);
- }
-
- fn reset(&mut self) {
- *self = Self::new();
- }
-
- fn output_bits(&self) -> usize {
- 0
- }
- }
- };
-}
-
-impl_digest_common!(md5::Md5, 128);
-impl_digest_common!(sha1::Sha1, 160);
-impl_digest_common!(sha2::Sha224, 224);
-impl_digest_common!(sha2::Sha256, 256);
-impl_digest_common!(sha2::Sha384, 384);
-impl_digest_common!(sha2::Sha512, 512);
-
-impl_digest_common!(sha3::Sha3_224, 224);
-impl_digest_common!(sha3::Sha3_256, 256);
-impl_digest_common!(sha3::Sha3_384, 384);
-impl_digest_common!(sha3::Sha3_512, 512);
-impl_digest_shake!(sha3::Shake128);
-impl_digest_shake!(sha3::Shake256);
-
-/// A struct that writes to a digest.
-///
-/// This struct wraps a [`Digest`] and provides a [`Write`]
-/// implementation that passes input bytes directly to the
-/// [`Digest::input`].
-///
-/// On Windows, if `binary` is `false`, then the [`write`]
-/// implementation replaces instances of "\r\n" with "\n" before passing
-/// the input bytes to the [`digest`].
-pub struct DigestWriter<'a> {
- digest: &'a mut Box<dyn Digest>,
-
- /// Whether to write to the digest in binary mode or text mode on Windows.
- ///
- /// If this is `false`, then instances of "\r\n" are replaced with
- /// "\n" before passing input bytes to the [`digest`].
- #[allow(dead_code)]
- binary: bool,
-
- /// Whether the previous
- #[allow(dead_code)]
- was_last_character_carriage_return: bool,
- // TODO These are dead code only on non-Windows operating systems.
- // It might be better to use a `#[cfg(windows)]` guard here.
-}
-
-impl<'a> DigestWriter<'a> {
- pub fn new(digest: &'a mut Box<dyn Digest>, binary: bool) -> DigestWriter {
- let was_last_character_carriage_return = false;
- DigestWriter {
- digest,
- binary,
- was_last_character_carriage_return,
- }
- }
-
- pub fn finalize(&mut self) -> bool {
- if self.was_last_character_carriage_return {
- self.digest.input(&[b'\r']);
- true
- } else {
- false
- }
- }
-}
-
-impl<'a> Write for DigestWriter<'a> {
- #[cfg(not(windows))]
- fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
- self.digest.input(buf);
- Ok(buf.len())
- }
-
- #[cfg(windows)]
- fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
- if self.binary {
- self.digest.input(buf);
- return Ok(buf.len());
- }
-
- // The remaining code handles Windows text mode, where we must
- // replace each occurrence of "\r\n" with "\n".
- //
- // First, if the last character written was "\r" and the first
- // character in the current buffer to write is not "\n", then we
- // need to write the "\r" that we buffered from the previous
- // call to `write()`.
- let n = buf.len();
- if self.was_last_character_carriage_return && n > 0 && buf[0] != b'\n' {
- self.digest.input(&[b'\r']);
- }
-
- // Next, find all occurrences of "\r\n", inputting the slice
- // just before the "\n" in the previous instance of "\r\n" and
- // the beginning of this "\r\n".
- let mut i_prev = 0;
- for i in memmem::find_iter(buf, b"\r\n") {
- self.digest.input(&buf[i_prev..i]);
- i_prev = i + 1;
- }
-
- // Finally, check whether the last character is "\r". If so,
- // buffer it until we know that the next character is not "\n",
- // which can only be known on the next call to `write()`.
- //
- // This all assumes that `write()` will be called on adjacent
- // blocks of the input.
- if n > 0 && buf[n - 1] == b'\r' {
- self.was_last_character_carriage_return = true;
- self.digest.input(&buf[i_prev..n - 1]);
- } else {
- self.was_last_character_carriage_return = false;
- self.digest.input(&buf[i_prev..n]);
- }
-
- // Even though we dropped a "\r" for each "\r\n" we found, we
- // still report the number of bytes written as `n`. This is
- // because the meaning of the returned number is supposed to be
- // the number of bytes consumed by the writer, so that if the
- // calling code were calling `write()` in a loop, it would know
- // where the next contiguous slice of the buffer starts.
- Ok(n)
- }
-
- fn flush(&mut self) -> std::io::Result<()> {
- Ok(())
- }
-}
-
-#[cfg(test)]
-mod tests {
-
- /// Test for replacing a "\r\n" sequence with "\n" when the "\r" is
- /// at the end of one block and the "\n" is at the beginning of the
- /// next block, when reading in blocks.
- #[cfg(windows)]
- #[test]
- fn test_crlf_across_blocks() {
- use std::io::Write;
-
- use crate::digest::Digest;
- use crate::digest::DigestWriter;
-
- // Writing "\r" in one call to `write()`, and then "\n" in another.
- let mut digest = Box::new(md5::Md5::new()) as Box<dyn Digest>;
- let mut writer_crlf = DigestWriter::new(&mut digest, false);
- writer_crlf.write_all(&[b'\r']).unwrap();
- writer_crlf.write_all(&[b'\n']).unwrap();
- writer_crlf.finalize();
- let result_crlf = digest.result_str();
-
- // We expect "\r\n" to be replaced with "\n" in text mode on Windows.
- let mut digest = Box::new(md5::Md5::new()) as Box<dyn Digest>;
- let mut writer_lf = DigestWriter::new(&mut digest, false);
- writer_lf.write_all(&[b'\n']).unwrap();
- writer_lf.finalize();
- let result_lf = digest.result_str();
-
- assert_eq!(result_crlf, result_lf);
- }
-}
diff --git a/src/uu/hashsum/src/hashsum.rs b/src/uu/hashsum/src/hashsum.rs
index 5e0973a16599629988123649fe9e7a3a8c134073..1e73ffab2707061321ee1a57711c6d7f3b389b3a 100644
--- a/src/uu/hashsum/src/hashsum.rs
+++ b/src/uu/hashsum/src/hashsum.rs
@@ -1,238 +1,158 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Alex Lyon <arcterus@mail.com>
-// * (c) Vsevolod Velichko <torkvemada@sorokdva.net>
-// * (c) Gil Cottle <gcottle@redtown.org>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) algo, algoname, regexes, nread, nonames
-mod digest;
-
-use self::digest::Digest;
-use self::digest::DigestWriter;
-
use clap::builder::ValueParser;
use clap::crate_version;
+use clap::value_parser;
use clap::ArgAction;
use clap::{Arg, ArgMatches, Command};
-use hex::encode;
-use md5::Md5;
-use regex::Regex;
-use sha1::Sha1;
-use sha2::{Sha224, Sha256, Sha384, Sha512};
-use sha3::{Sha3_224, Sha3_256, Sha3_384, Sha3_512, Shake128, Shake256};
-use std::cmp::Ordering;
-use std::error::Error;
use std::ffi::{OsStr, OsString};
use std::fs::File;
-use std::io::{self, stdin, BufRead, BufReader, Read};
+use std::io::{stdin, BufReader, Read};
use std::iter;
use std::num::ParseIntError;
use std::path::Path;
-use uucore::crash;
-use uucore::display::Quotable;
-use uucore::error::{FromIo, UError, UResult};
-use uucore::show_warning;
+use uucore::checksum::calculate_blake2b_length;
+use uucore::checksum::create_sha3;
+use uucore::checksum::detect_algo;
+use uucore::checksum::digest_reader;
+use uucore::checksum::escape_filename;
+use uucore::checksum::perform_checksum_validation;
+use uucore::checksum::ChecksumError;
+use uucore::checksum::HashAlgorithm;
+use uucore::error::{FromIo, UResult};
+use uucore::sum::{Digest, Sha3_224, Sha3_256, Sha3_384, Sha3_512, Shake128, Shake256};
+use uucore::{format_usage, help_about, help_usage};
const NAME: &str = "hashsum";
+const ABOUT: &str = help_about!("hashsum.md");
+const USAGE: &str = help_usage!("hashsum.md");
struct Options {
algoname: &'static str,
digest: Box<dyn Digest + 'static>,
binary: bool,
- check: bool,
+ //check: bool,
tag: bool,
nonames: bool,
- status: bool,
- quiet: bool,
- strict: bool,
- warn: bool,
+ //status: bool,
+ //quiet: bool,
+ //strict: bool,
+ //warn: bool,
output_bits: usize,
+ zero: bool,
+ //ignore_missing: bool,
}
+/// Creates a hasher instance based on the command-line flags.
+///
+/// # Arguments
+///
+/// * `matches` - A reference to the `ArgMatches` object containing the command-line arguments.
+///
+/// # Returns
+///
+/// Returns a UResult of a tuple containing the algorithm name, the hasher instance, and
+/// the output length in bits or an Err if multiple hash algorithms are specified or if a
+/// required flag is missing.
#[allow(clippy::cognitive_complexity)]
-fn detect_algo(
- program: &str,
- matches: &ArgMatches,
-) -> (&'static str, Box<dyn Digest + 'static>, usize) {
- let mut alg: Option<Box<dyn Digest>> = None;
- let mut name: &'static str = "";
- let mut output_bits = 0;
- match program {
- "md5sum" => ("MD5", Box::new(Md5::new()) as Box<dyn Digest>, 128),
- "sha1sum" => ("SHA1", Box::new(Sha1::new()) as Box<dyn Digest>, 160),
- "sha224sum" => ("SHA224", Box::new(Sha224::new()) as Box<dyn Digest>, 224),
- "sha256sum" => ("SHA256", Box::new(Sha256::new()) as Box<dyn Digest>, 256),
- "sha384sum" => ("SHA384", Box::new(Sha384::new()) as Box<dyn Digest>, 384),
- "sha512sum" => ("SHA512", Box::new(Sha512::new()) as Box<dyn Digest>, 512),
- "b2sum" => (
- "BLAKE2",
- Box::new(blake2b_simd::State::new()) as Box<dyn Digest>,
- 512,
- ),
- "b3sum" => (
- "BLAKE3",
- Box::new(blake3::Hasher::new()) as Box<dyn Digest>,
- 256,
- ),
- "sha3sum" => match matches.get_one::<usize>("bits") {
- Some(224) => (
- "SHA3-224",
- Box::new(Sha3_224::new()) as Box<dyn Digest>,
- 224,
- ),
- Some(256) => (
- "SHA3-256",
- Box::new(Sha3_256::new()) as Box<dyn Digest>,
- 256,
- ),
- Some(384) => (
- "SHA3-384",
- Box::new(Sha3_384::new()) as Box<dyn Digest>,
- 384,
- ),
- Some(512) => (
- "SHA3-512",
- Box::new(Sha3_512::new()) as Box<dyn Digest>,
- 512,
- ),
- Some(_) => crash!(
- 1,
- "Invalid output size for SHA3 (expected 224, 256, 384, or 512)"
- ),
- None => crash!(1, "--bits required for SHA3"),
- },
- "sha3-224sum" => (
- "SHA3-224",
- Box::new(Sha3_224::new()) as Box<dyn Digest>,
- 224,
- ),
- "sha3-256sum" => (
- "SHA3-256",
- Box::new(Sha3_256::new()) as Box<dyn Digest>,
- 256,
- ),
- "sha3-384sum" => (
- "SHA3-384",
- Box::new(Sha3_384::new()) as Box<dyn Digest>,
- 384,
- ),
- "sha3-512sum" => (
- "SHA3-512",
- Box::new(Sha3_512::new()) as Box<dyn Digest>,
- 512,
- ),
- "shake128sum" => match matches.get_one::<usize>("bits") {
- Some(bits) => (
- "SHAKE128",
- Box::new(Shake128::new()) as Box<dyn Digest>,
- *bits,
- ),
- None => crash!(1, "--bits required for SHAKE-128"),
- },
- "shake256sum" => match matches.get_one::<usize>("bits") {
- Some(bits) => (
- "SHAKE256",
- Box::new(Shake256::new()) as Box<dyn Digest>,
- *bits,
- ),
- None => crash!(1, "--bits required for SHAKE-256"),
- },
- _ => {
- {
- let mut set_or_crash = |n, val, bits| {
- if alg.is_some() {
- crash!(1, "You cannot combine multiple hash algorithms!")
- };
- name = n;
- alg = Some(val);
- output_bits = bits;
- };
- if matches.get_flag("md5") {
- set_or_crash("MD5", Box::new(Md5::new()), 128);
- }
- if matches.get_flag("sha1") {
- set_or_crash("SHA1", Box::new(Sha1::new()), 160);
- }
- if matches.get_flag("sha224") {
- set_or_crash("SHA224", Box::new(Sha224::new()), 224);
- }
- if matches.get_flag("sha256") {
- set_or_crash("SHA256", Box::new(Sha256::new()), 256);
- }
- if matches.get_flag("sha384") {
- set_or_crash("SHA384", Box::new(Sha384::new()), 384);
- }
- if matches.get_flag("sha512") {
- set_or_crash("SHA512", Box::new(Sha512::new()), 512);
- }
- if matches.get_flag("b2sum") {
- set_or_crash("BLAKE2", Box::new(blake2b_simd::State::new()), 512);
- }
- if matches.get_flag("b3sum") {
- set_or_crash("BLAKE3", Box::new(blake3::Hasher::new()), 256);
- }
- if matches.get_flag("sha3") {
- match matches.get_one::<usize>("bits") {
- Some(224) => set_or_crash(
- "SHA3-224",
- Box::new(Sha3_224::new()) as Box<dyn Digest>,
- 224,
- ),
- Some(256) => set_or_crash(
- "SHA3-256",
- Box::new(Sha3_256::new()) as Box<dyn Digest>,
- 256,
- ),
- Some(384) => set_or_crash(
- "SHA3-384",
- Box::new(Sha3_384::new()) as Box<dyn Digest>,
- 384,
- ),
- Some(512) => set_or_crash(
- "SHA3-512",
- Box::new(Sha3_512::new()) as Box<dyn Digest>,
- 512,
- ),
- Some(_) => crash!(
- 1,
- "Invalid output size for SHA3 (expected 224, 256, 384, or 512)"
- ),
- None => crash!(1, "--bits required for SHA3"),
- }
- }
- if matches.get_flag("sha3-224") {
- set_or_crash("SHA3-224", Box::new(Sha3_224::new()), 224);
- }
- if matches.get_flag("sha3-256") {
- set_or_crash("SHA3-256", Box::new(Sha3_256::new()), 256);
- }
- if matches.get_flag("sha3-384") {
- set_or_crash("SHA3-384", Box::new(Sha3_384::new()), 384);
- }
- if matches.get_flag("sha3-512") {
- set_or_crash("SHA3-512", Box::new(Sha3_512::new()), 512);
- }
- if matches.get_flag("shake128") {
- match matches.get_one::<usize>("bits") {
- Some(bits) => set_or_crash("SHAKE128", Box::new(Shake128::new()), *bits),
- None => crash!(1, "--bits required for SHAKE-128"),
- }
- }
- if matches.get_flag("shake256") {
- match matches.get_one::<usize>("bits") {
- Some(bits) => set_or_crash("SHAKE256", Box::new(Shake256::new()), *bits),
- None => crash!(1, "--bits required for SHAKE-256"),
- }
- }
- }
- let alg = alg.unwrap_or_else(|| crash!(1, "You must specify hash algorithm!"));
- (name, alg, output_bits)
+fn create_algorithm_from_flags(matches: &ArgMatches) -> UResult<HashAlgorithm> {
+ let mut alg: Option<HashAlgorithm> = None;
+
+ let mut set_or_err = |new_alg: HashAlgorithm| -> UResult<()> {
+ if alg.is_some() {
+ return Err(ChecksumError::CombineMultipleAlgorithms.into());
}
+ alg = Some(new_alg);
+ Ok(())
+ };
+
+ if matches.get_flag("md5") {
+ set_or_err(detect_algo("md5sum", None)?)?;
}
+ if matches.get_flag("sha1") {
+ set_or_err(detect_algo("sha1sum", None)?)?;
+ }
+ if matches.get_flag("sha224") {
+ set_or_err(detect_algo("sha224sum", None)?)?;
+ }
+ if matches.get_flag("sha256") {
+ set_or_err(detect_algo("sha256sum", None)?)?;
+ }
+ if matches.get_flag("sha384") {
+ set_or_err(detect_algo("sha384sum", None)?)?;
+ }
+ if matches.get_flag("sha512") {
+ set_or_err(detect_algo("sha512sum", None)?)?;
+ }
+ if matches.get_flag("b2sum") {
+ set_or_err(detect_algo("b2sum", None)?)?;
+ }
+ if matches.get_flag("b3sum") {
+ set_or_err(detect_algo("b3sum", None)?)?;
+ }
+ if matches.get_flag("sha3") {
+ let bits = matches.get_one::<usize>("bits").cloned();
+ set_or_err(create_sha3(bits)?)?;
+ }
+ if matches.get_flag("sha3-224") {
+ set_or_err(HashAlgorithm {
+ name: "SHA3-224",
+ create_fn: Box::new(|| Box::new(Sha3_224::new())),
+ bits: 224,
+ })?;
+ }
+ if matches.get_flag("sha3-256") {
+ set_or_err(HashAlgorithm {
+ name: "SHA3-256",
+ create_fn: Box::new(|| Box::new(Sha3_256::new())),
+ bits: 256,
+ })?;
+ }
+ if matches.get_flag("sha3-384") {
+ set_or_err(HashAlgorithm {
+ name: "SHA3-384",
+ create_fn: Box::new(|| Box::new(Sha3_384::new())),
+ bits: 384,
+ })?;
+ }
+ if matches.get_flag("sha3-512") {
+ set_or_err(HashAlgorithm {
+ name: "SHA3-512",
+ create_fn: Box::new(|| Box::new(Sha3_512::new())),
+ bits: 512,
+ })?;
+ }
+ if matches.get_flag("shake128") {
+ match matches.get_one::<usize>("bits") {
+ Some(bits) => set_or_err(HashAlgorithm {
+ name: "SHAKE128",
+ create_fn: Box::new(|| Box::new(Shake128::new())),
+ bits: *bits,
+ })?,
+ None => return Err(ChecksumError::BitsRequiredForShake128.into()),
+ };
+ }
+ if matches.get_flag("shake256") {
+ match matches.get_one::<usize>("bits") {
+ Some(bits) => set_or_err(HashAlgorithm {
+ name: "SHAKE256",
+ create_fn: Box::new(|| Box::new(Shake256::new())),
+ bits: *bits,
+ })?,
+ None => return Err(ChecksumError::BitsRequiredForShake256.into()),
+ };
+ }
+
+ if alg.is_none() {
+ return Err(ChecksumError::NeedAlgorithmToHash.into());
+ }
+
+ Ok(alg.unwrap())
}
// TODO: return custom error type
@@ -245,7 +165,7 @@ pub fn uumain(mut args: impl uucore::Args) -> UResult<()> {
// if there is no program name for some reason, default to "hashsum"
let program = args.next().unwrap_or_else(|| OsString::from(NAME));
let binary_name = Path::new(&program)
- .file_name()
+ .file_stem()
.unwrap_or_else(|| OsStr::new(NAME))
.to_string_lossy();
@@ -254,7 +174,7 @@ pub fn uumain(mut args: impl uucore::Args) -> UResult<()> {
// Default binary in Windows, text mode otherwise
let binary_flag_default = cfg!(windows);
- let command = uu_app(&binary_name);
+ let (command, is_hashsum_bin) = uu_app(&binary_name);
// FIXME: this should use try_get_matches_from() and crash!(), but at the moment that just
// causes "error: " to be printed twice (once from crash!() and once from clap). With
@@ -262,7 +182,22 @@ pub fn uumain(mut args: impl uucore::Args) -> UResult<()> {
// least somewhat better from a user's perspective.
let matches = command.try_get_matches_from(args)?;
- let (name, algo, bits) = detect_algo(&binary_name, &matches);
+ let input_length: Option<&usize> = if binary_name == "b2sum" {
+ matches.get_one::<usize>(options::LENGTH)
+ } else {
+ None
+ };
+
+ let length = match input_length {
+ Some(length) => calculate_blake2b_length(*length)?,
+ None => None,
+ };
+
+ let algo = if is_hashsum_bin {
+ create_algorithm_from_flags(&matches)?
+ } else {
+ detect_algo(&binary_name, length)?
+ };
let binary = if matches.get_flag("binary") {
true
@@ -279,29 +214,86 @@ pub fn uumain(mut args: impl uucore::Args) -> UResult<()> {
.unwrap_or(&false);
let status = matches.get_flag("status");
let quiet = matches.get_flag("quiet") || status;
- let strict = matches.get_flag("strict");
+ //let strict = matches.get_flag("strict");
let warn = matches.get_flag("warn") && !status;
+ let zero = matches.get_flag("zero");
+ let ignore_missing = matches.get_flag("ignore-missing");
+
+ if ignore_missing && !check {
+ // --ignore-missing needs -c
+ return Err(ChecksumError::IgnoreNotCheck.into());
+ }
let opts = Options {
- algoname: name,
- digest: algo,
- output_bits: bits,
+ algoname: algo.name,
+ digest: (algo.create_fn)(),
+ output_bits: algo.bits,
binary,
- check,
+ //check,
tag,
nonames,
- status,
- quiet,
- strict,
- warn,
+ //status,
+ //quiet,
+ //strict,
+ //warn,
+ zero,
+ //ignore_missing,
};
- match matches.get_many::<OsString>("FILE") {
+ if check {
+ let text_flag = matches.get_flag("text");
+ let binary_flag = matches.get_flag("binary");
+ let strict = matches.get_flag("strict");
+
+ if binary_flag || text_flag {
+ return Err(ChecksumError::BinaryTextConflict.into());
+ }
+
+ // Execute the checksum validation based on the presence of files or the use of stdin
+ // Determine the source of input: a list of files or stdin.
+ let input = matches.get_many::<OsString>(options::FILE).map_or_else(
+ || iter::once(OsStr::new("-")).collect::<Vec<_>>(),
+ |files| files.map(OsStr::new).collect::<Vec<_>>(),
+ );
+
+ // Execute the checksum validation
+ return perform_checksum_validation(
+ input.iter().copied(),
+ strict,
+ status,
+ warn,
+ binary_flag,
+ ignore_missing,
+ quiet,
+ Some(algo.name),
+ Some(algo.bits),
+ );
+ }
+
+ // Show the hashsum of the input
+ match matches.get_many::<OsString>(options::FILE) {
Some(files) => hashsum(opts, files.map(|f| f.as_os_str())),
None => hashsum(opts, iter::once(OsStr::new("-"))),
}
}
+mod options {
+ //pub const ALGORITHM: &str = "algorithm";
+ pub const FILE: &str = "file";
+ //pub const UNTAGGED: &str = "untagged";
+ pub const TAG: &str = "tag";
+ pub const LENGTH: &str = "length";
+ //pub const RAW: &str = "raw";
+ //pub const BASE64: &str = "base64";
+ pub const CHECK: &str = "check";
+ pub const STRICT: &str = "strict";
+ pub const TEXT: &str = "text";
+ pub const BINARY: &str = "binary";
+ pub const STATUS: &str = "status";
+ pub const WARN: &str = "warn";
+ pub const QUIET: &str = "quiet";
+}
+
pub fn uu_app_common() -> Command {
#[cfg(windows)]
const BINARY_HELP: &str = "read in binary mode (default)";
@@ -313,30 +305,34 @@ pub fn uu_app_common() -> Command {
const TEXT_HELP: &str = "read in text mode (default)";
Command::new(uucore::util_name())
.version(crate_version!())
- .about("Compute and check message digests.")
+ .about(ABOUT)
+ .override_usage(format_usage(USAGE))
.infer_long_args(true)
+ .args_override_self(true)
.arg(
- Arg::new("binary")
+ Arg::new(options::BINARY)
.short('b')
.long("binary")
.help(BINARY_HELP)
.action(ArgAction::SetTrue),
)
.arg(
- Arg::new("check")
+ Arg::new(options::CHECK)
.short('c')
.long("check")
.help("read hashsums from the FILEs and check them")
- .action(ArgAction::SetTrue),
+ .action(ArgAction::SetTrue)
+ .conflicts_with("tag"),
)
.arg(
- Arg::new("tag")
+ Arg::new(options::TAG)
.long("tag")
.help("create a BSD-style checksum")
- .action(ArgAction::SetTrue),
+ .action(ArgAction::SetTrue)
+ .conflicts_with("text"),
)
.arg(
- Arg::new("text")
+ Arg::new(options::TEXT)
.short('t')
.long("text")
.help(TEXT_HELP)
@@ -344,42 +340,74 @@ pub fn uu_app_common() -> Command {
.action(ArgAction::SetTrue),
)
.arg(
- Arg::new("quiet")
+ Arg::new(options::QUIET)
.short('q')
- .long("quiet")
+ .long(options::QUIET)
.help("don't print OK for each successfully verified file")
.action(ArgAction::SetTrue),
)
.arg(
- Arg::new("status")
+ Arg::new(options::STATUS)
.short('s')
.long("status")
.help("don't output anything, status code shows success")
.action(ArgAction::SetTrue),
)
.arg(
- Arg::new("strict")
+ Arg::new(options::STRICT)
.long("strict")
.help("exit non-zero for improperly formatted checksum lines")
.action(ArgAction::SetTrue),
)
.arg(
- Arg::new("warn")
+ Arg::new("ignore-missing")
+ .long("ignore-missing")
+ .help("don't fail or report status for missing files")
+ .action(ArgAction::SetTrue),
+ )
+ .arg(
+ Arg::new(options::WARN)
.short('w')
.long("warn")
.help("warn about improperly formatted checksum lines")
.action(ArgAction::SetTrue),
)
.arg(
- Arg::new("FILE")
+ Arg::new("zero")
+ .short('z')
+ .long("zero")
+ .help("end each output line with NUL, not newline")
+ .action(ArgAction::SetTrue),
+ )
+ .arg(
+ Arg::new(options::FILE)
.index(1)
.action(ArgAction::Append)
- .value_name("FILE")
+ .value_name(options::FILE)
.value_hint(clap::ValueHint::FilePath)
.value_parser(ValueParser::os_string()),
)
}
+pub fn uu_app_length() -> Command {
+ uu_app_opt_length(uu_app_common())
+}
+
+fn uu_app_opt_length(command: Command) -> Command {
+ command.arg(
+ Arg::new(options::LENGTH)
+ .long(options::LENGTH)
+ .value_parser(value_parser!(usize))
+ .short('l')
+ .help(
+ "digest length in bits; must not exceed the max for the blake2 algorithm \
+ and must be a multiple of 8",
+ )
+ .overrides_with(options::LENGTH)
+ .action(ArgAction::Set),
+ )
+}
+
pub fn uu_app_b3sum() -> Command {
uu_app_b3sum_opts(uu_app_common())
}
@@ -448,43 +476,25 @@ pub fn uu_app_custom() -> Command {
// hashsum is handled differently in build.rs, therefore this is not the same
// as in other utilities.
-fn uu_app(binary_name: &str) -> Command {
+fn uu_app(binary_name: &str) -> (Command, bool) {
match binary_name {
// These all support the same options.
"md5sum" | "sha1sum" | "sha224sum" | "sha256sum" | "sha384sum" | "sha512sum" => {
- uu_app_common()
+ (uu_app_common(), false)
}
// b2sum supports the md5sum options plus -l/--length.
- "b2sum" => uu_app_common(), // TODO: Implement -l/--length
+ "b2sum" => (uu_app_length(), false),
// These have never been part of GNU Coreutils, but can function with the same
// options as md5sum.
- "sha3-224sum" | "sha3-256sum" | "sha3-384sum" | "sha3-512sum" => uu_app_common(),
+ "sha3-224sum" | "sha3-256sum" | "sha3-384sum" | "sha3-512sum" => (uu_app_common(), false),
// These have never been part of GNU Coreutils, and require an additional --bits
// option to specify their output size.
- "sha3sum" | "shake128sum" | "shake256sum" => uu_app_bits(),
+ "sha3sum" | "shake128sum" | "shake256sum" => (uu_app_bits(), false),
// b3sum has never been part of GNU Coreutils, and has a --no-names option in
// addition to the b2sum options.
- "b3sum" => uu_app_b3sum(),
+ "b3sum" => (uu_app_b3sum(), false),
// We're probably just being called as `hashsum`, so give them everything.
- _ => uu_app_custom(),
- }
-}
-
-#[derive(Debug)]
-enum HashsumError {
- InvalidRegex,
- InvalidFormat,
-}
-
-impl Error for HashsumError {}
-impl UError for HashsumError {}
-
-impl std::fmt::Display for HashsumError {
- fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
- match self {
- Self::InvalidRegex => write!(f, "invalid regular expression"),
- Self::InvalidFormat => Ok(()),
- }
+ _ => (uu_app_custom(), true),
}
}
@@ -493,9 +503,6 @@ fn hashsum<'a, I>(mut options: Options, files: I) -> UResult<()>
where
I: Iterator<Item = &'a OsStr>,
{
- let mut bad_format = 0;
- let mut failed_cksum = 0;
- let mut failed_open_file = 0;
let binary_marker = if options.binary { "*" } else { " " };
for filename in files {
let filename = Path::new(filename);
@@ -510,178 +517,40 @@ where
File::open(filename).map_err_context(|| "failed to open file".to_string())?;
Box::new(file_buf) as Box<dyn Read>
});
- if options.check {
- // Set up Regexes for line validation and parsing
- //
- // First, we compute the number of bytes we expect to be in
- // the digest string. If the algorithm has a variable number
- // of output bits, then we use the `+` modifier in the
- // regular expression, otherwise we use the `{n}` modifier,
- // where `n` is the number of bytes.
- let bytes = options.digest.output_bits() / 4;
- let modifier = if bytes > 0 {
- format!("{{{}}}", bytes)
- } else {
- "+".to_string()
- };
- let gnu_re = Regex::new(&format!(
- r"^(?P<digest>[a-fA-F0-9]{}) (?P<binary>[ \*])(?P<fileName>.*)",
- modifier,
- ))
- .map_err(|_| HashsumError::InvalidRegex)?;
- let bsd_re = Regex::new(&format!(
- r"^{algorithm} \((?P<fileName>.*)\) = (?P<digest>[a-fA-F0-9]{digest_size})",
- algorithm = options.algoname,
- digest_size = modifier,
- ))
- .map_err(|_| HashsumError::InvalidRegex)?;
-
- let buffer = file;
- for (i, maybe_line) in buffer.lines().enumerate() {
- let line = match maybe_line {
- Ok(l) => l,
- Err(e) => return Err(e.map_err_context(|| "failed to read file".to_string())),
- };
- let (ck_filename, sum, binary_check) = match gnu_re.captures(&line) {
- Some(caps) => (
- caps.name("fileName").unwrap().as_str(),
- caps.name("digest").unwrap().as_str().to_ascii_lowercase(),
- caps.name("binary").unwrap().as_str() == "*",
- ),
- None => match bsd_re.captures(&line) {
- Some(caps) => (
- caps.name("fileName").unwrap().as_str(),
- caps.name("digest").unwrap().as_str().to_ascii_lowercase(),
- true,
- ),
- None => {
- bad_format += 1;
- if options.strict {
- return Err(HashsumError::InvalidFormat.into());
- }
- if options.warn {
- show_warning!(
- "{}: {}: improperly formatted {} checksum line",
- filename.maybe_quote(),
- i + 1,
- options.algoname
- );
- }
- continue;
- }
- },
- };
- let f = match File::open(ck_filename) {
- Err(_) => {
- failed_open_file += 1;
- println!(
- "{}: {}: No such file or directory",
- uucore::util_name(),
- ck_filename
- );
- println!("{}: FAILED open or read", ck_filename);
- continue;
- }
- Ok(file) => file,
- };
- let mut ckf = BufReader::new(Box::new(f) as Box<dyn Read>);
- let real_sum = digest_reader(
- &mut options.digest,
- &mut ckf,
- binary_check,
- options.output_bits,
- )
- .map_err_context(|| "failed to read input".to_string())?
- .to_ascii_lowercase();
- // FIXME: Filenames with newlines should be treated specially.
- // GNU appears to replace newlines by \n and backslashes by
- // \\ and prepend a backslash (to the hash or filename) if it did
- // this escaping.
- // Different sorts of output (checking vs outputting hashes) may
- // handle this differently. Compare carefully to GNU.
- // If you can, try to preserve invalid unicode using OsStr(ing)Ext
- // and display it using uucore::display::print_verbatim(). This is
- // easier (and more important) on Unix than on Windows.
- if sum == real_sum {
- if !options.quiet {
- println!("{}: OK", ck_filename);
- }
+
+ let (sum, _) = digest_reader(
+ &mut options.digest,
+ &mut file,
+ options.binary,
+ options.output_bits,
+ )
+ .map_err_context(|| "failed to read input".to_string())?;
+ let (escaped_filename, prefix) = escape_filename(filename);
+ if options.tag {
+ if options.algoname == "blake2b" {
+ if options.digest.output_bits() == 512 {
+ println!("BLAKE2b ({escaped_filename}) = {sum}");
} else {
- if !options.status {
- println!("{}: FAILED", ck_filename);
- }
- failed_cksum += 1;
+ // special case for BLAKE2b with non-default output length
+ println!(
+ "BLAKE2b-{} ({escaped_filename}) = {sum}",
+ options.digest.output_bits()
+ );
}
- }
- } else {
- let sum = digest_reader(
- &mut options.digest,
- &mut file,
- options.binary,
- options.output_bits,
- )
- .map_err_context(|| "failed to read input".to_string())?;
- if options.tag {
- println!("{} ({}) = {}", options.algoname, filename.display(), sum);
- } else if options.nonames {
- println!("{}", sum);
} else {
- println!("{} {}{}", sum, binary_marker, filename.display());
+ println!(
+ "{prefix}{} ({escaped_filename}) = {sum}",
+ options.algoname.to_ascii_uppercase()
+ );
}
+ } else if options.nonames {
+ println!("{sum}");
+ } else if options.zero {
+ // with zero, we don't escape the filename
+ print!("{sum} {binary_marker}{}\0", filename.display());
+ } else {
+ println!("{prefix}{sum} {binary_marker}{escaped_filename}");
}
}
- if !options.status {
- match bad_format.cmp(&1) {
- Ordering::Equal => show_warning!("{} line is improperly formatted", bad_format),
- Ordering::Greater => show_warning!("{} lines are improperly formatted", bad_format),
- Ordering::Less => {}
- };
- if failed_cksum > 0 {
- show_warning!("{} computed checksum did NOT match", failed_cksum);
- }
- match failed_open_file.cmp(&1) {
- Ordering::Equal => show_warning!("{} listed file could not be read", failed_open_file),
- Ordering::Greater => {
- show_warning!("{} listed files could not be read", failed_open_file);
- }
- Ordering::Less => {}
- }
- }
-
Ok(())
}
-
-fn digest_reader<T: Read>(
- digest: &mut Box<dyn Digest>,
- reader: &mut BufReader<T>,
- binary: bool,
- output_bits: usize,
-) -> io::Result<String> {
- digest.reset();
-
- // Read bytes from `reader` and write those bytes to `digest`.
- //
- // If `binary` is `false` and the operating system is Windows, then
- // `DigestWriter` replaces "\r\n" with "\n" before it writes the
- // bytes into `digest`. Otherwise, it just inserts the bytes as-is.
- //
- // In order to support replacing "\r\n", we must call `finalize()`
- // in order to support the possibility that the last character read
- // from the reader was "\r". (This character gets buffered by
- // `DigestWriter` and only written if the following character is
- // "\n". But when "\r" is the last character read, we need to force
- // it to be written.)
- let mut digest_writer = DigestWriter::new(digest, binary);
- std::io::copy(reader, &mut digest_writer)?;
- digest_writer.finalize();
-
- if digest.output_bits() > 0 {
- Ok(digest.result_str())
- } else {
- // Assume it's SHAKE. result_str() doesn't work with shake (as of 8/30/2016)
- let mut bytes = Vec::new();
- bytes.resize((output_bits + 7) / 8, 0);
- digest.result(&mut bytes);
- Ok(encode(bytes))
- }
-}
diff --git a/src/uu/head/BENCHMARKING.md b/src/uu/head/BENCHMARKING.md
index 29ce4c46b43ba688344dd239f25bb47924552e52..d751d1f7fff604ca8b3c216fc8753124006f5760 100644
--- a/src/uu/head/BENCHMARKING.md
+++ b/src/uu/head/BENCHMARKING.md
@@ -5,23 +5,31 @@ GNU version of `head`, you can use a benchmarking tool like
[hyperfine][0]. On Ubuntu 18.04 or later, you can install `hyperfine` by
running
- sudo apt-get install hyperfine
+```shell
+sudo apt-get install hyperfine
+```
Next, build the `head` binary under the release profile:
- cargo build --release -p uu_head
+```shell
+cargo build --release -p uu_head
+```
Now, get a text file to test `head` on. I used the *Complete Works of
William Shakespeare*, which is in the public domain in the United States
and most other parts of the world.
- wget -O shakespeare.txt https://www.gutenberg.org/files/100/100-0.txt
+```shell
+wget -O shakespeare.txt https://www.gutenberg.org/files/100/100-0.txt
+```
This particular file has about 170,000 lines, each of which is no longer
than 96 characters:
- $ wc -lL shakespeare.txt
- 170592 96 shakespeare.txt
+```shell
+$ wc -lL shakespeare.txt
+170592 96 shakespeare.txt
+```
You could use files of different shapes and sizes to test the
performance of `head` in different situations. For a larger file, you
@@ -32,9 +40,11 @@ contains about 130 million lines.
Finally, you can compare the performance of the two versions of `head`
by running, for example,
- hyperfine \
- "head -n 100000 shakespeare.txt" \
- "target/release/head -n 100000 shakespeare.txt"
+```shell
+hyperfine \
+ "head -n 100000 shakespeare.txt" \
+ "target/release/head -n 100000 shakespeare.txt"
+```
[0]: https://github.com/sharkdp/hyperfine
[1]: https://www.wikidata.org/wiki/Wikidata:Database_download
diff --git a/src/uu/head/Cargo.toml b/src/uu/head/Cargo.toml
index 3a4dd42f22a8ff5df25ab2fa396e01f54ab7d011..a6e2a24cbf5693435f9d5acac132d779da0268d9 100644
--- a/src/uu/head/Cargo.toml
+++ b/src/uu/head/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_head"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "head ~ (uutils) display the first lines of input"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/head.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-memchr = "2"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["ringbuffer", "lines"] }
+clap = { workspace = true }
+memchr = { workspace = true }
+uucore = { workspace = true, features = ["ringbuffer", "lines", "fs"] }
[[bin]]
name = "head"
diff --git a/src/uu/head/head.md b/src/uu/head/head.md
new file mode 100644
index 0000000000000000000000000000000000000000..476f3affc308a029e14c25973a2b4ab821d37fe3
--- /dev/null
+++ b/src/uu/head/head.md
@@ -0,0 +1,11 @@
+# head
+
+```
+head [FLAG]... [FILE]...
+```
+
+Print the first 10 lines of each `FILE` to standard output.
+With more than one `FILE`, precede each with a header giving the file name.
+With no `FILE`, or when `FILE` is `-`, read standard input.
+
+Mandatory arguments to long flags are mandatory for short flags too.
diff --git a/src/uu/head/src/head.rs b/src/uu/head/src/head.rs
index a006d5a90bb12ea6c74047e7d5723bef70b5efde..a6bb7b53fc0fd17f2c430e3821231be1c443f3e3 100644
--- a/src/uu/head/src/head.rs
+++ b/src/uu/head/src/head.rs
@@ -1,31 +1,26 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-// spell-checker:ignore (vars) zlines BUFWRITER seekable
+// spell-checker:ignore (vars) BUFWRITER seekable
use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
use std::ffi::OsString;
use std::io::{self, BufWriter, ErrorKind, Read, Seek, SeekFrom, Write};
use uucore::display::Quotable;
-use uucore::error::{FromIo, UError, UResult, USimpleError};
+use uucore::error::{FromIo, UResult, USimpleError};
+use uucore::line_ending::LineEnding;
use uucore::lines::lines;
-use uucore::{format_usage, show};
+use uucore::{format_usage, help_about, help_usage, show};
const BUF_SIZE: usize = 65536;
/// The capacity in bytes for buffered writers.
const BUFWRITER_CAPACITY: usize = 16_384; // 16 kilobytes
-const ABOUT: &str = "\
- Print the first 10 lines of each FILE to standard output.\n\
- With more than one FILE, precede each with a header giving the file name.\n\
- With no FILE, or when FILE is -, read standard input.\n\
- \n\
- Mandatory arguments to long flags are mandatory for short flags too.\
- ";
-const USAGE: &str = "{} [FLAG]... [FILE]...";
+const ABOUT: &str = help_about!("head.md");
+const USAGE: &str = help_usage!("head.md");
mod options {
pub const BYTES_NAME: &str = "BYTES";
@@ -36,6 +31,7 @@ mod options {
pub const FILES_NAME: &str = "FILE";
pub const PRESUME_INPUT_PIPE: &str = "-PRESUME-INPUT-PIPE";
}
+
mod parse;
mod take;
use take::take_all_but;
@@ -134,7 +130,7 @@ impl Mode {
fn from(matches: &ArgMatches) -> Result<Self, String> {
if let Some(v) = matches.get_one::<String>(options::BYTES_NAME) {
let (n, all_but_last) =
- parse::parse_num(v).map_err(|err| format!("invalid number of bytes: {}", err))?;
+ parse::parse_num(v).map_err(|err| format!("invalid number of bytes: {err}"))?;
if all_but_last {
Ok(Self::AllButLastBytes(n))
} else {
@@ -142,7 +138,7 @@ impl Mode {
}
} else if let Some(v) = matches.get_one::<String>(options::LINES_NAME) {
let (n, all_but_last) =
- parse::parse_num(v).map_err(|err| format!("invalid number of lines: {}", err))?;
+ parse::parse_num(v).map_err(|err| format!("invalid number of lines: {err}"))?;
if all_but_last {
Ok(Self::AllButLastLines(n))
} else {
@@ -190,7 +186,7 @@ fn arg_iterate<'a>(
struct HeadOptions {
pub quiet: bool,
pub verbose: bool,
- pub zeroed: bool,
+ pub line_ending: LineEnding,
pub presume_input_pipe: bool,
pub mode: Mode,
pub files: Vec<String>,
@@ -203,13 +199,13 @@ impl HeadOptions {
options.quiet = matches.get_flag(options::QUIET_NAME);
options.verbose = matches.get_flag(options::VERBOSE_NAME);
- options.zeroed = matches.get_flag(options::ZERO_NAME);
+ options.line_ending = LineEnding::from_zero_flag(matches.get_flag(options::ZERO_NAME));
options.presume_input_pipe = matches.get_flag(options::PRESUME_INPUT_PIPE);
options.mode = Mode::from(matches)?;
options.files = match matches.get_many::<String>(options::FILES_NAME) {
- Some(v) => v.map(|s| s.to_owned()).collect(),
+ Some(v) => v.cloned().collect(),
None => vec!["-".to_owned()],
};
//println!("{:#?}", options);
@@ -233,9 +229,8 @@ where
Ok(())
}
-fn read_n_lines(input: &mut impl std::io::BufRead, n: u64, zero: bool) -> std::io::Result<()> {
+fn read_n_lines(input: &mut impl std::io::BufRead, n: u64, separator: u8) -> std::io::Result<()> {
// Read the first `n` lines from the `input` reader.
- let separator = if zero { b'\0' } else { b'\n' };
let mut reader = take_lines(input, n, separator);
// Write those bytes to `stdout`.
@@ -248,69 +243,72 @@ fn read_n_lines(input: &mut impl std::io::BufRead, n: u64, zero: bool) -> std::i
Ok(())
}
-fn read_but_last_n_bytes(input: &mut impl std::io::BufRead, n: usize) -> std::io::Result<()> {
+fn catch_too_large_numbers_in_backwards_bytes_or_lines(n: u64) -> Option<usize> {
+ match usize::try_from(n) {
+ Ok(value) => Some(value),
+ Err(e) => {
+ show!(USimpleError::new(
+ 1,
+ format!("{e}: number of -bytes or -lines is too large")
+ ));
+ None
+ }
+ }
+}
+
+fn read_but_last_n_bytes(input: &mut impl std::io::BufRead, n: u64) -> std::io::Result<()> {
if n == 0 {
//prints everything
- return read_n_bytes(input, std::u64::MAX);
+ return read_n_bytes(input, u64::MAX);
}
- let stdout = std::io::stdout();
- let mut stdout = stdout.lock();
+ if let Some(n) = catch_too_large_numbers_in_backwards_bytes_or_lines(n) {
+ let stdout = std::io::stdout();
+ let mut stdout = stdout.lock();
- let mut ring_buffer = vec![0u8; n];
+ let mut ring_buffer = Vec::new();
- // first we fill the ring buffer
- if let Err(e) = input.read_exact(&mut ring_buffer) {
- if e.kind() == ErrorKind::UnexpectedEof {
- return Ok(());
- } else {
- return Err(e);
- }
- }
- let mut buffer = [0u8; BUF_SIZE];
- loop {
- let read = loop {
- match input.read(&mut buffer) {
- Ok(n) => break n,
+ let mut buffer = [0u8; BUF_SIZE];
+ let mut total_read = 0;
+
+ loop {
+ let read = match input.read(&mut buffer) {
+ Ok(0) => break,
+ Ok(read) => read,
Err(e) => match e.kind() {
- ErrorKind::Interrupted => {}
+ ErrorKind::Interrupted => continue,
_ => return Err(e),
},
+ };
+
+ total_read += read;
+
+ if total_read <= n {
+ // Fill the ring buffer without exceeding n bytes
+ let overflow = total_read - n;
+ ring_buffer.extend_from_slice(&buffer[..read - overflow]);
+ } else {
+ // Write the ring buffer and the part of the buffer that exceeds n
+ stdout.write_all(&ring_buffer)?;
+ stdout.write_all(&buffer[..read - n + ring_buffer.len()])?;
+ ring_buffer.clear();
+ ring_buffer.extend_from_slice(&buffer[read - n + ring_buffer.len()..read]);
}
- };
- if read == 0 {
- return Ok(());
- } else if read >= n {
- stdout.write_all(&ring_buffer)?;
- stdout.write_all(&buffer[..read - n])?;
- for i in 0..n {
- ring_buffer[i] = buffer[read - n + i];
- }
- } else {
- stdout.write_all(&ring_buffer[..read])?;
- for i in 0..n - read {
- ring_buffer[i] = ring_buffer[read + i];
- }
- ring_buffer[n - read..].copy_from_slice(&buffer[..read]);
}
}
+
+ Ok(())
}
fn read_but_last_n_lines(
input: impl std::io::BufRead,
- n: usize,
- zero: bool,
+ n: u64,
+ separator: u8,
) -> std::io::Result<()> {
- if zero {
- let stdout = std::io::stdout();
- let mut stdout = stdout.lock();
- for bytes in take_all_but(lines(input, b'\0'), n) {
- stdout.write_all(&bytes?)?;
- }
- } else {
+ if let Some(n) = catch_too_large_numbers_in_backwards_bytes_or_lines(n) {
let stdout = std::io::stdout();
let mut stdout = stdout.lock();
- for bytes in take_all_but(lines(input, b'\n'), n) {
+ for bytes in take_all_but(lines(input, separator), n) {
stdout.write_all(&bytes?)?;
}
}
@@ -356,7 +354,7 @@ fn read_but_last_n_lines(
/// assert_eq!(find_nth_line_from_end(&mut input, 4, false).unwrap(), 0);
/// assert_eq!(find_nth_line_from_end(&mut input, 1000, false).unwrap(), 0);
/// ```
-fn find_nth_line_from_end<R>(input: &mut R, n: u64, zeroed: bool) -> std::io::Result<u64>
+fn find_nth_line_from_end<R>(input: &mut R, n: u64, separator: u8) -> std::io::Result<u64>
where
R: Read + Seek,
{
@@ -376,30 +374,60 @@ where
))?;
input.read_exact(buffer)?;
for byte in buffer.iter().rev() {
- match byte {
- b'\n' if !zeroed => {
- lines += 1;
- }
- 0u8 if zeroed => {
- lines += 1;
- }
- _ => {}
+ if byte == &separator {
+ lines += 1;
}
// if it were just `n`,
if lines == n + 1 {
- input.seek(SeekFrom::Start(0))?;
+ input.rewind()?;
return Ok(size - i);
}
i += 1;
}
if size - i == 0 {
- input.seek(SeekFrom::Start(0))?;
+ input.rewind()?;
return Ok(0);
}
}
}
+fn is_seekable(input: &mut std::fs::File) -> bool {
+ let current_pos = input.stream_position();
+ current_pos.is_ok()
+ && input.seek(SeekFrom::End(0)).is_ok()
+ && input.seek(SeekFrom::Start(current_pos.unwrap())).is_ok()
+}
+
fn head_backwards_file(input: &mut std::fs::File, options: &HeadOptions) -> std::io::Result<()> {
+ let st = input.metadata()?;
+ let seekable = is_seekable(input);
+ let blksize_limit = uucore::fs::sane_blksize::sane_blksize_from_metadata(&st);
+ if !seekable || st.len() <= blksize_limit {
+ return head_backwards_without_seek_file(input, options);
+ }
+
+ head_backwards_on_seekable_file(input, options)
+}
+
+fn head_backwards_without_seek_file(
+ input: &mut std::fs::File,
+ options: &HeadOptions,
+) -> std::io::Result<()> {
+ let reader = &mut std::io::BufReader::with_capacity(BUF_SIZE, &*input);
+
+ match options.mode {
+ Mode::AllButLastBytes(n) => read_but_last_n_bytes(reader, n)?,
+ Mode::AllButLastLines(n) => read_but_last_n_lines(reader, n, options.line_ending.into())?,
+ _ => unreachable!(),
+ }
+
+ Ok(())
+}
+
+fn head_backwards_on_seekable_file(
+ input: &mut std::fs::File,
+ options: &HeadOptions,
+) -> std::io::Result<()> {
match options.mode {
Mode::AllButLastBytes(n) => {
let size = input.metadata()?.len();
@@ -413,7 +441,7 @@ fn head_backwards_file(input: &mut std::fs::File, options: &HeadOptions) -> std:
}
}
Mode::AllButLastLines(n) => {
- let found = find_nth_line_from_end(input, n, options.zeroed)?;
+ let found = find_nth_line_from_end(input, n, options.line_ending.into())?;
read_n_bytes(
&mut std::io::BufReader::with_capacity(BUF_SIZE, input),
found,
@@ -432,12 +460,13 @@ fn head_file(input: &mut std::fs::File, options: &HeadOptions) -> std::io::Resul
Mode::FirstLines(n) => read_n_lines(
&mut std::io::BufReader::with_capacity(BUF_SIZE, input),
n,
- options.zeroed,
+ options.line_ending.into(),
),
Mode::AllButLastBytes(_) | Mode::AllButLastLines(_) => head_backwards_file(input, options),
}
}
+#[allow(clippy::cognitive_complexity)]
fn uu_head(options: &HeadOptions) -> UResult<()> {
let mut first = true;
for file in &options.files {
@@ -452,29 +481,12 @@ fn uu_head(options: &HeadOptions) -> UResult<()> {
let stdin = std::io::stdin();
let mut stdin = stdin.lock();
- // Outputting "all-but-last" requires us to use a ring buffer with size n, so n
- // must be converted from u64 to usize to fit in memory. If such conversion fails,
- // it means the platform doesn't have enough memory to hold the buffer, so we fail.
- if let Mode::AllButLastLines(n) | Mode::AllButLastBytes(n) = options.mode {
- if let Err(e) = usize::try_from(n) {
- show!(USimpleError::new(
- 1,
- format!("{}: number of bytes is too large", e)
- ));
- continue;
- };
- };
-
match options.mode {
Mode::FirstBytes(n) => read_n_bytes(&mut stdin, n),
- // unwrap is guaranteed to succeed because we checked the value of n above
- Mode::AllButLastBytes(n) => {
- read_but_last_n_bytes(&mut stdin, n.try_into().unwrap())
- }
- Mode::FirstLines(n) => read_n_lines(&mut stdin, n, options.zeroed),
- // unwrap is guaranteed to succeed because we checked the value of n above
+ Mode::AllButLastBytes(n) => read_but_last_n_bytes(&mut stdin, n),
+ Mode::FirstLines(n) => read_n_lines(&mut stdin, n, options.line_ending.into()),
Mode::AllButLastLines(n) => {
- read_but_last_n_lines(&mut stdin, n.try_into().unwrap(), options.zeroed)
+ read_but_last_n_lines(&mut stdin, n, options.line_ending.into())
}
}
}
@@ -493,7 +505,7 @@ fn uu_head(options: &HeadOptions) -> UResult<()> {
if !first {
println!();
}
- println!("==> {} <==", name);
+ println!("==> {name} <==");
}
head_file(&mut file, options)
}
@@ -506,7 +518,7 @@ fn uu_head(options: &HeadOptions) -> UResult<()> {
};
show!(USimpleError::new(
1,
- format!("error reading {}: Input/output error", name)
+ format!("error reading {name}: Input/output error")
));
}
first = false;
@@ -536,6 +548,7 @@ mod tests {
use std::io::Cursor;
use super::*;
+
fn options(args: &str) -> Result<HeadOptions, String> {
let combined = "head ".to_owned() + args;
let args = combined.split_whitespace().map(OsString::from);
@@ -543,13 +556,15 @@ mod tests {
.get_matches_from(arg_iterate(args).map_err(|_| String::from("Arg iterate failed"))?);
HeadOptions::get_from(&matches)
}
+
#[test]
fn test_args_modes() {
let args = options("-n -10M -vz").unwrap();
- assert!(args.zeroed);
+ assert_eq!(args.line_ending, LineEnding::Nul);
assert!(args.verbose);
assert_eq!(args.mode, Mode::AllButLastLines(10 * 1024 * 1024));
}
+
#[test]
fn test_gnu_compatibility() {
let args = options("-n 1 -c 1 -n 5 -c kiB -vqvqv").unwrap(); // spell-checker:disable-line
@@ -559,35 +574,43 @@ mod tests {
assert_eq!(options("-2b").unwrap().mode, Mode::FirstBytes(1024));
assert_eq!(options("-5 -c 1").unwrap().mode, Mode::FirstBytes(1));
}
+
#[test]
+ #[allow(clippy::cognitive_complexity)]
fn all_args_test() {
assert!(options("--silent").unwrap().quiet);
assert!(options("--quiet").unwrap().quiet);
assert!(options("-q").unwrap().quiet);
assert!(options("--verbose").unwrap().verbose);
assert!(options("-v").unwrap().verbose);
- assert!(options("--zero-terminated").unwrap().zeroed);
- assert!(options("-z").unwrap().zeroed);
+ assert_eq!(
+ options("--zero-terminated").unwrap().line_ending,
+ LineEnding::Nul
+ );
+ assert_eq!(options("-z").unwrap().line_ending, LineEnding::Nul);
assert_eq!(options("--lines 15").unwrap().mode, Mode::FirstLines(15));
assert_eq!(options("-n 15").unwrap().mode, Mode::FirstLines(15));
assert_eq!(options("--bytes 15").unwrap().mode, Mode::FirstBytes(15));
assert_eq!(options("-c 15").unwrap().mode, Mode::FirstBytes(15));
}
+
#[test]
fn test_options_errors() {
assert!(options("-n IsThisTheRealLife?").is_err());
assert!(options("-c IsThisJustFantasy").is_err());
}
+
#[test]
fn test_options_correct_defaults() {
- let opts: HeadOptions = Default::default();
+ let opts = HeadOptions::default();
assert!(!opts.verbose);
assert!(!opts.quiet);
- assert!(!opts.zeroed);
+ assert_eq!(opts.line_ending, LineEnding::Newline);
assert_eq!(opts.mode, Mode::FirstLines(10));
assert!(opts.files.is_empty());
}
+
fn arg_outputs(src: &str) -> Result<String, ()> {
let split = src.split_whitespace().map(OsString::from);
match arg_iterate(split) {
@@ -600,6 +623,7 @@ mod tests {
Err(_) => Err(()),
}
}
+
#[test]
fn test_arg_iterate() {
// test that normal args remain unchanged
@@ -624,31 +648,31 @@ mod tests {
//test that empty args remain unchanged
assert_eq!(arg_outputs("head"), Ok("head".to_owned()));
}
+
#[test]
#[cfg(target_os = "linux")]
fn test_arg_iterate_bad_encoding() {
- #[allow(clippy::invalid_utf8_in_unchecked)]
- let invalid = unsafe { std::str::from_utf8_unchecked(b"\x80\x81") };
+ use std::os::unix::ffi::OsStringExt;
+ let invalid = OsString::from_vec(vec![b'\x80', b'\x81']);
// this arises from a conversion from OsString to &str
- assert!(
- arg_iterate(vec![OsString::from("head"), OsString::from(invalid)].into_iter()).is_err()
- );
+ assert!(arg_iterate(vec![OsString::from("head"), invalid].into_iter()).is_err());
}
+
#[test]
fn read_early_exit() {
let mut empty = std::io::BufReader::new(std::io::Cursor::new(Vec::new()));
assert!(read_n_bytes(&mut empty, 0).is_ok());
- assert!(read_n_lines(&mut empty, 0, false).is_ok());
+ assert!(read_n_lines(&mut empty, 0, b'\n').is_ok());
}
#[test]
fn test_find_nth_line_from_end() {
let mut input = Cursor::new("x\ny\nz\n");
- assert_eq!(find_nth_line_from_end(&mut input, 0, false).unwrap(), 6);
- assert_eq!(find_nth_line_from_end(&mut input, 1, false).unwrap(), 4);
- assert_eq!(find_nth_line_from_end(&mut input, 2, false).unwrap(), 2);
- assert_eq!(find_nth_line_from_end(&mut input, 3, false).unwrap(), 0);
- assert_eq!(find_nth_line_from_end(&mut input, 4, false).unwrap(), 0);
- assert_eq!(find_nth_line_from_end(&mut input, 1000, false).unwrap(), 0);
+ assert_eq!(find_nth_line_from_end(&mut input, 0, b'\n').unwrap(), 6);
+ assert_eq!(find_nth_line_from_end(&mut input, 1, b'\n').unwrap(), 4);
+ assert_eq!(find_nth_line_from_end(&mut input, 2, b'\n').unwrap(), 2);
+ assert_eq!(find_nth_line_from_end(&mut input, 3, b'\n').unwrap(), 0);
+ assert_eq!(find_nth_line_from_end(&mut input, 4, b'\n').unwrap(), 0);
+ assert_eq!(find_nth_line_from_end(&mut input, 1000, b'\n').unwrap(), 0);
}
}
diff --git a/src/uu/head/src/parse.rs b/src/uu/head/src/parse.rs
index 3b7c718ab39b6da1e36c1a8bed60ccc1d65cfcf9..dce60bae012ff880fffeae16dff29012af5c8c8f 100644
--- a/src/uu/head/src/parse.rs
+++ b/src/uu/head/src/parse.rs
@@ -1,16 +1,17 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::ffi::OsString;
-use uucore::parse_size::{parse_size, ParseSizeError};
+use uucore::parse_size::{parse_size_u64, ParseSizeError};
#[derive(PartialEq, Eq, Debug)]
pub enum ParseError {
Syntax,
Overflow,
}
+
/// Parses obsolete syntax
/// head -NUM\[kmzv\] // spell-checker:disable-line
pub fn parse_obsolete(src: &str) -> Option<Result<impl Iterator<Item = OsString>, ParseError>> {
@@ -29,65 +30,7 @@ pub fn parse_obsolete(src: &str) -> Option<Result<impl Iterator<Item = OsString>
}
}
if has_num {
- match src[1..=num_end].parse::<usize>() {
- Ok(num) => {
- let mut quiet = false;
- let mut verbose = false;
- let mut zero_terminated = false;
- let mut multiplier = None;
- let mut c = last_char;
- loop {
- // not that here, we only match lower case 'k', 'c', and 'm'
- match c {
- // we want to preserve order
- // this also saves us 1 heap allocation
- 'q' => {
- quiet = true;
- verbose = false;
- }
- 'v' => {
- verbose = true;
- quiet = false;
- }
- 'z' => zero_terminated = true,
- 'c' => multiplier = Some(1),
- 'b' => multiplier = Some(512),
- 'k' => multiplier = Some(1024),
- 'm' => multiplier = Some(1024 * 1024),
- '\0' => {}
- _ => return Some(Err(ParseError::Syntax)),
- }
- if let Some((_, next)) = chars.next() {
- c = next;
- } else {
- break;
- }
- }
- let mut options = Vec::new();
- if quiet {
- options.push(OsString::from("-q"));
- }
- if verbose {
- options.push(OsString::from("-v"));
- }
- if zero_terminated {
- options.push(OsString::from("-z"));
- }
- if let Some(n) = multiplier {
- options.push(OsString::from("-c"));
- let num = match num.checked_mul(n) {
- Some(n) => n,
- None => return Some(Err(ParseError::Overflow)),
- };
- options.push(OsString::from(format!("{}", num)));
- } else {
- options.push(OsString::from("-n"));
- options.push(OsString::from(format!("{}", num)));
- }
- Some(Ok(options.into_iter()))
- }
- Err(_) => Some(Err(ParseError::Overflow)),
- }
+ process_num_block(&src[1..=num_end], last_char, &mut chars)
} else {
None
}
@@ -95,6 +38,74 @@ pub fn parse_obsolete(src: &str) -> Option<Result<impl Iterator<Item = OsString>
None
}
}
+
+/// Processes the numeric block of the input string to generate the appropriate options.
+fn process_num_block(
+ src: &str,
+ last_char: char,
+ chars: &mut std::str::CharIndices,
+) -> Option<Result<impl Iterator<Item = OsString>, ParseError>> {
+ match src.parse::<usize>() {
+ Ok(num) => {
+ let mut quiet = false;
+ let mut verbose = false;
+ let mut zero_terminated = false;
+ let mut multiplier = None;
+ let mut c = last_char;
+ loop {
+ // note that here, we only match lower case 'k', 'c', and 'm'
+ match c {
+ // we want to preserve order
+ // this also saves us 1 heap allocation
+ 'q' => {
+ quiet = true;
+ verbose = false;
+ }
+ 'v' => {
+ verbose = true;
+ quiet = false;
+ }
+ 'z' => zero_terminated = true,
+ 'c' => multiplier = Some(1),
+ 'b' => multiplier = Some(512),
+ 'k' => multiplier = Some(1024),
+ 'm' => multiplier = Some(1024 * 1024),
+ '\0' => {}
+ _ => return Some(Err(ParseError::Syntax)),
+ }
+ if let Some((_, next)) = chars.next() {
+ c = next;
+ } else {
+ break;
+ }
+ }
+ let mut options = Vec::new();
+ if quiet {
+ options.push(OsString::from("-q"));
+ }
+ if verbose {
+ options.push(OsString::from("-v"));
+ }
+ if zero_terminated {
+ options.push(OsString::from("-z"));
+ }
+ if let Some(n) = multiplier {
+ options.push(OsString::from("-c"));
+ let num = match num.checked_mul(n) {
+ Some(n) => n,
+ None => return Some(Err(ParseError::Overflow)),
+ };
+ options.push(OsString::from(format!("{num}")));
+ } else {
+ options.push(OsString::from("-n"));
+ options.push(OsString::from(format!("{num}")));
+ }
+ Some(Ok(options.into_iter()))
+ }
+ Err(_) => Some(Err(ParseError::Overflow)),
+ }
+}
+
/// Parses an -c or -n argument,
/// the bool specifies whether to read from the end
pub fn parse_num(src: &str) -> Result<(u64, bool), ParseSizeError> {
@@ -113,12 +124,19 @@ pub fn parse_num(src: &str) -> Result<(u64, bool), ParseSizeError> {
return Err(ParseSizeError::ParseFailure(src.to_string()));
}
- parse_size(size_string).map(|n| (n, all_but_last))
+ // remove leading zeros so that size is interpreted as decimal, not octal
+ let trimmed_string = size_string.trim_start_matches('0');
+ if trimmed_string.is_empty() {
+ Ok((0, all_but_last))
+ } else {
+ parse_size_u64(trimmed_string).map(|n| (n, all_but_last))
+ }
}
#[cfg(test)]
mod tests {
use super::*;
+
fn obsolete(src: &str) -> Option<Result<Vec<String>, ParseError>> {
let r = parse_obsolete(src);
match r {
@@ -129,10 +147,13 @@ mod tests {
None => None,
}
}
+
fn obsolete_result(src: &[&str]) -> Option<Result<Vec<String>, ParseError>> {
Some(Ok(src.iter().map(|s| s.to_string()).collect()))
}
+
#[test]
+ #[allow(clippy::cognitive_complexity)]
fn test_parse_numbers_obsolete() {
assert_eq!(obsolete("-5"), obsolete_result(&["-n", "5"]));
assert_eq!(obsolete("-100"), obsolete_result(&["-n", "100"]));
@@ -151,16 +172,19 @@ mod tests {
obsolete_result(&["-z", "-c", "110100480"])
);
}
+
#[test]
fn test_parse_errors_obsolete() {
assert_eq!(obsolete("-5n"), Some(Err(ParseError::Syntax)));
assert_eq!(obsolete("-5c5"), Some(Err(ParseError::Syntax)));
}
+
#[test]
fn test_parse_obsolete_no_match() {
assert_eq!(obsolete("-k"), None);
assert_eq!(obsolete("asd"), None);
}
+
#[test]
#[cfg(target_pointer_width = "64")]
fn test_parse_obsolete_overflow_x64() {
@@ -173,6 +197,7 @@ mod tests {
Some(Err(ParseError::Overflow))
);
}
+
#[test]
#[cfg(target_pointer_width = "32")]
fn test_parse_obsolete_overflow_x32() {
diff --git a/src/uu/head/src/take.rs b/src/uu/head/src/take.rs
index 47beba8a48da7fdc643138e3eb497077deea4db0..da48afd6a860883961fd2c4f1c8c020bcc8e5482 100644
--- a/src/uu/head/src/take.rs
+++ b/src/uu/head/src/take.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//! Take all but the last elements of an iterator.
use std::io::Read;
diff --git a/src/uu/hostid/Cargo.toml b/src/uu/hostid/Cargo.toml
index 348e35723bf65c2954e6de43ae3e941d23da048a..5f9655c2ee5d1496aa8ceddbf717b40430237ea7 100644
--- a/src/uu/hostid/Cargo.toml
+++ b/src/uu/hostid/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_hostid"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "hostid ~ (uutils) display the numeric identifier of the current host"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/hostid.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-libc = "0.2.137"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "hostid"
diff --git a/src/uu/hostid/hostid.md b/src/uu/hostid/hostid.md
new file mode 100644
index 0000000000000000000000000000000000000000..940cf5e5d36733f0c6674a19f8366a7032a73ac1
--- /dev/null
+++ b/src/uu/hostid/hostid.md
@@ -0,0 +1,7 @@
+# hostid
+
+```
+hostid [options]
+```
+
+Print the numeric identifier (in hexadecimal) for the current host
diff --git a/src/uu/hostid/src/hostid.rs b/src/uu/hostid/src/hostid.rs
index 293a9cacdb294836759d3a0f9a3b760dc9ced8db..157cfc420b4353ce4280b170c7f902a7ed28a86f 100644
--- a/src/uu/hostid/src/hostid.rs
+++ b/src/uu/hostid/src/hostid.rs
@@ -1,18 +1,16 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Maciej Dziardziel <fiedzia@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) gethostid
use clap::{crate_version, Command};
use libc::c_long;
-use uucore::{error::UResult, format_usage};
+use uucore::{error::UResult, format_usage, help_about, help_usage};
-const USAGE: &str = "{} [options]";
-const ABOUT: &str = "Print the numeric identifier (in hexadecimal) for the current host";
+const USAGE: &str = help_usage!("hostid.md");
+const ABOUT: &str = help_about!("hostid.md");
// currently rust libc interface doesn't include gethostid
extern "C" {
@@ -21,7 +19,7 @@ extern "C" {
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- uu_app().get_matches_from(args);
+ uu_app().try_get_matches_from(args)?;
hostid();
Ok(())
}
@@ -50,5 +48,5 @@ fn hostid() {
let mask = 0xffff_ffff;
result &= mask;
- println!("{:0>8x}", result);
+ println!("{result:0>8x}");
}
diff --git a/src/uu/hostname/Cargo.toml b/src/uu/hostname/Cargo.toml
index e4df402632983d0d32be3ca09e2e7491ec570fdb..d5ec07f87ea5a9e9fffe45de36c9e438dcb4edc7 100644
--- a/src/uu/hostname/Cargo.toml
+++ b/src/uu/hostname/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_hostname"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "hostname ~ (uutils) display or set the host name of the current host"
@@ -15,12 +15,15 @@ edition = "2021"
path = "src/hostname.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-hostname = { version = "0.3", features = ["set"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["wide"] }
+clap = { workspace = true }
+hostname = { workspace = true, features = ["set"] }
+uucore = { workspace = true, features = ["wide"] }
[target.'cfg(target_os = "windows")'.dependencies]
-windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_Networking_WinSock", "Win32_Foundation"] }
+windows-sys = { workspace = true, features = [
+ "Win32_Networking_WinSock",
+ "Win32_Foundation",
+] }
[[bin]]
name = "hostname"
diff --git a/src/uu/hostname/hostname.md b/src/uu/hostname/hostname.md
new file mode 100644
index 0000000000000000000000000000000000000000..f9e852c4b9e1430c3beacda15459451434104429
--- /dev/null
+++ b/src/uu/hostname/hostname.md
@@ -0,0 +1,7 @@
+# hostname
+
+```
+hostname [OPTION]... [HOSTNAME]
+```
+
+Display or set the system's host name.
diff --git a/src/uu/hostname/src/hostname.rs b/src/uu/hostname/src/hostname.rs
index 92950f137decc556ca7fe54f78c6bfd8317286d9..6a318cb8c26286d27ad1b1fed56f154b0eb6dab3 100644
--- a/src/uu/hostname/src/hostname.rs
+++ b/src/uu/hostname/src/hostname.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Alan Andrade <alan.andradec@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) MAKEWORD addrs hashset
@@ -16,11 +14,11 @@ use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
use uucore::{
error::{FromIo, UResult},
- format_usage,
+ format_usage, help_about, help_usage,
};
-static ABOUT: &str = "Display or set the system's host name.";
-const USAGE: &str = "{} [OPTION]... [HOSTNAME]";
+const ABOUT: &str = help_about!("hostname.md");
+const USAGE: &str = help_usage!("hostname.md");
static OPT_DOMAIN: &str = "domain";
static OPT_IP_ADDRESS: &str = "ip-address";
@@ -41,10 +39,10 @@ mod wsa {
let mut data = std::mem::MaybeUninit::<WSADATA>::uninit();
WSAStartup(0x0202, data.as_mut_ptr())
};
- if err != 0 {
- Err(io::Error::from_raw_os_error(err))
- } else {
+ if err == 0 {
Ok(WsaHandle(()))
+ } else {
+ Err(io::Error::from_raw_os_error(err))
}
}
@@ -164,7 +162,7 @@ fn display_hostname(matches: &ArgMatches) -> UResult<()> {
}
}
- println!("{}", hostname);
+ println!("{hostname}");
Ok(())
}
diff --git a/src/uu/id/Cargo.toml b/src/uu/id/Cargo.toml
index 4437b489817c1f4e6ecfbde8e982279b77f1309f..ee4be843904a1aa9529a05849f55aced72e76f3b 100644
--- a/src/uu/id/Cargo.toml
+++ b/src/uu/id/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_id"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "id ~ (uutils) display user and group information for USER"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/id.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["entries", "process"] }
-selinux = { version="0.3", optional = true }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["entries", "process"] }
+selinux = { workspace = true, optional = true }
[[bin]]
name = "id"
diff --git a/src/uu/id/id.md b/src/uu/id/id.md
new file mode 100644
index 0000000000000000000000000000000000000000..bb7330314ab553befb0388569ba004bf2e24704f
--- /dev/null
+++ b/src/uu/id/id.md
@@ -0,0 +1,18 @@
+# id
+
+```
+id [OPTION]... [USER]...
+```
+
+Print user and group information for each specified `USER`,
+or (when `USER` omitted) for the current user.
+
+## After help
+
+The id utility displays the user and group names and numeric IDs, of the
+calling process, to the standard output. If the real and effective IDs are
+different, both are displayed, otherwise only the real ID is displayed.
+
+If a user (login name or user ID) is specified, the user and group IDs of
+that user are displayed. In this case, the real and effective IDs are
+assumed to be the same.
diff --git a/src/uu/id/src/id.rs b/src/uu/id/src/id.rs
index a26034f47a93426155c1335c3f416fb1d41d3426..e803708bdceee948a9b58a7b9cb087c183d1a682 100644
--- a/src/uu/id/src/id.rs
+++ b/src/uu/id/src/id.rs
@@ -1,8 +1,5 @@
// This file is part of the uutils coreutils package.
//
-// (c) Alan Andrade <alan.andradec@gmail.com>
-// (c) Jian Zeng <anonymousknight96 AT gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
@@ -44,8 +41,9 @@ use uucore::error::UResult;
use uucore::error::{set_exit_code, USimpleError};
pub use uucore::libc;
use uucore::libc::{getlogin, uid_t};
+use uucore::line_ending::LineEnding;
use uucore::process::{getegid, geteuid, getgid, getuid};
-use uucore::{format_usage, show_error};
+use uucore::{format_usage, help_about, help_section, help_usage, show_error};
macro_rules! cstr2cow {
($v:expr) => {
@@ -53,9 +51,9 @@ macro_rules! cstr2cow {
};
}
-static ABOUT: &str = "Print user and group information for each specified USER,
-or (when USER omitted) for the current user.";
-const USAGE: &str = "{} [OPTION]... [USER]...";
+const ABOUT: &str = help_about!("id.md");
+const USAGE: &str = help_usage!("id.md");
+const AFTER_HELP: &str = help_section!("after help", "id.md");
#[cfg(not(feature = "selinux"))]
static CONTEXT_HELP_TEXT: &str = "print only the security context of the process (not enabled)";
@@ -76,15 +74,6 @@ mod options {
pub const ARG_USERS: &str = "USER";
}
-fn get_description() -> &'static str {
- "The id utility displays the user and group names and numeric IDs, of the \
- calling process, to the standard output. If the real and effective IDs are \
- different, both are displayed, otherwise only the real ID is displayed.\n\n\
- If a user (login name or user ID) is specified, the user and group IDs of \
- that user are displayed. In this case, the real and effective IDs are \
- assumed to be the same."
-}
-
struct Ids {
uid: u32, // user id
gid: u32, // group id
@@ -120,10 +109,9 @@ struct State {
}
#[uucore::main]
+#[allow(clippy::cognitive_complexity)]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let matches = uu_app()
- .after_help(get_description())
- .try_get_matches_from(args)?;
+ let matches = uu_app().after_help(AFTER_HELP).try_get_matches_from(args)?;
let users: Vec<String> = matches
.get_many::<String>(options::ARG_USERS)
@@ -185,13 +173,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
" ".to_string()
}
};
- let line_ending = {
- if state.zflag {
- '\0'
- } else {
- '\n'
- }
- };
+ let line_ending = LineEnding::from_zero_flag(state.zflag);
if state.cflag {
if state.selinux_supported {
@@ -214,9 +196,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
}
for i in 0..=users.len() {
- let possible_pw = if !state.user_specified {
- None
- } else {
+ let possible_pw = if state.user_specified {
match Passwd::locate(users[i].as_str()) {
Ok(p) => Some(p),
Err(_) => {
@@ -229,6 +209,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
}
}
}
+ } else {
+ None
};
// GNU's `id` does not support the flags: -p/-P/-A.
@@ -324,9 +306,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
}
if default_format {
- id_print(&mut state, &groups);
+ id_print(&state, &groups);
}
- print!("{}", line_ending);
+ print!("{line_ending}");
if i + 1 >= users.len() {
break;
@@ -342,6 +324,7 @@ pub fn uu_app() -> Command {
.about(ABOUT)
.override_usage(format_usage(USAGE))
.infer_long_args(true)
+ .args_override_self(true)
.arg(
Arg::new(options::OPT_AUDIT)
.short('A')
@@ -414,6 +397,7 @@ pub fn uu_app() -> Command {
Arg::new(options::OPT_PASSWORD)
.short('P')
.help("Display the id as a password file entry.")
+ .conflicts_with(options::OPT_HUMAN_READABLE)
.action(ArgAction::SetTrue),
)
.arg(
@@ -468,11 +452,11 @@ fn pretty(possible_pw: Option<Passwd>) {
let rid = getuid();
if let Ok(p) = Passwd::locate(rid) {
if login == p.name {
- println!("login\t{}", login);
+ println!("login\t{login}");
}
println!("uid\t{}", p.name);
} else {
- println!("uid\t{}", rid);
+ println!("uid\t{rid}");
}
let eid = getegid();
@@ -480,7 +464,7 @@ fn pretty(possible_pw: Option<Passwd>) {
if let Ok(p) = Passwd::locate(eid) {
println!("euid\t{}", p.name);
} else {
- println!("euid\t{}", eid);
+ println!("euid\t{eid}");
}
}
@@ -489,7 +473,7 @@ fn pretty(possible_pw: Option<Passwd>) {
if let Ok(g) = Group::locate(rid) {
println!("euid\t{}", g.name);
} else {
- println!("euid\t{}", rid);
+ println!("euid\t{rid}");
}
}
@@ -525,7 +509,7 @@ fn pline(possible_uid: Option<uid_t>) {
);
}
-#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(any(target_os = "linux", target_os = "android", target_os = "openbsd"))]
fn pline(possible_uid: Option<uid_t>) {
let uid = possible_uid.unwrap_or_else(getuid);
let pw = Passwd::locate(uid).unwrap();
@@ -542,10 +526,10 @@ fn pline(possible_uid: Option<uid_t>) {
);
}
-#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(any(target_os = "linux", target_os = "android", target_os = "openbsd"))]
fn auditid() {}
-#[cfg(not(any(target_os = "linux", target_os = "android")))]
+#[cfg(not(any(target_os = "linux", target_os = "android", target_os = "openbsd")))]
fn auditid() {
use std::mem::MaybeUninit;
@@ -566,7 +550,7 @@ fn auditid() {
println!("asid={}", auditinfo.ai_asid);
}
-fn id_print(state: &mut State, groups: &[u32]) {
+fn id_print(state: &State, groups: &[u32]) {
let uid = state.ids.as_ref().unwrap().uid;
let gid = state.ids.as_ref().unwrap().gid;
let euid = state.ids.as_ref().unwrap().euid;
@@ -642,7 +626,7 @@ fn id_print(state: &mut State, groups: &[u32]) {
}
}
-#[cfg(not(any(target_os = "linux", target_os = "android")))]
+#[cfg(not(any(target_os = "linux", target_os = "android", target_os = "openbsd")))]
mod audit {
use super::libc::{c_int, c_uint, dev_t, pid_t, uid_t};
diff --git a/src/uu/install/Cargo.toml b/src/uu/install/Cargo.toml
index b51f2bbd22657926378103142fa5b5df6b07ddf0..46afbb2dd9d6d789d8221e1467fc9578d8d83fda 100644
--- a/src/uu/install/Cargo.toml
+++ b/src/uu/install/Cargo.toml
@@ -1,10 +1,7 @@
[package]
name = "uu_install"
-version = "0.0.17"
-authors = [
- "Ben Eills <ben@beneills.com>",
- "uutils developers",
-]
+version = "0.0.27"
+authors = ["Ben Eills <ben@beneills.com>", "uutils developers"]
license = "MIT"
description = "install ~ (uutils) copy files from SOURCE to DESTINATION (with specified attributes)"
@@ -18,14 +15,18 @@ edition = "2021"
path = "src/install.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-filetime = "0.2"
-file_diff = "1.0.0"
-libc = ">= 0.2"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["fs", "mode", "perms", "entries"] }
-
-[dev-dependencies]
-time = "0.3"
+clap = { workspace = true }
+filetime = { workspace = true }
+file_diff = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true, features = [
+ "backup-control",
+ "fs",
+ "mode",
+ "perms",
+ "entries",
+ "process",
+] }
[[bin]]
name = "install"
diff --git a/src/uu/install/install.md b/src/uu/install/install.md
new file mode 100644
index 0000000000000000000000000000000000000000..ac6a70f4219fc646f7a5b91734ea69ddc1067dfc
--- /dev/null
+++ b/src/uu/install/install.md
@@ -0,0 +1,8 @@
+# install
+
+```
+install [OPTION]... [FILE]...
+```
+
+Copy SOURCE to DEST or multiple SOURCE(s) to the existing
+DIRECTORY, while setting permission modes and owner/group
diff --git a/src/uu/install/src/install.rs b/src/uu/install/src/install.rs
index db9fe7d3c4e1f853cd7b188d66d2fd1654b3851f..331a50f6741a255ed8919dfd5787fd368cd259d1 100644
--- a/src/uu/install/src/install.rs
+++ b/src/uu/install/src/install.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Ben Eills <ben@beneills.com>
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) rwxr sourcepath targetpath Isnt uioerror
@@ -12,16 +10,6 @@ mod mode;
use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
use file_diff::diff;
use filetime::{set_file_times, FileTime};
-use uucore::backup_control::{self, BackupMode};
-use uucore::display::Quotable;
-use uucore::entries::{grp2gid, usr2uid};
-use uucore::error::{FromIo, UError, UIoError, UResult, UUsageError};
-use uucore::fs::dir_strip_dot_for_creation;
-use uucore::mode::get_umask;
-use uucore::perms::{wrap_chown, Verbosity, VerbosityLevel};
-use uucore::{format_usage, show, show_error, show_if_err, uio_error};
-
-use libc::{getegid, geteuid};
use std::error::Error;
use std::fmt::{Debug, Display};
use std::fs;
@@ -31,6 +19,15 @@ use std::os::unix::fs::MetadataExt;
use std::os::unix::prelude::OsStrExt;
use std::path::{Path, PathBuf, MAIN_SEPARATOR};
use std::process;
+use uucore::backup_control::{self, BackupMode};
+use uucore::display::Quotable;
+use uucore::entries::{grp2gid, usr2uid};
+use uucore::error::{FromIo, UError, UIoError, UResult, UUsageError};
+use uucore::fs::dir_strip_dot_for_creation;
+use uucore::mode::get_umask;
+use uucore::perms::{wrap_chown, Verbosity, VerbosityLevel};
+use uucore::process::{getegid, geteuid};
+use uucore::{format_usage, help_about, help_usage, show, show_error, show_if_err, uio_error};
const DEFAULT_MODE: u32 = 0o755;
const DEFAULT_STRIP_PROGRAM: &str = "strip";
@@ -41,8 +38,8 @@ pub struct Behavior {
specified_mode: Option<u32>,
backup_mode: BackupMode,
suffix: String,
- owner: String,
- group: String,
+ owner_id: Option<u32>,
+ group_id: Option<u32>,
verbose: bool,
preserve_timestamps: bool,
compare: bool,
@@ -58,15 +55,17 @@ enum InstallError {
DirNeedsArg(),
CreateDirFailed(PathBuf, std::io::Error),
ChmodFailed(PathBuf),
+ ChownFailed(PathBuf, String),
InvalidTarget(PathBuf),
TargetDirIsntDir(PathBuf),
BackupFailed(PathBuf, PathBuf, std::io::Error),
InstallFailed(PathBuf, PathBuf, std::io::Error),
StripProgramFailed(String),
MetadataFailed(std::io::Error),
- NoSuchUser(String),
- NoSuchGroup(String),
+ InvalidUser(String),
+ InvalidGroup(String),
OmittingDirectory(PathBuf),
+ NotADirectory(PathBuf),
}
impl UError for InstallError {
@@ -87,7 +86,7 @@ impl Error for InstallError {}
impl Display for InstallError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
- Self::Unimplemented(opt) => write!(f, "Unimplemented feature: {}", opt),
+ Self::Unimplemented(opt) => write!(f, "Unimplemented feature: {opt}"),
Self::DirNeedsArg() => {
write!(
f,
@@ -99,6 +98,7 @@ impl Display for InstallError {
Display::fmt(&uio_error!(e, "failed to create {}", dir.quote()), f)
}
Self::ChmodFailed(file) => write!(f, "failed to chmod {}", file.quote()),
+ Self::ChownFailed(file, msg) => write!(f, "failed to chown {}: {}", file.quote(), msg),
Self::InvalidTarget(target) => write!(
f,
"invalid target {}: No such file or directory",
@@ -115,11 +115,14 @@ impl Display for InstallError {
&uio_error!(e, "cannot install {} to {}", from.quote(), to.quote()),
f,
),
- Self::StripProgramFailed(msg) => write!(f, "strip program failed: {}", msg),
+ Self::StripProgramFailed(msg) => write!(f, "strip program failed: {msg}"),
Self::MetadataFailed(e) => Display::fmt(&uio_error!(e, ""), f),
- Self::NoSuchUser(user) => write!(f, "no such user: {}", user.maybe_quote()),
- Self::NoSuchGroup(group) => write!(f, "no such group: {}", group.maybe_quote()),
+ Self::InvalidUser(user) => write!(f, "invalid user: {}", user.quote()),
+ Self::InvalidGroup(group) => write!(f, "invalid group: {}", group.quote()),
Self::OmittingDirectory(dir) => write!(f, "omitting directory {}", dir.quote()),
+ Self::NotADirectory(dir) => {
+ write!(f, "failed to access {}: Not a directory", dir.quote())
+ }
}
}
}
@@ -142,9 +145,8 @@ impl Behavior {
}
}
-static ABOUT: &str = "Copy SOURCE to DEST or multiple SOURCE(s) to the existing
- DIRECTORY, while setting permission modes and owner/group";
-const USAGE: &str = "{} [OPTION]... [FILE]...";
+const ABOUT: &str = help_about!("install.md");
+const USAGE: &str = help_usage!("install.md");
static OPT_COMPARE: &str = "compare";
static OPT_DIRECTORY: &str = "directory";
@@ -376,9 +378,7 @@ fn behavior(matches: &ArgMatches) -> UResult<Behavior> {
};
let backup_mode = backup_control::determine_backup_mode(matches)?;
- let target_dir = matches
- .get_one::<String>(OPT_TARGET_DIRECTORY)
- .map(|d| d.to_owned());
+ let target_dir = matches.get_one::<String>(OPT_TARGET_DIRECTORY).cloned();
let preserve_timestamps = matches.get_flag(OPT_PRESERVE_TIMESTAMPS);
let compare = matches.get_flag(OPT_COMPARE);
@@ -391,21 +391,44 @@ fn behavior(matches: &ArgMatches) -> UResult<Behavior> {
show_error!("Options --compare and --strip are mutually exclusive");
return Err(1.into());
}
+
+ let owner = matches
+ .get_one::<String>(OPT_OWNER)
+ .map(|s| s.as_str())
+ .unwrap_or("")
+ .to_string();
+
+ let owner_id = if owner.is_empty() {
+ None
+ } else {
+ match usr2uid(&owner) {
+ Ok(u) => Some(u),
+ Err(_) => return Err(InstallError::InvalidUser(owner.clone()).into()),
+ }
+ };
+
+ let group = matches
+ .get_one::<String>(OPT_GROUP)
+ .map(|s| s.as_str())
+ .unwrap_or("")
+ .to_string();
+
+ let group_id = if group.is_empty() {
+ None
+ } else {
+ match grp2gid(&group) {
+ Ok(g) => Some(g),
+ Err(_) => return Err(InstallError::InvalidGroup(group.clone()).into()),
+ }
+ };
+
Ok(Behavior {
main_function,
specified_mode,
backup_mode,
suffix: backup_control::determine_backup_suffix(matches),
- owner: matches
- .get_one::<String>(OPT_OWNER)
- .map(|s| s.as_str())
- .unwrap_or("")
- .to_string(),
- group: matches
- .get_one::<String>(OPT_GROUP)
- .map(|s| s.as_str())
- .unwrap_or("")
- .to_string(),
+ owner_id,
+ group_id,
verbose: matches.get_flag(OPT_VERBOSE),
preserve_timestamps,
compare,
@@ -466,6 +489,8 @@ fn directory(paths: &[String], b: &Behavior) -> UResult<()> {
uucore::error::set_exit_code(1);
continue;
}
+
+ show_if_err!(chown_optional_user_group(path, b));
}
// If the exit code was set, or show! has been called at least once
// (which sets the exit code as well), function execution will end after
@@ -502,6 +527,7 @@ fn is_potential_directory_path(path: &Path) -> bool {
///
/// Returns a Result type with the Err variant containing the error message.
///
+#[allow(clippy::cognitive_complexity)]
fn standard(mut paths: Vec<String>, b: &Behavior) -> UResult<()> {
// first check that paths contains at least one element
if paths.is_empty() {
@@ -542,6 +568,13 @@ fn standard(mut paths: Vec<String>, b: &Behavior) -> UResult<()> {
};
if let Some(to_create) = to_create {
+ // if the path ends in /, remove it
+ let to_create = if to_create.to_string_lossy().ends_with('/') {
+ Path::new(to_create.to_str().unwrap().trim_end_matches('/'))
+ } else {
+ to_create
+ };
+
if !to_create.exists() {
if b.verbose {
let mut result = PathBuf::new();
@@ -558,12 +591,13 @@ fn standard(mut paths: Vec<String>, b: &Behavior) -> UResult<()> {
if let Err(e) = fs::create_dir_all(to_create) {
return Err(InstallError::CreateDirFailed(to_create.to_path_buf(), e).into());
}
+ }
+ }
+ if b.target_dir.is_some() {
+ let p = to_create.unwrap();
- // Silent the warning as we want to the error message
- #[allow(clippy::question_mark)]
- if mode::chmod(to_create, b.mode()).is_err() {
- return Err(InstallError::ChmodFailed(to_create.to_path_buf()).into());
- }
+ if !p.exists() || !p.is_dir() {
+ return Err(InstallError::NotADirectory(p.to_path_buf()).into());
}
}
}
@@ -574,7 +608,7 @@ fn standard(mut paths: Vec<String>, b: &Behavior) -> UResult<()> {
let source = sources.first().unwrap();
if source.is_dir() {
- return Err(InstallError::OmittingDirectory(source.to_path_buf()).into());
+ return Err(InstallError::OmittingDirectory(source.clone()).into());
}
if target.is_file() || is_new_file_path(&target) {
@@ -599,7 +633,7 @@ fn copy_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UR
if !target_dir.is_dir() {
return Err(InstallError::TargetDirIsntDir(target_dir.to_path_buf()).into());
}
- for sourcepath in files.iter() {
+ for sourcepath in files {
if let Err(err) = sourcepath
.metadata()
.map_err_context(|| format!("cannot stat {}", sourcepath.quote()))
@@ -609,7 +643,7 @@ fn copy_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UR
}
if sourcepath.is_dir() {
- let err = InstallError::OmittingDirectory(sourcepath.to_path_buf());
+ let err = InstallError::OmittingDirectory(sourcepath.clone());
show!(err);
continue;
}
@@ -626,47 +660,104 @@ fn copy_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UR
Ok(())
}
-/// Copy one file to a new location, changing metadata.
+/// Handle incomplete user/group parings for chown.
///
/// Returns a Result type with the Err variant containing the error message.
+/// If the user is root, revert the uid & gid
///
/// # Parameters
///
-/// _from_ must exist as a non-directory.
-/// _to_ must be a non-existent file, whose parent directory exists.
+/// _path_ must exist.
///
/// # Errors
///
-/// If the copy system call fails, we print a verbose error and return an empty error value.
+/// If the owner or group are invalid or copy system call fails, we print a verbose error and
+/// return an empty error value.
///
-#[allow(clippy::cognitive_complexity)]
-fn copy(from: &Path, to: &Path, b: &Behavior) -> UResult<()> {
- if b.compare && !need_copy(from, to, b)? {
+fn chown_optional_user_group(path: &Path, b: &Behavior) -> UResult<()> {
+ // GNU coreutils doesn't print chown operations during install with verbose flag.
+ let verbosity = Verbosity {
+ groups_only: b.owner_id.is_none(),
+ level: VerbosityLevel::Normal,
+ };
+
+ // Determine the owner and group IDs to be used for chown.
+ let (owner_id, group_id) = if b.owner_id.is_some() || b.group_id.is_some() {
+ (b.owner_id, b.group_id)
+ } else if geteuid() == 0 {
+ // Special case for root user.
+ (Some(0), Some(0))
+ } else {
+ // No chown operation needed.
return Ok(());
+ };
+
+ let meta = match fs::metadata(path) {
+ Ok(meta) => meta,
+ Err(e) => return Err(InstallError::MetadataFailed(e).into()),
+ };
+ match wrap_chown(path, &meta, owner_id, group_id, false, verbosity) {
+ Ok(msg) if b.verbose && !msg.is_empty() => println!("chown: {msg}"),
+ Ok(_) => {}
+ Err(e) => return Err(InstallError::ChownFailed(path.to_path_buf(), e).into()),
}
- // Declare the path here as we may need it for the verbose output below.
- let mut backup_path = None;
- // Perform backup, if any, before overwriting 'to'
- //
- // The codes actually making use of the backup process don't seem to agree
- // on how best to approach the issue. (mv and ln, for example)
+ Ok(())
+}
+
+/// Perform backup before overwriting.
+///
+/// # Parameters
+///
+/// * `to` - The destination file path.
+/// * `b` - The behavior configuration.
+///
+/// # Returns
+///
+/// Returns an Option containing the backup path, or None if backup is not needed.
+///
+fn perform_backup(to: &Path, b: &Behavior) -> UResult<Option<PathBuf>> {
if to.exists() {
if b.verbose {
println!("removed {}", to.quote());
}
- backup_path = backup_control::get_backup_path(b.backup_mode, to, &b.suffix);
+ let backup_path = backup_control::get_backup_path(b.backup_mode, to, &b.suffix);
if let Some(ref backup_path) = backup_path {
// TODO!!
if let Err(err) = fs::rename(to, backup_path) {
- return Err(InstallError::BackupFailed(
- to.to_path_buf(),
- backup_path.to_path_buf(),
- err,
- )
- .into());
+ return Err(
+ InstallError::BackupFailed(to.to_path_buf(), backup_path.clone(), err).into(),
+ );
}
}
+ Ok(backup_path)
+ } else {
+ Ok(None)
+ }
+}
+
+/// Copy a file from one path to another.
+///
+/// # Parameters
+///
+/// * `from` - The source file path.
+/// * `to` - The destination file path.
+///
+/// # Returns
+///
+/// Returns an empty Result or an error in case of failure.
+///
+fn copy_file(from: &Path, to: &Path) -> UResult<()> {
+ // fs::copy fails if destination is a invalid symlink.
+ // so lets just remove all existing files at destination before copy.
+ if let Err(e) = fs::remove_file(to) {
+ if e.kind() != std::io::ErrorKind::NotFound {
+ show_error!(
+ "Failed to remove existing file {}. Error: {:?}",
+ to.display(),
+ e
+ );
+ }
}
if from.as_os_str() == "/dev/null" {
@@ -681,107 +772,134 @@ fn copy(from: &Path, to: &Path, b: &Behavior) -> UResult<()> {
} else if let Err(err) = fs::copy(from, to) {
return Err(InstallError::InstallFailed(from.to_path_buf(), to.to_path_buf(), err).into());
}
+ Ok(())
+}
- if b.strip && cfg!(not(windows)) {
- match process::Command::new(&b.strip_program).arg(to).output() {
- Ok(o) => {
- if !o.status.success() {
- // Follow GNU's behavior: if strip fails, removes the target
- let _ = fs::remove_file(to);
- return Err(InstallError::StripProgramFailed(
- String::from_utf8(o.stderr).unwrap_or_default(),
- )
- .into());
- }
- }
- Err(e) => {
+/// Strip a file using an external program.
+///
+/// # Parameters
+///
+/// * `to` - The destination file path.
+/// * `b` - The behavior configuration.
+///
+/// # Returns
+///
+/// Returns an empty Result or an error in case of failure.
+///
+fn strip_file(to: &Path, b: &Behavior) -> UResult<()> {
+ // Check if the filename starts with a hyphen and adjust the path
+ let to_str = to.as_os_str().to_str().unwrap_or_default();
+ let to = if to_str.starts_with('-') {
+ let mut new_path = PathBuf::from(".");
+ new_path.push(to);
+ new_path
+ } else {
+ to.to_path_buf()
+ };
+ match process::Command::new(&b.strip_program).arg(&to).status() {
+ Ok(status) => {
+ if !status.success() {
// Follow GNU's behavior: if strip fails, removes the target
let _ = fs::remove_file(to);
- return Err(InstallError::StripProgramFailed(e.to_string()).into());
+ return Err(InstallError::StripProgramFailed(format!(
+ "strip process terminated abnormally - exit code: {}",
+ status.code().unwrap()
+ ))
+ .into());
}
}
+ Err(e) => {
+ // Follow GNU's behavior: if strip fails, removes the target
+ let _ = fs::remove_file(to);
+ return Err(InstallError::StripProgramFailed(e.to_string()).into());
+ }
}
+ Ok(())
+}
+/// Set ownership and permissions on the destination file.
+///
+/// # Parameters
+///
+/// * `to` - The destination file path.
+/// * `b` - The behavior configuration.
+///
+/// # Returns
+///
+/// Returns an empty Result or an error in case of failure.
+///
+fn set_ownership_and_permissions(to: &Path, b: &Behavior) -> UResult<()> {
// Silent the warning as we want to the error message
#[allow(clippy::question_mark)]
if mode::chmod(to, b.mode()).is_err() {
return Err(InstallError::ChmodFailed(to.to_path_buf()).into());
}
- if !b.owner.is_empty() {
- let meta = match fs::metadata(to) {
- Ok(meta) => meta,
- Err(e) => return Err(InstallError::MetadataFailed(e).into()),
- };
+ chown_optional_user_group(to, b)?;
- let owner_id = match usr2uid(&b.owner) {
- Ok(g) => g,
- _ => return Err(InstallError::NoSuchUser(b.owner.clone()).into()),
- };
- let gid = meta.gid();
- match wrap_chown(
- to,
- &meta,
- Some(owner_id),
- Some(gid),
- false,
- Verbosity {
- groups_only: false,
- level: VerbosityLevel::Normal,
- },
- ) {
- Ok(n) => {
- if !n.is_empty() {
- show_error!("{}", n);
- }
- }
- Err(e) => show_error!("{}", e),
- }
- }
+ Ok(())
+}
- if !b.group.is_empty() {
- let meta = match fs::metadata(to) {
- Ok(meta) => meta,
- Err(e) => return Err(InstallError::MetadataFailed(e).into()),
- };
+/// Preserve timestamps on the destination file.
+///
+/// # Parameters
+///
+/// * `from` - The source file path.
+/// * `to` - The destination file path.
+///
+/// # Returns
+///
+/// Returns an empty Result or an error in case of failure.
+///
+fn preserve_timestamps(from: &Path, to: &Path) -> UResult<()> {
+ let meta = match fs::metadata(from) {
+ Ok(meta) => meta,
+ Err(e) => return Err(InstallError::MetadataFailed(e).into()),
+ };
- let group_id = match grp2gid(&b.group) {
- Ok(g) => g,
- _ => return Err(InstallError::NoSuchGroup(b.group.clone()).into()),
- };
- match wrap_chown(
- to,
- &meta,
- Some(group_id),
- None,
- false,
- Verbosity {
- groups_only: true,
- level: VerbosityLevel::Normal,
- },
- ) {
- Ok(n) => {
- if !n.is_empty() {
- show_error!("{}", n);
- }
- }
- Err(e) => show_error!("{}", e),
+ let modified_time = FileTime::from_last_modification_time(&meta);
+ let accessed_time = FileTime::from_last_access_time(&meta);
+
+ match set_file_times(to, accessed_time, modified_time) {
+ Ok(_) => Ok(()),
+ Err(e) => {
+ show_error!("{}", e);
+ Ok(())
}
}
+}
- if b.preserve_timestamps {
- let meta = match fs::metadata(from) {
- Ok(meta) => meta,
- Err(e) => return Err(InstallError::MetadataFailed(e).into()),
- };
+/// Copy one file to a new location, changing metadata.
+///
+/// Returns a Result type with the Err variant containing the error message.
+///
+/// # Parameters
+///
+/// _from_ must exist as a non-directory.
+/// _to_ must be a non-existent file, whose parent directory exists.
+///
+/// # Errors
+///
+/// If the copy system call fails, we print a verbose error and return an empty error value.
+///
+fn copy(from: &Path, to: &Path, b: &Behavior) -> UResult<()> {
+ if b.compare && !need_copy(from, to, b)? {
+ return Ok(());
+ }
+ // Declare the path here as we may need it for the verbose output below.
+ let backup_path = perform_backup(to, b)?;
- let modified_time = FileTime::from_last_modification_time(&meta);
- let accessed_time = FileTime::from_last_access_time(&meta);
+ copy_file(from, to)?;
- match set_file_times(to, accessed_time, modified_time) {
- Ok(_) => {}
- Err(e) => show_error!("{}", e),
- }
+ #[cfg(not(windows))]
+ if b.strip {
+ strip_file(to, b)?;
+ }
+
+ set_ownership_and_permissions(to, b)?;
+
+ if b.preserve_timestamps {
+ preserve_timestamps(from, to)?;
}
if b.verbose {
@@ -813,65 +931,74 @@ fn copy(from: &Path, to: &Path, b: &Behavior) -> UResult<()> {
/// Crashes the program if a nonexistent owner or group is specified in _b_.
///
fn need_copy(from: &Path, to: &Path, b: &Behavior) -> UResult<bool> {
+ // Attempt to retrieve metadata for the source file.
+ // If this fails, assume the file needs to be copied.
let from_meta = match fs::metadata(from) {
Ok(meta) => meta,
Err(_) => return Ok(true),
};
+
+ // Attempt to retrieve metadata for the destination file.
+ // If this fails, assume the file needs to be copied.
let to_meta = match fs::metadata(to) {
Ok(meta) => meta,
Err(_) => return Ok(true),
};
- // setuid || setgid || sticky
+ // Define special file mode bits (setuid, setgid, sticky).
let extra_mode: u32 = 0o7000;
+ // Define all file mode bits (including permissions).
// setuid || setgid || sticky || permissions
let all_modes: u32 = 0o7777;
+ // Check if any special mode bits are set in the specified mode,
+ // source file mode, or destination file mode.
if b.specified_mode.unwrap_or(0) & extra_mode != 0
|| from_meta.mode() & extra_mode != 0
|| to_meta.mode() & extra_mode != 0
{
return Ok(true);
}
+
+ // Check if the mode of the destination file differs from the specified mode.
if b.mode() != to_meta.mode() & all_modes {
return Ok(true);
}
+ // Check if either the source or destination is not a file.
if !from_meta.is_file() || !to_meta.is_file() {
return Ok(true);
}
+ // Check if the file sizes differ.
if from_meta.len() != to_meta.len() {
return Ok(true);
}
// TODO: if -P (#1809) and from/to contexts mismatch, return true.
- if !b.owner.is_empty() {
- let owner_id = match usr2uid(&b.owner) {
- Ok(id) => id,
- _ => return Err(InstallError::NoSuchUser(b.owner.clone()).into()),
- };
+ // Check if the owner ID is specified and differs from the destination file's owner.
+ if let Some(owner_id) = b.owner_id {
if owner_id != to_meta.uid() {
return Ok(true);
}
- } else if !b.group.is_empty() {
- let group_id = match grp2gid(&b.group) {
- Ok(id) => id,
- _ => return Err(InstallError::NoSuchGroup(b.group.clone()).into()),
- };
+ }
+
+ // Check if the group ID is specified and differs from the destination file's group.
+ if let Some(group_id) = b.group_id {
if group_id != to_meta.gid() {
return Ok(true);
}
} else {
#[cfg(not(target_os = "windows"))]
- unsafe {
- if to_meta.uid() != geteuid() || to_meta.gid() != getegid() {
- return Ok(true);
- }
+ // Check if the destination file's owner or group
+ // differs from the effective user/group ID of the process.
+ if to_meta.uid() != geteuid() || to_meta.gid() != getegid() {
+ return Ok(true);
}
}
+ // Check if the contents of the source and destination files differ.
if !diff(from.to_str().unwrap(), to.to_str().unwrap()) {
return Ok(true);
}
diff --git a/src/uu/install/src/mode.rs b/src/uu/install/src/mode.rs
index 6c76dd0167785e978b5fe25f3d488b30444de938..ebdec14afe6cba27c607fd65748e44cb5b430085 100644
--- a/src/uu/install/src/mode.rs
+++ b/src/uu/install/src/mode.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::fs;
use std::path::Path;
#[cfg(not(windows))]
@@ -5,10 +9,7 @@ use uucore::mode;
/// Takes a user-supplied string and tries to parse to u16 mode bitmask.
pub fn parse(mode_string: &str, considering_dir: bool, umask: u32) -> Result<u32, String> {
- let numbers: &[char] = &['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
-
- // Passing 000 as the existing permissions seems to mirror GNU behavior.
- if mode_string.contains(numbers) {
+ if mode_string.chars().any(|c| c.is_ascii_digit()) {
mode::parse_numeric(0, mode_string, considering_dir)
} else {
mode::parse_symbolic(0, mode_string, umask, considering_dir)
diff --git a/src/uu/join/BENCHMARKING.md b/src/uu/join/BENCHMARKING.md
index 07a006b2dc948980a29822b83e18afde6d4c6fe6..80814ed1cb716cc6fd7c9bc641555f91b690774e 100644
--- a/src/uu/join/BENCHMARKING.md
+++ b/src/uu/join/BENCHMARKING.md
@@ -17,11 +17,14 @@ A benchmark with `-j` and `-i` shows the following time:
| libc | 25% | I/O and memory allocation. |
More detailed profiles can be obtained via [flame graphs](https://github.com/flamegraph-rs/flamegraph):
-```
+
+```shell
cargo flamegraph --bin join --package uu_join -- file1 file2 > /dev/null
```
+
You may need to add the following lines to the top-level `Cargo.toml` to get full stack traces:
-```
+
+```toml
[profile.release]
debug = true
```
@@ -34,22 +37,26 @@ in practice many CSV datasets will function well after being sorted.
Like most of the utils, the recommended tool for benchmarking is [hyperfine](https://github.com/sharkdp/hyperfine).
To benchmark your changes:
- - checkout the main branch (without your changes), do a `--release` build, and back up the executable produced at `target/release/join`
- - checkout your working branch (with your changes), do a `--release` build
- - run
- ```
- hyperfine -w 5 "/path/to/main/branch/build/join file1 file2" "/path/to/working/branch/build/join file1 file2"
- ```
- - you'll likely need to add additional options to both commands, such as a field separator, or if you're benchmarking some particular behavior
- - you can also optionally benchmark against GNU's join
+
+- checkout the main branch (without your changes), do a `--release` build, and back up the executable produced at `target/release/join`
+- checkout your working branch (with your changes), do a `--release` build
+- run
+
+ ```shell
+ hyperfine -w 5 "/path/to/main/branch/build/join file1 file2" "/path/to/working/branch/build/join file1 file2"
+ ```
+
+ - you'll likely need to add additional options to both commands, such as a field separator, or if you're benchmarking some particular behavior
+ - you can also optionally benchmark against GNU's join
## What to benchmark
The following options can have a non-trivial impact on performance:
- - `-a`/`-v` if one of the two files has significantly more lines than the other
- - `-j`/`-1`/`-2` cause work to be done to grab the appropriate field
- - `-i` adds a call to `to_ascii_lowercase()` that adds some time for allocating and dropping memory for the lowercase key
- - `--nocheck-order` causes some calls of `Input::compare` to be skipped
+
+- `-a`/`-v` if one of the two files has significantly more lines than the other
+- `-j`/`-1`/`-2` cause work to be done to grab the appropriate field
+- `-i` adds a call to `to_ascii_lowercase()` that adds some time for allocating and dropping memory for the lowercase key
+- `--nocheck-order` causes some calls of `Input::compare` to be skipped
The content of the files being joined has a very significant impact on the performance.
Things like how long each line is, how many fields there are, how long the key fields are, how many lines there are, how many lines can be joined, and how many lines each line can be joined with all change the behavior of the hotpaths.
diff --git a/src/uu/join/Cargo.toml b/src/uu/join/Cargo.toml
index 3b82311855ceb7d6b8e40ad76e9edcf17ff6735d..9281528dce9b02cdfb4433d7f90223f327a22b15 100644
--- a/src/uu/join/Cargo.toml
+++ b/src/uu/join/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_join"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "join ~ (uutils) merge lines from inputs with matching join fields"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/join.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
-memchr = "2"
+clap = { workspace = true }
+uucore = { workspace = true }
+memchr = { workspace = true }
[[bin]]
name = "join"
diff --git a/src/uu/join/join.md b/src/uu/join/join.md
new file mode 100644
index 0000000000000000000000000000000000000000..04275342a6e00b2762521f011c5fe34f5901b37f
--- /dev/null
+++ b/src/uu/join/join.md
@@ -0,0 +1,10 @@
+# join
+
+```
+join [OPTION]... FILE1 FILE2
+```
+
+For each pair of input lines with identical join fields, write a line to
+standard output. The default join field is the first, delimited by blanks.
+
+When `FILE1` or `FILE2` (not both) is `-`, read standard input.
diff --git a/src/uu/join/src/join.rs b/src/uu/join/src/join.rs
index 42234415918c2b41b07ecb9f4f7008c208de59df..20d8bc461ec8fc646e2c552b62ddaa822cafc07d 100644
--- a/src/uu/join/src/join.rs
+++ b/src/uu/join/src/join.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Konstantin Pospelov <kupospelov@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) autoformat FILENUM whitespaces pairable unpairable nocheck
@@ -11,7 +9,6 @@ use clap::builder::ValueParser;
use clap::{crate_version, Arg, ArgAction, Command};
use memchr::{memchr3_iter, memchr_iter};
use std::cmp::Ordering;
-use std::convert::From;
use std::error::Error;
use std::ffi::OsString;
use std::fmt::Display;
@@ -21,8 +18,12 @@ use std::num::IntErrorKind;
#[cfg(unix)]
use std::os::unix::ffi::OsStrExt;
use uucore::display::Quotable;
-use uucore::error::{set_exit_code, UError, UResult, USimpleError};
-use uucore::{crash, crash_if_err};
+use uucore::error::{set_exit_code, FromIo, UError, UResult, USimpleError};
+use uucore::line_ending::LineEnding;
+use uucore::{crash_if_err, format_usage, help_about, help_usage};
+
+const ABOUT: &str = help_about!("join.md");
+const USAGE: &str = help_usage!("join.md");
#[derive(Debug)]
enum JoinError {
@@ -41,7 +42,7 @@ impl Error for JoinError {}
impl Display for JoinError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
- Self::IOError(e) => write!(f, "io error: {}", e),
+ Self::IOError(e) => write!(f, "io error: {e}"),
Self::UnorderedInput(e) => f.write_str(e),
}
}
@@ -59,13 +60,6 @@ enum FileNum {
File2,
}
-#[repr(u8)]
-#[derive(Copy, Clone)]
-enum LineEnding {
- Nul = 0,
- Newline = b'\n',
-}
-
#[derive(Copy, Clone, PartialEq)]
enum Sep {
Char(u8),
@@ -125,12 +119,7 @@ struct Repr<'a> {
}
impl<'a> Repr<'a> {
- fn new(
- line_ending: LineEnding,
- separator: u8,
- format: &'a [Spec],
- empty: &'a [u8],
- ) -> Repr<'a> {
+ fn new(line_ending: LineEnding, separator: u8, format: &'a [Spec], empty: &'a [u8]) -> Self {
Repr {
line_ending,
separator,
@@ -339,37 +328,30 @@ impl<'a> State<'a> {
key: usize,
line_ending: LineEnding,
print_unpaired: bool,
- ) -> State<'a> {
- let f = if name == "-" {
+ ) -> UResult<Self> {
+ let file_buf = if name == "-" {
Box::new(stdin.lock()) as Box<dyn BufRead>
} else {
- match File::open(name) {
- Ok(file) => Box::new(BufReader::new(file)) as Box<dyn BufRead>,
- Err(err) => crash!(1, "{}: {}", name.maybe_quote(), err),
- }
+ let file = File::open(name).map_err_context(|| format!("{}", name.maybe_quote()))?;
+ Box::new(BufReader::new(file)) as Box<dyn BufRead>
};
- State {
+ Ok(State {
key,
file_name: name,
file_num,
print_unpaired,
- lines: f.split(line_ending as u8),
+ lines: file_buf.split(line_ending as u8),
max_len: 1,
seq: Vec::new(),
line_num: 0,
has_failed: false,
has_unpaired: false,
- }
+ })
}
/// Skip the current unpaired line.
- fn skip_line(
- &mut self,
- writer: &mut impl Write,
- input: &Input,
- repr: &Repr,
- ) -> Result<(), JoinError> {
+ fn skip_line(&mut self, writer: &mut impl Write, input: &Input, repr: &Repr) -> UResult<()> {
if self.print_unpaired {
self.print_first_line(writer, repr)?;
}
@@ -380,7 +362,7 @@ impl<'a> State<'a> {
/// Keep reading line sequence until the key does not change, return
/// the first line whose key differs.
- fn extend(&mut self, input: &Input) -> Result<Option<Line>, JoinError> {
+ fn extend(&mut self, input: &Input) -> UResult<Option<Line>> {
while let Some(line) = self.next_line(input)? {
let diff = input.compare(self.get_current_key(), line.get_field(self.key));
@@ -489,12 +471,7 @@ impl<'a> State<'a> {
0
}
- fn finalize(
- &mut self,
- writer: &mut impl Write,
- input: &Input,
- repr: &Repr,
- ) -> Result<(), JoinError> {
+ fn finalize(&mut self, writer: &mut impl Write, input: &Input, repr: &Repr) -> UResult<()> {
if self.has_line() {
if self.print_unpaired {
self.print_first_line(writer, repr)?;
@@ -596,19 +573,38 @@ impl<'a> State<'a> {
}
}
-#[uucore::main]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let matches = uu_app().try_get_matches_from(args)?;
-
- let keys = parse_field_number_option(matches.get_one::<String>("j").map(|s| s.as_str()))?;
- let key1 = parse_field_number_option(matches.get_one::<String>("1").map(|s| s.as_str()))?;
- let key2 = parse_field_number_option(matches.get_one::<String>("2").map(|s| s.as_str()))?;
+fn parse_separator(value_os: &OsString) -> UResult<Sep> {
+ #[cfg(unix)]
+ let value = value_os.as_bytes();
+ #[cfg(not(unix))]
+ let value = match value_os.to_str() {
+ Some(value) => value.as_bytes(),
+ None => {
+ return Err(USimpleError::new(
+ 1,
+ "unprintable field separators are only supported on unix-like platforms",
+ ));
+ }
+ };
+ match value.len() {
+ 0 => Ok(Sep::Line),
+ 1 => Ok(Sep::Char(value[0])),
+ 2 if value[0] == b'\\' && value[1] == b'0' => Ok(Sep::Char(0)),
+ _ => Err(USimpleError::new(
+ 1,
+ format!("multi-character tab {}", value_os.to_string_lossy()),
+ )),
+ }
+}
- let mut settings = Settings::default();
+fn parse_print_settings(matches: &clap::ArgMatches) -> UResult<(bool, bool, bool)> {
+ let mut print_joined = true;
+ let mut print_unpaired1 = false;
+ let mut print_unpaired2 = false;
let v_values = matches.get_many::<String>("v");
if v_values.is_some() {
- settings.print_joined = false;
+ print_joined = false;
}
let unpaired = v_values
@@ -616,41 +612,43 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
.chain(matches.get_many("a").unwrap_or_default());
for file_num in unpaired {
match parse_file_number(file_num)? {
- FileNum::File1 => settings.print_unpaired1 = true,
- FileNum::File2 => settings.print_unpaired2 = true,
+ FileNum::File1 => print_unpaired1 = true,
+ FileNum::File2 => print_unpaired2 = true,
}
}
+ Ok((print_joined, print_unpaired1, print_unpaired2))
+}
+
+fn get_and_parse_field_number(matches: &clap::ArgMatches, key: &str) -> UResult<Option<usize>> {
+ let value = matches.get_one::<String>(key).map(|s| s.as_str());
+ parse_field_number_option(value)
+}
+
+/// Parses the command-line arguments and constructs a `Settings` struct.
+///
+/// This function takes the matches from the command-line arguments, processes them,
+/// and returns a `Settings` struct that encapsulates the configuration for the program.
+#[allow(clippy::field_reassign_with_default)]
+fn parse_settings(matches: &clap::ArgMatches) -> UResult<Settings> {
+ let keys = get_and_parse_field_number(matches, "j")?;
+ let key1 = get_and_parse_field_number(matches, "1")?;
+ let key2 = get_and_parse_field_number(matches, "2")?;
+
+ let (print_joined, print_unpaired1, print_unpaired2) = parse_print_settings(matches)?;
+
+ let mut settings = Settings::default();
+
+ settings.print_joined = print_joined;
+ settings.print_unpaired1 = print_unpaired1;
+ settings.print_unpaired2 = print_unpaired2;
+
settings.ignore_case = matches.get_flag("i");
settings.key1 = get_field_number(keys, key1)?;
settings.key2 = get_field_number(keys, key2)?;
-
if let Some(value_os) = matches.get_one::<OsString>("t") {
- #[cfg(unix)]
- let value = value_os.as_bytes();
- #[cfg(not(unix))]
- let value = match value_os.to_str() {
- Some(value) => value.as_bytes(),
- None => {
- return Err(USimpleError::new(
- 1,
- "unprintable field separators are only supported on unix-like platforms",
- ))
- }
- };
- settings.separator = match value.len() {
- 0 => Sep::Line,
- 1 => Sep::Char(value[0]),
- 2 if value[0] == b'\\' && value[1] == b'0' => Sep::Char(0),
- _ => {
- return Err(USimpleError::new(
- 1,
- format!("multi-character tab {}", value_os.to_string_lossy()),
- ))
- }
- };
+ settings.separator = parse_separator(value_os)?;
}
-
if let Some(format) = matches.get_one::<String>("o") {
if format == "auto" {
settings.autoformat = true;
@@ -679,9 +677,16 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
settings.headers = true;
}
- if matches.get_flag("z") {
- settings.line_ending = LineEnding::Nul;
- }
+ settings.line_ending = LineEnding::from_zero_flag(matches.get_flag("z"));
+
+ Ok(settings)
+}
+
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+ let matches = uu_app().try_get_matches_from(args)?;
+
+ let settings = parse_settings(&matches)?;
let file1 = matches.get_one::<String>("file1").unwrap();
let file2 = matches.get_one::<String>("file2").unwrap();
@@ -690,21 +695,14 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
return Err(USimpleError::new(1, "both files cannot be standard input"));
}
- match exec(file1, file2, settings) {
- Ok(_) => Ok(()),
- Err(e) => Err(USimpleError::new(1, format!("{}", e))),
- }
+ exec(file1, file2, settings)
}
pub fn uu_app() -> Command {
Command::new(uucore::util_name())
.version(crate_version!())
- .about(
- "For each pair of input lines with identical join fields, write a line to
-standard output. The default join field is the first, delimited by blanks.
-
-When FILE1 or FILE2 (not both) is -, read standard input.",
- )
+ .about(ABOUT)
+ .override_usage(format_usage(USAGE))
.infer_long_args(true)
.arg(
Arg::new("a")
@@ -818,7 +816,7 @@ FILENUM is 1 or 2, corresponding to FILE1 or FILE2",
)
}
-fn exec(file1: &str, file2: &str, settings: Settings) -> Result<(), JoinError> {
+fn exec(file1: &str, file2: &str, settings: Settings) -> UResult<()> {
let stdin = stdin();
let mut state1 = State::new(
@@ -828,7 +826,7 @@ fn exec(file1: &str, file2: &str, settings: Settings) -> Result<(), JoinError> {
settings.key1,
settings.line_ending,
settings.print_unpaired1,
- );
+ )?;
let mut state2 = State::new(
FileNum::File2,
@@ -837,7 +835,7 @@ fn exec(file1: &str, file2: &str, settings: Settings) -> Result<(), JoinError> {
settings.key2,
settings.line_ending,
settings.print_unpaired2,
- );
+ )?;
let input = Input::new(
settings.separator,
diff --git a/src/uu/kill/Cargo.toml b/src/uu/kill/Cargo.toml
index 21431e3fe0ca60f633d65483a1d9f0fd237870c7..92e2c004ac2cb8b86ef46aba01b296d86077f45c 100644
--- a/src/uu/kill/Cargo.toml
+++ b/src/uu/kill/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_kill"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "kill ~ (uutils) send a signal to a process"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/kill.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-nix = { version = "0.25", features = ["signal"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["signals"] }
+clap = { workspace = true }
+nix = { workspace = true, features = ["signal"] }
+uucore = { workspace = true, features = ["signals"] }
[[bin]]
name = "kill"
diff --git a/src/uu/kill/kill.md b/src/uu/kill/kill.md
new file mode 100644
index 0000000000000000000000000000000000000000..1e3e2b3d094ce0821e104335cd78be6448f3c541
--- /dev/null
+++ b/src/uu/kill/kill.md
@@ -0,0 +1,7 @@
+# kill
+
+```
+kill [OPTIONS]... PID...
+```
+
+Send signal to processes or list information about signals.
diff --git a/src/uu/kill/src/kill.rs b/src/uu/kill/src/kill.rs
index 3e55f81664f9ac4e62bc31cae61879b40d14a250..6048acfb96a3bcbca78fbb6bd9fa284552deb0fe 100644
--- a/src/uu/kill/src/kill.rs
+++ b/src/uu/kill/src/kill.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Maciej Dziardziel <fiedzia@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) signalname pids killpg
@@ -12,12 +10,12 @@ use nix::sys::signal::{self, Signal};
use nix::unistd::Pid;
use std::io::Error;
use uucore::display::Quotable;
-use uucore::error::{FromIo, UError, UResult, USimpleError};
-use uucore::signals::{signal_by_name_or_value, ALL_SIGNALS};
-use uucore::{format_usage, show};
+use uucore::error::{FromIo, UResult, USimpleError};
+use uucore::signals::{signal_by_name_or_value, signal_name_by_value, ALL_SIGNALS};
+use uucore::{format_usage, help_about, help_usage, show};
-static ABOUT: &str = "Send signal to processes or list information about signals.";
-const USAGE: &str = "{} [OPTIONS]... PID...";
+static ABOUT: &str = help_about!("kill.md");
+const USAGE: &str = help_usage!("kill.md");
pub mod options {
pub static PIDS_OR_SIGNALS: &str = "pids_or_signals";
@@ -62,18 +60,39 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
} else {
15_usize //SIGTERM
};
- let sig: Signal = (sig as i32)
- .try_into()
- .map_err(|e| std::io::Error::from_raw_os_error(e as i32))?;
+
+ let sig_name = signal_name_by_value(sig);
+ // Signal does not support converting from EXIT
+ // Instead, nix::signal::kill expects Option::None to properly handle EXIT
+ let sig: Option<Signal> = if sig_name.is_some_and(|name| name == "EXIT") {
+ None
+ } else {
+ let sig = (sig as i32)
+ .try_into()
+ .map_err(|e| std::io::Error::from_raw_os_error(e as i32))?;
+ Some(sig)
+ };
+
let pids = parse_pids(&pids_or_signals)?;
- kill(sig, &pids);
- Ok(())
+ if pids.is_empty() {
+ Err(USimpleError::new(
+ 1,
+ "no process ID specified\n\
+ Try --help for more information.",
+ ))
+ } else {
+ kill(sig, &pids);
+ Ok(())
+ }
}
Mode::Table => {
table();
Ok(())
}
- Mode::List => list(pids_or_signals.get(0)),
+ Mode::List => {
+ list(&pids_or_signals);
+ Ok(())
+ }
}
}
@@ -133,24 +152,25 @@ fn handle_obsolete(args: &mut Vec<String>) -> Option<usize> {
}
fn table() {
- let name_width = ALL_SIGNALS.iter().map(|n| n.len()).max().unwrap();
-
- for (idx, signal) in ALL_SIGNALS.iter().enumerate() {
- print!("{0: >#2} {1: <#2$}", idx, signal, name_width + 2);
- if (idx + 1) % 7 == 0 {
- println!();
- }
+ // GNU kill doesn't list the EXIT signal with --table, so we ignore it, too
+ for (idx, signal) in ALL_SIGNALS
+ .iter()
+ .enumerate()
+ .filter(|(_, s)| **s != "EXIT")
+ {
+ println!("{0: >#2} {1}", idx, signal);
}
- println!();
}
fn print_signal(signal_name_or_value: &str) -> UResult<()> {
for (value, &signal) in ALL_SIGNALS.iter().enumerate() {
- if signal == signal_name_or_value || (format!("SIG{}", signal)) == signal_name_or_value {
- println!("{}", value);
+ if signal.eq_ignore_ascii_case(signal_name_or_value)
+ || format!("SIG{signal}").eq_ignore_ascii_case(signal_name_or_value)
+ {
+ println!("{value}");
return Ok(());
} else if signal_name_or_value == value.to_string() {
- println!("{}", signal);
+ println!("{signal}");
return Ok(());
}
}
@@ -161,27 +181,27 @@ fn print_signal(signal_name_or_value: &str) -> UResult<()> {
}
fn print_signals() {
- for (idx, signal) in ALL_SIGNALS.iter().enumerate() {
- if idx > 0 {
- print!(" ");
- }
- print!("{}", signal);
+ // GNU kill doesn't list the EXIT signal with --list, so we ignore it, too
+ for signal in ALL_SIGNALS.iter().filter(|x| **x != "EXIT") {
+ println!("{signal}");
}
- println!();
}
-fn list(arg: Option<&String>) -> UResult<()> {
- match arg {
- Some(x) => print_signal(x),
- None => {
- print_signals();
- Ok(())
+fn list(signals: &Vec<String>) {
+ if signals.is_empty() {
+ print_signals();
+ } else {
+ for signal in signals {
+ if let Err(e) = print_signal(signal) {
+ uucore::show!(e);
+ }
}
}
}
fn parse_signal_value(signal_name: &str) -> UResult<usize> {
- let optional_signal_value = signal_by_name_or_value(signal_name);
+ let signal_name_upcase = signal_name.to_uppercase();
+ let optional_signal_value = signal_by_name_or_value(&signal_name_upcase);
match optional_signal_value {
Some(x) => Ok(x),
None => Err(USimpleError::new(
@@ -201,11 +221,11 @@ fn parse_pids(pids: &[String]) -> UResult<Vec<i32>> {
.collect()
}
-fn kill(sig: Signal, pids: &[i32]) {
+fn kill(sig: Option<Signal>, pids: &[i32]) {
for &pid in pids {
if let Err(e) = signal::kill(Pid::from_raw(pid), sig) {
show!(Error::from_raw_os_error(e as i32)
- .map_err_context(|| format!("sending signal to {} failed", pid)));
+ .map_err_context(|| format!("sending signal to {pid} failed")));
}
}
}
diff --git a/src/uu/link/Cargo.toml b/src/uu/link/Cargo.toml
index 5a8984f1fd076b5e89414bcdb5cd310ee6b3a2b6..9d9d4dbe833d638cf7ebfdff5ac0730b232417e2 100644
--- a/src/uu/link/Cargo.toml
+++ b/src/uu/link/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_link"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "link ~ (uutils) create a hard (file system) link to FILE"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/link.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "link"
diff --git a/src/uu/link/link.md b/src/uu/link/link.md
new file mode 100644
index 0000000000000000000000000000000000000000..ea6a531b987e53889df0f2b82b1da47de49671e0
--- /dev/null
+++ b/src/uu/link/link.md
@@ -0,0 +1,7 @@
+# link
+
+```
+link FILE1 FILE2
+```
+
+Call the link function to create a link named FILE2 to an existing FILE1.
diff --git a/src/uu/link/src/link.rs b/src/uu/link/src/link.rs
index 80b2b1f9b50def9d0eaa5160c4c865f5572f5ef6..806e89828bb878227a92445160698bdb4fd1fe3b 100644
--- a/src/uu/link/src/link.rs
+++ b/src/uu/link/src/link.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Michael Gehring <mg@ebfe.org>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use clap::builder::ValueParser;
use clap::{crate_version, Arg, Command};
use std::ffi::OsString;
@@ -11,10 +9,10 @@ use std::fs::hard_link;
use std::path::Path;
use uucore::display::Quotable;
use uucore::error::{FromIo, UResult};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
-static ABOUT: &str = "Call the link function to create a link named FILE2 to an existing FILE1.";
-const USAGE: &str = "{} FILE1 FILE2";
+static ABOUT: &str = help_about!("link.md");
+const USAGE: &str = help_usage!("link.md");
pub mod options {
pub static FILES: &str = "FILES";
diff --git a/src/uu/ln/Cargo.toml b/src/uu/ln/Cargo.toml
index 2f07c8c4d52975ec826fca758c37c930742f9c2a..41c62227a2cd65bd281bc7a1c0969a1c7d2037d9 100644
--- a/src/uu/ln/Cargo.toml
+++ b/src/uu/ln/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_ln"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "ln ~ (uutils) create a (file system) link to TARGET"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/ln.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["fs"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["backup-control", "fs"] }
[[bin]]
name = "ln"
diff --git a/src/uu/ln/ln.md b/src/uu/ln/ln.md
new file mode 100644
index 0000000000000000000000000000000000000000..6bd6ee0161932690b50c6c0588061dea6ce06ab5
--- /dev/null
+++ b/src/uu/ln/ln.md
@@ -0,0 +1,21 @@
+# ln
+
+```
+ln [OPTION]... [-T] TARGET LINK_NAME
+ln [OPTION]... TARGET
+ln [OPTION]... TARGET... DIRECTORY
+ln [OPTION]... -t DIRECTORY TARGET...
+```
+
+Make links between files.
+
+## After Help
+
+In the 1st form, create a link to TARGET with the name LINK_NAME.
+In the 2nd form, create a link to TARGET in the current directory.
+In the 3rd and 4th forms, create links to each TARGET in DIRECTORY.
+Create hard links by default, symbolic links with --symbolic.
+By default, each destination (name of new link) should not already exist.
+When creating hard links, each TARGET must exist. Symbolic links
+can hold arbitrary text; if later resolved, a relative link is
+interpreted in relation to its parent directory.
diff --git a/src/uu/ln/src/ln.rs b/src/uu/ln/src/ln.rs
index 6ba8a98e85b48e51c48b56e08cd4fa934e89d974..a056ee256a192a7cbb4e72ae5a132bf840b49af9 100644
--- a/src/uu/ln/src/ln.rs
+++ b/src/uu/ln/src/ln.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Joseph Crail <jbcrail@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) srcpath targetpath EEXIST
@@ -11,9 +9,10 @@ use clap::{crate_version, Arg, ArgAction, Command};
use uucore::display::Quotable;
use uucore::error::{FromIo, UError, UResult};
use uucore::fs::{make_path_relative_to, paths_refer_to_same_file};
-use uucore::{format_usage, prompt_yes, show_error};
+use uucore::{format_usage, help_about, help_section, help_usage, prompt_yes, show_error};
use std::borrow::Cow;
+use std::collections::HashSet;
use std::error::Error;
use std::ffi::OsString;
use std::fmt::Display;
@@ -85,26 +84,9 @@ impl UError for LnError {
}
}
-fn long_usage() -> String {
- String::from(
- " In the 1st form, create a link to TARGET with the name LINK_NAME.
- In the 2nd form, create a link to TARGET in the current directory.
- In the 3rd and 4th forms, create links to each TARGET in DIRECTORY.
- Create hard links by default, symbolic links with --symbolic.
- By default, each destination (name of new link) should not already exist.
- When creating hard links, each TARGET must exist. Symbolic links
- can hold arbitrary text; if later resolved, a relative link is
- interpreted in relation to its parent directory.
- ",
- )
-}
-
-static ABOUT: &str = "change file owner and group";
-const USAGE: &str = "\
- {} [OPTION]... [-T] TARGET LINK_NAME
- {} [OPTION]... TARGET
- {} [OPTION]... TARGET... DIRECTORY
- {} [OPTION]... -t DIRECTORY TARGET...";
+const ABOUT: &str = help_about!("ln.md");
+const USAGE: &str = help_usage!("ln.md");
+const AFTER_HELP: &str = help_section!("after help", "ln.md");
mod options {
pub const FORCE: &str = "force";
@@ -124,14 +106,13 @@ static ARG_FILES: &str = "files";
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- // clap requires a 'static string
- let long_usage = format!(
- "{}\n{}",
- long_usage(),
+ let after_help = format!(
+ "{}\n\n{}",
+ AFTER_HELP,
backup_control::BACKUP_CONTROL_LONG_HELP
);
- let matches = uu_app().after_help(long_usage).try_get_matches_from(args)?;
+ let matches = uu_app().after_help(after_help).try_get_matches_from(args)?;
/* the list of files */
@@ -217,7 +198,7 @@ pub fn uu_app() -> Command {
Arg::new(options::LOGICAL)
.short('L')
.long(options::LOGICAL)
- .help("dereference TARGETs that are symbolic links")
+ .help("follow TARGETs that are symbolic links")
.overrides_with(options::PHYSICAL)
.action(ArgAction::SetTrue),
)
@@ -310,13 +291,16 @@ fn exec(files: &[PathBuf], settings: &Settings) -> UResult<()> {
link(&files[0], &files[1], settings)
}
+#[allow(clippy::cognitive_complexity)]
fn link_files_in_dir(files: &[PathBuf], target_dir: &Path, settings: &Settings) -> UResult<()> {
if !target_dir.is_dir() {
return Err(LnError::TargetIsDirectory(target_dir.to_owned()).into());
}
+ // remember the linked destinations for further usage
+ let mut linked_destinations: HashSet<PathBuf> = HashSet::with_capacity(files.len());
let mut all_successful = true;
- for srcpath in files.iter() {
+ for srcpath in files {
let targetpath =
if settings.no_dereference && matches!(settings.overwrite, OverwriteMode::Force) {
// In that case, we don't want to do link resolution
@@ -357,10 +341,20 @@ fn link_files_in_dir(files: &[PathBuf], target_dir: &Path, settings: &Settings)
}
};
- if let Err(e) = link(srcpath, &targetpath, settings) {
+ if linked_destinations.contains(&targetpath) {
+ // If the target file was already created in this ln call, do not overwrite
+ show_error!(
+ "will not overwrite just-created '{}' with '{}'",
+ targetpath.display(),
+ srcpath.display()
+ );
+ all_successful = false;
+ } else if let Err(e) = link(srcpath, &targetpath, settings) {
show_error!("{}", e);
all_successful = false;
}
+
+ linked_destinations.insert(targetpath.clone());
}
if all_successful {
Ok(())
@@ -382,6 +376,7 @@ fn relative_path<'a>(src: &'a Path, dst: &Path) -> Cow<'a, Path> {
src.into()
}
+#[allow(clippy::cognitive_complexity)]
fn link(src: &Path, dst: &Path, settings: &Settings) -> UResult<()> {
let mut backup_path = None;
let source: Cow<'_, Path> = if settings.relative {
@@ -409,8 +404,8 @@ fn link(src: &Path, dst: &Path, settings: &Settings) -> UResult<()> {
match settings.overwrite {
OverwriteMode::NoClobber => {}
OverwriteMode::Interactive => {
- if !prompt_yes!("overwrite {}?", dst.quote()) {
- return Ok(());
+ if !prompt_yes!("replace {}?", dst.quote()) {
+ return Err(LnError::SomeLinksFailed.into());
}
if fs::remove_file(dst).is_ok() {};
@@ -466,7 +461,7 @@ fn simple_backup_path(path: &Path, suffix: &str) -> PathBuf {
fn numbered_backup_path(path: &Path) -> PathBuf {
let mut i: u64 = 1;
loop {
- let new_path = simple_backup_path(path, &format!(".~{}~", i));
+ let new_path = simple_backup_path(path, &format!(".~{i}~"));
if !new_path.exists() {
return new_path;
}
diff --git a/src/uu/logname/Cargo.toml b/src/uu/logname/Cargo.toml
index a75e5efa7d9b4c64e0554f5f90e56f1638905ade..e5275580e01217d976ab450b01e3e14918650e47 100644
--- a/src/uu/logname/Cargo.toml
+++ b/src/uu/logname/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_logname"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "logname ~ (uutils) display the login name of the current user"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/logname.rs"
[dependencies]
-libc = "0.2.137"
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+libc = { workspace = true }
+clap = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "logname"
diff --git a/src/uu/logname/logname.md b/src/uu/logname/logname.md
new file mode 100644
index 0000000000000000000000000000000000000000..b997c206be884e89e9f02ac70d147a2807d08bdc
--- /dev/null
+++ b/src/uu/logname/logname.md
@@ -0,0 +1,7 @@
+# logname
+
+```
+logname
+```
+
+Print user's login name
diff --git a/src/uu/logname/src/logname.rs b/src/uu/logname/src/logname.rs
index ef6eb29407084d86a8ca215aba962c05906e2240..02a78cf4c3ca0a454d5b62cc0fbf1c9dcd6b9022 100644
--- a/src/uu/logname/src/logname.rs
+++ b/src/uu/logname/src/logname.rs
@@ -1,17 +1,13 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Benoit Benedetti <benoit.benedetti@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
-
-/* last synced with: logname (GNU coreutils) 8.22 */
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) getlogin userlogin
use clap::{crate_version, Command};
use std::ffi::CStr;
-use uucore::{error::UResult, show_error};
+use uucore::{error::UResult, format_usage, help_about, help_usage, show_error};
extern "C" {
// POSIX requires using getlogin (or equivalent code)
@@ -29,16 +25,15 @@ fn get_userlogin() -> Option<String> {
}
}
-static ABOUT: &str = "Print user's login name";
+const ABOUT: &str = help_about!("logname.md");
+const USAGE: &str = help_usage!("logname.md");
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_ignore();
-
let _ = uu_app().try_get_matches_from(args)?;
match get_userlogin() {
- Some(userlogin) => println!("{}", userlogin),
+ Some(userlogin) => println!("{userlogin}"),
None => show_error!("no login name"),
}
@@ -48,7 +43,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
pub fn uu_app() -> Command {
Command::new(uucore::util_name())
.version(crate_version!())
- .override_usage(uucore::execution_phrase())
+ .override_usage(format_usage(USAGE))
.about(ABOUT)
.infer_long_args(true)
}
diff --git a/src/uu/ls/BENCHMARKING.md b/src/uu/ls/BENCHMARKING.md
index 6bc15780586d6c2e1c69f1d65de055222f38c4d4..3103e43b0f1f9ce3f586e011858f140354cf6ac5 100644
--- a/src/uu/ls/BENCHMARKING.md
+++ b/src/uu/ls/BENCHMARKING.md
@@ -9,13 +9,13 @@ Run `cargo build --release` before benchmarking after you make a change!
## Simple recursive ls
-- Get a large tree, for example linux kernel source tree.
-- Benchmark simple recursive ls with hyperfine: `hyperfine --warmup 2 "target/release/coreutils ls -R tree > /dev/null"`.
+- Get a large tree, for example linux kernel source tree.
+- Benchmark simple recursive ls with hyperfine: `hyperfine --warmup 2 "target/release/coreutils ls -R tree > /dev/null"`.
## Recursive ls with all and long options
-- Same tree as above
-- Benchmark recursive ls with -al -R options with hyperfine: `hyperfine --warmup 2 "target/release/coreutils ls -al -R tree > /dev/null"`.
+- Same tree as above
+- Benchmark recursive ls with -al -R options with hyperfine: `hyperfine --warmup 2 "target/release/coreutils ls -al -R tree > /dev/null"`.
## Comparing with GNU ls
@@ -29,7 +29,8 @@ Example: `hyperfine --warmup 2 "target/release/coreutils ls -al -R tree > /dev/n
This can also be used to compare with version of ls built before your changes to ensure your change does not regress this.
Here is a `bash` script for doing this comparison:
-```bash
+
+```shell
#!/bin/bash
cargo build --no-default-features --features ls --release
args="$@"
@@ -46,12 +47,14 @@ hyperfine "ls $args" "target/release/coreutils ls $args"
## Cargo Flamegraph
With Cargo Flamegraph you can easily make a flamegraph of `ls`:
-```bash
+
+```shell
cargo flamegraph --cmd coreutils -- ls [additional parameters]
```
However, if the `-R` option is given, the output becomes pretty much useless due to recursion. We can fix this by merging all the direct recursive calls with `uniq`, below is a `bash` script that does this.
-```bash
+
+```shell
#!/bin/bash
cargo build --release --no-default-features --features ls
perf record target/release/coreutils ls "$@"
diff --git a/src/uu/ls/Cargo.toml b/src/uu/ls/Cargo.toml
index c68c6b5ae283b1e4b293bab6dcc2553bf8849278..16605fc5dee9bd6126c82f85e4c7f44f39d4780d 100644
--- a/src/uu/ls/Cargo.toml
+++ b/src/uu/ls/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_ls"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "ls ~ (uutils) display directory contents"
@@ -15,18 +15,26 @@ edition = "2021"
path = "src/ls.rs"
[dependencies]
-chrono = { version="^0.4.23", default-features=false, features=["std", "alloc", "clock"]}
-clap = { version = "4.0", features = ["wrap_help", "cargo", "env"] }
-unicode-width = "0.1.8"
-number_prefix = "0.4"
-term_grid = "0.1.5"
-terminal_size = "0.2.2"
-glob = "0.3.0"
-lscolors = { version = "0.13.0", default-features=false, features = ["nu-ansi-term"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features = ["entries", "fs"] }
-once_cell = "1.13.1"
-atty = "0.2"
-selinux = { version="0.3", optional = true }
+ansi-width = { workspace = true }
+clap = { workspace = true, features = ["env"] }
+chrono = { workspace = true }
+number_prefix = { workspace = true }
+uutils_term_grid = { workspace = true }
+terminal_size = { workspace = true }
+glob = { workspace = true }
+lscolors = { workspace = true }
+uucore = { workspace = true, features = [
+ "colors",
+ "entries",
+ "format",
+ "fs",
+ "fsxattr",
+ "quoting-style",
+ "version-cmp",
+] }
+once_cell = { workspace = true }
+selinux = { workspace = true, optional = true }
+hostname = { workspace = true }
[[bin]]
name = "ls"
diff --git a/src/uu/ls/ls.md b/src/uu/ls/ls.md
new file mode 100644
index 0000000000000000000000000000000000000000..01eec7e5052a1780bc8bc3e6a3dc28a1e277dda6
--- /dev/null
+++ b/src/uu/ls/ls.md
@@ -0,0 +1,12 @@
+# ls
+
+```
+ls [OPTION]... [FILE]...
+```
+
+List directory contents.
+Ignore files and directories starting with a '.' by default
+
+## After help
+
+The TIME_STYLE argument can be full-iso, long-iso, iso, locale or +FORMAT. FORMAT is interpreted like in date. Also the TIME_STYLE environment variable sets the default style to use.
diff --git a/src/uu/ls/src/dired.rs b/src/uu/ls/src/dired.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c73b11ae34504e9681ba36a9afd4520ec7db1fa9
--- /dev/null
+++ b/src/uu/ls/src/dired.rs
@@ -0,0 +1,343 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore dired subdired
+
+/// `dired` Module Documentation
+///
+/// This module handles the --dired output format, representing file and
+/// directory listings.
+///
+/// Key Mechanisms:
+/// 1. **Position Tracking**:
+/// - The module tracks byte positions for each file or directory entry.
+/// - `BytePosition`: Represents a byte range with start and end positions.
+/// - `DiredOutput`: Contains positions for DIRED and SUBDIRED outputs and
+/// maintains a padding value.
+///
+/// 2. **Padding**:
+/// - Padding is used when dealing with directory names or the "total" line.
+/// - The module adjusts byte positions by adding padding for these cases.
+/// - This ensures correct offset for subsequent files or directories.
+///
+/// 3. **Position Calculation**:
+/// - Functions like `calculate_dired`, `calculate_subdired`, and
+/// `calculate_and_update_positions` compute byte positions based on output
+/// length, previous positions, and padding.
+///
+/// 4. **Output**:
+/// - The module provides functions to print the DIRED output
+/// (`print_dired_output`) based on calculated positions and configuration.
+/// - Helpers like `print_positions` print positions with specific prefixes.
+///
+/// Overall, the module ensures each entry in the DIRED output has the correct
+/// byte position, considering additional lines or padding affecting positions.
+///
+use crate::Config;
+use std::fmt;
+use std::io::{BufWriter, Stdout, Write};
+use uucore::error::UResult;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct BytePosition {
+ pub start: usize,
+ pub end: usize,
+}
+
+/// Represents the output structure for DIRED, containing positions for both DIRED and SUBDIRED.
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct DiredOutput {
+ pub dired_positions: Vec<BytePosition>,
+ pub subdired_positions: Vec<BytePosition>,
+ pub padding: usize,
+}
+
+impl fmt::Display for BytePosition {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "{} {}", self.start, self.end)
+ }
+}
+
+// When --dired is used, all lines starts with 2 spaces
+static DIRED_TRAILING_OFFSET: usize = 2;
+
+fn get_offset_from_previous_line(dired_positions: &[BytePosition]) -> usize {
+ if let Some(last_position) = dired_positions.last() {
+ last_position.end + 1
+ } else {
+ 0
+ }
+}
+
+/// Calculates the byte positions for DIRED
+pub fn calculate_dired(
+ dired_positions: &[BytePosition],
+ output_display_len: usize,
+ dfn_len: usize,
+) -> (usize, usize) {
+ let offset_from_previous_line = get_offset_from_previous_line(dired_positions);
+
+ let start = output_display_len + offset_from_previous_line;
+ let end = start + dfn_len;
+ (start, end)
+}
+
+pub fn indent(out: &mut BufWriter<Stdout>) -> UResult<()> {
+ write!(out, " ")?;
+ Ok(())
+}
+
+pub fn calculate_subdired(dired: &mut DiredOutput, path_len: usize) {
+ let offset_from_previous_line = get_offset_from_previous_line(&dired.dired_positions);
+
+ let additional_offset = if dired.subdired_positions.is_empty() {
+ 0
+ } else {
+ // if we have several directories: \n\n
+ 2
+ };
+
+ let start = offset_from_previous_line + DIRED_TRAILING_OFFSET + additional_offset;
+ let end = start + path_len;
+ dired.subdired_positions.push(BytePosition { start, end });
+}
+
+/// Prints the dired output based on the given configuration and dired structure.
+pub fn print_dired_output(
+ config: &Config,
+ dired: &DiredOutput,
+ out: &mut BufWriter<Stdout>,
+) -> UResult<()> {
+ out.flush()?;
+ if dired.padding == 0 && !dired.dired_positions.is_empty() {
+ print_positions("//DIRED//", &dired.dired_positions);
+ }
+ if config.recursive {
+ print_positions("//SUBDIRED//", &dired.subdired_positions);
+ }
+ println!("//DIRED-OPTIONS// --quoting-style={}", config.quoting_style);
+ Ok(())
+}
+
+/// Helper function to print positions with a given prefix.
+fn print_positions(prefix: &str, positions: &Vec<BytePosition>) {
+ print!("{}", prefix);
+ for c in positions {
+ print!(" {}", c);
+ }
+ println!();
+}
+
+pub fn add_total(dired: &mut DiredOutput, total_len: usize) {
+ if dired.padding == 0 {
+ let offset_from_previous_line = get_offset_from_previous_line(&dired.dired_positions);
+ // when dealing with " total: xx", it isn't part of the //DIRED//
+ // so, we just keep the size line to add it to the position of the next file
+ dired.padding = total_len + offset_from_previous_line + DIRED_TRAILING_OFFSET;
+ } else {
+ // += because if we are in -R, we have " dir:\n total X". So, we need to take the
+ // previous padding too.
+ // and we already have the previous position in mind
+ dired.padding += total_len + DIRED_TRAILING_OFFSET;
+ }
+}
+
+// when using -R, we have the dirname. we need to add it to the padding
+pub fn add_dir_name(dired: &mut DiredOutput, dir_len: usize) {
+ // 1 for the ":" in " dirname:"
+ dired.padding += dir_len + DIRED_TRAILING_OFFSET + 1;
+}
+
+/// Calculates byte positions and updates the dired structure.
+pub fn calculate_and_update_positions(
+ dired: &mut DiredOutput,
+ output_display_len: usize,
+ dfn_len: usize,
+) {
+ let offset = dired
+ .dired_positions
+ .last()
+ .map_or(DIRED_TRAILING_OFFSET, |last_position| {
+ last_position.start + DIRED_TRAILING_OFFSET
+ });
+ let start = output_display_len + offset + DIRED_TRAILING_OFFSET;
+ let end = start + dfn_len;
+ update_positions(dired, start, end);
+}
+
+/// Updates the dired positions based on the given start and end positions.
+/// update when it is the first element in the list (to manage "total X")
+/// insert when it isn't the about total
+pub fn update_positions(dired: &mut DiredOutput, start: usize, end: usize) {
+ // padding can be 0 but as it doesn't matter
+ dired.dired_positions.push(BytePosition {
+ start: start + dired.padding,
+ end: end + dired.padding,
+ });
+ // Remove the previous padding
+ dired.padding = 0;
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_calculate_dired() {
+ let output_display = "sample_output".to_string();
+ let dfn = "sample_file".to_string();
+ let dired_positions = vec![BytePosition { start: 5, end: 10 }];
+ let (start, end) = calculate_dired(&dired_positions, output_display.len(), dfn.len());
+
+ assert_eq!(start, 24);
+ assert_eq!(end, 35);
+ }
+
+ #[test]
+ fn test_get_offset_from_previous_line() {
+ let positions = vec![
+ BytePosition { start: 0, end: 3 },
+ BytePosition { start: 4, end: 7 },
+ BytePosition { start: 8, end: 11 },
+ ];
+ assert_eq!(get_offset_from_previous_line(&positions), 12);
+ }
+ #[test]
+ fn test_calculate_subdired() {
+ let mut dired = DiredOutput {
+ dired_positions: vec![
+ BytePosition { start: 0, end: 3 },
+ BytePosition { start: 4, end: 7 },
+ BytePosition { start: 8, end: 11 },
+ ],
+ subdired_positions: vec![],
+ padding: 0,
+ };
+ let path_len = 5;
+ calculate_subdired(&mut dired, path_len);
+ assert_eq!(
+ dired.subdired_positions,
+ vec![BytePosition { start: 14, end: 19 }],
+ );
+ }
+
+ #[test]
+ fn test_add_dir_name() {
+ let mut dired = DiredOutput {
+ dired_positions: vec![
+ BytePosition { start: 0, end: 3 },
+ BytePosition { start: 4, end: 7 },
+ BytePosition { start: 8, end: 11 },
+ ],
+ subdired_positions: vec![],
+ padding: 0,
+ };
+ let dir_len = 5;
+ add_dir_name(&mut dired, dir_len);
+ assert_eq!(
+ dired,
+ DiredOutput {
+ dired_positions: vec![
+ BytePosition { start: 0, end: 3 },
+ BytePosition { start: 4, end: 7 },
+ BytePosition { start: 8, end: 11 },
+ ],
+ subdired_positions: vec![],
+ // 8 = 1 for the \n + 5 for dir_len + 2 for " " + 1 for :
+ padding: 8
+ }
+ );
+ }
+
+ #[test]
+ fn test_add_total() {
+ let mut dired = DiredOutput {
+ dired_positions: vec![
+ BytePosition { start: 0, end: 3 },
+ BytePosition { start: 4, end: 7 },
+ BytePosition { start: 8, end: 11 },
+ ],
+ subdired_positions: vec![],
+ padding: 0,
+ };
+ // if we have "total: 2"
+ let total_len = 8;
+ add_total(&mut dired, total_len);
+ // 22 = 8 (len) + 2 (padding) + 11 (previous position) + 1 (\n)
+ assert_eq!(dired.padding, 22);
+ }
+
+ #[test]
+ fn test_add_dir_name_and_total() {
+ // test when we have
+ // dirname:
+ // total 0
+ // -rw-r--r-- 1 sylvestre sylvestre 0 Sep 30 09:41 ab
+
+ let mut dired = DiredOutput {
+ dired_positions: vec![
+ BytePosition { start: 0, end: 3 },
+ BytePosition { start: 4, end: 7 },
+ BytePosition { start: 8, end: 11 },
+ ],
+ subdired_positions: vec![],
+ padding: 0,
+ };
+ let dir_len = 5;
+ add_dir_name(&mut dired, dir_len);
+ // 8 = 2 (" ") + 1 (\n) + 5 + 1 (: of dirname)
+ assert_eq!(dired.padding, 8);
+
+ let total_len = 8;
+ add_total(&mut dired, total_len);
+ assert_eq!(dired.padding, 18);
+ }
+
+ #[test]
+ fn test_dired_update_positions() {
+ let mut dired = DiredOutput {
+ dired_positions: vec![BytePosition { start: 5, end: 10 }],
+ subdired_positions: vec![],
+ padding: 10,
+ };
+
+ // Test with adjust = true
+ update_positions(&mut dired, 15, 20);
+ let last_position = dired.dired_positions.last().unwrap();
+ assert_eq!(last_position.start, 25); // 15 + 10 (end of the previous position)
+ assert_eq!(last_position.end, 30); // 20 + 10 (end of the previous position)
+
+ // Test with adjust = false
+ update_positions(&mut dired, 30, 35);
+ let last_position = dired.dired_positions.last().unwrap();
+ assert_eq!(last_position.start, 30);
+ assert_eq!(last_position.end, 35);
+ }
+
+ #[test]
+ fn test_calculate_and_update_positions() {
+ let mut dired = DiredOutput {
+ dired_positions: vec![
+ BytePosition { start: 0, end: 3 },
+ BytePosition { start: 4, end: 7 },
+ BytePosition { start: 8, end: 11 },
+ ],
+ subdired_positions: vec![],
+ padding: 5,
+ };
+ let output_display_len = 15;
+ let dfn_len = 5;
+ calculate_and_update_positions(&mut dired, output_display_len, dfn_len);
+ assert_eq!(
+ dired.dired_positions,
+ vec![
+ BytePosition { start: 0, end: 3 },
+ BytePosition { start: 4, end: 7 },
+ BytePosition { start: 8, end: 11 },
+ BytePosition { start: 32, end: 37 },
+ ]
+ );
+ assert_eq!(dired.padding, 0);
+ }
+}
diff --git a/src/uu/ls/src/ls.rs b/src/uu/ls/src/ls.rs
index fdf368e4ba0ad15d2db798fc528401511daf255b..d9bc00de309f49e694e993ae3e2ec1cab2eac3ee 100644
--- a/src/uu/ls/src/ls.rs
+++ b/src/uu/ls/src/ls.rs
@@ -1,27 +1,27 @@
// This file is part of the uutils coreutils package.
//
-// (c) Jeremiah Peschka <jeremiah.peschka@gmail.com>
-//
-// For the full copyright and license information, please view the LICENSE file
-// that was distributed with this source code.
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-// spell-checker:ignore (ToDO) cpio svgz webm somegroup nlink rmvb xspf tabsize dired
+// spell-checker:ignore (ToDO) somegroup nlink tabsize dired subdired dtype colorterm stringly
use clap::{
- builder::{NonEmptyStringValueParser, ValueParser},
+ builder::{NonEmptyStringValueParser, PossibleValue, ValueParser},
crate_version, Arg, ArgAction, Command,
};
use glob::{MatchOptions, Pattern};
-use lscolors::LsColors;
-use number_prefix::NumberPrefix;
-use once_cell::unsync::OnceCell;
-use std::collections::HashSet;
+use lscolors::{LsColors, Style};
+
+use ansi_width::ansi_width;
+use std::{cell::OnceCell, num::IntErrorKind};
+use std::{collections::HashSet, io::IsTerminal};
+
#[cfg(windows)]
use std::os::windows::fs::MetadataExt;
use std::{
cmp::Reverse,
error::Error,
- ffi::{OsStr, OsString},
+ ffi::OsString,
fmt::{Display, Write as FmtWrite},
fs::{self, DirEntry, FileType, Metadata, ReadDir},
io::{stdout, BufWriter, ErrorKind, Stdout, Write},
@@ -34,37 +34,48 @@ use std::{
os::unix::fs::{FileTypeExt, MetadataExt},
time::Duration,
};
-use term_grid::{Cell, Direction, Filling, Grid, GridOptions};
-use unicode_width::UnicodeWidthStr;
+use term_grid::{Direction, Filling, Grid, GridOptions};
+use uucore::error::USimpleError;
+use uucore::format::human::{human_readable, SizeFormat};
+#[cfg(all(unix, not(any(target_os = "android", target_os = "macos"))))]
+use uucore::fsxattr::has_acl;
#[cfg(any(
target_os = "linux",
target_os = "macos",
target_os = "android",
- target_os = "ios"
+ target_os = "ios",
+ target_os = "freebsd",
+ target_os = "dragonfly",
+ target_os = "netbsd",
+ target_os = "openbsd",
+ target_os = "illumos",
+ target_os = "solaris"
))]
use uucore::libc::{dev_t, major, minor};
#[cfg(unix)]
use uucore::libc::{S_IXGRP, S_IXOTH, S_IXUSR};
+use uucore::line_ending::LineEnding;
use uucore::quoting_style::{escape_name, QuotingStyle};
use uucore::{
display::Quotable,
error::{set_exit_code, UError, UResult},
format_usage,
fs::display_permissions,
- parse_size::parse_size,
+ parse_size::parse_size_u64,
+ shortcut_value_parser::ShortcutValueParser,
version_cmp::version_cmp,
};
-use uucore::{parse_glob, show, show_error, show_warning};
-
+use uucore::{help_about, help_section, help_usage, parse_glob, show, show_error, show_warning};
+mod dired;
+use dired::DiredOutput;
#[cfg(not(feature = "selinux"))]
static CONTEXT_HELP_TEXT: &str = "print any security context of each file (not enabled)";
#[cfg(feature = "selinux")]
static CONTEXT_HELP_TEXT: &str = "print any security context of each file";
-const ABOUT: &str = r#"List directory contents.
-Ignore files and directories starting with a '.' by default"#;
-
-const USAGE: &str = "{} [OPTION]... [FILE]...";
+const ABOUT: &str = help_about!("ls.md");
+const AFTER_HELP: &str = help_section!("after help", "ls.md");
+const USAGE: &str = help_usage!("ls.md");
pub mod options {
pub mod format {
@@ -149,12 +160,13 @@ pub mod options {
pub static GROUP_DIRECTORIES_FIRST: &str = "group-directories-first";
pub static ZERO: &str = "zero";
pub static DIRED: &str = "dired";
+ pub static HYPERLINK: &str = "hyperlink";
}
const DEFAULT_TERM_WIDTH: u16 = 80;
const POSIXLY_CORRECT_BLOCK_SIZE: u64 = 512;
-#[cfg(unix)]
const DEFAULT_BLOCK_SIZE: u64 = 1024;
+const DEFAULT_FILE_SIZE_BLOCK_SIZE: u64 = 1;
#[derive(Debug)]
enum LsError {
@@ -162,6 +174,8 @@ enum LsError {
IOError(std::io::Error),
IOErrorContext(std::io::Error, PathBuf, bool),
BlockSizeParseError(String),
+ ConflictingArgumentDired,
+ DiredAndZeroAreIncompatible,
AlreadyListedError(PathBuf),
TimeStyleParseError(String, Vec<String>),
}
@@ -173,9 +187,11 @@ impl UError for LsError {
Self::IOError(_) => 1,
Self::IOErrorContext(_, _, false) => 1,
Self::IOErrorContext(_, _, true) => 2,
- Self::BlockSizeParseError(_) => 1,
+ Self::BlockSizeParseError(_) => 2,
+ Self::ConflictingArgumentDired => 1,
+ Self::DiredAndZeroAreIncompatible => 2,
Self::AlreadyListedError(_) => 2,
- Self::TimeStyleParseError(_, _) => 1,
+ Self::TimeStyleParseError(_, _) => 2,
}
}
}
@@ -188,6 +204,12 @@ impl Display for LsError {
Self::BlockSizeParseError(s) => {
write!(f, "invalid --block-size argument {}", s.quote())
}
+ Self::ConflictingArgumentDired => {
+ write!(f, "--dired requires --format=long")
+ }
+ Self::DiredAndZeroAreIncompatible => {
+ write!(f, "--dired and --zero are incompatible")
+ }
Self::TimeStyleParseError(s, possible_time_styles) => {
write!(
f,
@@ -197,7 +219,7 @@ impl Display for LsError {
)
}
Self::InvalidLineWidth(s) => write!(f, "invalid line width: {}", s.quote()),
- Self::IOError(e) => write!(f, "general io error: {}", e),
+ Self::IOError(e) => write!(f, "general io error: {e}"),
Self::IOErrorContext(e, p, _) => {
let error_kind = e.kind();
let errno = e.raw_os_error().unwrap_or(1i32);
@@ -288,13 +310,7 @@ enum Sort {
Time,
Version,
Extension,
-}
-
-#[derive(PartialEq)]
-enum SizeFormat {
- Bytes,
- Binary, // Powers of 1024, --human-readable, -h
- Decimal, // Powers of 1000, --si
+ Width,
}
#[derive(PartialEq, Eq)]
@@ -390,7 +406,9 @@ pub struct Config {
color: Option<LsColors>,
long: LongFormat,
alloc_size: bool,
- block_size: Option<u64>,
+ file_size_block_size: u64,
+ #[allow(dead_code)]
+ block_size: u64, // is never read on Windows
width: u16,
// Dir and vdir needs access to this field
pub quoting_style: QuotingStyle,
@@ -399,7 +417,9 @@ pub struct Config {
context: bool,
selinux_supported: bool,
group_directories_first: bool,
- eol: char,
+ line_ending: LineEnding,
+ dired: bool,
+ hyperlink: bool,
}
// Fields that can be removed or added to the long format
@@ -426,36 +446,336 @@ struct PaddingCollection {
block_size: usize,
}
+/// Extracts the format to display the information based on the options provided.
+///
+/// # Returns
+///
+/// A tuple containing the Format variant and an Option containing a &'static str
+/// which corresponds to the option used to define the format.
+fn extract_format(options: &clap::ArgMatches) -> (Format, Option<&'static str>) {
+ if let Some(format_) = options.get_one::<String>(options::FORMAT) {
+ (
+ match format_.as_str() {
+ "long" | "verbose" => Format::Long,
+ "single-column" => Format::OneLine,
+ "columns" | "vertical" => Format::Columns,
+ "across" | "horizontal" => Format::Across,
+ "commas" => Format::Commas,
+ // below should never happen as clap already restricts the values.
+ _ => unreachable!("Invalid field for --format"),
+ },
+ Some(options::FORMAT),
+ )
+ } else if options.get_flag(options::format::LONG) {
+ (Format::Long, Some(options::format::LONG))
+ } else if options.get_flag(options::format::ACROSS) {
+ (Format::Across, Some(options::format::ACROSS))
+ } else if options.get_flag(options::format::COMMAS) {
+ (Format::Commas, Some(options::format::COMMAS))
+ } else if options.get_flag(options::format::COLUMNS) {
+ (Format::Columns, Some(options::format::COLUMNS))
+ } else if std::io::stdout().is_terminal() {
+ (Format::Columns, None)
+ } else {
+ (Format::OneLine, None)
+ }
+}
+
+/// Extracts the type of files to display
+///
+/// # Returns
+///
+/// A Files variant representing the type of files to display.
+fn extract_files(options: &clap::ArgMatches) -> Files {
+ if options.get_flag(options::files::ALL) {
+ Files::All
+ } else if options.get_flag(options::files::ALMOST_ALL) {
+ Files::AlmostAll
+ } else {
+ Files::Normal
+ }
+}
+
+/// Extracts the sorting method to use based on the options provided.
+///
+/// # Returns
+///
+/// A Sort variant representing the sorting method to use.
+fn extract_sort(options: &clap::ArgMatches) -> Sort {
+ if let Some(field) = options.get_one::<String>(options::SORT) {
+ match field.as_str() {
+ "none" => Sort::None,
+ "name" => Sort::Name,
+ "time" => Sort::Time,
+ "size" => Sort::Size,
+ "version" => Sort::Version,
+ "extension" => Sort::Extension,
+ "width" => Sort::Width,
+ // below should never happen as clap already restricts the values.
+ _ => unreachable!("Invalid field for --sort"),
+ }
+ } else if options.get_flag(options::sort::TIME) {
+ Sort::Time
+ } else if options.get_flag(options::sort::SIZE) {
+ Sort::Size
+ } else if options.get_flag(options::sort::NONE) {
+ Sort::None
+ } else if options.get_flag(options::sort::VERSION) {
+ Sort::Version
+ } else if options.get_flag(options::sort::EXTENSION) {
+ Sort::Extension
+ } else {
+ Sort::Name
+ }
+}
+
+/// Extracts the time to use based on the options provided.
+///
+/// # Returns
+///
+/// A Time variant representing the time to use.
+fn extract_time(options: &clap::ArgMatches) -> Time {
+ if let Some(field) = options.get_one::<String>(options::TIME) {
+ match field.as_str() {
+ "ctime" | "status" => Time::Change,
+ "access" | "atime" | "use" => Time::Access,
+ "birth" | "creation" => Time::Birth,
+ // below should never happen as clap already restricts the values.
+ _ => unreachable!("Invalid field for --time"),
+ }
+ } else if options.get_flag(options::time::ACCESS) {
+ Time::Access
+ } else if options.get_flag(options::time::CHANGE) {
+ Time::Change
+ } else {
+ Time::Modification
+ }
+}
+
+// Some env variables can be passed
+// For now, we are only verifying if empty or not and known for TERM
+fn is_color_compatible_term() -> bool {
+ let is_term_set = std::env::var("TERM").is_ok();
+ let is_colorterm_set = std::env::var("COLORTERM").is_ok();
+
+ let term = std::env::var("TERM").unwrap_or_default();
+ let colorterm = std::env::var("COLORTERM").unwrap_or_default();
+
+ // Search function in the TERM struct to manage the wildcards
+ let term_matches = |term: &str| -> bool {
+ uucore::colors::TERMS.iter().any(|&pattern| {
+ term == pattern
+ || (pattern.ends_with('*') && term.starts_with(&pattern[..pattern.len() - 1]))
+ })
+ };
+
+ if is_term_set && term.is_empty() && is_colorterm_set && colorterm.is_empty() {
+ return false;
+ }
+
+ if !term.is_empty() && !term_matches(&term) {
+ return false;
+ }
+ true
+}
+
+/// Extracts the color option to use based on the options provided.
+///
+/// # Returns
+///
+/// A boolean representing whether or not to use color.
+fn extract_color(options: &clap::ArgMatches) -> bool {
+ if !is_color_compatible_term() {
+ return false;
+ }
+
+ match options.get_one::<String>(options::COLOR) {
+ None => options.contains_id(options::COLOR),
+ Some(val) => match val.as_str() {
+ "" | "always" | "yes" | "force" => true,
+ "auto" | "tty" | "if-tty" => std::io::stdout().is_terminal(),
+ /* "never" | "no" | "none" | */ _ => false,
+ },
+ }
+}
+
+/// Extracts the hyperlink option to use based on the options provided.
+///
+/// # Returns
+///
+/// A boolean representing whether to hyperlink files.
+fn extract_hyperlink(options: &clap::ArgMatches) -> bool {
+ let hyperlink = options
+ .get_one::<String>(options::HYPERLINK)
+ .unwrap()
+ .as_str();
+
+ match hyperlink {
+ "always" | "yes" | "force" => true,
+ "auto" | "tty" | "if-tty" => std::io::stdout().is_terminal(),
+ "never" | "no" | "none" => false,
+ _ => unreachable!("should be handled by clap"),
+ }
+}
+
+/// Match the argument given to --quoting-style or the QUOTING_STYLE env variable.
+///
+/// # Arguments
+///
+/// * `style`: the actual argument string
+/// * `show_control` - A boolean value representing whether or not to show control characters.
+///
+/// # Returns
+///
+/// * An option with None if the style string is invalid, or a `QuotingStyle` wrapped in `Some`.
+fn match_quoting_style_name(style: &str, show_control: bool) -> Option<QuotingStyle> {
+ match style {
+ "literal" => Some(QuotingStyle::Literal { show_control }),
+ "shell" => Some(QuotingStyle::Shell {
+ escape: false,
+ always_quote: false,
+ show_control,
+ }),
+ "shell-always" => Some(QuotingStyle::Shell {
+ escape: false,
+ always_quote: true,
+ show_control,
+ }),
+ "shell-escape" => Some(QuotingStyle::Shell {
+ escape: true,
+ always_quote: false,
+ show_control,
+ }),
+ "shell-escape-always" => Some(QuotingStyle::Shell {
+ escape: true,
+ always_quote: true,
+ show_control,
+ }),
+ "c" => Some(QuotingStyle::C {
+ quotes: quoting_style::Quotes::Double,
+ }),
+ "escape" => Some(QuotingStyle::C {
+ quotes: quoting_style::Quotes::None,
+ }),
+ _ => None,
+ }
+}
+
+/// Extracts the quoting style to use based on the options provided.
+/// If no options are given, it looks if a default quoting style is provided
+/// through the QUOTING_STYLE environment variable.
+///
+/// # Arguments
+///
+/// * `options` - A reference to a clap::ArgMatches object containing command line arguments.
+/// * `show_control` - A boolean value representing whether or not to show control characters.
+///
+/// # Returns
+///
+/// A QuotingStyle variant representing the quoting style to use.
+fn extract_quoting_style(options: &clap::ArgMatches, show_control: bool) -> QuotingStyle {
+ let opt_quoting_style = options.get_one::<String>(options::QUOTING_STYLE);
+
+ if let Some(style) = opt_quoting_style {
+ match match_quoting_style_name(style, show_control) {
+ Some(qs) => qs,
+ None => unreachable!("Should have been caught by Clap"),
+ }
+ } else if options.get_flag(options::quoting::LITERAL) {
+ QuotingStyle::Literal { show_control }
+ } else if options.get_flag(options::quoting::ESCAPE) {
+ QuotingStyle::C {
+ quotes: quoting_style::Quotes::None,
+ }
+ } else if options.get_flag(options::quoting::C) {
+ QuotingStyle::C {
+ quotes: quoting_style::Quotes::Double,
+ }
+ } else if options.get_flag(options::DIRED) {
+ QuotingStyle::Literal { show_control }
+ } else {
+ // If set, the QUOTING_STYLE environment variable specifies a default style.
+ if let Ok(style) = std::env::var("QUOTING_STYLE") {
+ match match_quoting_style_name(style.as_str(), show_control) {
+ Some(qs) => return qs,
+ None => eprintln!(
+ "{}: Ignoring invalid value of environment variable QUOTING_STYLE: '{}'",
+ std::env::args().next().unwrap_or("ls".to_string()),
+ style
+ ),
+ }
+ }
+
+ // By default, `ls` uses Shell escape quoting style when writing to a terminal file
+ // descriptor and Literal otherwise.
+ if std::io::stdout().is_terminal() {
+ QuotingStyle::Shell {
+ escape: true,
+ always_quote: false,
+ show_control,
+ }
+ } else {
+ QuotingStyle::Literal { show_control }
+ }
+ }
+}
+
+/// Extracts the indicator style to use based on the options provided.
+///
+/// # Returns
+///
+/// An IndicatorStyle variant representing the indicator style to use.
+fn extract_indicator_style(options: &clap::ArgMatches) -> IndicatorStyle {
+ if let Some(field) = options.get_one::<String>(options::INDICATOR_STYLE) {
+ match field.as_str() {
+ "none" => IndicatorStyle::None,
+ "file-type" => IndicatorStyle::FileType,
+ "classify" => IndicatorStyle::Classify,
+ "slash" => IndicatorStyle::Slash,
+ &_ => IndicatorStyle::None,
+ }
+ } else if let Some(field) = options.get_one::<String>(options::indicator_style::CLASSIFY) {
+ match field.as_str() {
+ "never" | "no" | "none" => IndicatorStyle::None,
+ "always" | "yes" | "force" => IndicatorStyle::Classify,
+ "auto" | "tty" | "if-tty" => {
+ if std::io::stdout().is_terminal() {
+ IndicatorStyle::Classify
+ } else {
+ IndicatorStyle::None
+ }
+ }
+ &_ => IndicatorStyle::None,
+ }
+ } else if options.get_flag(options::indicator_style::SLASH) {
+ IndicatorStyle::Slash
+ } else if options.get_flag(options::indicator_style::FILE_TYPE) {
+ IndicatorStyle::FileType
+ } else {
+ IndicatorStyle::None
+ }
+}
+
+fn parse_width(s: &str) -> Result<u16, LsError> {
+ let radix = if s.starts_with('0') && s.len() > 1 {
+ 8
+ } else {
+ 10
+ };
+ match u16::from_str_radix(s, radix) {
+ Ok(x) => Ok(x),
+ Err(e) => match e.kind() {
+ IntErrorKind::PosOverflow => Ok(u16::MAX),
+ _ => Err(LsError::InvalidLineWidth(s.into())),
+ },
+ }
+}
impl Config {
#[allow(clippy::cognitive_complexity)]
pub fn from(options: &clap::ArgMatches) -> UResult<Self> {
let context = options.get_flag(options::CONTEXT);
- let (mut format, opt) = if let Some(format_) = options.get_one::<String>(options::FORMAT) {
- (
- match format_.as_str() {
- "long" | "verbose" => Format::Long,
- "single-column" => Format::OneLine,
- "columns" | "vertical" => Format::Columns,
- "across" | "horizontal" => Format::Across,
- "commas" => Format::Commas,
- // below should never happen as clap already restricts the values.
- _ => unreachable!("Invalid field for --format"),
- },
- Some(options::FORMAT),
- )
- } else if options.get_flag(options::format::LONG) {
- (Format::Long, Some(options::format::LONG))
- } else if options.get_flag(options::format::ACROSS) {
- (Format::Across, Some(options::format::ACROSS))
- } else if options.get_flag(options::format::COMMAS) {
- (Format::Commas, Some(options::format::COMMAS))
- } else if options.get_flag(options::format::COLUMNS) {
- (Format::Columns, Some(options::format::COLUMNS))
- } else if atty::is(atty::Stream::Stdout) {
- (Format::Columns, None)
- } else {
- (Format::OneLine, None)
- };
+ let (mut format, opt) = extract_format(options);
+ let files = extract_files(options);
// The -o, -n and -g options are tricky. They cannot override with each
// other because it's possible to combine them. For example, the option
@@ -504,72 +824,19 @@ impl Config {
}
}
- let files = if options.get_flag(options::files::ALL) {
- Files::All
- } else if options.get_flag(options::files::ALMOST_ALL) {
- Files::AlmostAll
- } else {
- Files::Normal
- };
-
- let sort = if let Some(field) = options.get_one::<String>(options::SORT) {
- match field.as_str() {
- "none" => Sort::None,
- "name" => Sort::Name,
- "time" => Sort::Time,
- "size" => Sort::Size,
- "version" => Sort::Version,
- "extension" => Sort::Extension,
- // below should never happen as clap already restricts the values.
- _ => unreachable!("Invalid field for --sort"),
- }
- } else if options.get_flag(options::sort::TIME) {
- Sort::Time
- } else if options.get_flag(options::sort::SIZE) {
- Sort::Size
- } else if options.get_flag(options::sort::NONE) {
- Sort::None
- } else if options.get_flag(options::sort::VERSION) {
- Sort::Version
- } else if options.get_flag(options::sort::EXTENSION) {
- Sort::Extension
- } else {
- Sort::Name
- };
-
- let time = if let Some(field) = options.get_one::<String>(options::TIME) {
- match field.as_str() {
- "ctime" | "status" => Time::Change,
- "access" | "atime" | "use" => Time::Access,
- "birth" | "creation" => Time::Birth,
- // below should never happen as clap already restricts the values.
- _ => unreachable!("Invalid field for --time"),
- }
- } else if options.get_flag(options::time::ACCESS) {
- Time::Access
- } else if options.get_flag(options::time::CHANGE) {
- Time::Change
- } else {
- Time::Modification
- };
-
- let mut needs_color = match options.get_one::<String>(options::COLOR) {
- None => options.contains_id(options::COLOR),
- Some(val) => match val.as_str() {
- "" | "always" | "yes" | "force" => true,
- "auto" | "tty" | "if-tty" => atty::is(atty::Stream::Stdout),
- /* "never" | "no" | "none" | */ _ => false,
- },
- };
+ let sort = extract_sort(options);
+ let time = extract_time(options);
+ let mut needs_color = extract_color(options);
+ let hyperlink = extract_hyperlink(options);
- let cmd_line_bs = options.get_one::<String>(options::size::BLOCK_SIZE);
- let opt_si = cmd_line_bs.is_some()
+ let opt_block_size = options.get_one::<String>(options::size::BLOCK_SIZE);
+ let opt_si = opt_block_size.is_some()
&& options
.get_one::<String>(options::size::BLOCK_SIZE)
.unwrap()
.eq("si")
|| options.get_flag(options::size::SI);
- let opt_hr = (cmd_line_bs.is_some()
+ let opt_hr = (opt_block_size.is_some()
&& options
.get_one::<String>(options::size::BLOCK_SIZE)
.unwrap()
@@ -577,10 +844,6 @@ impl Config {
|| options.get_flag(options::size::HUMAN_READABLE);
let opt_kb = options.get_flag(options::size::KIBIBYTES);
- let bs_env_var = std::env::var_os("BLOCK_SIZE");
- let ls_bs_env_var = std::env::var_os("LS_BLOCK_SIZE");
- let pc_env_var = std::env::var_os("POSIXLY_CORRECT");
-
let size_format = if opt_si {
SizeFormat::Decimal
} else if opt_hr {
@@ -589,38 +852,66 @@ impl Config {
SizeFormat::Bytes
};
- let raw_bs = if let Some(cmd_line_bs) = cmd_line_bs {
- OsString::from(cmd_line_bs)
- } else if !opt_kb {
- if let Some(ls_bs_env_var) = ls_bs_env_var {
- ls_bs_env_var
- } else if let Some(bs_env_var) = bs_env_var {
- bs_env_var
- } else {
- OsString::from("")
- }
+ let env_var_blocksize = std::env::var_os("BLOCKSIZE");
+ let env_var_block_size = std::env::var_os("BLOCK_SIZE");
+ let env_var_ls_block_size = std::env::var_os("LS_BLOCK_SIZE");
+ let env_var_posixly_correct = std::env::var_os("POSIXLY_CORRECT");
+ let mut is_env_var_blocksize = false;
+
+ let raw_block_size = if let Some(opt_block_size) = opt_block_size {
+ OsString::from(opt_block_size)
+ } else if let Some(env_var_ls_block_size) = env_var_ls_block_size {
+ env_var_ls_block_size
+ } else if let Some(env_var_block_size) = env_var_block_size {
+ env_var_block_size
+ } else if let Some(env_var_blocksize) = env_var_blocksize {
+ is_env_var_blocksize = true;
+ env_var_blocksize
} else {
OsString::from("")
};
- let block_size: Option<u64> = if !opt_si && !opt_hr && !raw_bs.is_empty() {
- match parse_size(&raw_bs.to_string_lossy()) {
- Ok(size) => Some(size),
+ let (file_size_block_size, block_size) = if !opt_si && !opt_hr && !raw_block_size.is_empty()
+ {
+ match parse_size_u64(&raw_block_size.to_string_lossy()) {
+ Ok(size) => match (is_env_var_blocksize, opt_kb) {
+ (true, true) => (DEFAULT_FILE_SIZE_BLOCK_SIZE, DEFAULT_BLOCK_SIZE),
+ (true, false) => (DEFAULT_FILE_SIZE_BLOCK_SIZE, size),
+ (false, true) => {
+ // --block-size overrides -k
+ if opt_block_size.is_some() {
+ (size, size)
+ } else {
+ (size, DEFAULT_BLOCK_SIZE)
+ }
+ }
+ (false, false) => (size, size),
+ },
Err(_) => {
- show!(LsError::BlockSizeParseError(
- cmd_line_bs.unwrap().to_owned()
- ));
- None
+ // only fail if invalid block size was specified with --block-size,
+ // ignore invalid block size from env vars
+ if let Some(invalid_block_size) = opt_block_size {
+ return Err(Box::new(LsError::BlockSizeParseError(
+ invalid_block_size.clone(),
+ )));
+ }
+ if is_env_var_blocksize {
+ (DEFAULT_FILE_SIZE_BLOCK_SIZE, DEFAULT_BLOCK_SIZE)
+ } else {
+ (DEFAULT_BLOCK_SIZE, DEFAULT_BLOCK_SIZE)
+ }
}
}
- } else if let Some(pc) = pc_env_var {
- if pc.as_os_str() == OsStr::new("true") || pc == OsStr::new("1") {
- Some(POSIXLY_CORRECT_BLOCK_SIZE)
+ } else if env_var_posixly_correct.is_some() {
+ if opt_kb {
+ (DEFAULT_FILE_SIZE_BLOCK_SIZE, DEFAULT_BLOCK_SIZE)
} else {
- None
+ (DEFAULT_FILE_SIZE_BLOCK_SIZE, POSIXLY_CORRECT_BLOCK_SIZE)
}
+ } else if opt_si {
+ (DEFAULT_FILE_SIZE_BLOCK_SIZE, 1000)
} else {
- None
+ (DEFAULT_FILE_SIZE_BLOCK_SIZE, DEFAULT_BLOCK_SIZE)
};
let long = {
@@ -640,20 +931,7 @@ impl Config {
};
let width = match options.get_one::<String>(options::WIDTH) {
- Some(x) => {
- if x.starts_with('0') && x.len() > 1 {
- // Read number as octal
- match u16::from_str_radix(x, 8) {
- Ok(v) => v,
- Err(_) => return Err(LsError::InvalidLineWidth(x.into()).into()),
- }
- } else {
- match x.parse::<u16>() {
- Ok(u) => u,
- Err(_) => return Err(LsError::InvalidLineWidth(x.into()).into()),
- }
- }
- }
+ Some(x) => parse_width(x)?,
None => match terminal_size::terminal_size() {
Some((width, _)) => width.0,
None => match std::env::var_os("COLUMNS") {
@@ -678,94 +956,17 @@ impl Config {
} else if options.get_flag(options::SHOW_CONTROL_CHARS) {
true
} else {
- !atty::is(atty::Stream::Stdout)
- };
-
- let opt_quoting_style = options
- .get_one::<String>(options::QUOTING_STYLE)
- .map(|cmd_line_qs| cmd_line_qs.to_owned());
-
- let mut quoting_style = if let Some(style) = opt_quoting_style {
- match style.as_str() {
- "literal" => QuotingStyle::Literal { show_control },
- "shell" => QuotingStyle::Shell {
- escape: false,
- always_quote: false,
- show_control,
- },
- "shell-always" => QuotingStyle::Shell {
- escape: false,
- always_quote: true,
- show_control,
- },
- "shell-escape" => QuotingStyle::Shell {
- escape: true,
- always_quote: false,
- show_control,
- },
- "shell-escape-always" => QuotingStyle::Shell {
- escape: true,
- always_quote: true,
- show_control,
- },
- "c" => QuotingStyle::C {
- quotes: quoting_style::Quotes::Double,
- },
- "escape" => QuotingStyle::C {
- quotes: quoting_style::Quotes::None,
- },
- _ => unreachable!("Should have been caught by Clap"),
- }
- } else if options.get_flag(options::quoting::LITERAL) {
- QuotingStyle::Literal { show_control }
- } else if options.get_flag(options::quoting::ESCAPE) {
- QuotingStyle::C {
- quotes: quoting_style::Quotes::None,
- }
- } else if options.get_flag(options::quoting::C) {
- QuotingStyle::C {
- quotes: quoting_style::Quotes::Double,
- }
- } else {
- // TODO: use environment variable if available
- QuotingStyle::Shell {
- escape: true,
- always_quote: false,
- show_control,
- }
+ !std::io::stdout().is_terminal()
};
- let indicator_style = if let Some(field) =
- options.get_one::<String>(options::INDICATOR_STYLE)
- {
- match field.as_str() {
- "none" => IndicatorStyle::None,
- "file-type" => IndicatorStyle::FileType,
- "classify" => IndicatorStyle::Classify,
- "slash" => IndicatorStyle::Slash,
- &_ => IndicatorStyle::None,
- }
- } else if let Some(field) = options.get_one::<String>(options::indicator_style::CLASSIFY) {
- match field.as_str() {
- "never" | "no" | "none" => IndicatorStyle::None,
- "always" | "yes" | "force" => IndicatorStyle::Classify,
- "auto" | "tty" | "if-tty" => {
- if atty::is(atty::Stream::Stdout) {
- IndicatorStyle::Classify
- } else {
- IndicatorStyle::None
- }
- }
- &_ => IndicatorStyle::None,
- }
- } else if options.get_flag(options::indicator_style::SLASH) {
- IndicatorStyle::Slash
- } else if options.get_flag(options::indicator_style::FILE_TYPE) {
- IndicatorStyle::FileType
+ let mut quoting_style = extract_quoting_style(options, show_control);
+ let indicator_style = extract_indicator_style(options);
+ // Only parse the value to "--time-style" if it will become relevant.
+ let time_style = if format == Format::Long {
+ parse_time_style(options)?
} else {
- IndicatorStyle::None
+ TimeStyle::Iso
};
- let time_style = parse_time_style(options)?;
let mut ignore_patterns: Vec<Pattern> = Vec::new();
@@ -882,6 +1083,14 @@ impl Config {
None
};
+ let dired = options.get_flag(options::DIRED);
+ if dired && format != Format::Long {
+ return Err(Box::new(LsError::ConflictingArgumentDired));
+ }
+ if dired && format == Format::Long && options.get_flag(options::ZERO) {
+ return Err(Box::new(LsError::DiredAndZeroAreIncompatible));
+ }
+
let dereference = if options.get_flag(options::dereference::ALL) {
Dereference::All
} else if options.get_flag(options::dereference::ARGS) {
@@ -913,6 +1122,7 @@ impl Config {
inode: options.get_flag(options::INODE),
long,
alloc_size: options.get_flag(options::size::ALLOCATION_SIZE),
+ file_size_block_size,
block_size,
width,
quoting_style,
@@ -930,11 +1140,9 @@ impl Config {
}
},
group_directories_first: options.get_flag(options::GROUP_DIRECTORIES_FIRST),
- eol: if options.get_flag(options::ZERO) {
- '\0'
- } else {
- '\n'
- },
+ line_ending: LineEnding::from_zero_flag(options.get_flag(options::ZERO)),
+ dired,
+ hyperlink,
})
}
}
@@ -943,7 +1151,22 @@ impl Config {
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let command = uu_app();
- let matches = command.get_matches_from(args);
+ let matches = match command.try_get_matches_from(args) {
+ // clap successfully parsed the arguments:
+ Ok(matches) => matches,
+ // --help, --version, etc.:
+ Err(e) if e.exit_code() == 0 => {
+ return Err(e.into());
+ }
+ // Errors in argument *values* cause exit code 1:
+ Err(e) if e.kind() == clap::error::ErrorKind::InvalidValue => {
+ return Err(USimpleError::new(1, e.to_string()));
+ }
+ // All other argument parsing errors cause exit code 2:
+ Err(e) => {
+ return Err(USimpleError::new(2, e.to_string()));
+ }
+ };
let config = Config::from(&matches)?;
@@ -962,6 +1185,7 @@ pub fn uu_app() -> Command {
.about(ABOUT)
.infer_long_args(true)
.disable_help_flag(true)
+ .args_override_self(true)
.arg(
Arg::new(options::HELP)
.long(options::HELP)
@@ -973,7 +1197,7 @@ pub fn uu_app() -> Command {
Arg::new(options::FORMAT)
.long(options::FORMAT)
.help("Set the display format.")
- .value_parser([
+ .value_parser(ShortcutValueParser::new([
"long",
"verbose",
"single-column",
@@ -982,7 +1206,7 @@ pub fn uu_app() -> Command {
"across",
"horizontal",
"commas",
- ])
+ ]))
.hide_possible_values(true)
.require_equals(true)
.overrides_with_all([
@@ -1058,7 +1282,6 @@ pub fn uu_app() -> Command {
.arg(
Arg::new(options::ZERO)
.long(options::ZERO)
- .conflicts_with(options::DIRED)
.overrides_with(options::ZERO)
.help("List entries separated by ASCII NUL characters.")
.action(ArgAction::SetTrue),
@@ -1067,9 +1290,24 @@ pub fn uu_app() -> Command {
Arg::new(options::DIRED)
.long(options::DIRED)
.short('D')
- .hide(true)
+ .help("generate output designed for Emacs' dired (Directory Editor) mode")
.action(ArgAction::SetTrue),
)
+ .arg(
+ Arg::new(options::HYPERLINK)
+ .long(options::HYPERLINK)
+ .help("hyperlink file names WHEN")
+ .value_parser(ShortcutValueParser::new([
+ PossibleValue::new("always").alias("yes").alias("force"),
+ PossibleValue::new("auto").alias("tty").alias("if-tty"),
+ PossibleValue::new("never").alias("no").alias("none"),
+ ]))
+ .require_equals(true)
+ .num_args(0..=1)
+ .default_missing_value("always")
+ .default_value("never")
+ .value_name("WHEN"),
+ )
// The next four arguments do not override with the other format
// options, see the comment in Config::from for the reason.
// Ideally, they would use Arg::override_with, with their own name
@@ -1109,15 +1347,15 @@ pub fn uu_app() -> Command {
Arg::new(options::QUOTING_STYLE)
.long(options::QUOTING_STYLE)
.help("Set quoting style.")
- .value_parser([
- "literal",
- "shell",
- "shell-always",
- "shell-escape",
- "shell-escape-always",
- "c",
- "escape",
- ])
+ .value_parser(ShortcutValueParser::new([
+ PossibleValue::new("literal"),
+ PossibleValue::new("shell"),
+ PossibleValue::new("shell-escape"),
+ PossibleValue::new("shell-always"),
+ PossibleValue::new("shell-escape-always"),
+ PossibleValue::new("c").alias("c-maybe"),
+ PossibleValue::new("escape"),
+ ]))
.overrides_with_all([
options::QUOTING_STYLE,
options::quoting::LITERAL,
@@ -1129,6 +1367,7 @@ pub fn uu_app() -> Command {
Arg::new(options::quoting::LITERAL)
.short('N')
.long(options::quoting::LITERAL)
+ .alias("l")
.help("Use literal quoting style. Equivalent to `--quoting-style=literal`")
.overrides_with_all([
options::QUOTING_STYLE,
@@ -1191,9 +1430,11 @@ pub fn uu_app() -> Command {
\tbirth time: birth, creation;",
)
.value_name("field")
- .value_parser([
- "atime", "access", "use", "ctime", "status", "birth", "creation",
- ])
+ .value_parser(ShortcutValueParser::new([
+ PossibleValue::new("atime").alias("access").alias("use"),
+ PossibleValue::new("ctime").alias("status"),
+ PossibleValue::new("birth").alias("creation"),
+ ]))
.hide_possible_values(true)
.require_equals(true)
.overrides_with_all([options::TIME, options::time::ACCESS, options::time::CHANGE]),
@@ -1251,9 +1492,9 @@ pub fn uu_app() -> Command {
.arg(
Arg::new(options::SORT)
.long(options::SORT)
- .help("Sort by <field>: name, none (-U), time (-t), size (-S) or extension (-X)")
+ .help("Sort by <field>: name, none (-U), time (-t), size (-S), extension (-X) or width")
.value_name("field")
- .value_parser(["name", "none", "time", "size", "version", "extension"])
+ .value_parser(ShortcutValueParser::new(["name", "none", "time", "size", "version", "extension", "width"]))
.require_equals(true)
.overrides_with_all([
options::SORT,
@@ -1358,7 +1599,7 @@ pub fn uu_app() -> Command {
Arg::new(options::dereference::DIR_ARGS)
.long(options::dereference::DIR_ARGS)
.help(
- "Do not dereference symlinks except when they link to directories and are \
+ "Do not follow symlinks except when they link to directories and are \
given as command line arguments.",
)
.overrides_with_all([
@@ -1372,7 +1613,7 @@ pub fn uu_app() -> Command {
Arg::new(options::dereference::ARGS)
.short('H')
.long(options::dereference::ARGS)
- .help("Do not dereference symlinks except when given as command line arguments.")
+ .help("Do not follow symlinks except when given as command line arguments.")
.overrides_with_all([
options::dereference::ALL,
options::dereference::DIR_ARGS,
@@ -1431,7 +1672,7 @@ pub fn uu_app() -> Command {
.short('h')
.long(options::size::HUMAN_READABLE)
.help("Print human readable file sizes (e.g. 1K 234M 56G).")
- .overrides_with(options::size::SI)
+ .overrides_with_all([options::size::BLOCK_SIZE, options::size::SI])
.action(ArgAction::SetTrue),
)
.arg(
@@ -1448,6 +1689,7 @@ pub fn uu_app() -> Command {
Arg::new(options::size::SI)
.long(options::size::SI)
.help("Print human readable file sizes using powers of 1000 instead of 1024.")
+ .overrides_with_all([options::size::BLOCK_SIZE, options::size::HUMAN_READABLE])
.action(ArgAction::SetTrue),
)
.arg(
@@ -1455,7 +1697,8 @@ pub fn uu_app() -> Command {
.long(options::size::BLOCK_SIZE)
.require_equals(true)
.value_name("BLOCK_SIZE")
- .help("scale sizes by BLOCK_SIZE when printing them"),
+ .help("scale sizes by BLOCK_SIZE when printing them")
+ .overrides_with_all([options::size::SI, options::size::HUMAN_READABLE]),
)
.arg(
Arg::new(options::INODE)
@@ -1499,9 +1742,11 @@ pub fn uu_app() -> Command {
Arg::new(options::COLOR)
.long(options::COLOR)
.help("Color output based on file type.")
- .value_parser([
- "always", "yes", "force", "auto", "tty", "if-tty", "never", "no", "none",
- ])
+ .value_parser(ShortcutValueParser::new([
+ PossibleValue::new("always").alias("yes").alias("force"),
+ PossibleValue::new("auto").alias("tty").alias("if-tty"),
+ PossibleValue::new("never").alias("no").alias("none"),
+ ]))
.require_equals(true)
.num_args(0..=1),
)
@@ -1512,7 +1757,7 @@ pub fn uu_app() -> Command {
"Append indicator with style WORD to entry names: \
none (default), slash (-p), file-type (--file-type), classify (-F)",
)
- .value_parser(["none", "slash", "file-type", "classify"])
+ .value_parser(ShortcutValueParser::new(["none", "slash", "file-type", "classify"]))
.overrides_with_all([
options::indicator_style::FILE_TYPE,
options::indicator_style::SLASH,
@@ -1543,9 +1788,11 @@ pub fn uu_app() -> Command {
--dereference-command-line-symlink-to-dir options are specified.",
)
.value_name("when")
- .value_parser([
- "always", "yes", "force", "auto", "tty", "if-tty", "never", "no", "none",
- ])
+ .value_parser(ShortcutValueParser::new([
+ PossibleValue::new("always").alias("yes").alias("force"),
+ PossibleValue::new("auto").alias("tty").alias("if-tty"),
+ PossibleValue::new("never").alias("no").alias("none"),
+ ]))
.default_missing_value("always")
.require_equals(true)
.num_args(0..=1)
@@ -1620,10 +1867,7 @@ pub fn uu_app() -> Command {
.value_hint(clap::ValueHint::AnyPath)
.value_parser(ValueParser::os_string()),
)
- .after_help(
- "The TIME_STYLE argument can be full-iso, long-iso, iso, locale or +FORMAT. FORMAT is interpreted like in date. \
- Also the TIME_STYLE environment variable sets the default style to use.",
- )
+ .after_help(AFTER_HELP)
}
/// Represents a Path along with it's associated data.
@@ -1634,6 +1878,8 @@ struct PathData {
// Result<MetaData> got from symlink_metadata() or metadata() based on config
md: OnceCell<Option<Metadata>>,
ft: OnceCell<Option<FileType>>,
+ // can be used to avoid reading the metadata. Can be also called d_type:
+ // https://www.gnu.org/software/libc/manual/html_node/Directory-Entries.html
de: Option<DirEntry>,
// Name of the file - will be empty for . or ..
display_name: OsString,
@@ -1729,10 +1975,11 @@ impl PathData {
}
}
- fn md(&self, out: &mut BufWriter<Stdout>) -> Option<&Metadata> {
+ fn get_metadata(&self, out: &mut BufWriter<Stdout>) -> Option<&Metadata> {
self.md
.get_or_init(|| {
// check if we can use DirEntry metadata
+ // it will avoid a call to stat()
if !self.must_dereference {
if let Some(dir_entry) = &self.de {
return dir_entry.metadata().ok();
@@ -1740,7 +1987,7 @@ impl PathData {
}
// if not, check if we can use Path metadata
- match get_metadata(self.p_buf.as_path(), self.must_dereference) {
+ match get_metadata_with_deref_opt(self.p_buf.as_path(), self.must_dereference) {
Err(err) => {
// FIXME: A bit tricky to propagate the result here
out.flush().unwrap();
@@ -1769,15 +2016,28 @@ impl PathData {
fn file_type(&self, out: &mut BufWriter<Stdout>) -> Option<&FileType> {
self.ft
- .get_or_init(|| self.md(out).map(|md| md.file_type()))
+ .get_or_init(|| self.get_metadata(out).map(|md| md.file_type()))
.as_ref()
}
}
+fn show_dir_name(path_data: &PathData, out: &mut BufWriter<Stdout>, config: &Config) {
+ if config.hyperlink {
+ let name = escape_name(&path_data.display_name, &config.quoting_style);
+ let hyperlink = create_hyperlink(&name, path_data);
+ write!(out, "{}:", hyperlink).unwrap();
+ } else {
+ write!(out, "{}:", path_data.p_buf.display()).unwrap();
+ }
+}
+
+#[allow(clippy::cognitive_complexity)]
pub fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> {
let mut files = Vec::<PathData>::new();
let mut dirs = Vec::<PathData>::new();
let mut out = BufWriter::new(stdout());
+ let mut dired = DiredOutput::default();
+ let mut style_manager = StyleManager::new();
let initial_locs_len = locs.len();
for loc in locs {
@@ -1789,7 +2049,7 @@ pub fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> {
// Proper GNU handling is don't show if dereferenced symlink DNE
// but only for the base dir, for a child dir show, and print ?s
// in long format
- if path_data.md(&mut out).is_none() {
+ if path_data.get_metadata(&mut out).is_none() {
continue;
}
@@ -1811,7 +2071,7 @@ pub fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> {
sort_entries(&mut files, config, &mut out);
sort_entries(&mut dirs, config, &mut out);
- display_items(&files, config, &mut out)?;
+ display_items(&files, config, &mut out, &mut dired, &mut style_manager)?;
for (pos, path_data) in dirs.iter().enumerate() {
// Do read_dir call here to match GNU semantics by printing
@@ -1833,9 +2093,23 @@ pub fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> {
// Print dir heading - name... 'total' comes after error display
if initial_locs_len > 1 || config.recursive {
if pos.eq(&0usize) && files.is_empty() {
- writeln!(out, "{}:", path_data.p_buf.display())?;
+ if config.dired {
+ dired::indent(&mut out)?;
+ }
+ show_dir_name(path_data, &mut out, config);
+ writeln!(out)?;
+ if config.dired {
+ // First directory displayed
+ let dir_len = path_data.display_name.len();
+ // add the //SUBDIRED// coordinates
+ dired::calculate_subdired(&mut dired, dir_len);
+ // Add the padding for the dir name
+ dired::add_dir_name(&mut dired, dir_len);
+ }
} else {
- writeln!(out, "\n{}:", path_data.p_buf.display())?;
+ writeln!(out)?;
+ show_dir_name(path_data, &mut out, config);
+ writeln!(out)?;
}
}
let mut listed_ancestors = HashSet::new();
@@ -1843,9 +2117,19 @@ pub fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> {
&path_data.p_buf,
path_data.must_dereference,
)?);
- enter_directory(path_data, read_dir, config, &mut out, &mut listed_ancestors)?;
+ enter_directory(
+ path_data,
+ read_dir,
+ config,
+ &mut out,
+ &mut listed_ancestors,
+ &mut dired,
+ &mut style_manager,
+ )?;
+ }
+ if config.dired {
+ dired::print_dired_output(config, &dired, &mut out)?;
}
-
Ok(())
}
@@ -1853,22 +2137,32 @@ fn sort_entries(entries: &mut [PathData], config: &Config, out: &mut BufWriter<S
match config.sort {
Sort::Time => entries.sort_by_key(|k| {
Reverse(
- k.md(out)
+ k.get_metadata(out)
.and_then(|md| get_system_time(md, config))
.unwrap_or(UNIX_EPOCH),
)
}),
- Sort::Size => entries.sort_by_key(|k| Reverse(k.md(out).map(|md| md.len()).unwrap_or(0))),
+ Sort::Size => {
+ entries.sort_by_key(|k| Reverse(k.get_metadata(out).map(|md| md.len()).unwrap_or(0)));
+ }
// The default sort in GNU ls is case insensitive
Sort::Name => entries.sort_by(|a, b| a.display_name.cmp(&b.display_name)),
- Sort::Version => entries
- .sort_by(|a, b| version_cmp(&a.p_buf.to_string_lossy(), &b.p_buf.to_string_lossy())),
+ Sort::Version => entries.sort_by(|a, b| {
+ version_cmp(&a.p_buf.to_string_lossy(), &b.p_buf.to_string_lossy())
+ .then(a.p_buf.to_string_lossy().cmp(&b.p_buf.to_string_lossy()))
+ }),
Sort::Extension => entries.sort_by(|a, b| {
a.p_buf
.extension()
.cmp(&b.p_buf.extension())
.then(a.p_buf.file_stem().cmp(&b.p_buf.file_stem()))
}),
+ Sort::Width => entries.sort_by(|a, b| {
+ a.display_name
+ .len()
+ .cmp(&b.display_name.len())
+ .then(a.display_name.cmp(&b.display_name))
+ }),
Sort::None => {}
}
@@ -1891,7 +2185,8 @@ fn sort_entries(entries: &mut [PathData], config: &Config, out: &mut BufWriter<S
!match md {
None | Some(None) => {
// If it metadata cannot be determined, treat as a file.
- get_metadata(p.p_buf.as_path(), true).map_or_else(|_| false, |m| m.is_dir())
+ get_metadata_with_deref_opt(p.p_buf.as_path(), true)
+ .map_or_else(|_| false, |m| m.is_dir())
}
Some(Some(m)) => m.is_dir(),
}
@@ -1929,19 +2224,27 @@ fn should_display(entry: &DirEntry, config: &Config) -> bool {
require_literal_separator: false,
case_sensitive: true,
};
- let file_name = entry.file_name().into_string().unwrap();
+ let file_name = entry.file_name();
+ // If the decoding fails, still show an incorrect rendering
+ let file_name = match file_name.to_str() {
+ Some(s) => s.to_string(),
+ None => file_name.to_string_lossy().into_owned(),
+ };
!config
.ignore_patterns
.iter()
.any(|p| p.matches_with(&file_name, options))
}
+#[allow(clippy::cognitive_complexity)]
fn enter_directory(
path_data: &PathData,
read_dir: ReadDir,
config: &Config,
out: &mut BufWriter<Stdout>,
listed_ancestors: &mut HashSet<FileInformation>,
+ dired: &mut DiredOutput,
+ style_manager: &mut StyleManager,
) -> UResult<()> {
// Create vec of entries with initial dot files
let mut entries: Vec<PathData> = if config.files == Files::All {
@@ -1987,10 +2290,14 @@ fn enter_directory(
// Print total after any error display
if config.format == Format::Long || config.alloc_size {
- display_total(&entries, config, out)?;
+ let total = return_total(&entries, config, out)?;
+ write!(out, "{}", total.as_str())?;
+ if config.dired {
+ dired::add_total(dired, total.len());
+ }
}
- display_items(&entries, config, out)?;
+ display_items(&entries, config, out, dired, style_manager)?;
if config.recursive {
for e in entries
@@ -2011,16 +2318,40 @@ fn enter_directory(
continue;
}
Ok(rd) => {
- if !listed_ancestors
+ if listed_ancestors
.insert(FileInformation::from_path(&e.p_buf, e.must_dereference)?)
{
- out.flush()?;
- show!(LsError::AlreadyListedError(e.p_buf.clone()));
- } else {
- writeln!(out, "\n{}:", e.p_buf.display())?;
- enter_directory(e, rd, config, out, listed_ancestors)?;
+ // when listing several directories in recursive mode, we show
+ // "dirname:" at the beginning of the file list
+ writeln!(out)?;
+ if config.dired {
+ // We already injected the first dir
+ // Continue with the others
+ // 2 = \n + \n
+ dired.padding = 2;
+ dired::indent(out)?;
+ let dir_name_size = e.p_buf.to_string_lossy().len();
+ dired::calculate_subdired(dired, dir_name_size);
+ // inject dir name
+ dired::add_dir_name(dired, dir_name_size);
+ }
+
+ show_dir_name(e, out, config);
+ writeln!(out)?;
+ enter_directory(
+ e,
+ rd,
+ config,
+ out,
+ listed_ancestors,
+ dired,
+ style_manager,
+ )?;
listed_ancestors
.remove(&FileInformation::from_path(&e.p_buf, e.must_dereference)?);
+ } else {
+ out.flush()?;
+ show!(LsError::AlreadyListedError(e.p_buf.clone()));
}
}
}
@@ -2030,7 +2361,7 @@ fn enter_directory(
Ok(())
}
-fn get_metadata(p_buf: &Path, dereference: bool) -> std::io::Result<Metadata> {
+fn get_metadata_with_deref_opt(p_buf: &Path, dereference: bool) -> std::io::Result<Metadata> {
if dereference {
p_buf.metadata()
} else {
@@ -2044,7 +2375,7 @@ fn display_dir_entry_size(
out: &mut BufWriter<std::io::Stdout>,
) -> (usize, usize, usize, usize, usize, usize) {
// TODO: Cache/memorize the display_* results so we don't have to recalculate them.
- if let Some(md) = entry.md(out) {
+ if let Some(md) = entry.get_metadata(out) {
let (size_len, major_len, minor_len) = match display_len_or_rdev(md, config) {
SizeOrDeviceId::Device(major, minor) => (
(major.len() + minor.len() + 2usize),
@@ -2067,28 +2398,33 @@ fn display_dir_entry_size(
}
fn pad_left(string: &str, count: usize) -> String {
- format!("{:>width$}", string, width = count)
+ format!("{string:>count$}")
}
fn pad_right(string: &str, count: usize) -> String {
- format!("{:<width$}", string, width = count)
+ format!("{string:<count$}")
}
-fn display_total(items: &[PathData], config: &Config, out: &mut BufWriter<Stdout>) -> UResult<()> {
+fn return_total(
+ items: &[PathData],
+ config: &Config,
+ out: &mut BufWriter<Stdout>,
+) -> UResult<String> {
let mut total_size = 0;
for item in items {
total_size += item
- .md(out)
+ .get_metadata(out)
.as_ref()
.map_or(0, |md| get_block_size(md, config));
}
- write!(
- out,
+ if config.dired {
+ dired::indent(out)?;
+ }
+ Ok(format!(
"total {}{}",
display_size(total_size, config),
- config.eol
- )?;
- Ok(())
+ config.line_ending
+ ))
}
fn display_additional_leading_info(
@@ -2101,7 +2437,7 @@ fn display_additional_leading_info(
#[cfg(unix)]
{
if config.inode {
- let i = if let Some(md) = item.md(out) {
+ let i = if let Some(md) = item.get_metadata(out) {
get_inode(md)
} else {
"?".to_owned()
@@ -2111,14 +2447,14 @@ fn display_additional_leading_info(
}
if config.alloc_size {
- let s = if let Some(md) = item.md(out) {
+ let s = if let Some(md) = item.get_metadata(out) {
display_size(get_block_size(md, config), config)
} else {
"?".to_owned()
};
// extra space is insert to align the sizes, as needed for all formats, except for the comma format.
if config.format == Format::Commas {
- write!(result, "{} ", s).unwrap();
+ write!(result, "{s} ").unwrap();
} else {
write!(result, "{} ", pad_left(&s, padding.block_size)).unwrap();
};
@@ -2126,11 +2462,23 @@ fn display_additional_leading_info(
Ok(result)
}
-fn display_items(items: &[PathData], config: &Config, out: &mut BufWriter<Stdout>) -> UResult<()> {
+#[allow(clippy::cognitive_complexity)]
+fn display_items(
+ items: &[PathData],
+ config: &Config,
+ out: &mut BufWriter<Stdout>,
+ dired: &mut DiredOutput,
+ style_manager: &mut StyleManager,
+) -> UResult<()> {
// `-Z`, `--context`:
// Display the SELinux security context or '?' if none is found. When used with the `-l`
// option, print the security context to the left of the size column.
+ let quoted = items.iter().any(|item| {
+ let name = escape_name(&item.display_name, &config.quoting_style);
+ name.starts_with('\'')
+ });
+
if config.format == Format::Long {
let padding_collection = calculate_padding_collection(items, config, out);
@@ -2139,15 +2487,24 @@ fn display_items(items: &[PathData], config: &Config, out: &mut BufWriter<Stdout
if config.inode || config.alloc_size {
let more_info =
display_additional_leading_info(item, &padding_collection, config, out)?;
- write!(out, "{}", more_info)?;
+
+ write!(out, "{more_info}")?;
}
#[cfg(not(unix))]
if config.alloc_size {
let more_info =
display_additional_leading_info(item, &padding_collection, config, out)?;
- write!(out, "{}", more_info)?;
+ write!(out, "{more_info}")?;
}
- display_item_long(item, &padding_collection, config, out)?;
+ display_item_long(
+ item,
+ &padding_collection,
+ config,
+ out,
+ dired,
+ style_manager,
+ quoted,
+ )?;
}
} else {
let mut longest_context_len = 1;
@@ -2164,45 +2521,47 @@ fn display_items(items: &[PathData], config: &Config, out: &mut BufWriter<Stdout
let padding = calculate_padding_collection(items, config, out);
let mut names_vec = Vec::new();
-
for i in items {
let more_info = display_additional_leading_info(i, &padding, config, out)?;
- let cell = display_file_name(i, config, prefix_context, more_info, out);
+ let cell = display_item_name(i, config, prefix_context, more_info, out, style_manager);
names_vec.push(cell);
}
- let names = names_vec.into_iter();
+ let mut names = names_vec.into_iter();
match config.format {
- Format::Columns => display_grid(names, config.width, Direction::TopToBottom, out)?,
- Format::Across => display_grid(names, config.width, Direction::LeftToRight, out)?,
+ Format::Columns => {
+ display_grid(names, config.width, Direction::TopToBottom, out, quoted)?;
+ }
+ Format::Across => {
+ display_grid(names, config.width, Direction::LeftToRight, out, quoted)?;
+ }
Format::Commas => {
let mut current_col = 0;
- let mut names = names;
if let Some(name) = names.next() {
- write!(out, "{}", name.contents)?;
- current_col = name.width as u16 + 2;
+ write!(out, "{}", name)?;
+ current_col = ansi_width(&name) as u16 + 2;
}
for name in names {
- let name_width = name.width as u16;
+ let name_width = ansi_width(&name) as u16;
// If the width is 0 we print one single line
if config.width != 0 && current_col + name_width + 1 > config.width {
current_col = name_width + 2;
- write!(out, ",\n{}", name.contents)?;
+ write!(out, ",\n{}", name)?;
} else {
current_col += name_width + 2;
- write!(out, ", {}", name.contents)?;
+ write!(out, ", {}", name)?;
}
}
// Current col is never zero again if names have been printed.
// So we print a newline.
if current_col > 0 {
- write!(out, "{}", config.eol)?;
+ write!(out, "{}", config.line_ending)?;
}
}
_ => {
for name in names {
- write!(out, "{}{}", name.contents, config.eol)?;
+ write!(out, "{}{}", name, config.line_ending)?;
}
}
};
@@ -2225,17 +2584,7 @@ fn get_block_size(md: &Metadata, config: &Config) -> u64 {
};
match config.size_format {
SizeFormat::Binary | SizeFormat::Decimal => raw_blocks,
- SizeFormat::Bytes => {
- if cfg!(unix) {
- if let Some(user_block_size) = config.block_size {
- raw_blocks / user_block_size
- } else {
- raw_blocks / DEFAULT_BLOCK_SIZE
- }
- } else {
- raw_blocks
- }
- }
+ SizeFormat::Bytes => raw_blocks / config.block_size,
}
}
#[cfg(not(unix))]
@@ -2246,10 +2595,11 @@ fn get_block_size(md: &Metadata, config: &Config) -> u64 {
}
fn display_grid(
- names: impl Iterator<Item = Cell>,
+ names: impl Iterator<Item = String>,
width: u16,
direction: Direction,
out: &mut BufWriter<Stdout>,
+ quoted: bool,
) -> UResult<()> {
if width == 0 {
// If the width is 0 we print one single line
@@ -2259,30 +2609,48 @@ fn display_grid(
write!(out, " ")?;
}
printed_something = true;
- write!(out, "{}", name.contents)?;
+ write!(out, "{name}")?;
}
if printed_something {
writeln!(out)?;
}
} else {
- let mut grid = Grid::new(GridOptions {
- filling: Filling::Spaces(2),
- direction,
- });
-
- for name in names {
- grid.add(name);
- }
-
- match grid.fit_into_width(width as usize) {
- Some(output) => {
- write!(out, "{}", output)?;
- }
- // Width is too small for the grid, so we fit it in one column
- None => {
- write!(out, "{}", grid.fit_into_columns(1))?;
- }
- }
+ let names = if quoted {
+ // In case some names are quoted, GNU adds a space before each
+ // entry that does not start with a quote to make it prettier
+ // on multiline.
+ //
+ // Example:
+ // ```
+ // $ ls
+ // 'a\nb' bar
+ // foo baz
+ // ^ ^
+ // These spaces is added
+ // ```
+ names
+ .map(|n| {
+ if n.starts_with('\'') || n.starts_with('"') {
+ n
+ } else {
+ format!(" {n}")
+ }
+ })
+ .collect()
+ } else {
+ names.collect()
+ };
+ let grid = Grid::new(
+ names,
+ GridOptions {
+ // TODO: To match gnu/tests/ls/stat-dtype.sh
+ // we might want to have Filling::Text("\t".to_string());
+ filling: Filling::Spaces(2),
+ direction,
+ width: width as usize,
+ },
+ );
+ write!(out, "{grid}")?;
}
Ok(())
}
@@ -2298,11 +2666,11 @@ fn display_grid(
/// * `author` ([`display_uname`], config-optional)
/// * `size / rdev` ([`display_len_or_rdev`])
/// * `system_time` ([`get_system_time`])
-/// * `file_name` ([`display_file_name`])
+/// * `item_name` ([`display_item_name`])
///
/// This function needs to display information in columns:
/// * permissions and system_time are already guaranteed to be pre-formatted in fixed length.
-/// * file_name is the last column and is left-aligned.
+/// * item_name is the last column and is left-aligned.
/// * Everything else needs to be padded using [`pad_left`].
///
/// That's why we have the parameters:
@@ -2315,16 +2683,29 @@ fn display_grid(
/// ```
/// that decide the maximum possible character count of each field.
#[allow(clippy::write_literal)]
+#[allow(clippy::cognitive_complexity)]
fn display_item_long(
item: &PathData,
padding: &PaddingCollection,
config: &Config,
out: &mut BufWriter<Stdout>,
+ dired: &mut DiredOutput,
+ style_manager: &mut StyleManager,
+ quoted: bool,
) -> UResult<()> {
- if let Some(md) = item.md(out) {
+ let mut output_display: String = String::new();
+ if config.dired {
+ output_display += " ";
+ }
+ if let Some(md) = item.get_metadata(out) {
+ #[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.as_os_str());
write!(
- out,
- "{}{} {}",
+ output_display,
+ "{}{}{} {}",
display_permissions(md, true),
if item.security_context.len() > 1 {
// GNU `ls` uses a "." character to indicate a file with a security context,
@@ -2333,50 +2714,61 @@ fn display_item_long(
} else {
""
},
+ if is_acl_set {
+ // if acl has been set, we display a "+" at the end of the file permissions
+ "+"
+ } else {
+ ""
+ },
pad_left(&display_symlink_count(md), padding.link_count)
- )?;
+ )
+ .unwrap();
if config.long.owner {
write!(
- out,
+ output_display,
" {}",
pad_right(&display_uname(md, config), padding.uname)
- )?;
+ )
+ .unwrap();
}
if config.long.group {
write!(
- out,
+ output_display,
" {}",
pad_right(&display_group(md, config), padding.group)
- )?;
+ )
+ .unwrap();
}
if config.context {
write!(
- out,
+ output_display,
" {}",
pad_right(&item.security_context, padding.context)
- )?;
+ )
+ .unwrap();
}
// Author is only different from owner on GNU/Hurd, so we reuse
// the owner, since GNU/Hurd is not currently supported by Rust.
if config.long.author {
write!(
- out,
+ output_display,
" {}",
pad_right(&display_uname(md, config), padding.uname)
- )?;
+ )
+ .unwrap();
}
match display_len_or_rdev(md, config) {
SizeOrDeviceId::Size(size) => {
- write!(out, " {}", pad_left(&size, padding.size))?;
+ write!(output_display, " {}", pad_left(&size, padding.size)).unwrap();
}
SizeOrDeviceId::Device(major, minor) => {
write!(
- out,
+ output_display,
" {}, {}",
pad_left(
&major,
@@ -2396,13 +2788,30 @@ fn display_item_long(
#[cfg(unix)]
padding.minor,
),
- )?;
+ )
+ .unwrap();
}
};
- let dfn = display_file_name(item, config, None, String::new(), out).contents;
+ write!(output_display, " {} ", display_date(md, config)).unwrap();
- write!(out, " {} {}{}", display_date(md, config), dfn, config.eol)?;
+ let item_name = display_item_name(item, config, None, String::new(), out, style_manager);
+
+ let displayed_item = if quoted && !item_name.starts_with('\'') {
+ format!(" {}", item_name)
+ } else {
+ item_name
+ };
+
+ if config.dired {
+ let (start, end) = dired::calculate_dired(
+ &dired.dired_positions,
+ output_display.len(),
+ displayed_item.len(),
+ );
+ dired::update_positions(dired, start, end);
+ }
+ write!(output_display, "{}{}", displayed_item, config.line_ending).unwrap();
} else {
#[cfg(unix)]
let leading_char = {
@@ -2438,9 +2847,9 @@ fn display_item_long(
};
write!(
- out,
+ output_display,
"{}{} {}",
- format_args!("{}?????????", leading_char),
+ format_args!("{leading_char}?????????"),
if item.security_context.len() > 1 {
// GNU `ls` uses a "." character to indicate a file with a security context,
// but not other alternate access method.
@@ -2449,41 +2858,54 @@ fn display_item_long(
""
},
pad_left("?", padding.link_count)
- )?;
+ )
+ .unwrap();
if config.long.owner {
- write!(out, " {}", pad_right("?", padding.uname))?;
+ write!(output_display, " {}", pad_right("?", padding.uname)).unwrap();
}
if config.long.group {
- write!(out, " {}", pad_right("?", padding.group))?;
+ write!(output_display, " {}", pad_right("?", padding.group)).unwrap();
}
if config.context {
write!(
- out,
+ output_display,
" {}",
pad_right(&item.security_context, padding.context)
- )?;
+ )
+ .unwrap();
}
// Author is only different from owner on GNU/Hurd, so we reuse
// the owner, since GNU/Hurd is not currently supported by Rust.
if config.long.author {
- write!(out, " {}", pad_right("?", padding.uname))?;
+ write!(output_display, " {}", pad_right("?", padding.uname)).unwrap();
}
- let dfn = display_file_name(item, config, None, String::new(), out).contents;
+ let displayed_item =
+ display_item_name(item, config, None, String::new(), out, style_manager);
let date_len = 12;
- writeln!(
- out,
- " {} {} {}",
+ write!(
+ output_display,
+ " {} {} ",
pad_left("?", padding.size),
pad_left("?", date_len),
- dfn,
- )?;
+ )
+ .unwrap();
+
+ if config.dired {
+ dired::calculate_and_update_positions(
+ dired,
+ output_display.len(),
+ displayed_item.trim().len(),
+ );
+ }
+ write!(output_display, "{}{}", displayed_item, config.line_ending).unwrap();
}
+ write!(out, "{}", output_display)?;
Ok(())
}
@@ -2545,7 +2967,7 @@ fn display_group(metadata: &Metadata, config: &Config) -> String {
}
#[cfg(target_os = "redox")]
-fn display_group(metadata: &Metadata, config: &Config) -> String {
+fn display_group(metadata: &Metadata, _config: &Config) -> String {
metadata.gid().to_string()
}
@@ -2591,7 +3013,8 @@ fn display_date(metadata: &Metadata, config: &Config) -> String {
Some(time) => {
//Date is recent if from past 6 months
//According to GNU a Gregorian year has 365.2425 * 24 * 60 * 60 == 31556952 seconds on the average.
- let recent = time + chrono::Duration::seconds(31_556_952 / 2) > chrono::Local::now();
+ let recent = time + chrono::TimeDelta::try_seconds(31_556_952 / 2).unwrap()
+ > chrono::Local::now();
match &config.time_style {
TimeStyle::FullIso => time.format("%Y-%m-%d %H:%M:%S.%f %z"),
@@ -2616,30 +3039,6 @@ fn display_date(metadata: &Metadata, config: &Config) -> String {
}
}
-// There are a few peculiarities to how GNU formats the sizes:
-// 1. One decimal place is given if and only if the size is smaller than 10
-// 2. It rounds sizes up.
-// 3. The human-readable format uses powers for 1024, but does not display the "i"
-// that is commonly used to denote Kibi, Mebi, etc.
-// 4. Kibi and Kilo are denoted differently ("k" and "K", respectively)
-fn format_prefixed(prefixed: &NumberPrefix<f64>) -> String {
- match prefixed {
- NumberPrefix::Standalone(bytes) => bytes.to_string(),
- NumberPrefix::Prefixed(prefix, bytes) => {
- // Remove the "i" from "Ki", "Mi", etc. if present
- let prefix_str = prefix.symbol().trim_end_matches('i');
-
- // Check whether we get more than 10 if we round up to the first decimal
- // because we want do display 9.81 as "9.9", not as "10".
- if (10.0 * bytes).ceil() >= 100.0 {
- format!("{:.0}{}", bytes.ceil(), prefix_str)
- } else {
- format!("{:.1}{}", (10.0 * bytes).ceil() / 10.0, prefix_str)
- }
- }
- }
-}
-
#[allow(dead_code)]
enum SizeOrDeviceId {
Size(String),
@@ -2651,7 +3050,13 @@ fn display_len_or_rdev(metadata: &Metadata, config: &Config) -> SizeOrDeviceId {
target_os = "linux",
target_os = "macos",
target_os = "android",
- target_os = "ios"
+ target_os = "ios",
+ target_os = "freebsd",
+ target_os = "dragonfly",
+ target_os = "netbsd",
+ target_os = "openbsd",
+ target_os = "illumos",
+ target_os = "solaris"
))]
{
let ft = metadata.file_type();
@@ -2663,36 +3068,20 @@ fn display_len_or_rdev(metadata: &Metadata, config: &Config) -> SizeOrDeviceId {
return SizeOrDeviceId::Device(major.to_string(), minor.to_string());
}
}
- // Reported file len only adjusted for block_size when block_size is set
- if let Some(user_block_size) = config.block_size {
- // ordinary division of unsigned integers rounds down,
- // this is similar to the Rust API for division that rounds up,
- // currently in nightly only, however once
- // https://github.com/rust-lang/rust/pull/88582 : "div_ceil"
- // is stable we should use that instead
- let len_adjusted = {
- let d = metadata.len() / user_block_size;
- let r = metadata.len() % user_block_size;
- if r == 0 {
- d
- } else {
- d + 1
- }
- };
- SizeOrDeviceId::Size(display_size(len_adjusted, config))
- } else {
- SizeOrDeviceId::Size(display_size(metadata.len(), config))
- }
+ let len_adjusted = {
+ let d = metadata.len() / config.file_size_block_size;
+ let r = metadata.len() % config.file_size_block_size;
+ if r == 0 {
+ d
+ } else {
+ d + 1
+ }
+ };
+ SizeOrDeviceId::Size(display_size(len_adjusted, config))
}
fn display_size(size: u64, config: &Config) -> String {
- // NOTE: The human-readable behavior deviates from the GNU ls.
- // The GNU ls uses binary prefixes by default.
- match config.size_format {
- SizeFormat::Binary => format_prefixed(&NumberPrefix::binary(size as f64)),
- SizeFormat::Decimal => format_prefixed(&NumberPrefix::decimal(size as f64)),
- SizeFormat::Bytes => size.to_string(),
- }
+ human_readable(size, config.size_format)
}
#[cfg(unix)]
@@ -2720,7 +3109,11 @@ fn classify_file(path: &PathData, out: &mut BufWriter<Stdout>) -> Option<char> {
Some('=')
} else if file_type.is_fifo() {
Some('|')
- } else if file_type.is_file() && file_is_executable(path.md(out).as_ref().unwrap()) {
+ } else if file_type.is_file()
+ // Safe unwrapping if the file was removed between listing and display
+ // See https://github.com/uutils/coreutils/issues/5371
+ && path.get_metadata(out).map(file_is_executable).unwrap_or_default()
+ {
Some('*')
} else {
None
@@ -2741,42 +3134,31 @@ fn classify_file(path: &PathData, out: &mut BufWriter<Stdout>) -> Option<char> {
/// * `config.format` to display symlink targets if `Format::Long`. This function is also
/// responsible for coloring symlink target names if `config.color` is specified.
/// * `config.context` to prepend security context to `name` if compiled with `feat_selinux`.
+/// * `config.hyperlink` decides whether to hyperlink the item
///
/// Note that non-unicode sequences in symlink targets are dealt with using
/// [`std::path::Path::to_string_lossy`].
-#[allow(unused_variables)]
-fn display_file_name(
+#[allow(clippy::cognitive_complexity)]
+fn display_item_name(
path: &PathData,
config: &Config,
prefix_context: Option<usize>,
more_info: String,
out: &mut BufWriter<Stdout>,
-) -> Cell {
+ style_manager: &mut StyleManager,
+) -> String {
// This is our return value. We start by `&path.display_name` and modify it along the way.
let mut name = escape_name(&path.display_name, &config.quoting_style);
- // We need to keep track of the width ourselves instead of letting term_grid
- // infer it because the color codes mess up term_grid's width calculation.
- let mut width = name.width();
+ if config.hyperlink {
+ name = create_hyperlink(&name, path);
+ }
if let Some(ls_colors) = &config.color {
- let md = path.md(out);
- name = if md.is_some() {
- color_name(name, &path.p_buf, md, ls_colors)
- } else {
- color_name(
- name,
- &path.p_buf,
- path.p_buf.symlink_metadata().ok().as_ref(),
- ls_colors,
- )
- };
+ name = color_name(name, path, ls_colors, style_manager, out, None);
}
if config.format != Format::Long && !more_info.is_empty() {
- // increment width here b/c name was given colors and name.width() is now the wrong
- // size for display
- width += more_info.width();
name = more_info + &name;
}
@@ -2804,7 +3186,6 @@ fn display_file_name(
if let Some(c) = char_opt {
name.push(c);
- width += 1;
}
}
@@ -2813,55 +3194,55 @@ fn display_file_name(
&& path.file_type(out).unwrap().is_symlink()
&& !path.must_dereference
{
- if let Ok(target) = path.p_buf.read_link() {
- name.push_str(" -> ");
-
- // We might as well color the symlink output after the arrow.
- // This makes extra system calls, but provides important information that
- // people run `ls -l --color` are very interested in.
- if let Some(ls_colors) = &config.color {
- // We get the absolute path to be able to construct PathData with valid Metadata.
- // This is because relative symlinks will fail to get_metadata.
- let mut absolute_target = target.clone();
- if target.is_relative() {
- if let Some(parent) = path.p_buf.parent() {
- absolute_target = parent.join(absolute_target);
+ match path.p_buf.read_link() {
+ Ok(target) => {
+ name.push_str(" -> ");
+
+ // We might as well color the symlink output after the arrow.
+ // This makes extra system calls, but provides important information that
+ // people run `ls -l --color` are very interested in.
+ if let Some(ls_colors) = &config.color {
+ // We get the absolute path to be able to construct PathData with valid Metadata.
+ // This is because relative symlinks will fail to get_metadata.
+ let mut absolute_target = target.clone();
+ if target.is_relative() {
+ if let Some(parent) = path.p_buf.parent() {
+ absolute_target = parent.join(absolute_target);
+ }
}
- }
- let target_data = PathData::new(absolute_target, None, None, config, false);
+ let target_data = PathData::new(absolute_target, None, None, config, false);
- // If we have a symlink to a valid file, we use the metadata of said file.
- // Because we use an absolute path, we can assume this is guaranteed to exist.
- // Otherwise, we use path.md(), which will guarantee we color to the same
- // color of non-existent symlinks according to style_for_path_with_metadata.
- if path.md(out).is_none()
- && get_metadata(target_data.p_buf.as_path(), target_data.must_dereference)
+ // If we have a symlink to a valid file, we use the metadata of said file.
+ // Because we use an absolute path, we can assume this is guaranteed to exist.
+ // Otherwise, we use path.md(), which will guarantee we color to the same
+ // color of non-existent symlinks according to style_for_path_with_metadata.
+ if path.get_metadata(out).is_none()
+ && get_metadata_with_deref_opt(
+ target_data.p_buf.as_path(),
+ target_data.must_dereference,
+ )
.is_err()
- {
- name.push_str(&path.p_buf.read_link().unwrap().to_string_lossy());
+ {
+ name.push_str(&path.p_buf.read_link().unwrap().to_string_lossy());
+ } else {
+ name.push_str(&color_name(
+ escape_name(target.as_os_str(), &config.quoting_style),
+ path,
+ ls_colors,
+ style_manager,
+ out,
+ Some(&target_data),
+ ));
+ }
} else {
- // Use fn get_metadata instead of md() here and above because ls
- // should not exit with an err, if we are unable to obtain the target_metadata
- let target_metadata = match get_metadata(
- target_data.p_buf.as_path(),
- target_data.must_dereference,
- ) {
- Ok(md) => md,
- Err(_) => path.md(out).unwrap().to_owned(),
- };
-
- name.push_str(&color_name(
- escape_name(target.as_os_str(), &config.quoting_style),
- &target_data.p_buf,
- Some(&target_metadata),
- ls_colors,
- ));
+ // If no coloring is required, we just use target as is.
+ // Apply the right quoting
+ name.push_str(&escape_name(target.as_os_str(), &config.quoting_style));
}
- } else {
- // If no coloring is required, we just use target as is.
- // Apply the right quoting
- name.push_str(&escape_name(target.as_os_str(), &config.quoting_style));
+ }
+ Err(err) => {
+ show!(LsError::IOErrorContext(err, path.p_buf.clone(), false));
}
}
}
@@ -2870,28 +3251,129 @@ fn display_file_name(
// to get correct alignment from later calls to`display_grid()`.
if config.context {
if let Some(pad_count) = prefix_context {
- let security_context = if !matches!(config.format, Format::Commas) {
- pad_left(&path.security_context, pad_count)
+ let security_context = if matches!(config.format, Format::Commas) {
+ path.security_context.clone()
} else {
- path.security_context.to_owned()
+ pad_left(&path.security_context, pad_count)
};
- name = format!("{} {}", security_context, name);
- width += security_context.len() + 1;
+ name = format!("{security_context} {name}");
+ }
+ }
+
+ name
+}
+
+fn create_hyperlink(name: &str, path: &PathData) -> String {
+ let hostname = hostname::get().unwrap_or(OsString::from(""));
+ let hostname = hostname.to_string_lossy();
+
+ let absolute_path = fs::canonicalize(&path.p_buf).unwrap_or_default();
+ let absolute_path = absolute_path.to_string_lossy();
+
+ #[cfg(not(target_os = "windows"))]
+ let unencoded_chars = "_-.:~/";
+ #[cfg(target_os = "windows")]
+ let unencoded_chars = "_-.:~/\\";
+
+ // percentage encoding of path
+ let absolute_path: String = absolute_path
+ .chars()
+ .map(|c| {
+ if c.is_alphanumeric() || unencoded_chars.contains(c) {
+ c.to_string()
+ } else {
+ format!("%{:02x}", c as u8)
+ }
+ })
+ .collect();
+
+ // \x1b = ESC, \x07 = BEL
+ format!("\x1b]8;;file://{hostname}{absolute_path}\x07{name}\x1b]8;;\x07")
+}
+
+/// We need this struct to be able to store the previous style.
+/// This because we need to check the previous value in case we don't need
+/// the reset
+struct StyleManager {
+ current_style: Option<Style>,
+}
+
+impl StyleManager {
+ fn new() -> Self {
+ Self {
+ current_style: None,
+ }
+ }
+
+ fn apply_style(&mut self, new_style: &Style, name: &str) -> String {
+ if let Some(current) = &self.current_style {
+ if *current == *new_style {
+ // Current style is the same as new style, apply without reset.
+ let mut style = new_style.to_nu_ansi_term_style();
+ style.prefix_with_reset = false;
+ return style.paint(name).to_string();
+ }
}
+
+ // We are getting a new style, we need to reset it
+ self.current_style = Some(new_style.clone());
+ new_style
+ .to_nu_ansi_term_style()
+ .reset_before_style()
+ .paint(name)
+ .to_string()
}
+}
- Cell {
- contents: name,
- width,
+fn apply_style_based_on_metadata(
+ path: &PathData,
+ md_option: Option<&Metadata>,
+ ls_colors: &LsColors,
+ style_manager: &mut StyleManager,
+ name: &str,
+) -> String {
+ match ls_colors.style_for_path_with_metadata(&path.p_buf, md_option) {
+ Some(style) => style_manager.apply_style(style, name),
+ None => name.to_owned(),
}
}
-fn color_name(name: String, path: &Path, md: Option<&Metadata>, ls_colors: &LsColors) -> String {
- match ls_colors.style_for_path_with_metadata(path, md) {
- Some(style) => {
- return style.to_nu_ansi_term_style().paint(name).to_string();
+/// Colors the provided name based on the style determined for the given path
+/// This function is quite long because it tries to leverage DirEntry to avoid
+/// unnecessary calls to stat()
+/// and manages the symlink errors
+fn color_name(
+ name: String,
+ path: &PathData,
+ ls_colors: &LsColors,
+ style_manager: &mut StyleManager,
+ out: &mut BufWriter<Stdout>,
+ target_symlink: Option<&PathData>,
+) -> String {
+ if !path.must_dereference {
+ // If we need to dereference (follow) a symlink, we will need to get the metadata
+ if let Some(de) = &path.de {
+ // There is a DirEntry, we don't need to get the metadata for the color
+ return match ls_colors.style_for(de) {
+ Some(style) => style_manager.apply_style(style, &name),
+ None => name,
+ };
}
- None => name,
+ }
+
+ if let Some(target) = target_symlink {
+ // use the optional target_symlink
+ // Use fn get_metadata_with_deref_opt instead of get_metadata() here because ls
+ // should not exit with an err, if we are unable to obtain the target_metadata
+ let md_res = get_metadata_with_deref_opt(target.p_buf.as_path(), path.must_dereference);
+ let md = md_res.or(path.p_buf.symlink_metadata());
+ apply_style_based_on_metadata(path, md.ok().as_ref(), ls_colors, style_manager, &name)
+ } else {
+ let md_option = path.get_metadata(out);
+ let symlink_metadata = path.p_buf.symlink_metadata().ok();
+ let md = md_option.or(symlink_metadata.as_ref());
+
+ apply_style_based_on_metadata(path, md, ls_colors, style_manager, &name)
}
}
@@ -2917,6 +3399,20 @@ fn display_inode(metadata: &Metadata) -> String {
#[allow(unused_variables)]
fn get_security_context(config: &Config, p_buf: &Path, must_dereference: bool) -> String {
let substitute_string = "?".to_string();
+ // If we must dereference, ensure that the symlink is actually valid even if the system
+ // does not support SELinux.
+ // Conforms to the GNU coreutils where a dangling symlink results in exit code 1.
+ if must_dereference {
+ match get_metadata_with_deref_opt(p_buf, must_dereference) {
+ Err(err) => {
+ // The Path couldn't be dereferenced, so return early and set exit code 1
+ // to indicate a minor error
+ show!(LsError::IOErrorContext(err, p_buf.to_path_buf(), false));
+ return substitute_string;
+ }
+ Ok(md) => (),
+ }
+ }
if config.selinux_supported {
#[cfg(feature = "selinux")]
{
@@ -2972,7 +3468,7 @@ fn calculate_padding_collection(
for item in items {
#[cfg(unix)]
if config.inode {
- let inode_len = if let Some(md) = item.md(out) {
+ let inode_len = if let Some(md) = item.get_metadata(out) {
display_inode(md).len()
} else {
continue;
@@ -2981,7 +3477,7 @@ fn calculate_padding_collection(
}
if config.alloc_size {
- if let Some(md) = item.md(out) {
+ if let Some(md) = item.get_metadata(out) {
let block_size_len = display_size(get_block_size(md, config), config).len();
padding_collections.block_size = block_size_len.max(padding_collections.block_size);
}
@@ -3006,7 +3502,7 @@ fn calculate_padding_collection(
padding_collections.minor = minor_len.max(padding_collections.minor);
padding_collections.size = size_len
.max(padding_collections.size)
- .max(padding_collections.major + padding_collections.minor + 2usize);
+ .max(padding_collections.major);
}
}
}
@@ -3031,7 +3527,7 @@ fn calculate_padding_collection(
for item in items {
if config.alloc_size {
- if let Some(md) = item.md(out) {
+ if let Some(md) = item.get_metadata(out) {
let block_size_len = display_size(get_block_size(md, config), config).len();
padding_collections.block_size = block_size_len.max(padding_collections.block_size);
}
diff --git a/src/uu/mkdir/Cargo.toml b/src/uu/mkdir/Cargo.toml
index 93aaea73fee2a186c2d708c96c45eb2c73a59666..a007eebb82388e4f6f0f486465c2e08e54637c26 100644
--- a/src/uu/mkdir/Cargo.toml
+++ b/src/uu/mkdir/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_mkdir"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "mkdir ~ (uutils) create DIRECTORY"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/mkdir.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["fs", "mode"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["fs", "mode"] }
[[bin]]
name = "mkdir"
diff --git a/src/uu/mkdir/mkdir.md b/src/uu/mkdir/mkdir.md
new file mode 100644
index 0000000000000000000000000000000000000000..eea3d2eb063d210f91c4009338823a20ca96967f
--- /dev/null
+++ b/src/uu/mkdir/mkdir.md
@@ -0,0 +1,13 @@
+# mkdir
+
+<!-- spell-checker:ignore ugoa -->
+
+```
+mkdir [OPTION]... DIRECTORY...
+```
+
+Create the given DIRECTORY(ies) if they do not exist
+
+## After Help
+
+Each MODE is of the form '[ugoa]*([-+=]([rwxXst]*|[ugo]))+|[-+=]?[0-7]+'.
diff --git a/src/uu/mkdir/src/mkdir.rs b/src/uu/mkdir/src/mkdir.rs
index 038d688f9fbcdc50e182bf4f85666c23749637f5..c29905ef4a78af1a3dd3a2611ebf686531dd23b4 100644
--- a/src/uu/mkdir/src/mkdir.rs
+++ b/src/uu/mkdir/src/mkdir.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Nicholas Juszczak <juszczakn@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) ugoa cmode
@@ -18,12 +16,13 @@ use uucore::error::{UResult, USimpleError};
#[cfg(not(windows))]
use uucore::mode;
use uucore::{display::Quotable, fs::dir_strip_dot_for_creation};
-use uucore::{format_usage, show, show_if_err};
+use uucore::{format_usage, help_about, help_section, help_usage, show_if_err};
-static DEFAULT_PERM: u32 = 0o755;
+static DEFAULT_PERM: u32 = 0o777;
-static ABOUT: &str = "Create the given DIRECTORY(ies) if they do not exist";
-const USAGE: &str = "{} [OPTION]... [USER]";
+const ABOUT: &str = help_about!("mkdir.md");
+const USAGE: &str = help_usage!("mkdir.md");
+const AFTER_HELP: &str = help_section!("after help", "mkdir.md");
mod options {
pub const MODE: &str = "mode";
@@ -32,10 +31,6 @@ mod options {
pub const DIRS: &str = "dirs";
}
-fn get_long_usage() -> &'static str {
- "Each MODE is of the form '[ugoa]*([-+=]([rwxXst]*|[ugo]))+|[-+=]?[0-7]+'."
-}
-
#[cfg(windows)]
fn get_mode(_matches: &ArgMatches, _mode_had_minus_prefix: bool) -> Result<u32, String> {
Ok(DEFAULT_PERM)
@@ -43,31 +38,27 @@ fn get_mode(_matches: &ArgMatches, _mode_had_minus_prefix: bool) -> Result<u32,
#[cfg(not(windows))]
fn get_mode(matches: &ArgMatches, mode_had_minus_prefix: bool) -> Result<u32, String> {
- let digits: &[char] = &['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
- // Translate a ~str in octal form to u16, default to 755
// Not tested on Windows
let mut new_mode = DEFAULT_PERM;
- match matches.get_one::<String>(options::MODE) {
- Some(m) => {
- for mode in m.split(',') {
- if mode.contains(digits) {
- new_mode = mode::parse_numeric(new_mode, m, true)?;
+
+ if let Some(m) = matches.get_one::<String>(options::MODE) {
+ for mode in m.split(',') {
+ if mode.chars().any(|c| c.is_ascii_digit()) {
+ new_mode = mode::parse_numeric(new_mode, m, true)?;
+ } else {
+ let cmode = if mode_had_minus_prefix {
+ // clap parsing is finished, now put prefix back
+ format!("-{mode}")
} else {
- let cmode = if mode_had_minus_prefix {
- // clap parsing is finished, now put prefix back
- format!("-{}", mode)
- } else {
- mode.to_string()
- };
- new_mode = mode::parse_symbolic(new_mode, &cmode, mode::get_umask(), true)?;
- }
+ mode.to_string()
+ };
+ new_mode = mode::parse_symbolic(new_mode, &cmode, mode::get_umask(), true)?;
}
- Ok(new_mode)
- }
- None => {
- // If no mode argument is specified return the mode derived from umask
- Ok(!mode::get_umask() & 0o0777)
}
+ Ok(new_mode)
+ } else {
+ // If no mode argument is specified return the mode derived from umask
+ Ok(!mode::get_umask() & 0o0777)
}
}
@@ -92,9 +83,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
// Linux-specific options, not implemented
// opts.optflag("Z", "context", "set SELinux security context" +
// " of each created directory to CTX"),
- let matches = uu_app()
- .after_help(get_long_usage())
- .try_get_matches_from(args)?;
+ let matches = uu_app().after_help(AFTER_HELP).try_get_matches_from(args)?;
let dirs = matches
.get_many::<OsString>(options::DIRS)
@@ -148,22 +137,35 @@ pub fn uu_app() -> Command {
*/
fn exec(dirs: ValuesRef<OsString>, recursive: bool, mode: u32, verbose: bool) -> UResult<()> {
for dir in dirs {
- // Special case to match GNU's behavior:
- // mkdir -p foo/. should work and just create foo/
- // std::fs::create_dir("foo/."); fails in pure Rust
- let path = if recursive {
- dir_strip_dot_for_creation(&PathBuf::from(dir))
- } else {
- // Normal case
- PathBuf::from(dir)
- };
- show_if_err!(mkdir(path.as_path(), recursive, mode, verbose));
+ let path_buf = PathBuf::from(dir);
+ let path = path_buf.as_path();
+
+ show_if_err!(mkdir(path, recursive, mode, verbose));
}
Ok(())
}
-fn mkdir(path: &Path, recursive: bool, mode: u32, verbose: bool) -> UResult<()> {
- create_dir(path, recursive, verbose)?;
+/// Create directory at a given `path`.
+///
+/// ## Options
+///
+/// * `recursive` --- create parent directories for the `path`, if they do not
+/// exist.
+/// * `mode` --- file mode for the directories (not implemented on windows).
+/// * `verbose` --- print a message for each printed directory.
+///
+/// ## Trailing dot
+///
+/// To match the GNU behavior, a path with the last directory being a single dot
+/// (like `some/path/to/.`) is created (with the dot stripped).
+pub fn mkdir(path: &Path, recursive: bool, mode: u32, verbose: bool) -> UResult<()> {
+ // Special case to match GNU's behavior:
+ // mkdir -p foo/. should work and just create foo/
+ // std::fs::create_dir("foo/."); fails in pure Rust
+ let path_buf = dir_strip_dot_for_creation(path);
+ let path = path_buf.as_path();
+
+ create_dir(path, recursive, verbose, false)?;
chmod(path, mode)
}
@@ -184,7 +186,9 @@ fn chmod(_path: &Path, _mode: u32) -> UResult<()> {
Ok(())
}
-fn create_dir(path: &Path, recursive: bool, verbose: bool) -> UResult<()> {
+// `is_parent` argument is not used on windows
+#[allow(unused_variables)]
+fn create_dir(path: &Path, recursive: bool, verbose: bool, is_parent: bool) -> UResult<()> {
if path.exists() && !recursive {
return Err(USimpleError::new(
1,
@@ -197,7 +201,7 @@ fn create_dir(path: &Path, recursive: bool, verbose: bool) -> UResult<()> {
if recursive {
match path.parent() {
- Some(p) => create_dir(p, recursive, verbose)?,
+ Some(p) => create_dir(p, recursive, verbose, true)?,
None => {
USimpleError::new(1, "failed to create whole tree");
}
@@ -212,6 +216,12 @@ fn create_dir(path: &Path, recursive: bool, verbose: bool) -> UResult<()> {
path.quote()
);
}
+ #[cfg(not(windows))]
+ if is_parent {
+ // directories created by -p have permission bits set to '=rwx,u+wx',
+ // which is umask modified by 'u+wx'
+ chmod(path, (!mode::get_umask() & 0o0777) | 0o0300)?;
+ }
Ok(())
}
Err(_) if path.is_dir() => Ok(()),
diff --git a/src/uu/mkfifo/Cargo.toml b/src/uu/mkfifo/Cargo.toml
index 0fc9cad74ba3cc100fe6605932143590f88dccd8..80f72e3a9933fbb09c0270b71152fdf5baee10dc 100644
--- a/src/uu/mkfifo/Cargo.toml
+++ b/src/uu/mkfifo/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_mkfifo"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "mkfifo ~ (uutils) create FIFOs (named pipes)"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/mkfifo.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-libc = "0.2.137"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "mkfifo"
diff --git a/src/uu/mkfifo/mkfifo.md b/src/uu/mkfifo/mkfifo.md
new file mode 100644
index 0000000000000000000000000000000000000000..b634378292211917953324b6d75ed45e3b9afb0e
--- /dev/null
+++ b/src/uu/mkfifo/mkfifo.md
@@ -0,0 +1,7 @@
+# mkfifo
+
+```
+mkfifo [OPTION]... NAME...
+```
+
+Create a FIFO with the given name.
diff --git a/src/uu/mkfifo/src/mkfifo.rs b/src/uu/mkfifo/src/mkfifo.rs
index 24fbba679fceb0eeb39fba3e5c8de83655d24580..9320f76ed043410c2ac941c02865cc8e8f02b1e1 100644
--- a/src/uu/mkfifo/src/mkfifo.rs
+++ b/src/uu/mkfifo/src/mkfifo.rs
@@ -1,19 +1,17 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Michael Gehring <mg@ebfe.org>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use clap::{crate_version, Arg, ArgAction, Command};
use libc::mkfifo;
use std::ffi::CString;
use uucore::display::Quotable;
use uucore::error::{UResult, USimpleError};
-use uucore::{format_usage, show};
+use uucore::{format_usage, help_about, help_usage, show};
-static USAGE: &str = "{} [OPTION]... NAME...";
-static ABOUT: &str = "Create a FIFO with the given name.";
+static USAGE: &str = help_usage!("mkfifo.md");
+static ABOUT: &str = help_about!("mkfifo.md");
mod options {
pub static MODE: &str = "mode";
@@ -24,8 +22,6 @@ mod options {
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_ignore();
-
let matches = uu_app().try_get_matches_from(args)?;
if matches.contains_id(options::CONTEXT) {
@@ -38,13 +34,13 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let mode = match matches.get_one::<String>(options::MODE) {
Some(m) => match usize::from_str_radix(m, 8) {
Ok(m) => m,
- Err(e) => return Err(USimpleError::new(1, format!("invalid mode: {}", e))),
+ Err(e) => return Err(USimpleError::new(1, format!("invalid mode: {e}"))),
},
None => 0o666,
};
let fifos: Vec<String> = match matches.get_many::<String>(options::FIFO) {
- Some(v) => v.clone().map(|s| s.to_owned()).collect(),
+ Some(v) => v.cloned().collect(),
None => return Err(USimpleError::new(1, "missing operand")),
};
diff --git a/src/uu/mknod/Cargo.toml b/src/uu/mknod/Cargo.toml
index 8fbcc0777a8ccb3d3898b0920a940df4e6c66821..bb50dfc7a2d87c625346ce7095bbe290410e4acb 100644
--- a/src/uu/mknod/Cargo.toml
+++ b/src/uu/mknod/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_mknod"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "mknod ~ (uutils) create special file NAME of TYPE"
@@ -16,9 +16,9 @@ name = "uu_mknod"
path = "src/mknod.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-libc = "^0.2.137"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["mode"] }
+clap = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true, features = ["mode"] }
[[bin]]
name = "mknod"
diff --git a/src/uu/mknod/mknod.md b/src/uu/mknod/mknod.md
new file mode 100644
index 0000000000000000000000000000000000000000..78da970252e5d3c86b18d641591a8a631bec51cb
--- /dev/null
+++ b/src/uu/mknod/mknod.md
@@ -0,0 +1,25 @@
+# mknod
+
+```
+mknod [OPTION]... NAME TYPE [MAJOR MINOR]
+```
+
+Create the special file NAME of the given TYPE.
+
+## After Help
+
+Mandatory arguments to long options are mandatory for short options too.
+`-m`, `--mode=MODE` set file permission bits to `MODE`, not `a=rw - umask`
+
+Both `MAJOR` and `MINOR` must be specified when `TYPE` is `b`, `c`, or `u`, and they
+must be omitted when `TYPE` is `p`. If `MAJOR` or `MINOR` begins with `0x` or `0X`,
+it is interpreted as hexadecimal; otherwise, if it begins with 0, as octal;
+otherwise, as decimal. `TYPE` may be:
+
+* `b` create a block (buffered) special file
+* `c`, `u` create a character (unbuffered) special file
+* `p` create a FIFO
+
+NOTE: your shell may have its own version of mknod, which usually supersedes
+the version described here. Please refer to your shell's documentation
+for details about the options it supports.
diff --git a/src/uu/mknod/src/mknod.rs b/src/uu/mknod/src/mknod.rs
index 2a1290d41b910cdb875d186d4e37cd7154c548a5..15a0fdacdb8014d1e2e476bd6d6f1c2e2f12dd9b 100644
--- a/src/uu/mknod/src/mknod.rs
+++ b/src/uu/mknod/src/mknod.rs
@@ -1,7 +1,5 @@
// This file is part of the uutils coreutils package.
//
-// (c) Jian Zeng <anonymousknight96@gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
@@ -14,28 +12,11 @@ use std::ffi::CString;
use uucore::display::Quotable;
use uucore::error::{set_exit_code, UResult, USimpleError, UUsageError};
-use uucore::format_usage;
-
-static ABOUT: &str = "Create the special file NAME of the given TYPE.";
-static USAGE: &str = "{} [OPTION]... NAME TYPE [MAJOR MINOR]";
-static LONG_HELP: &str = "Mandatory arguments to long options are mandatory for short options too.
--m, --mode=MODE set file permission bits to MODE, not a=rw - umask
---help display this help and exit
---version output version information and exit
-
-Both MAJOR and MINOR must be specified when TYPE is b, c, or u, and they
-must be omitted when TYPE is p. If MAJOR or MINOR begins with 0x or 0X,
-it is interpreted as hexadecimal; otherwise, if it begins with 0, as octal;
-otherwise, as decimal. TYPE may be:
+use uucore::{format_usage, help_about, help_section, help_usage};
-b create a block (buffered) special file
-c, u create a character (unbuffered) special file
-p create a FIFO
-
-NOTE: your shell may have its own version of mknod, which usually supersedes
-the version described here. Please refer to your shell's documentation
-for details about the options it supports.
-";
+const ABOUT: &str = help_about!("mknod.md");
+const USAGE: &str = help_usage!("mknod.md");
+const AFTER_HELP: &str = help_section!("after help", "mknod.md");
const MODE_RW_UGO: mode_t = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
@@ -87,7 +68,6 @@ fn _mknod(file_name: &str, mode: mode_t, dev: dev_t) -> i32 {
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_ignore();
// Linux-specific options, not implemented
// opts.optflag("Z", "", "set the SELinux security context to default type");
// opts.optopt("", "context", "like -Z, or if CTX is specified then set the SELinux or SMACK security context to CTX");
@@ -118,12 +98,10 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
matches.get_one::<u64>("major"),
matches.get_one::<u64>("minor"),
) {
- (_, None) | (None, _) => {
- return Err(UUsageError::new(
- 1,
- "Special files require major and minor device numbers.",
- ));
- }
+ (_, None) | (None, _) => Err(UUsageError::new(
+ 1,
+ "Special files require major and minor device numbers.",
+ )),
(Some(&major), Some(&minor)) => {
let dev = makedev(major, minor);
let exit_code = match file_type {
@@ -142,7 +120,7 @@ pub fn uu_app() -> Command {
Command::new(uucore::util_name())
.version(crate_version!())
.override_usage(format_usage(USAGE))
- .after_help(LONG_HELP)
+ .after_help(AFTER_HELP)
.about(ABOUT)
.infer_long_args(true)
.arg(
@@ -184,7 +162,7 @@ fn get_mode(matches: &ArgMatches) -> Result<mode_t, String> {
match matches.get_one::<String>("mode") {
None => Ok(MODE_RW_UGO),
Some(str_mode) => uucore::mode::parse_mode(str_mode)
- .map_err(|e| format!("invalid mode ({})", e))
+ .map_err(|e| format!("invalid mode ({e})"))
.and_then(|mode| {
if mode > 0o777 {
Err("mode must specify only file permission bits".to_string())
diff --git a/src/uu/mknod/src/parsemode.rs b/src/uu/mknod/src/parsemode.rs
deleted file mode 100644
index 2767cb30376ad077a371310fafe7d74765c8e5c0..0000000000000000000000000000000000000000
--- a/src/uu/mknod/src/parsemode.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-// spell-checker:ignore (path) osrelease
-
-use libc::{mode_t, S_IRGRP, S_IROTH, S_IRUSR, S_IWGRP, S_IWOTH, S_IWUSR};
-
-use uucore::mode;
-
-pub const MODE_RW_UGO: mode_t = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
-
-pub fn parse_mode(mode: &str) -> Result<mode_t, String> {
- let arr: &[char] = &['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
- let result = if mode.contains(arr) {
- mode::parse_numeric(MODE_RW_UGO as u32, mode)
- } else {
- mode::parse_symbolic(MODE_RW_UGO as u32, mode, true)
- };
- result.map(|mode| mode as mode_t)
-}
-
-#[cfg(test)]
-mod test {
- /// Test if the program is running under WSL
- // ref: <https://github.com/microsoft/WSL/issues/4555> @@ <https://archive.is/dP0bz>
- // ToDO: test on WSL2 which likely doesn't need special handling; plan change to `is_wsl_1()` if WSL2 is less needy
- pub fn is_wsl() -> bool {
- #[cfg(target_os = "linux")]
- {
- if let Ok(b) = std::fs::read("/proc/sys/kernel/osrelease") {
- if let Ok(s) = std::str::from_utf8(&b) {
- let a = s.to_ascii_lowercase();
- return a.contains("microsoft") || a.contains("wsl");
- }
- }
- }
- false
- }
-
- #[test]
- fn symbolic_modes() {
- assert_eq!(super::parse_mode("u+x").unwrap(), 0o766);
- assert_eq!(
- super::parse_mode("+x").unwrap(),
- if !is_wsl() { 0o777 } else { 0o776 }
- );
- assert_eq!(super::parse_mode("a-w").unwrap(), 0o444);
- assert_eq!(super::parse_mode("g-r").unwrap(), 0o626);
- }
-
- #[test]
- fn numeric_modes() {
- assert_eq!(super::parse_mode("644").unwrap(), 0o644);
- assert_eq!(super::parse_mode("+100").unwrap(), 0o766);
- assert_eq!(super::parse_mode("-4").unwrap(), 0o662);
- }
-}
diff --git a/src/uu/mktemp/Cargo.toml b/src/uu/mktemp/Cargo.toml
index d00fb4c05cfd5124f00ec34f0a514ae96fc9a6f3..08c4c63f3713582feb1c8a60cf179901d82fd832 100644
--- a/src/uu/mktemp/Cargo.toml
+++ b/src/uu/mktemp/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_mktemp"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "mktemp ~ (uutils) create and display a temporary file or directory from TEMPLATE"
@@ -15,10 +15,10 @@ edition = "2021"
path = "src/mktemp.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-rand = "0.8"
-tempfile = "3"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+rand = { workspace = true }
+tempfile = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "mktemp"
diff --git a/src/uu/mktemp/mktemp.md b/src/uu/mktemp/mktemp.md
new file mode 100644
index 0000000000000000000000000000000000000000..75b56d66751e2123febb4f0774bc6bef422d15e6
--- /dev/null
+++ b/src/uu/mktemp/mktemp.md
@@ -0,0 +1,7 @@
+# mktemp
+
+```
+mktemp [OPTION]... [TEMPLATE]
+```
+
+Create a temporary file or directory.
diff --git a/src/uu/mktemp/src/mktemp.rs b/src/uu/mktemp/src/mktemp.rs
index 740644c952cbea61b609714209fa3cc075971f0c..00f23c50adcd10e49279bda529041ab8c8ec6ce2 100644
--- a/src/uu/mktemp/src/mktemp.rs
+++ b/src/uu/mktemp/src/mktemp.rs
@@ -1,20 +1,18 @@
// This file is part of the uutils coreutils package.
//
-// (c) Sunrin SHIMURA
-// Collaborator: Jian Zeng
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
// spell-checker:ignore (paths) GPGHome findxs
-use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
+use clap::{builder::ValueParser, crate_version, Arg, ArgAction, ArgMatches, Command};
use uucore::display::{println_verbatim, Quotable};
use uucore::error::{FromIo, UError, UResult, UUsageError};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
use std::env;
use std::error::Error;
+use std::ffi::OsStr;
use std::fmt::Display;
use std::io::ErrorKind;
use std::iter;
@@ -28,8 +26,8 @@ use std::os::unix::prelude::PermissionsExt;
use rand::Rng;
use tempfile::Builder;
-static ABOUT: &str = "create a temporary file or directory.";
-const USAGE: &str = "{} [OPTION]... [TEMPLATE]";
+const ABOUT: &str = help_about!("mktemp.md");
+const USAGE: &str = help_usage!("mktemp.md");
static DEFAULT_TEMPLATE: &str = "tmp.XXXXXXXXXX";
@@ -38,10 +36,16 @@ static OPT_DRY_RUN: &str = "dry-run";
static OPT_QUIET: &str = "quiet";
static OPT_SUFFIX: &str = "suffix";
static OPT_TMPDIR: &str = "tmpdir";
+static OPT_P: &str = "p";
static OPT_T: &str = "t";
static ARG_TEMPLATE: &str = "template";
+#[cfg(not(windows))]
+const TMPDIR_ENV_VAR: &str = "TMPDIR";
+#[cfg(windows)]
+const TMPDIR_ENV_VAR: &str = "TMP";
+
#[derive(Debug)]
enum MkTempError {
PersistError(PathBuf),
@@ -112,88 +116,58 @@ impl Display for MkTempError {
/// This provides a layer of indirection between the application logic
/// and the argument parsing library `clap`, allowing each to vary
/// independently.
-struct Options {
+#[derive(Clone)]
+pub struct Options {
/// Whether to create a temporary directory instead of a file.
- directory: bool,
+ pub directory: bool,
/// Whether to just print the name of a file that would have been created.
- dry_run: bool,
+ pub dry_run: bool,
/// Whether to suppress file creation error messages.
- quiet: bool,
+ pub quiet: bool,
/// The directory in which to create the temporary file.
///
/// If `None`, the file will be created in the current directory.
- tmpdir: Option<String>,
+ pub tmpdir: Option<PathBuf>,
/// The suffix to append to the temporary file, if any.
- suffix: Option<String>,
+ pub suffix: Option<String>,
/// Whether to treat the template argument as a single file path component.
- treat_as_template: bool,
+ pub treat_as_template: bool,
/// The template to use for the name of the temporary file.
- template: String,
-}
-
-/// Decide whether the argument to `--tmpdir` should actually be the template.
-///
-/// This function is required to work around a limitation of `clap`,
-/// the command-line argument parsing library. In case the command
-/// line is
-///
-/// ```sh
-/// mktemp --tmpdir XXX
-/// ```
-///
-/// the program should behave like
-///
-/// ```sh
-/// mktemp --tmpdir=${TMPDIR:-/tmp} XXX
-/// ```
-///
-/// However, `clap` thinks that `XXX` is the value of the `--tmpdir`
-/// option. This function returns `true` in this case and `false`
-/// in all other cases.
-fn is_tmpdir_argument_actually_the_template(matches: &ArgMatches) -> bool {
- if !matches.contains_id(ARG_TEMPLATE) {
- if let Some(tmpdir) = matches.get_one::<String>(OPT_TMPDIR) {
- if !Path::new(tmpdir).is_dir() && tmpdir.contains("XXX") {
- return true;
- }
- }
- }
- false
+ pub template: String,
}
impl Options {
fn from(matches: &ArgMatches) -> Self {
- // Special case to work around a limitation of `clap`; see
- // `is_tmpdir_argument_actually_the_template()` for more
- // information.
- //
- // Fixed in clap 3
- // See https://github.com/clap-rs/clap/pull/1587
- let (tmpdir, template) = if is_tmpdir_argument_actually_the_template(matches) {
- let tmpdir = Some(env::temp_dir().display().to_string());
- let template = matches.get_one::<String>(OPT_TMPDIR).unwrap().to_string();
- (tmpdir, template)
- } else {
+ let tmpdir = matches
+ .get_one::<PathBuf>(OPT_TMPDIR)
+ .or_else(|| matches.get_one::<PathBuf>(OPT_P))
+ .cloned();
+ let (tmpdir, template) = match matches.get_one::<String>(ARG_TEMPLATE) {
// If no template argument is given, `--tmpdir` is implied.
- match matches.get_one::<String>(ARG_TEMPLATE) {
- None => {
- let tmpdir = match matches.get_one::<String>(OPT_TMPDIR) {
- None => Some(env::temp_dir().display().to_string()),
- Some(tmpdir) => Some(tmpdir.to_string()),
- };
- let template = DEFAULT_TEMPLATE;
- (tmpdir, template.to_string())
- }
- Some(template) => {
- let tmpdir = matches.get_one::<String>(OPT_TMPDIR).map(String::from);
- (tmpdir, template.to_string())
- }
+ None => {
+ let tmpdir = Some(tmpdir.unwrap_or_else(env::temp_dir));
+ let template = DEFAULT_TEMPLATE;
+ (tmpdir, template.to_string())
+ }
+ Some(template) => {
+ let tmpdir = if env::var(TMPDIR_ENV_VAR).is_ok() && matches.get_flag(OPT_T) {
+ env::var_os(TMPDIR_ENV_VAR).map(|t| t.into())
+ } else if tmpdir.is_some() {
+ tmpdir
+ } else if matches.get_flag(OPT_T) || matches.contains_id(OPT_TMPDIR) {
+ // If --tmpdir is given without an argument, or -t is given
+ // export in TMPDIR
+ Some(env::temp_dir())
+ } else {
+ None
+ };
+ (tmpdir, template.to_string())
}
};
Self {
@@ -220,7 +194,7 @@ impl Options {
/// `num_rand_chars`.
struct Params {
/// The directory that will contain the temporary file.
- directory: String,
+ directory: PathBuf,
/// The (non-random) prefix of the temporary file.
prefix: String,
@@ -262,8 +236,13 @@ impl Params {
let (i, j) = match find_last_contiguous_block_of_xs(&options.template) {
None => {
let s = match options.suffix {
+ // If a suffix is specified, the error message includes the template without the suffix.
+ Some(_) => options
+ .template
+ .chars()
+ .take(options.template.len())
+ .collect::<String>(),
None => options.template,
- Some(s) => format!("{}{}", options.template, s),
};
return Err(MkTempError::TooFewXs(s));
}
@@ -281,7 +260,7 @@ impl Params {
.join(prefix_from_template)
.display()
.to_string();
- if options.treat_as_template && prefix.contains(MAIN_SEPARATOR) {
+ if options.treat_as_template && prefix_from_template.contains(MAIN_SEPARATOR) {
return Err(MkTempError::PrefixContainsDirSeparator(options.template));
}
if tmpdir.is_some() && Path::new(prefix_from_template).is_absolute() {
@@ -313,7 +292,7 @@ impl Params {
// the template is "XXXabc", then `suffix` is "abc.txt".
let suffix_from_option = options.suffix.unwrap_or_default();
let suffix_from_template = &options.template[j..];
- let suffix = format!("{}{}", suffix_from_template, suffix_from_option);
+ let suffix = format!("{suffix_from_template}{suffix_from_option}");
if suffix.contains(MAIN_SEPARATOR) {
return Err(MkTempError::SuffixContainsDirSeparator(suffix));
}
@@ -325,7 +304,7 @@ impl Params {
let num_rand_chars = j - i;
Ok(Self {
- directory,
+ directory: directory.into(),
prefix,
num_rand_chars,
suffix,
@@ -335,8 +314,7 @@ impl Params {
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_lossy();
-
+ let args: Vec<_> = args.collect();
let matches = match uu_app().try_get_matches_from(&args) {
Ok(m) => m,
Err(e) => {
@@ -358,9 +336,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
if env::var("POSIXLY_CORRECT").is_ok() {
// If POSIXLY_CORRECT was set, template MUST be the last argument.
- if is_tmpdir_argument_actually_the_template(&matches) || matches.contains_id(ARG_TEMPLATE) {
+ if matches.contains_id(ARG_TEMPLATE) {
// Template argument was provided, check if was the last one.
- if args.last().unwrap() != &options.template {
+ if args.last().unwrap() != OsStr::new(&options.template) {
return Err(Box::new(MkTempError::TooManyTemplates));
}
}
@@ -385,12 +363,13 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
exec(&tmpdir, &prefix, rand, &suffix, make_dir)
};
- if suppress_file_err {
+ let res = if suppress_file_err {
// Mapping all UErrors to ExitCodes prevents the errors from being printed
res.map_err(|e| e.code().into())
} else {
res
- }
+ };
+ println_verbatim(res?).map_err_context(|| "failed to print directory name".to_owned())
}
pub fn uu_app() -> Command {
@@ -430,8 +409,16 @@ pub fn uu_app() -> Command {
.value_name("SUFFIX"),
)
.arg(
- Arg::new(OPT_TMPDIR)
+ Arg::new(OPT_P)
.short('p')
+ .help("short form of --tmpdir")
+ .value_name("DIR")
+ .num_args(1)
+ .value_parser(ValueParser::path_buf())
+ .value_hint(clap::ValueHint::DirPath),
+ )
+ .arg(
+ Arg::new(OPT_TMPDIR)
.long(OPT_TMPDIR)
.help(
"interpret TEMPLATE relative to DIR; if DIR is not specified, use \
@@ -443,6 +430,10 @@ pub fn uu_app() -> Command {
// Allows use of default argument just by setting --tmpdir. Else,
// use provided input to generate tmpdir
.num_args(0..=1)
+ // Require an equals to avoid ambiguity if no tmpdir is supplied
+ .require_equals(true)
+ .overrides_with(OPT_P)
+ .value_parser(ValueParser::path_buf())
.value_hint(clap::ValueHint::DirPath),
)
.arg(
@@ -457,7 +448,7 @@ pub fn uu_app() -> Command {
.arg(Arg::new(ARG_TEMPLATE).num_args(..=1))
}
-pub fn dry_exec(tmpdir: &str, prefix: &str, rand: usize, suffix: &str) -> UResult<()> {
+fn dry_exec(tmpdir: &Path, prefix: &str, rand: usize, suffix: &str) -> UResult<PathBuf> {
let len = prefix.len() + suffix.len() + rand;
let mut buf = Vec::with_capacity(len);
buf.extend(prefix.as_bytes());
@@ -467,7 +458,7 @@ pub fn dry_exec(tmpdir: &str, prefix: &str, rand: usize, suffix: &str) -> UResul
// Randomize.
let bytes = &mut buf[prefix.len()..prefix.len() + rand];
rand::thread_rng().fill(bytes);
- for byte in bytes.iter_mut() {
+ for byte in bytes {
*byte = match *byte % 62 {
v @ 0..=9 => v + b'0',
v @ 10..=35 => v - 10 + b'a',
@@ -478,7 +469,7 @@ pub fn dry_exec(tmpdir: &str, prefix: &str, rand: usize, suffix: &str) -> UResul
// We guarantee utf8.
let buf = String::from_utf8(buf).unwrap();
let tmpdir = Path::new(tmpdir).join(buf);
- println_verbatim(tmpdir).map_err_context(|| "failed to print directory name".to_owned())
+ Ok(tmpdir)
}
/// Create a temporary directory with the given parameters.
@@ -492,7 +483,7 @@ pub fn dry_exec(tmpdir: &str, prefix: &str, rand: usize, suffix: &str) -> UResul
///
/// If the temporary directory could not be written to disk or if the
/// given directory `dir` does not exist.
-fn make_temp_dir(dir: &str, prefix: &str, rand: usize, suffix: &str) -> UResult<PathBuf> {
+fn make_temp_dir(dir: &Path, prefix: &str, rand: usize, suffix: &str) -> UResult<PathBuf> {
let mut builder = Builder::new();
builder.prefix(prefix).rand_bytes(rand).suffix(suffix);
match builder.tempdir_in(dir) {
@@ -524,7 +515,7 @@ fn make_temp_dir(dir: &str, prefix: &str, rand: usize, suffix: &str) -> UResult<
///
/// If the file could not be written to disk or if the directory does
/// not exist.
-fn make_temp_file(dir: &str, prefix: &str, rand: usize, suffix: &str) -> UResult<PathBuf> {
+fn make_temp_file(dir: &Path, prefix: &str, rand: usize, suffix: &str) -> UResult<PathBuf> {
let mut builder = Builder::new();
builder.prefix(prefix).rand_bytes(rand).suffix(suffix);
match builder.tempfile_in(dir) {
@@ -543,7 +534,7 @@ fn make_temp_file(dir: &str, prefix: &str, rand: usize, suffix: &str) -> UResult
}
}
-fn exec(dir: &str, prefix: &str, rand: usize, suffix: &str, make_dir: bool) -> UResult<()> {
+fn exec(dir: &Path, prefix: &str, rand: usize, suffix: &str, make_dir: bool) -> UResult<PathBuf> {
let path = if make_dir {
make_temp_dir(dir, prefix, rand, suffix)?
} else {
@@ -562,7 +553,27 @@ fn exec(dir: &str, prefix: &str, rand: usize, suffix: &str, make_dir: bool) -> U
// relative path.
let path = Path::new(dir).join(filename);
- println_verbatim(path).map_err_context(|| "failed to print directory name".to_owned())
+ Ok(path)
+}
+
+/// Create a temporary file or directory
+///
+/// Behavior is determined by the `options` parameter, see [`Options`] for details.
+pub fn mktemp(options: &Options) -> UResult<PathBuf> {
+ // Parse file path parameters from the command-line options.
+ let Params {
+ directory: tmpdir,
+ prefix,
+ num_rand_chars: rand,
+ suffix,
+ } = Params::from(options.clone())?;
+
+ // Create the temporary file or directory, or simulate creating it.
+ if options.dry_run {
+ dry_exec(&tmpdir, &prefix, rand, &suffix)
+ } else {
+ exec(&tmpdir, &prefix, rand, &suffix, options.directory)
+ }
}
#[cfg(test)]
diff --git a/src/uu/more/Cargo.toml b/src/uu/more/Cargo.toml
index b52ed1880748f37dd052179eb558998e0c14326e..fad3d7bbfc2238aa7e9f4cd5bd97a18459a25a28 100644
--- a/src/uu/more/Cargo.toml
+++ b/src/uu/more/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_more"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "more ~ (uutils) input perusal filter"
@@ -15,15 +15,17 @@ edition = "2021"
path = "src/more.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
-crossterm = ">=0.19"
-atty = "0.2"
-unicode-width = "0.1.7"
-unicode-segmentation = "1.9.0"
+clap = { workspace = true }
+uucore = { workspace = true }
+crossterm = { workspace = true }
+unicode-width = { workspace = true }
+unicode-segmentation = { workspace = true }
[target.'cfg(all(unix, not(target_os = "fuchsia")))'.dependencies]
-nix = { version = "0.25", default-features = false }
+nix = { workspace = true }
+
+[target.'cfg(target_os = "macos")'.dependencies]
+crossterm = { workspace = true, features = ["use-dev-tty"] }
[[bin]]
name = "more"
diff --git a/src/uu/more/more.md b/src/uu/more/more.md
new file mode 100644
index 0000000000000000000000000000000000000000..e63ca1a87fb3d440f46ccb9ce39dd3a80270a676
--- /dev/null
+++ b/src/uu/more/more.md
@@ -0,0 +1,8 @@
+# more
+
+```
+more [OPTIONS] FILE...
+```
+
+Display the contents of a text file
+
diff --git a/src/uu/more/src/more.rs b/src/uu/more/src/more.rs
index a58e108ae6d2a66b393b469cc51e6c4d708dfbb0..0b8c838f29d120f541b609026ac1e64ace3a1439 100644
--- a/src/uu/more/src/more.rs
+++ b/src/uu/more/src/more.rs
@@ -1,33 +1,34 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Martin Kysel <code@martinkysel.com>
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
-
-// spell-checker:ignore (methods) isnt
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::{
fs::File,
io::{stdin, stdout, BufReader, Read, Stdout, Write},
+ panic::set_hook,
path::Path,
time::Duration,
};
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{crate_version, value_parser, Arg, ArgAction, ArgMatches, Command};
use crossterm::event::KeyEventKind;
use crossterm::{
+ cursor::{MoveTo, MoveUp},
event::{self, Event, KeyCode, KeyEvent, KeyModifiers},
execute, queue,
style::Attribute,
- terminal,
+ terminal::{self, Clear, ClearType},
};
use unicode_segmentation::UnicodeSegmentation;
use unicode_width::UnicodeWidthStr;
-use uucore::display::Quotable;
use uucore::error::{UResult, USimpleError, UUsageError};
+use uucore::{display::Quotable, show};
+use uucore::{format_usage, help_about, help_usage};
+const ABOUT: &str = help_about!("more.md");
+const USAGE: &str = help_usage!("more.md");
const BELL: &str = "\x07";
pub mod options {
@@ -45,14 +46,67 @@ pub mod options {
pub const FILES: &str = "files";
}
-const MULTI_FILE_TOP_PROMPT: &str = "::::::::::::::\n{}\n::::::::::::::\n";
+const MULTI_FILE_TOP_PROMPT: &str = "\r::::::::::::::\n\r{}\n\r::::::::::::::\n";
+
+struct Options {
+ clean_print: bool,
+ from_line: usize,
+ lines: Option<u16>,
+ pattern: Option<String>,
+ print_over: bool,
+ silent: bool,
+ squeeze: bool,
+}
+
+impl Options {
+ fn from(matches: &ArgMatches) -> Self {
+ let lines = match (
+ matches.get_one::<u16>(options::LINES).copied(),
+ matches.get_one::<u16>(options::NUMBER).copied(),
+ ) {
+ // We add 1 to the number of lines to display because the last line
+ // is used for the banner
+ (Some(number), _) if number > 0 => Some(number + 1),
+ (None, Some(number)) if number > 0 => Some(number + 1),
+ (_, _) => None,
+ };
+ let from_line = match matches.get_one::<usize>(options::FROM_LINE).copied() {
+ Some(number) if number > 1 => number - 1,
+ _ => 0,
+ };
+ let pattern = matches
+ .get_one::<String>(options::PATTERN)
+ .map(|s| s.to_owned());
+ Self {
+ clean_print: matches.get_flag(options::CLEAN_PRINT),
+ from_line,
+ lines,
+ pattern,
+ print_over: matches.get_flag(options::PRINT_OVER),
+ silent: matches.get_flag(options::SILENT),
+ squeeze: matches.get_flag(options::SQUEEZE),
+ }
+ }
+}
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let matches = uu_app().get_matches_from(args);
+ // Disable raw mode before exiting if a panic occurs
+ set_hook(Box::new(|panic_info| {
+ terminal::disable_raw_mode().unwrap();
+ print!("\r");
+ println!("{panic_info}");
+ }));
+
+ let matches = match uu_app().try_get_matches_from(args) {
+ Ok(m) => m,
+ Err(e) => return Err(e.into()),
+ };
+
+ let mut options = Options::from(&matches);
let mut buff = String::new();
- let silent = matches.get_flag(options::SILENT);
+
if let Some(files) = matches.get_many::<String>(options::FILES) {
let mut stdout = setup_term();
let length = files.len();
@@ -62,43 +116,72 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let file = Path::new(file);
if file.is_dir() {
terminal::disable_raw_mode().unwrap();
- return Err(UUsageError::new(
- 1,
+ show!(UUsageError::new(
+ 0,
format!("{} is a directory.", file.quote()),
));
+ terminal::enable_raw_mode().unwrap();
+ continue;
}
if !file.exists() {
terminal::disable_raw_mode().unwrap();
- return Err(USimpleError::new(
- 1,
+ show!(USimpleError::new(
+ 0,
format!("cannot open {}: No such file or directory", file.quote()),
));
+ terminal::enable_raw_mode().unwrap();
+ continue;
}
- if length > 1 {
- buff.push_str(&MULTI_FILE_TOP_PROMPT.replace("{}", file.to_str().unwrap()));
- }
- let mut reader = BufReader::new(File::open(file).unwrap());
+ let opened_file = match File::open(file) {
+ Err(why) => {
+ terminal::disable_raw_mode().unwrap();
+ show!(USimpleError::new(
+ 0,
+ format!("cannot open {}: {}", file.quote(), why.kind()),
+ ));
+ terminal::enable_raw_mode().unwrap();
+ continue;
+ }
+ Ok(opened_file) => opened_file,
+ };
+ let mut reader = BufReader::new(opened_file);
reader.read_to_string(&mut buff).unwrap();
- more(&buff, &mut stdout, next_file.copied(), silent)?;
+ more(
+ &buff,
+ &mut stdout,
+ length > 1,
+ file.to_str(),
+ next_file.copied(),
+ &mut options,
+ )?;
buff.clear();
}
reset_term(&mut stdout);
- } else if atty::isnt(atty::Stream::Stdin) {
+ } else {
stdin().read_to_string(&mut buff).unwrap();
+ if buff.is_empty() {
+ return Err(UUsageError::new(1, "bad usage"));
+ }
let mut stdout = setup_term();
- more(&buff, &mut stdout, None, silent)?;
+ more(&buff, &mut stdout, false, None, None, &mut options)?;
reset_term(&mut stdout);
- } else {
- return Err(UUsageError::new(1, "bad usage"));
}
Ok(())
}
pub fn uu_app() -> Command {
Command::new(uucore::util_name())
- .about("A file perusal filter for CRT viewing.")
+ .about(ABOUT)
+ .override_usage(format_usage(USAGE))
.version(crate_version!())
.infer_long_args(true)
+ .arg(
+ Arg::new(options::PRINT_OVER)
+ .short('c')
+ .long(options::PRINT_OVER)
+ .help("Do not scroll, display text and clean line ends")
+ .action(ArgAction::SetTrue),
+ )
.arg(
Arg::new(options::SILENT)
.short('d')
@@ -106,76 +189,74 @@ pub fn uu_app() -> Command {
.help("Display help instead of ringing bell")
.action(ArgAction::SetTrue),
)
- // The commented arguments below are unimplemented:
- /*
- .arg(
- Arg::new(options::LOGICAL)
- .short('f')
- .long(options::LOGICAL)
- .help("Count logical rather than screen lines"),
- )
- .arg(
- Arg::new(options::NO_PAUSE)
- .short('l')
- .long(options::NO_PAUSE)
- .help("Suppress pause after form feed"),
- )
- .arg(
- Arg::new(options::PRINT_OVER)
- .short('c')
- .long(options::PRINT_OVER)
- .help("Do not scroll, display text and clean line ends"),
- )
.arg(
Arg::new(options::CLEAN_PRINT)
.short('p')
.long(options::CLEAN_PRINT)
- .help("Do not scroll, clean screen and display text"),
+ .help("Do not scroll, clean screen and display text")
+ .action(ArgAction::SetTrue),
)
.arg(
Arg::new(options::SQUEEZE)
.short('s')
.long(options::SQUEEZE)
- .help("Squeeze multiple blank lines into one"),
+ .help("Squeeze multiple blank lines into one")
+ .action(ArgAction::SetTrue),
)
.arg(
Arg::new(options::PLAIN)
.short('u')
.long(options::PLAIN)
- .help("Suppress underlining and bold"),
+ .action(ArgAction::SetTrue)
+ .hide(true),
+ )
+ .arg(
+ Arg::new(options::PATTERN)
+ .short('P')
+ .long(options::PATTERN)
+ .allow_hyphen_values(true)
+ .required(false)
+ .value_name("pattern")
+ .help("Display file beginning from pattern match"),
+ )
+ .arg(
+ Arg::new(options::FROM_LINE)
+ .short('F')
+ .long(options::FROM_LINE)
+ .num_args(1)
+ .value_name("number")
+ .value_parser(value_parser!(usize))
+ .help("Display file beginning from line number"),
)
.arg(
Arg::new(options::LINES)
.short('n')
.long(options::LINES)
.value_name("number")
- .takes_value(true)
+ .num_args(1)
+ .value_parser(value_parser!(u16).range(0..))
.help("The number of lines per screen full"),
)
.arg(
Arg::new(options::NUMBER)
- .allow_hyphen_values(true)
.long(options::NUMBER)
- .required(false)
- .takes_value(true)
+ .num_args(1)
+ .value_parser(value_parser!(u16).range(0..))
.help("Same as --lines"),
)
+ // The commented arguments below are unimplemented:
+ /*
.arg(
- Arg::new(options::FROM_LINE)
- .short('F')
- .allow_hyphen_values(true)
- .required(false)
- .takes_value(true)
- .value_name("number")
- .help("Display file beginning from line number"),
+ Arg::new(options::LOGICAL)
+ .short('f')
+ .long(options::LOGICAL)
+ .help("Count logical rather than screen lines"),
)
.arg(
- Arg::new(options::PATTERN)
- .short('P')
- .allow_hyphen_values(true)
- .required(false)
- .takes_value(true)
- .help("Display file beginning from pattern match"),
+ Arg::new(options::NO_PAUSE)
+ .short('l')
+ .long(options::NO_PAUSE)
+ .help("Suppress pause after form feed"),
)
*/
.arg(
@@ -204,7 +285,7 @@ fn setup_term() -> usize {
fn reset_term(stdout: &mut std::io::Stdout) {
terminal::disable_raw_mode().unwrap();
// Clear the prompt
- queue!(stdout, terminal::Clear(terminal::ClearType::CurrentLine)).unwrap();
+ queue!(stdout, terminal::Clear(ClearType::CurrentLine)).unwrap();
// Move cursor to the beginning without printing new line
print!("\r");
stdout.flush().unwrap();
@@ -214,13 +295,50 @@ fn reset_term(stdout: &mut std::io::Stdout) {
#[inline(always)]
fn reset_term(_: &mut usize) {}
-fn more(buff: &str, stdout: &mut Stdout, next_file: Option<&str>, silent: bool) -> UResult<()> {
- let (cols, rows) = terminal::size().unwrap();
+fn more(
+ buff: &str,
+ stdout: &mut Stdout,
+ multiple_file: bool,
+ file: Option<&str>,
+ next_file: Option<&str>,
+ options: &mut Options,
+) -> UResult<()> {
+ let (cols, mut rows) = terminal::size().unwrap();
+ if let Some(number) = options.lines {
+ rows = number;
+ }
+
let lines = break_buff(buff, usize::from(cols));
- let mut pager = Pager::new(rows, lines, next_file, silent);
+ let mut pager = Pager::new(rows, lines, next_file, options);
+
+ if options.pattern.is_some() {
+ match search_pattern_in_file(&pager.lines, &options.pattern) {
+ Some(number) => pager.upper_mark = number,
+ None => {
+ execute!(stdout, terminal::Clear(terminal::ClearType::CurrentLine))?;
+ stdout.write_all("\rPattern not found\n".as_bytes())?;
+ pager.content_rows -= 1;
+ }
+ }
+ }
+
+ if multiple_file {
+ execute!(stdout, terminal::Clear(terminal::ClearType::CurrentLine)).unwrap();
+ stdout.write_all(
+ MULTI_FILE_TOP_PROMPT
+ .replace("{}", file.unwrap_or_default())
+ .as_bytes(),
+ )?;
+ pager.content_rows -= 3;
+ }
pager.draw(stdout, None);
- if pager.should_close() {
+ if multiple_file {
+ options.from_line = 0;
+ pager.content_rows += 3;
+ }
+
+ if pager.should_close() && next_file.is_none() {
return Ok(());
}
@@ -252,6 +370,11 @@ fn more(buff: &str, stdout: &mut Stdout, next_file: Option<&str>, silent: bool)
modifiers: KeyModifiers::NONE,
..
})
+ | Event::Key(KeyEvent {
+ code: KeyCode::PageDown,
+ modifiers: KeyModifiers::NONE,
+ ..
+ })
| Event::Key(KeyEvent {
code: KeyCode::Char(' '),
modifiers: KeyModifiers::NONE,
@@ -267,8 +390,14 @@ fn more(buff: &str, stdout: &mut Stdout, next_file: Option<&str>, silent: bool)
code: KeyCode::Up,
modifiers: KeyModifiers::NONE,
..
+ })
+ | Event::Key(KeyEvent {
+ code: KeyCode::PageUp,
+ modifiers: KeyModifiers::NONE,
+ ..
}) => {
pager.page_up();
+ paging_add_back_message(options, stdout)?;
}
Event::Key(KeyEvent {
code: KeyCode::Char('j'),
@@ -289,7 +418,7 @@ fn more(buff: &str, stdout: &mut Stdout, next_file: Option<&str>, silent: bool)
pager.prev_line();
}
Event::Resize(col, row) => {
- pager.page_resize(col, row);
+ pager.page_resize(col, row, options.lines);
}
Event::Key(KeyEvent {
code: KeyCode::Char(k),
@@ -298,6 +427,16 @@ fn more(buff: &str, stdout: &mut Stdout, next_file: Option<&str>, silent: bool)
_ => continue,
}
+ if options.print_over {
+ execute!(
+ std::io::stdout(),
+ MoveTo(0, 0),
+ Clear(ClearType::FromCursorDown)
+ )
+ .unwrap();
+ } else if options.clean_print {
+ execute!(std::io::stdout(), Clear(ClearType::All), MoveTo(0, 0)).unwrap();
+ }
pager.draw(stdout, wrong_key);
}
}
@@ -312,18 +451,22 @@ struct Pager<'a> {
next_file: Option<&'a str>,
line_count: usize,
silent: bool,
+ squeeze: bool,
+ line_squeezed: usize,
}
impl<'a> Pager<'a> {
- fn new(rows: u16, lines: Vec<String>, next_file: Option<&'a str>, silent: bool) -> Self {
+ fn new(rows: u16, lines: Vec<String>, next_file: Option<&'a str>, options: &Options) -> Self {
let line_count = lines.len();
Self {
- upper_mark: 0,
+ upper_mark: options.from_line,
content_rows: rows.saturating_sub(1),
lines,
next_file,
line_count,
- silent,
+ silent: options.silent,
+ squeeze: options.squeeze,
+ line_squeezed: 0,
}
}
@@ -349,7 +492,21 @@ impl<'a> Pager<'a> {
}
fn page_up(&mut self) {
- self.upper_mark = self.upper_mark.saturating_sub(self.content_rows.into());
+ let content_row_usize: usize = self.content_rows.into();
+ self.upper_mark = self
+ .upper_mark
+ .saturating_sub(content_row_usize.saturating_add(self.line_squeezed));
+
+ if self.squeeze {
+ let iter = self.lines.iter().take(self.upper_mark).rev();
+ for line in iter {
+ if line.is_empty() {
+ self.upper_mark = self.upper_mark.saturating_sub(1);
+ } else {
+ break;
+ }
+ }
+ }
}
fn next_line(&mut self) {
@@ -361,31 +518,62 @@ impl<'a> Pager<'a> {
}
// TODO: Deal with column size changes.
- fn page_resize(&mut self, _: u16, row: u16) {
- self.content_rows = row.saturating_sub(1);
+ fn page_resize(&mut self, _: u16, row: u16, option_line: Option<u16>) {
+ if option_line.is_none() {
+ self.content_rows = row.saturating_sub(1);
+ };
}
- fn draw(&self, stdout: &mut std::io::Stdout, wrong_key: Option<char>) {
+ fn draw(&mut self, stdout: &mut std::io::Stdout, wrong_key: Option<char>) {
+ self.draw_lines(stdout);
let lower_mark = self
.line_count
.min(self.upper_mark.saturating_add(self.content_rows.into()));
- self.draw_lines(stdout);
self.draw_prompt(stdout, lower_mark, wrong_key);
stdout.flush().unwrap();
}
- fn draw_lines(&self, stdout: &mut std::io::Stdout) {
+ fn draw_lines(&mut self, stdout: &mut std::io::Stdout) {
execute!(stdout, terminal::Clear(terminal::ClearType::CurrentLine)).unwrap();
- let displayed_lines = self
- .lines
- .iter()
- .skip(self.upper_mark)
- .take(self.content_rows.into());
+
+ self.line_squeezed = 0;
+ let mut previous_line_blank = false;
+ let mut displayed_lines = Vec::new();
+ let mut iter = self.lines.iter().skip(self.upper_mark);
+
+ while displayed_lines.len() < self.content_rows as usize {
+ match iter.next() {
+ Some(line) => {
+ if self.squeeze {
+ match (line.is_empty(), previous_line_blank) {
+ (true, false) => {
+ previous_line_blank = true;
+ displayed_lines.push(line);
+ }
+ (false, true) => {
+ previous_line_blank = false;
+ displayed_lines.push(line);
+ }
+ (false, false) => displayed_lines.push(line),
+ (true, true) => {
+ self.line_squeezed += 1;
+ self.upper_mark += 1;
+ }
+ }
+ } else {
+ displayed_lines.push(line);
+ }
+ }
+ // if none the end of the file is reached
+ None => {
+ self.upper_mark = self.line_count;
+ break;
+ }
+ }
+ }
for line in displayed_lines {
- stdout
- .write_all(format!("\r{}\n", line).as_bytes())
- .unwrap();
+ stdout.write_all(format!("\r{line}\n").as_bytes()).unwrap();
}
}
@@ -399,15 +587,13 @@ impl<'a> Pager<'a> {
)
};
- let status = format!("--More--({})", status_inner);
-
+ let status = format!("--More--({status_inner})");
let banner = match (self.silent, wrong_key) {
(true, Some(key)) => format!(
- "{} [Unknown key: '{}'. Press 'h' for instructions. (unimplemented)]",
- status, key
+ "{status} [Unknown key: '{key}'. Press 'h' for instructions. (unimplemented)]"
),
- (true, None) => format!("{}[Press space to continue, 'q' to quit.]", status),
- (false, Some(_)) => format!("{}{}", status, BELL),
+ (true, None) => format!("{status}[Press space to continue, 'q' to quit.]"),
+ (false, Some(_)) => format!("{status}{BELL}"),
(false, None) => status,
};
@@ -422,6 +608,27 @@ impl<'a> Pager<'a> {
}
}
+fn search_pattern_in_file(lines: &[String], pattern: &Option<String>) -> Option<usize> {
+ let pattern = pattern.clone().unwrap_or_default();
+ if lines.is_empty() || pattern.is_empty() {
+ return None;
+ }
+ for (line_number, line) in lines.iter().enumerate() {
+ if line.contains(pattern.as_str()) {
+ return Some(line_number);
+ }
+ }
+ None
+}
+
+fn paging_add_back_message(options: &Options, stdout: &mut std::io::Stdout) -> UResult<()> {
+ if options.lines.is_some() {
+ execute!(stdout, MoveUp(1))?;
+ stdout.write_all("\n\r...back 1 page\n".as_bytes())?;
+ }
+ Ok(())
+}
+
// Break the lines on the cols of the terminal
fn break_buff(buff: &str, cols: usize) -> Vec<String> {
let mut lines = Vec::with_capacity(buff.lines().count());
@@ -462,7 +669,7 @@ fn break_line(line: &str, cols: usize) -> Vec<String> {
#[cfg(test)]
mod tests {
- use super::break_line;
+ use super::{break_line, search_pattern_in_file};
use unicode_width::UnicodeWidthStr;
#[test]
@@ -510,4 +717,53 @@ mod tests {
// Each 👩ðŸ»â€ðŸ”¬ is 6 character width it break line to the closest number to 80 => 6 * 13 = 78
assert_eq!((78, 42), (widths[0], widths[1]));
}
+
+ #[test]
+ fn test_search_pattern_empty_lines() {
+ let lines = vec![];
+ let pattern = Some(String::from("pattern"));
+ assert_eq!(None, search_pattern_in_file(&lines, &pattern));
+ }
+
+ #[test]
+ fn test_search_pattern_empty_pattern() {
+ let lines = vec![String::from("line1"), String::from("line2")];
+ let pattern = None;
+ assert_eq!(None, search_pattern_in_file(&lines, &pattern));
+ }
+
+ #[test]
+ fn test_search_pattern_found_pattern() {
+ let lines = vec![
+ String::from("line1"),
+ String::from("line2"),
+ String::from("pattern"),
+ ];
+ let lines2 = vec![
+ String::from("line1"),
+ String::from("line2"),
+ String::from("pattern"),
+ String::from("pattern2"),
+ ];
+ let lines3 = vec![
+ String::from("line1"),
+ String::from("line2"),
+ String::from("other_pattern"),
+ ];
+ let pattern = Some(String::from("pattern"));
+ assert_eq!(2, search_pattern_in_file(&lines, &pattern).unwrap());
+ assert_eq!(2, search_pattern_in_file(&lines2, &pattern).unwrap());
+ assert_eq!(2, search_pattern_in_file(&lines3, &pattern).unwrap());
+ }
+
+ #[test]
+ fn test_search_pattern_not_found_pattern() {
+ let lines = vec![
+ String::from("line1"),
+ String::from("line2"),
+ String::from("something"),
+ ];
+ let pattern = Some(String::from("pattern"));
+ assert_eq!(None, search_pattern_in_file(&lines, &pattern));
+ }
}
diff --git a/src/uu/mv/Cargo.toml b/src/uu/mv/Cargo.toml
index 7ef27415362686ebdfc541749d8f4208e0cdfeef..74029fc997e7ea6be639940bc3c7f53a4b80fc1c 100644
--- a/src/uu/mv/Cargo.toml
+++ b/src/uu/mv/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_mv"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "mv ~ (uutils) move (rename) SOURCE to DESTINATION"
@@ -15,11 +15,15 @@ edition = "2021"
path = "src/mv.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-fs_extra = "1.1.0"
-indicatif = "0.17"
-
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+fs_extra = { workspace = true }
+indicatif = { workspace = true }
+uucore = { workspace = true, features = [
+ "backup-control",
+ "fs",
+ "fsxattr",
+ "update-control",
+] }
[[bin]]
name = "mv"
diff --git a/src/uu/mv/mv.md b/src/uu/mv/mv.md
new file mode 100644
index 0000000000000000000000000000000000000000..6fcee46973fcecd0765415b166fccf2a83e1bf96
--- /dev/null
+++ b/src/uu/mv/mv.md
@@ -0,0 +1,23 @@
+# mv
+
+```
+mv [OPTION]... [-T] SOURCE DEST
+mv [OPTION]... SOURCE... DIRECTORY
+mv [OPTION]... -t DIRECTORY SOURCE...
+```
+Move `SOURCE` to `DEST`, or multiple `SOURCE`(s) to `DIRECTORY`.
+
+## After Help
+
+When specifying more than one of -i, -f, -n, only the final one will take effect.
+
+Do not move a non-directory that has an existing destination with the same or newer modification timestamp;
+instead, silently skip the file without failing. If the move is across file system boundaries, the comparison is
+to the source timestamp truncated to the resolutions of the destination file system and of the system calls used
+to update timestamps; this avoids duplicate work if several `mv -u` commands are executed with the same source
+and destination. This option is ignored if the `-n` or `--no-clobber` option is also specified. which gives more control
+over which existing files in the destination are replaced, and its value can be one of the following:
+
+* `all` This is the default operation when an `--update` option is not specified, and results in all existing files in the destination being replaced.
+* `none` This is similar to the `--no-clobber` option, in that no files in the destination are replaced, but also skipping a file does not induce a failure.
+* `older` This is the default operation when `--update` is specified, and results in files being replaced if they’re older than the corresponding source file.
diff --git a/src/uu/mv/src/error.rs b/src/uu/mv/src/error.rs
index 77f7778360164a5e63a28a02f7b7a19dcfdefa30..f989d4e1332935019d92a17070ad7d5c06bece89 100644
--- a/src/uu/mv/src/error.rs
+++ b/src/uu/mv/src/error.rs
@@ -1,7 +1,7 @@
// This file is part of the uutils coreutils package.
//
-// For the full copyright and license information, please view the LICENSE file
-// that was distributed with this source code.
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::error::Error;
use std::fmt::{Display, Formatter, Result};
@@ -10,11 +10,15 @@ use uucore::error::UError;
#[derive(Debug)]
pub enum MvError {
NoSuchFile(String),
+ CannotStatNotADirectory(String),
SameFile(String, String),
SelfSubdirectory(String),
+ SelfTargetSubdirectory(String, String),
DirectoryToNonDirectory(String),
NonDirectoryToDirectory(String, String),
NotADirectory(String),
+ TargetNotADirectory(String),
+ FailedToAccessNotADirectory(String),
}
impl Error for MvError {}
@@ -22,22 +26,29 @@ impl UError for MvError {}
impl Display for MvError {
fn fmt(&self, f: &mut Formatter) -> Result {
match self {
- Self::NoSuchFile(s) => write!(f, "cannot stat {}: No such file or directory", s),
- Self::SameFile(s, t) => write!(f, "{} and {} are the same file", s, t),
+ Self::NoSuchFile(s) => write!(f, "cannot stat {s}: No such file or directory"),
+ Self::CannotStatNotADirectory(s) => write!(f, "cannot stat {s}: Not a directory"),
+ Self::SameFile(s, t) => write!(f, "{s} and {t} are the same file"),
Self::SelfSubdirectory(s) => write!(
f,
- "cannot move '{s}' to a subdirectory of itself, '{s}/{s}'",
- s = s
+ "cannot move '{s}' to a subdirectory of itself, '{s}/{s}'"
),
- Self::DirectoryToNonDirectory(t) => {
- write!(f, "cannot overwrite directory {} with non-directory", t)
- }
- Self::NonDirectoryToDirectory(s, t) => write!(
+ Self::SelfTargetSubdirectory(s, t) => write!(
f,
- "cannot overwrite non-directory {} with directory {}",
- t, s
+ "cannot move '{s}' to a subdirectory of itself, '{t}/{s}'"
),
- Self::NotADirectory(t) => write!(f, "target {} is not a directory", t),
+ Self::DirectoryToNonDirectory(t) => {
+ write!(f, "cannot overwrite directory {t} with non-directory")
+ }
+ Self::NonDirectoryToDirectory(s, t) => {
+ write!(f, "cannot overwrite non-directory {t} with directory {s}")
+ }
+ Self::NotADirectory(t) => write!(f, "target {t}: Not a directory"),
+ Self::TargetNotADirectory(t) => write!(f, "target directory {t}: Not a directory"),
+
+ Self::FailedToAccessNotADirectory(t) => {
+ write!(f, "failed to access {t}: Not a directory")
+ }
}
}
}
diff --git a/src/uu/mv/src/mv.rs b/src/uu/mv/src/mv.rs
index 66b31a97710b1d8fed034a4bf7a2aa913ab5f23d..3722f134f27dd697ae7175a035fed23e84cf8490 100644
--- a/src/uu/mv/src/mv.rs
+++ b/src/uu/mv/src/mv.rs
@@ -1,18 +1,16 @@
// This file is part of the uutils coreutils package.
//
-// (c) Orvar Segerström <orvarsegerstrom@gmail.com>
-// (c) Sokovikov Evgeniy <skv-headless@yandex.ru>
-//
-// For the full copyright and license information, please view the LICENSE file
-// that was distributed with this source code.
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-// spell-checker:ignore (ToDO) sourcepath targetpath
+// spell-checker:ignore (ToDO) sourcepath targetpath nushell canonicalized
mod error;
use clap::builder::ValueParser;
use clap::{crate_version, error::ErrorKind, Arg, ArgAction, ArgMatches, Command};
use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
+use std::collections::HashSet;
use std::env;
use std::ffi::OsString;
use std::fs;
@@ -22,10 +20,21 @@ use std::os::unix;
#[cfg(windows)]
use std::os::windows;
use std::path::{Path, PathBuf};
-use uucore::backup_control::{self, BackupMode};
+use uucore::backup_control::{self, source_is_target_backup};
use uucore::display::Quotable;
-use uucore::error::{FromIo, UError, UResult, USimpleError, UUsageError};
-use uucore::{format_usage, prompt_yes, show};
+use uucore::error::{set_exit_code, FromIo, UResult, USimpleError, UUsageError};
+use uucore::fs::{
+ are_hardlinks_or_one_way_symlink_to_same_file, are_hardlinks_to_same_file,
+ path_ends_with_terminator,
+};
+#[cfg(all(unix, not(any(target_os = "macos", target_os = "redox"))))]
+use uucore::fsxattr;
+use uucore::update_control;
+
+// These are exposed for projects (e.g. nushell) that want to create an `Options` value, which
+// requires these enums
+pub use uucore::{backup_control::BackupMode, update_control::UpdateMode};
+use uucore::{format_usage, help_about, help_section, help_usage, prompt_yes, show};
use fs_extra::dir::{
get_size as dir_get_size, move_dir, move_dir_with_progress, CopyOptions as DirCopyOptions,
@@ -34,31 +43,62 @@ use fs_extra::dir::{
use crate::error::MvError;
-pub struct Behavior {
- overwrite: OverwriteMode,
- backup: BackupMode,
- suffix: String,
- update: bool,
- target_dir: Option<OsString>,
- no_target_dir: bool,
- verbose: bool,
- strip_slashes: bool,
- progress_bar: bool,
+/// Options contains all the possible behaviors and flags for mv.
+///
+/// All options are public so that the options can be programmatically
+/// constructed by other crates, such as nushell. That means that this struct is
+/// part of our public API. It should therefore not be changed without good reason.
+///
+/// The fields are documented with the arguments that determine their value.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Options {
+ /// specifies overwrite behavior
+ /// '-n' '--no-clobber'
+ /// '-i' '--interactive'
+ /// '-f' '--force'
+ pub overwrite: OverwriteMode,
+
+ /// `--backup[=CONTROL]`, `-b`
+ pub backup: BackupMode,
+
+ /// '-S' --suffix' backup suffix
+ pub suffix: String,
+
+ /// Available update mode "--update-mode=all|none|older"
+ pub update: UpdateMode,
+
+ /// Specifies target directory
+ /// '-t, --target-directory=DIRECTORY'
+ pub target_dir: Option<OsString>,
+
+ /// Treat destination as a normal file
+ /// '-T, --no-target-directory
+ pub no_target_dir: bool,
+
+ /// '-v, --verbose'
+ pub verbose: bool,
+
+ /// '--strip-trailing-slashes'
+ pub strip_slashes: bool,
+
+ /// '-g, --progress'
+ pub progress_bar: bool,
}
-#[derive(Clone, Eq, PartialEq)]
+/// specifies behavior of the overwrite flag
+#[derive(Clone, Debug, Eq, PartialEq)]
pub enum OverwriteMode {
+ /// '-n' '--no-clobber' do not overwrite
NoClobber,
+ /// '-i' '--interactive' prompt before overwrite
Interactive,
+ ///'-f' '--force' overwrite without prompt
Force,
}
-static ABOUT: &str = "Move SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.";
-static LONG_HELP: &str = "";
-const USAGE: &str = "\
- {} [OPTION]... [-T] SOURCE DEST
- {} [OPTION]... SOURCE... DIRECTORY
- {} [OPTION]... -t DIRECTORY SOURCE...";
+const ABOUT: &str = help_about!("mv.md");
+const USAGE: &str = help_usage!("mv.md");
+const AFTER_HELP: &str = help_section!("after help", "mv.md");
static OPT_FORCE: &str = "force";
static OPT_INTERACTIVE: &str = "interactive";
@@ -66,46 +106,34 @@ static OPT_NO_CLOBBER: &str = "no-clobber";
static OPT_STRIP_TRAILING_SLASHES: &str = "strip-trailing-slashes";
static OPT_TARGET_DIRECTORY: &str = "target-directory";
static OPT_NO_TARGET_DIRECTORY: &str = "no-target-directory";
-static OPT_UPDATE: &str = "update";
static OPT_VERBOSE: &str = "verbose";
static OPT_PROGRESS: &str = "progress";
static ARG_FILES: &str = "files";
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let help = format!(
- "{}\n{}",
- LONG_HELP,
- backup_control::BACKUP_CONTROL_LONG_HELP
- );
- let mut app = uu_app().after_help(help);
+ let mut app = uu_app();
let matches = app.try_get_matches_from_mut(args)?;
- if !matches.contains_id(OPT_TARGET_DIRECTORY)
- && matches
- .get_many::<OsString>(ARG_FILES)
- .map(|f| f.len())
- .unwrap_or(0)
- == 1
- {
+ let files: Vec<OsString> = matches
+ .get_many::<OsString>(ARG_FILES)
+ .unwrap_or_default()
+ .cloned()
+ .collect();
+
+ if files.len() == 1 && !matches.contains_id(OPT_TARGET_DIRECTORY) {
app.error(
ErrorKind::TooFewValues,
format!(
- "The argument '<{}>...' requires at least 2 values, but only 1 was provided",
- ARG_FILES
+ "The argument '<{ARG_FILES}>...' requires at least 2 values, but only 1 was provided"
),
)
.exit();
}
- let files: Vec<OsString> = matches
- .get_many::<OsString>(ARG_FILES)
- .unwrap_or_default()
- .map(|v| v.to_os_string())
- .collect();
-
let overwrite_mode = determine_overwrite_mode(&matches);
let backup_mode = backup_control::determine_backup_mode(&matches)?;
+ let update_mode = update_control::determine_update_mode(&matches);
if overwrite_mode == OverwriteMode::NoClobber && backup_mode != BackupMode::NoBackup {
return Err(UUsageError::new(
@@ -116,21 +144,29 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let backup_suffix = backup_control::determine_backup_suffix(&matches);
- let behavior = Behavior {
+ let target_dir = matches
+ .get_one::<OsString>(OPT_TARGET_DIRECTORY)
+ .map(OsString::from);
+
+ if let Some(ref maybe_dir) = target_dir {
+ if !Path::new(&maybe_dir).is_dir() {
+ return Err(MvError::TargetNotADirectory(maybe_dir.quote().to_string()).into());
+ }
+ }
+
+ let opts = Options {
overwrite: overwrite_mode,
backup: backup_mode,
suffix: backup_suffix,
- update: matches.get_flag(OPT_UPDATE),
- target_dir: matches
- .get_one::<OsString>(OPT_TARGET_DIRECTORY)
- .map(OsString::from),
+ update: update_mode,
+ target_dir,
no_target_dir: matches.get_flag(OPT_NO_TARGET_DIRECTORY),
verbose: matches.get_flag(OPT_VERBOSE),
strip_slashes: matches.get_flag(OPT_STRIP_TRAILING_SLASHES),
progress_bar: matches.get_flag(OPT_PROGRESS),
};
- exec(&files[..], &behavior)
+ mv(&files[..], &opts)
}
pub fn uu_app() -> Command {
@@ -138,14 +174,17 @@ pub fn uu_app() -> Command {
.version(crate_version!())
.about(ABOUT)
.override_usage(format_usage(USAGE))
+ .after_help(format!(
+ "{AFTER_HELP}\n\n{}",
+ backup_control::BACKUP_CONTROL_LONG_HELP
+ ))
.infer_long_args(true)
- .arg(backup_control::arguments::backup())
- .arg(backup_control::arguments::backup_no_args())
.arg(
Arg::new(OPT_FORCE)
.short('f')
.long(OPT_FORCE)
.help("do not prompt before overwriting")
+ .overrides_with_all([OPT_INTERACTIVE, OPT_NO_CLOBBER])
.action(ArgAction::SetTrue),
)
.arg(
@@ -153,6 +192,7 @@ pub fn uu_app() -> Command {
.short('i')
.long(OPT_INTERACTIVE)
.help("prompt before override")
+ .overrides_with_all([OPT_FORCE, OPT_NO_CLOBBER])
.action(ArgAction::SetTrue),
)
.arg(
@@ -160,6 +200,7 @@ pub fn uu_app() -> Command {
.short('n')
.long(OPT_NO_CLOBBER)
.help("do not overwrite an existing file")
+ .overrides_with_all([OPT_FORCE, OPT_INTERACTIVE])
.action(ArgAction::SetTrue),
)
.arg(
@@ -168,7 +209,11 @@ pub fn uu_app() -> Command {
.help("remove any trailing slashes from each SOURCE argument")
.action(ArgAction::SetTrue),
)
+ .arg(backup_control::arguments::backup())
+ .arg(backup_control::arguments::backup_no_args())
.arg(backup_control::arguments::suffix())
+ .arg(update_control::arguments::update())
+ .arg(update_control::arguments::update_no_args())
.arg(
Arg::new(OPT_TARGET_DIRECTORY)
.short('t')
@@ -186,16 +231,6 @@ pub fn uu_app() -> Command {
.help("treat DEST as a normal file")
.action(ArgAction::SetTrue),
)
- .arg(
- Arg::new(OPT_UPDATE)
- .short('u')
- .long(OPT_UPDATE)
- .help(
- "move only when the SOURCE file is newer than the destination file \
- or when the destination file is missing",
- )
- .action(ArgAction::SetTrue),
- )
.arg(
Arg::new(OPT_VERBOSE)
.short('v')
@@ -238,106 +273,148 @@ fn determine_overwrite_mode(matches: &ArgMatches) -> OverwriteMode {
}
}
-fn exec(files: &[OsString], b: &Behavior) -> UResult<()> {
- let paths: Vec<PathBuf> = {
- let paths = files.iter().map(Path::new);
+fn parse_paths(files: &[OsString], opts: &Options) -> Vec<PathBuf> {
+ let paths = files.iter().map(Path::new);
+
+ if opts.strip_slashes {
+ paths
+ .map(|p| p.components().as_path().to_owned())
+ .collect::<Vec<PathBuf>>()
+ } else {
+ paths.map(|p| p.to_owned()).collect::<Vec<PathBuf>>()
+ }
+}
+
+fn handle_two_paths(source: &Path, target: &Path, opts: &Options) -> UResult<()> {
+ if opts.backup == BackupMode::SimpleBackup
+ && source_is_target_backup(source, target, &opts.suffix)
+ {
+ return Err(io::Error::new(
+ io::ErrorKind::NotFound,
+ format!(
+ "backing up {} might destroy source; {} not moved",
+ target.quote(),
+ source.quote()
+ ),
+ )
+ .into());
+ }
+ if source.symlink_metadata().is_err() {
+ return Err(if path_ends_with_terminator(source) {
+ MvError::CannotStatNotADirectory(source.quote().to_string()).into()
+ } else {
+ MvError::NoSuchFile(source.quote().to_string()).into()
+ });
+ }
- // Strip slashes from path, if strip opt present
- if b.strip_slashes {
- paths
- .map(|p| p.components().as_path().to_owned())
- .collect::<Vec<PathBuf>>()
+ if (source.eq(target)
+ || are_hardlinks_to_same_file(source, target)
+ || are_hardlinks_or_one_way_symlink_to_same_file(source, target))
+ && opts.backup == BackupMode::NoBackup
+ {
+ if source.eq(Path::new(".")) || source.ends_with("/.") || source.is_file() {
+ return Err(
+ MvError::SameFile(source.quote().to_string(), target.quote().to_string()).into(),
+ );
} else {
- paths.map(|p| p.to_owned()).collect::<Vec<PathBuf>>()
+ return Err(MvError::SelfSubdirectory(source.display().to_string()).into());
}
- };
-
- if let Some(ref name) = b.target_dir {
- return move_files_into_dir(&paths, &PathBuf::from(name), b);
}
- match paths.len() {
- /* case 0/1 are not possible thanks to clap */
- 2 => {
- let source = &paths[0];
- let target = &paths[1];
- // Here we use the `symlink_metadata()` method instead of `exists()`,
- // since it handles dangling symlinks correctly. The method gives an
- // `Ok()` results unless the source does not exist, or the user
- // lacks permission to access metadata.
- if source.symlink_metadata().is_err() {
- return Err(MvError::NoSuchFile(source.quote().to_string()).into());
- }
- // GNU semantics are: if the source and target are the same, no move occurs and we print an error
- if source.eq(target) {
- // Done to match GNU semantics for the dot file
- if source.eq(Path::new(".")) || source.ends_with("/.") || source.is_file() {
- return Err(MvError::SameFile(
- source.quote().to_string(),
- target.quote().to_string(),
- )
- .into());
- } else {
- return Err(MvError::SelfSubdirectory(source.display().to_string()).into());
- }
- }
+ let target_is_dir = target.is_dir();
+ let source_is_dir = source.is_dir();
- if target.is_dir() {
- if b.no_target_dir {
- if source.is_dir() {
- rename(source, target, b, None).map_err_context(|| {
- format!("cannot move {} to {}", source.quote(), target.quote())
- })
- } else {
- Err(MvError::DirectoryToNonDirectory(target.quote().to_string()).into())
- }
- } else {
- move_files_into_dir(&[source.clone()], target, b)
- }
- } else if target.exists() && source.is_dir() {
- match b.overwrite {
- OverwriteMode::NoClobber => return Ok(()),
- OverwriteMode::Interactive => {
- if !prompt_yes!("overwrite {}? ", target.quote()) {
- return Ok(());
- }
- }
- OverwriteMode::Force => {}
- };
- Err(MvError::NonDirectoryToDirectory(
- source.quote().to_string(),
- target.quote().to_string(),
- )
- .into())
+ if path_ends_with_terminator(target)
+ && (!target_is_dir && !source_is_dir)
+ && !opts.no_target_dir
+ && opts.update != UpdateMode::ReplaceIfOlder
+ {
+ return Err(MvError::FailedToAccessNotADirectory(target.quote().to_string()).into());
+ }
+
+ if target_is_dir {
+ if opts.no_target_dir {
+ if source.is_dir() {
+ rename(source, target, opts, None).map_err_context(|| {
+ format!("cannot move {} to {}", source.quote(), target.quote())
+ })
} else {
- rename(source, target, b, None).map_err(|e| USimpleError::new(1, format!("{}", e)))
+ Err(MvError::DirectoryToNonDirectory(target.quote().to_string()).into())
}
+ // Check that source & target do not contain same subdir/dir when both exist
+ // mkdir dir1/dir2; mv dir1 dir1/dir2
+ } else if target.starts_with(source) {
+ Err(MvError::SelfTargetSubdirectory(
+ source.display().to_string(),
+ target.display().to_string(),
+ )
+ .into())
+ } else {
+ move_files_into_dir(&[source.to_path_buf()], target, opts)
}
- _ => {
- if b.no_target_dir {
- return Err(UUsageError::new(
- 1,
- format!("mv: extra operand {}", files[2].quote()),
- ));
+ } else if target.exists() && source.is_dir() {
+ match opts.overwrite {
+ OverwriteMode::NoClobber => return Ok(()),
+ OverwriteMode::Interactive => {
+ if !prompt_yes!("overwrite {}? ", target.quote()) {
+ return Err(io::Error::new(io::ErrorKind::Other, "").into());
+ }
}
- let target_dir = paths.last().unwrap();
- let sources = &paths[..paths.len() - 1];
+ OverwriteMode::Force => {}
+ };
+ Err(MvError::NonDirectoryToDirectory(
+ source.quote().to_string(),
+ target.quote().to_string(),
+ )
+ .into())
+ } else {
+ rename(source, target, opts, None).map_err(|e| USimpleError::new(1, format!("{e}")))
+ }
+}
- move_files_into_dir(sources, target_dir, b)
- }
+fn handle_multiple_paths(paths: &[PathBuf], opts: &Options) -> UResult<()> {
+ if opts.no_target_dir {
+ return Err(UUsageError::new(
+ 1,
+ format!("mv: extra operand {}", paths[2].quote()),
+ ));
+ }
+ let target_dir = paths.last().unwrap();
+ let sources = &paths[..paths.len() - 1];
+
+ move_files_into_dir(sources, target_dir, opts)
+}
+
+/// Execute the mv command. This moves 'source' to 'target', where
+/// 'target' is a directory. If 'target' does not exist, and source is a single
+/// file or directory, then 'source' will be renamed to 'target'.
+pub fn mv(files: &[OsString], opts: &Options) -> UResult<()> {
+ let paths = parse_paths(files, opts);
+
+ if let Some(ref name) = opts.target_dir {
+ return move_files_into_dir(&paths, &PathBuf::from(name), opts);
+ }
+
+ match paths.len() {
+ 2 => handle_two_paths(&paths[0], &paths[1], opts),
+ _ => handle_multiple_paths(&paths, opts),
}
}
-fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UResult<()> {
+#[allow(clippy::cognitive_complexity)]
+fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, options: &Options) -> UResult<()> {
+ // remember the moved destinations for further usage
+ let mut moved_destinations: HashSet<PathBuf> = HashSet::with_capacity(files.len());
+
if !target_dir.is_dir() {
return Err(MvError::NotADirectory(target_dir.quote().to_string()).into());
}
- let canonized_target_dir = target_dir
+ let canonicalized_target_dir = target_dir
.canonicalize()
.unwrap_or_else(|_| target_dir.to_path_buf());
- let multi_progress = b.progress_bar.then(MultiProgress::new);
+ let multi_progress = options.progress_bar.then(MultiProgress::new);
let count_progress = if let Some(ref multi_progress) = multi_progress {
if files.len() > 1 {
@@ -353,7 +430,7 @@ fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UR
None
};
- for sourcepath in files.iter() {
+ for sourcepath in files {
if let Some(ref pb) = count_progress {
pb.set_message(sourcepath.to_string_lossy().to_string());
}
@@ -366,10 +443,24 @@ fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UR
}
};
+ if moved_destinations.contains(&targetpath) && options.backup != BackupMode::NumberedBackup
+ {
+ // If the target file was already created in this mv call, do not overwrite
+ show!(USimpleError::new(
+ 1,
+ format!(
+ "will not overwrite just-created '{}' with '{}'",
+ targetpath.display(),
+ sourcepath.display()
+ ),
+ ));
+ continue;
+ }
+
// Check if we have mv dir1 dir2 dir2
// And generate an error if this is the case
- if let Ok(canonized_source) = sourcepath.canonicalize() {
- if canonized_source == canonized_target_dir {
+ if let Ok(canonicalized_source) = sourcepath.canonicalize() {
+ if canonicalized_source == canonicalized_target_dir {
// User tried to move directory to itself, warning is shown
// and process of moving files is continued.
show!(USimpleError::new(
@@ -378,7 +469,7 @@ fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UR
"cannot move '{}' to a subdirectory of itself, '{}/{}'",
sourcepath.display(),
target_dir.display(),
- canonized_target_dir.components().last().map_or_else(
+ canonicalized_target_dir.components().last().map_or_else(
|| target_dir.display().to_string(),
|dir| { PathBuf::from(dir.as_os_str()).display().to_string() }
)
@@ -388,25 +479,27 @@ fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UR
}
}
- let rename_result = rename(sourcepath, &targetpath, b, multi_progress.as_ref())
- .map_err_context(|| {
- format!(
- "cannot move {} to {}",
- sourcepath.quote(),
- targetpath.quote()
- )
- });
-
- if let Err(e) = rename_result {
- match multi_progress {
- Some(ref pb) => pb.suspend(|| show!(e)),
- None => show!(e),
- };
- };
-
+ match rename(sourcepath, &targetpath, options, multi_progress.as_ref()) {
+ Err(e) if e.to_string().is_empty() => set_exit_code(1),
+ Err(e) => {
+ let e = e.map_err_context(|| {
+ format!(
+ "cannot move {} to {}",
+ sourcepath.quote(),
+ targetpath.quote()
+ )
+ });
+ match multi_progress {
+ Some(ref pb) => pb.suspend(|| show!(e)),
+ None => show!(e),
+ };
+ }
+ Ok(()) => (),
+ }
if let Some(ref pb) = count_progress {
pb.inc(1);
}
+ moved_destinations.insert(targetpath.clone());
}
Ok(())
}
@@ -414,36 +507,46 @@ fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UR
fn rename(
from: &Path,
to: &Path,
- b: &Behavior,
+ opts: &Options,
multi_progress: Option<&MultiProgress>,
) -> io::Result<()> {
let mut backup_path = None;
if to.exists() {
- if b.update && b.overwrite == OverwriteMode::Interactive {
+ if opts.update == UpdateMode::ReplaceIfOlder && opts.overwrite == OverwriteMode::Interactive
+ {
// `mv -i --update old new` when `new` exists doesn't move anything
// and exit with 0
return Ok(());
}
- match b.overwrite {
- OverwriteMode::NoClobber => return Ok(()),
+ if opts.update == UpdateMode::ReplaceNone {
+ return Ok(());
+ }
+
+ if (opts.update == UpdateMode::ReplaceIfOlder)
+ && fs::metadata(from)?.modified()? <= fs::metadata(to)?.modified()?
+ {
+ return Ok(());
+ }
+
+ match opts.overwrite {
+ OverwriteMode::NoClobber => {
+ let err_msg = format!("not replacing {}", to.quote());
+ return Err(io::Error::new(io::ErrorKind::Other, err_msg));
+ }
OverwriteMode::Interactive => {
if !prompt_yes!("overwrite {}?", to.quote()) {
- return Ok(());
+ return Err(io::Error::new(io::ErrorKind::Other, ""));
}
}
OverwriteMode::Force => {}
};
- backup_path = backup_control::get_backup_path(b.backup, to, &b.suffix);
+ backup_path = backup_control::get_backup_path(opts.backup, to, &opts.suffix);
if let Some(ref backup_path) = backup_path {
rename_with_fallback(to, backup_path, multi_progress)?;
}
-
- if b.update && fs::metadata(from)?.modified()? <= fs::metadata(to)?.modified()? {
- return Ok(());
- }
}
// "to" may no longer exist if it was backed up
@@ -460,22 +563,22 @@ fn rename(
rename_with_fallback(from, to, multi_progress)?;
- if b.verbose {
+ if opts.verbose {
let message = match backup_path {
Some(path) => format!(
- "{} -> {} (backup: {})",
+ "renamed {} -> {} (backup: {})",
from.quote(),
to.quote(),
path.quote()
),
- None => format!("{} -> {}", from.quote(), to.quote()),
+ None => format!("renamed {} -> {}", from.quote(), to.quote()),
};
match multi_progress {
Some(pb) => pb.suspend(|| {
- println!("{}", message);
+ println!("{message}");
}),
- None => println!("{}", message),
+ None => println!("{message}"),
};
}
Ok(())
@@ -531,6 +634,10 @@ fn rename_with_fallback(
None
};
+ #[cfg(all(unix, not(any(target_os = "macos", target_os = "redox"))))]
+ let xattrs =
+ fsxattr::retrieve_xattrs(from).unwrap_or_else(|_| std::collections::HashMap::new());
+
let result = if let Some(ref pb) = progress_bar {
move_dir_with_progress(from, to, &options, |process_info: TransitProcess| {
pb.set_position(process_info.copied_bytes);
@@ -541,16 +648,24 @@ fn rename_with_fallback(
move_dir(from, to, &options)
};
+ #[cfg(all(unix, not(any(target_os = "macos", target_os = "redox"))))]
+ fsxattr::apply_xattrs(to, xattrs).unwrap();
+
if let Err(err) = result {
return match err.kind {
fs_extra::error::ErrorKind::PermissionDenied => Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"Permission denied",
)),
- _ => Err(io::Error::new(io::ErrorKind::Other, format!("{:?}", err))),
+ _ => Err(io::Error::new(io::ErrorKind::Other, format!("{err:?}"))),
};
}
} else {
+ #[cfg(all(unix, not(any(target_os = "macos", target_os = "redox"))))]
+ fs::copy(from, to)
+ .and_then(|_| fsxattr::copy_xattrs(&from, &to))
+ .and_then(|_| fs::remove_file(from))?;
+ #[cfg(any(target_os = "macos", target_os = "redox", not(unix)))]
fs::copy(from, to).and_then(|_| fs::remove_file(from))?;
}
}
diff --git a/src/uu/nice/Cargo.toml b/src/uu/nice/Cargo.toml
index b3f013bdedf1ba780b14bed34e7558574c57d7a1..8a46e36e0cb28914fa47d23f450d3da3d9889c6e 100644
--- a/src/uu/nice/Cargo.toml
+++ b/src/uu/nice/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_nice"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "nice ~ (uutils) run PROGRAM with modified scheduling priority"
@@ -15,10 +15,10 @@ edition = "2021"
path = "src/nice.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-libc = "0.2.137"
-nix = { version = "0.25", default-features = false }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+libc = { workspace = true }
+nix = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "nice"
diff --git a/src/uu/nice/nice.md b/src/uu/nice/nice.md
new file mode 100644
index 0000000000000000000000000000000000000000..872c239cab1ae06cb5f915c4bd36165c5b00d1b3
--- /dev/null
+++ b/src/uu/nice/nice.md
@@ -0,0 +1,10 @@
+# nice
+
+```
+nice [OPTIONS] [COMMAND [ARGS]]
+```
+
+Run `COMMAND` with an adjusted niceness, which affects process scheduling.
+With no `COMMAND`, print the current niceness. Niceness values range from at
+least -20 (most favorable to the process) to 19 (least favorable to the
+process).
diff --git a/src/uu/nice/src/nice.rs b/src/uu/nice/src/nice.rs
index a2c8ceeef91f48ea3c117a3cc3b097be6ed8d9f9..3eaeba9565748163a9bb85833e07b0fe45607055 100644
--- a/src/uu/nice/src/nice.rs
+++ b/src/uu/nice/src/nice.rs
@@ -1,21 +1,19 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Alex Lyon <arcterus@mail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) getpriority execvp setpriority nstr PRIO cstrs ENOENT
use libc::{c_char, c_int, execvp, PRIO_PROCESS};
-use std::ffi::CString;
-use std::io::Error;
+use std::ffi::{CString, OsString};
+use std::io::{Error, Write};
use std::ptr;
use clap::{crate_version, Arg, ArgAction, Command};
use uucore::{
error::{set_exit_code, UClapError, UResult, USimpleError, UUsageError},
- format_usage, show_error, show_warning,
+ format_usage, help_about, help_usage, show_error,
};
pub mod options {
@@ -23,15 +21,92 @@ pub mod options {
pub static COMMAND: &str = "COMMAND";
}
-const ABOUT: &str = "\
- Run COMMAND with an adjusted niceness, which affects process scheduling. \
- With no COMMAND, print the current niceness. Niceness values range from at \
- least -20 (most favorable to the process) to 19 (least favorable to the \
- process).";
-const USAGE: &str = "{} [OPTIONS] [COMMAND [ARGS]]";
+const ABOUT: &str = help_about!("nice.md");
+const USAGE: &str = help_usage!("nice.md");
+
+fn is_prefix_of(maybe_prefix: &str, target: &str, min_match: usize) -> bool {
+ if maybe_prefix.len() < min_match || maybe_prefix.len() > target.len() {
+ return false;
+ }
+
+ &target[0..maybe_prefix.len()] == maybe_prefix
+}
+
+/// Transform legacy arguments into a standardized form.
+///
+/// The following are all legal argument sequences to GNU nice:
+/// - "-1"
+/// - "-n1"
+/// - "-+1"
+/// - "--1"
+/// - "-n -1"
+///
+/// It looks initially like we could add handling for "-{i}", "--{i}"
+/// and "-+{i}" for integers {i} and process them normally using clap.
+/// However, the meaning of "-1", for example, changes depending on
+/// its context with legacy argument parsing. clap will not prioritize
+/// hyphenated values to previous arguments over matching a known
+/// argument. So "-n" "-1" in this case is picked up as two
+/// arguments, not one argument with a value.
+///
+/// Given this context dependency, and the deep hole we end up digging
+/// with clap in this case, it's much simpler to just normalize the
+/// arguments to nice before clap starts work. Here, we insert a
+/// prefix of "-n" onto all arguments of the form "-{i}", "--{i}" and
+/// "-+{i}" which are not already preceded by "-n".
+fn standardize_nice_args(mut args: impl uucore::Args) -> impl uucore::Args {
+ let mut v = Vec::<OsString>::new();
+ let mut saw_n = false;
+ let mut saw_command = false;
+ if let Some(cmd) = args.next() {
+ v.push(cmd);
+ }
+ for s in args {
+ if saw_command {
+ v.push(s);
+ } else if saw_n {
+ let mut new_arg: OsString = "-n".into();
+ new_arg.push(s);
+ v.push(new_arg);
+ saw_n = false;
+ } else if s.to_str() == Some("-n")
+ || s.to_str()
+ .map(|s| is_prefix_of(s, "--adjustment", "--a".len()))
+ .unwrap_or_default()
+ {
+ saw_n = true;
+ } else if let Ok(s) = s.clone().into_string() {
+ if let Some(stripped) = s.strip_prefix('-') {
+ match stripped.parse::<i64>() {
+ Ok(ix) => {
+ let mut new_arg: OsString = "-n".into();
+ new_arg.push(ix.to_string());
+ v.push(new_arg);
+ }
+ Err(_) => {
+ v.push(s.into());
+ }
+ }
+ } else {
+ saw_command = true;
+ v.push(s.into());
+ }
+ } else {
+ saw_command = true;
+ v.push(s);
+ }
+ }
+ if saw_n {
+ v.push("-n".into());
+ }
+
+ v.into_iter()
+}
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+ let args = standardize_nice_args(args);
+
let matches = uu_app().try_get_matches_from(args).with_exit_code(125)?;
nix::errno::Errno::clear();
@@ -56,14 +131,14 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
Err(e) => {
return Err(USimpleError::new(
125,
- format!("\"{}\" is not a valid number: {}", nstr, e),
+ format!("\"{nstr}\" is not a valid number: {e}"),
))
}
}
}
None => {
if !matches.contains_id(options::COMMAND) {
- println!("{}", niceness);
+ println!("{niceness}");
return Ok(());
}
10_i32
@@ -71,8 +146,21 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
};
niceness += adjustment;
- if unsafe { libc::setpriority(PRIO_PROCESS, 0, niceness) } == -1 {
- show_warning!("setpriority: {}", Error::last_os_error());
+ // We can't use `show_warning` because that will panic if stderr
+ // isn't writable. The GNU test suite checks specifically that the
+ // exit code when failing to write the advisory is 125, but Rust
+ // will produce an exit code of 101 when it panics.
+ if unsafe { libc::setpriority(PRIO_PROCESS, 0, niceness) } == -1
+ && write!(
+ std::io::stderr(),
+ "{}: warning: setpriority: {}",
+ uucore::util_name(),
+ Error::last_os_error()
+ )
+ .is_err()
+ {
+ set_exit_code(125);
+ return Ok(());
}
let cstrs: Vec<CString> = matches
@@ -109,6 +197,8 @@ pub fn uu_app() -> Command {
.short('n')
.long(options::ADJUSTMENT)
.help("add N to the niceness (default is 10)")
+ .action(ArgAction::Set)
+ .overrides_with(options::ADJUSTMENT)
.allow_hyphen_values(true),
)
.arg(
diff --git a/src/uu/nl/Cargo.toml b/src/uu/nl/Cargo.toml
index 0d3d033414cfcecb319464d9b93ed1e8bb731a81..3ce4f3169408b79e9a473a40eff6198ff0b3f482 100644
--- a/src/uu/nl/Cargo.toml
+++ b/src/uu/nl/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_nl"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "nl ~ (uutils) display input with added line numbers"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/nl.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-regex = "1.7.0"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+regex = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "nl"
diff --git a/src/uu/nl/nl.md b/src/uu/nl/nl.md
new file mode 100644
index 0000000000000000000000000000000000000000..bf3952cb2aa68935ce5f3fb311f7b4161a6cf1d8
--- /dev/null
+++ b/src/uu/nl/nl.md
@@ -0,0 +1,23 @@
+# nl
+
+```
+nl [OPTION]... [FILE]...
+```
+
+Number lines of files
+
+## After Help
+
+`STYLE` is one of:
+
+* `a` number all lines
+* `t` number only nonempty lines
+* `n` number no lines
+* `pBRE` number only lines that contain a match for the basic regular
+ expression, `BRE`
+
+`FORMAT` is one of:
+
+* `ln` left justified, no leading zeros
+* `rn` right justified, no leading zeros
+* `rz` right justified, leading zeros
diff --git a/src/uu/nl/src/helper.rs b/src/uu/nl/src/helper.rs
index fa59d329aad230ea35bf84afca5644f575da5975..3e5a96b9ca2f9627d1b33bd3ad3cbbeca0e7e8e1 100644
--- a/src/uu/nl/src/helper.rs
+++ b/src/uu/nl/src/helper.rs
@@ -1,146 +1,80 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) conv
use crate::options;
-// parse_style parses a style string into a NumberingStyle.
-fn parse_style(chars: &[char]) -> Result<crate::NumberingStyle, String> {
- if chars.len() == 1 && chars[0] == 'a' {
- Ok(crate::NumberingStyle::NumberForAll)
- } else if chars.len() == 1 && chars[0] == 't' {
- Ok(crate::NumberingStyle::NumberForNonEmpty)
- } else if chars.len() == 1 && chars[0] == 'n' {
- Ok(crate::NumberingStyle::NumberForNone)
- } else if chars.len() > 1 && chars[0] == 'p' {
- let s: String = chars[1..].iter().cloned().collect();
- match regex::Regex::new(&s) {
- Ok(re) => Ok(crate::NumberingStyle::NumberForRegularExpression(Box::new(
- re,
- ))),
- Err(_) => Err(String::from("Illegal regular expression")),
- }
- } else {
- Err(String::from("Illegal style encountered"))
- }
-}
-
// parse_options loads the options into the settings, returning an array of
// error messages.
+#[allow(clippy::cognitive_complexity)]
pub fn parse_options(settings: &mut crate::Settings, opts: &clap::ArgMatches) -> Vec<String> {
// This vector holds error messages encountered.
let mut errs: Vec<String> = vec![];
- settings.renumber = !opts.contains_id(options::NO_RENUMBER);
- match opts.get_one::<String>(options::NUMBER_SEPARATOR) {
- None => {}
- Some(val) => {
- settings.number_separator = val.to_owned();
- }
+ settings.renumber = opts.get_flag(options::NO_RENUMBER);
+ if let Some(delimiter) = opts.get_one::<String>(options::SECTION_DELIMITER) {
+ // check whether the delimiter is a single ASCII char (1 byte)
+ // because GNU nl doesn't add a ':' to single non-ASCII chars
+ settings.section_delimiter = if delimiter.len() == 1 {
+ format!("{delimiter}:")
+ } else {
+ delimiter.clone()
+ };
}
- match opts.get_one::<String>(options::NUMBER_FORMAT) {
- None => {}
- Some(val) => match val.as_str() {
- "ln" => {
- settings.number_format = crate::NumberFormat::Left;
- }
- "rn" => {
- settings.number_format = crate::NumberFormat::Right;
- }
- "rz" => {
- settings.number_format = crate::NumberFormat::RightZero;
- }
- _ => {
- errs.push(String::from("Illegal value for -n"));
- }
- },
+ if let Some(val) = opts.get_one::<String>(options::NUMBER_SEPARATOR) {
+ settings.number_separator.clone_from(val);
}
- match opts.get_one::<String>(options::BODY_NUMBERING) {
+ settings.number_format = opts
+ .get_one::<String>(options::NUMBER_FORMAT)
+ .map(Into::into)
+ .unwrap_or_default();
+ match opts
+ .get_one::<String>(options::HEADER_NUMBERING)
+ .map(String::as_str)
+ .map(TryInto::try_into)
+ {
None => {}
- Some(val) => {
- let chars: Vec<char> = val.chars().collect();
- match parse_style(&chars) {
- Ok(s) => {
- settings.body_numbering = s;
- }
- Err(message) => {
- errs.push(message);
- }
- }
- }
+ Some(Ok(style)) => settings.header_numbering = style,
+ Some(Err(message)) => errs.push(message),
}
- match opts.get_one::<String>(options::FOOTER_NUMBERING) {
+ match opts
+ .get_one::<String>(options::BODY_NUMBERING)
+ .map(String::as_str)
+ .map(TryInto::try_into)
+ {
None => {}
- Some(val) => {
- let chars: Vec<char> = val.chars().collect();
- match parse_style(&chars) {
- Ok(s) => {
- settings.footer_numbering = s;
- }
- Err(message) => {
- errs.push(message);
- }
- }
- }
+ Some(Ok(style)) => settings.body_numbering = style,
+ Some(Err(message)) => errs.push(message),
}
- match opts.get_one::<String>(options::HEADER_NUMBERING) {
+ match opts
+ .get_one::<String>(options::FOOTER_NUMBERING)
+ .map(String::as_str)
+ .map(TryInto::try_into)
+ {
None => {}
- Some(val) => {
- let chars: Vec<char> = val.chars().collect();
- match parse_style(&chars) {
- Ok(s) => {
- settings.header_numbering = s;
- }
- Err(message) => {
- errs.push(message);
- }
- }
- }
+ Some(Ok(style)) => settings.footer_numbering = style,
+ Some(Err(message)) => errs.push(message),
}
- match opts.get_one::<String>(options::LINE_INCREMENT) {
+ match opts.get_one::<usize>(options::NUMBER_WIDTH) {
None => {}
- Some(val) => {
- let conv: Option<u64> = val.parse().ok();
- match conv {
- None => {
- errs.push(String::from("Illegal value for -i"));
- }
- Some(num) => settings.line_increment = num,
- }
- }
+ Some(num) if *num > 0 => settings.number_width = *num,
+ Some(_) => errs.push(String::from(
+ "Invalid line number field width: ‘0’: Numerical result out of range",
+ )),
}
- match opts.get_one::<String>(options::NUMBER_WIDTH) {
+ match opts.get_one::<u64>(options::JOIN_BLANK_LINES) {
None => {}
- Some(val) => {
- let conv: Option<usize> = val.parse().ok();
- match conv {
- None => {
- errs.push(String::from("Illegal value for -w"));
- }
- Some(num) => settings.number_width = num,
- }
- }
+ Some(num) if *num > 0 => settings.join_blank_lines = *num,
+ Some(_) => errs.push(String::from(
+ "Invalid line number of blank lines: ‘0’: Numerical result out of range",
+ )),
}
- match opts.get_one::<String>(options::STARTING_LINE_NUMBER) {
- None => {}
- Some(val) => {
- let conv: Option<u64> = val.parse().ok();
- match conv {
- None => {
- errs.push(String::from("Illegal value for -v"));
- }
- Some(num) => settings.starting_line_number = num,
- }
- }
+ if let Some(num) = opts.get_one::<i64>(options::LINE_INCREMENT) {
+ settings.line_increment = *num;
}
- match opts.get_one::<String>(options::JOIN_BLANK_LINES) {
- None => {}
- Some(val) => {
- let conv: Option<u64> = val.parse().ok();
- match conv {
- None => {
- errs.push(String::from("Illegal value for -l"));
- }
- Some(num) => settings.join_blank_lines = num,
- }
- }
+ if let Some(num) = opts.get_one::<i64>(options::STARTING_LINE_NUMBER) {
+ settings.starting_line_number = *num;
}
errs
}
diff --git a/src/uu/nl/src/nl.rs b/src/uu/nl/src/nl.rs
index a93dc12ef454505cb6b38b1e93fa8c205ca53d5e..c7e72f6e2e2ad020ac59b3c1e0480fc024d56735 100644
--- a/src/uu/nl/src/nl.rs
+++ b/src/uu/nl/src/nl.rs
@@ -1,25 +1,20 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Tobias Bohumir Schottdorf <tobias.schottdorf@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
-// *
-
-// spell-checker:ignore (ToDO) corasick memchr
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use clap::{crate_version, Arg, ArgAction, Command};
use std::fs::File;
use std::io::{stdin, BufRead, BufReader, Read};
-use std::iter::repeat;
use std::path::Path;
-use uucore::error::{FromIo, UResult, USimpleError};
-use uucore::format_usage;
+use uucore::error::{set_exit_code, FromIo, UResult, USimpleError};
+use uucore::{format_usage, help_about, help_section, help_usage, show_error};
mod helper;
-static ABOUT: &str = "number lines of files";
-static USAGE: &str = "{} [OPTION]... [FILE]...";
+const ABOUT: &str = help_about!("nl.md");
+const AFTER_HELP: &str = help_section!("after help", "nl.md");
+const USAGE: &str = help_usage!("nl.md");
// Settings store options used by nl to produce its output.
pub struct Settings {
@@ -28,10 +23,10 @@ pub struct Settings {
body_numbering: NumberingStyle,
footer_numbering: NumberingStyle,
// The variable corresponding to -d
- section_delimiter: [char; 2],
+ section_delimiter: String,
// The variables corresponding to the options -v, -i, -l, -w.
- starting_line_number: u64,
- line_increment: u64,
+ starting_line_number: i64,
+ line_increment: i64,
join_blank_lines: u64,
number_width: usize, // Used with String::from_char, hence usize.
// The format of the number and the (default value for)
@@ -42,29 +37,129 @@ pub struct Settings {
number_separator: String,
}
+impl Default for Settings {
+ fn default() -> Self {
+ Self {
+ header_numbering: NumberingStyle::None,
+ body_numbering: NumberingStyle::NonEmpty,
+ footer_numbering: NumberingStyle::None,
+ section_delimiter: String::from("\\:"),
+ starting_line_number: 1,
+ line_increment: 1,
+ join_blank_lines: 1,
+ number_width: 6,
+ number_format: NumberFormat::Right,
+ renumber: true,
+ number_separator: String::from("\t"),
+ }
+ }
+}
+
+struct Stats {
+ line_number: Option<i64>,
+ consecutive_empty_lines: u64,
+}
+
+impl Stats {
+ fn new(starting_line_number: i64) -> Self {
+ Self {
+ line_number: Some(starting_line_number),
+ consecutive_empty_lines: 0,
+ }
+ }
+}
+
// NumberingStyle stores which lines are to be numbered.
// The possible options are:
// 1. Number all lines
// 2. Number only nonempty lines
// 3. Don't number any lines at all
// 4. Number all lines that match a basic regular expression.
-#[allow(clippy::enum_variant_names)]
enum NumberingStyle {
- NumberForAll,
- NumberForNonEmpty,
- NumberForNone,
- NumberForRegularExpression(Box<regex::Regex>),
+ All,
+ NonEmpty,
+ None,
+ Regex(Box<regex::Regex>),
+}
+
+impl TryFrom<&str> for NumberingStyle {
+ type Error = String;
+
+ fn try_from(s: &str) -> Result<Self, Self::Error> {
+ match s {
+ "a" => Ok(Self::All),
+ "t" => Ok(Self::NonEmpty),
+ "n" => Ok(Self::None),
+ _ if s.starts_with('p') => match regex::Regex::new(&s[1..]) {
+ Ok(re) => Ok(Self::Regex(Box::new(re))),
+ Err(_) => Err(String::from("invalid regular expression")),
+ },
+ _ => Err(format!("invalid numbering style: '{s}'")),
+ }
+ }
}
// NumberFormat specifies how line numbers are output within their allocated
// space. They are justified to the left or right, in the latter case with
// the option of having all unused space to its left turned into leading zeroes.
+#[derive(Default)]
enum NumberFormat {
Left,
+ #[default]
Right,
RightZero,
}
+impl<T: AsRef<str>> From<T> for NumberFormat {
+ fn from(s: T) -> Self {
+ match s.as_ref() {
+ "ln" => Self::Left,
+ "rn" => Self::Right,
+ "rz" => Self::RightZero,
+ _ => unreachable!("Should have been caught by clap"),
+ }
+ }
+}
+
+impl NumberFormat {
+ // Turns a line number into a `String` with at least `min_width` chars,
+ // formatted according to the `NumberFormat`s variant.
+ fn format(&self, number: i64, min_width: usize) -> String {
+ match self {
+ Self::Left => format!("{number:<min_width$}"),
+ Self::Right => format!("{number:>min_width$}"),
+ Self::RightZero if number < 0 => format!("-{0:0>1$}", number.abs(), min_width - 1),
+ Self::RightZero => format!("{number:0>min_width$}"),
+ }
+ }
+}
+
+enum SectionDelimiter {
+ Header,
+ Body,
+ Footer,
+}
+
+impl SectionDelimiter {
+ // A valid section delimiter contains the pattern one to three times,
+ // and nothing else.
+ fn parse(s: &str, pattern: &str) -> Option<Self> {
+ if s.is_empty() || pattern.is_empty() {
+ return None;
+ }
+
+ let pattern_count = s.matches(pattern).count();
+ let is_length_ok = pattern_count * pattern.len() == s.len();
+
+ match (pattern_count, is_length_ok) {
+ (3, true) => Some(Self::Header),
+ (2, true) => Some(Self::Body),
+ (1, true) => Some(Self::Footer),
+ _ => None,
+ }
+ }
+}
+
pub mod options {
pub const HELP: &str = "help";
pub const FILE: &str = "file";
@@ -83,24 +178,9 @@ pub mod options {
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_lossy();
-
let matches = uu_app().try_get_matches_from(args)?;
- // A mutable settings object, initialized with the defaults.
- let mut settings = Settings {
- header_numbering: NumberingStyle::NumberForNone,
- body_numbering: NumberingStyle::NumberForAll,
- footer_numbering: NumberingStyle::NumberForNone,
- section_delimiter: ['\\', ':'],
- starting_line_number: 1,
- line_increment: 1,
- join_blank_lines: 1,
- number_width: 6,
- number_format: NumberFormat::Right,
- renumber: true,
- number_separator: String::from("\t"),
- };
+ let mut settings = Settings::default();
// Update the settings from the command line options, and terminate the
// program if some options could not successfully be parsed.
@@ -112,29 +192,31 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
));
}
- let mut read_stdin = false;
let files: Vec<String> = match matches.get_many::<String>(options::FILE) {
- Some(v) => v.clone().map(|v| v.to_owned()).collect(),
+ Some(v) => v.cloned().collect(),
None => vec!["-".to_owned()],
};
+ let mut stats = Stats::new(settings.starting_line_number);
+
for file in &files {
if file == "-" {
- // If both file names and '-' are specified, we choose to treat first all
- // regular files, and then read from stdin last.
- read_stdin = true;
- continue;
+ let mut buffer = BufReader::new(stdin());
+ nl(&mut buffer, &mut stats, &settings)?;
+ } else {
+ let path = Path::new(file);
+
+ if path.is_dir() {
+ show_error!("{}: Is a directory", path.display());
+ set_exit_code(1);
+ } else {
+ let reader = File::open(path).map_err_context(|| file.to_string())?;
+ let mut buffer = BufReader::new(reader);
+ nl(&mut buffer, &mut stats, &settings)?;
+ }
}
- let path = Path::new(file);
- let reader = File::open(path).map_err_context(|| file.to_string())?;
- let mut buffer = BufReader::new(reader);
- nl(&mut buffer, &settings)?;
}
- if read_stdin {
- let mut buffer = BufReader::new(stdin());
- nl(&mut buffer, &settings)?;
- }
Ok(())
}
@@ -143,6 +225,7 @@ pub fn uu_app() -> Command {
.about(ABOUT)
.version(crate_version!())
.override_usage(format_usage(USAGE))
+ .after_help(AFTER_HELP)
.infer_long_args(true)
.disable_help_flag(true)
.arg(
@@ -162,7 +245,7 @@ pub fn uu_app() -> Command {
.short('b')
.long(options::BODY_NUMBERING)
.help("use STYLE for numbering body lines")
- .value_name("SYNTAX"),
+ .value_name("STYLE"),
)
.arg(
Arg::new(options::SECTION_DELIMITER)
@@ -190,27 +273,31 @@ pub fn uu_app() -> Command {
.short('i')
.long(options::LINE_INCREMENT)
.help("line number increment at each line")
- .value_name("NUMBER"),
+ .value_name("NUMBER")
+ .value_parser(clap::value_parser!(i64)),
)
.arg(
Arg::new(options::JOIN_BLANK_LINES)
.short('l')
.long(options::JOIN_BLANK_LINES)
.help("group of NUMBER empty lines counted as one")
- .value_name("NUMBER"),
+ .value_name("NUMBER")
+ .value_parser(clap::value_parser!(u64)),
)
.arg(
Arg::new(options::NUMBER_FORMAT)
.short('n')
.long(options::NUMBER_FORMAT)
.help("insert line numbers according to FORMAT")
- .value_name("FORMAT"),
+ .value_name("FORMAT")
+ .value_parser(["ln", "rn", "rz"]),
)
.arg(
Arg::new(options::NO_RENUMBER)
.short('p')
.long(options::NO_RENUMBER)
- .help("do not reset line numbers at logical pages"),
+ .help("do not reset line numbers at logical pages")
+ .action(ArgAction::SetFalse),
)
.arg(
Arg::new(options::NUMBER_SEPARATOR)
@@ -224,179 +311,108 @@ pub fn uu_app() -> Command {
.short('v')
.long(options::STARTING_LINE_NUMBER)
.help("first line number on each logical page")
- .value_name("NUMBER"),
+ .value_name("NUMBER")
+ .value_parser(clap::value_parser!(i64)),
)
.arg(
Arg::new(options::NUMBER_WIDTH)
.short('w')
.long(options::NUMBER_WIDTH)
.help("use NUMBER columns for line numbers")
- .value_name("NUMBER"),
+ .value_name("NUMBER")
+ .value_parser(clap::value_parser!(usize)),
)
}
// nl implements the main functionality for an individual buffer.
-fn nl<T: Read>(reader: &mut BufReader<T>, settings: &Settings) -> UResult<()> {
- let regexp: regex::Regex = regex::Regex::new(r".?").unwrap();
- let mut line_no = settings.starting_line_number;
- // The current line number's width as a string. Using to_string is inefficient
- // but since we only do it once, it should not hurt.
- let mut line_no_width = line_no.to_string().len();
- let line_no_width_initial = line_no_width;
- // Stores the smallest integer with one more digit than line_no, so that
- // when line_no >= line_no_threshold, we need to use one more digit.
- let mut line_no_threshold = 10u64.pow(line_no_width as u32);
- let mut empty_line_count: u64 = 0;
- let fill_char = match settings.number_format {
- NumberFormat::RightZero => '0',
- _ => ' ',
- };
- // Initially, we use the body's line counting settings
- let mut regex_filter = match settings.body_numbering {
- NumberingStyle::NumberForRegularExpression(ref re) => re,
- _ => ®exp,
- };
- let mut line_filter: fn(&str, ®ex::Regex) -> bool = pass_regex;
- for l in reader.lines() {
- let mut l = l.map_err_context(|| "could not read line".to_string())?;
- // Sanitize the string. We want to print the newline ourselves.
- if l.ends_with('\n') {
- l.pop();
- }
- // Next we iterate through the individual chars to see if this
- // is one of the special lines starting a new "section" in the
- // document.
- let line = l;
- let mut odd = false;
- // matched_group counts how many copies of section_delimiter
- // this string consists of (0 if there's anything else)
- let mut matched_groups = 0u8;
- for c in line.chars() {
- // If this is a newline character, the loop should end.
- if c == '\n' {
- break;
- }
- // If we have already seen three groups (corresponding to
- // a header) or the current char does not form part of
- // a new group, then this line is not a segment indicator.
- if matched_groups >= 3 || settings.section_delimiter[usize::from(odd)] != c {
- matched_groups = 0;
- break;
- }
- if odd {
- // We have seen a new group and count it.
- matched_groups += 1;
- }
- odd = !odd;
- }
+fn nl<T: Read>(reader: &mut BufReader<T>, stats: &mut Stats, settings: &Settings) -> UResult<()> {
+ let mut current_numbering_style = &settings.body_numbering;
+
+ for line in reader.lines() {
+ let line = line.map_err_context(|| "could not read line".to_string())?;
- // See how many groups we matched. That will tell us if this is
- // a line starting a new segment, and the number of groups
- // indicates what type of segment.
- if matched_groups > 0 {
- // The current line is a section delimiter, so we output
- // a blank line.
- println!();
- // However the line does not count as a blank line, so we
- // reset the counter used for --join-blank-lines.
- empty_line_count = 0;
- match *match matched_groups {
- 3 => {
- // This is a header, so we may need to reset the
- // line number and the line width
- if settings.renumber {
- line_no = settings.starting_line_number;
- line_no_width = line_no_width_initial;
- line_no_threshold = 10u64.pow(line_no_width as u32);
- }
- &settings.header_numbering
- }
- 1 => &settings.footer_numbering,
- // The only option left is 2, but rust wants
- // a catch-all here.
- _ => &settings.body_numbering,
- } {
- NumberingStyle::NumberForAll => {
- line_filter = pass_all;
- }
- NumberingStyle::NumberForNonEmpty => {
- line_filter = pass_nonempty;
- }
- NumberingStyle::NumberForNone => {
- line_filter = pass_none;
- }
- NumberingStyle::NumberForRegularExpression(ref re) => {
- line_filter = pass_regex;
- regex_filter = re;
- }
- }
- continue;
- }
- // From this point on we format and print a "regular" line.
if line.is_empty() {
- // The line is empty, which means that we have to care
- // about the --join-blank-lines parameter.
- empty_line_count += 1;
+ stats.consecutive_empty_lines += 1;
} else {
- // This saves us from having to check for an empty string
- // in the next selector.
- empty_line_count = 0;
- }
- if !line_filter(&line, regex_filter)
- || (empty_line_count > 0 && empty_line_count < settings.join_blank_lines)
+ stats.consecutive_empty_lines = 0;
+ };
+
+ let new_numbering_style = match SectionDelimiter::parse(&line, &settings.section_delimiter)
{
- // No number is printed for this line. Either we did not
- // want to print one in the first place, or it is a blank
- // line but we are still collecting more blank lines via
- // the option --join-blank-lines.
- println!("{}", line);
- continue;
- }
- // If we make it here, then either we are printing a non-empty
- // line or assigning a line number to an empty line. Either
- // way, start counting empties from zero once more.
- empty_line_count = 0;
- // A line number is to be printed.
- let w = if settings.number_width > line_no_width {
- settings.number_width - line_no_width
- } else {
- 0
+ Some(SectionDelimiter::Header) => Some(&settings.header_numbering),
+ Some(SectionDelimiter::Body) => Some(&settings.body_numbering),
+ Some(SectionDelimiter::Footer) => Some(&settings.footer_numbering),
+ None => None,
};
- let fill: String = repeat(fill_char).take(w).collect();
- match settings.number_format {
- NumberFormat::Left => println!(
- "{1}{0}{2}{3}",
- fill, line_no, settings.number_separator, line
- ),
- _ => println!(
- "{0}{1}{2}{3}",
- fill, line_no, settings.number_separator, line
- ),
- }
- // Now update the variables for the (potential) next
- // line.
- line_no += settings.line_increment;
- while line_no >= line_no_threshold {
- // The line number just got longer.
- line_no_threshold *= 10;
- line_no_width += 1;
+
+ if let Some(new_style) = new_numbering_style {
+ current_numbering_style = new_style;
+ if settings.renumber {
+ stats.line_number = Some(settings.starting_line_number);
+ }
+ println!();
+ } else {
+ let is_line_numbered = match current_numbering_style {
+ // consider $join_blank_lines consecutive empty lines to be one logical line
+ // for numbering, and only number the last one
+ NumberingStyle::All
+ if line.is_empty()
+ && stats.consecutive_empty_lines % settings.join_blank_lines != 0 =>
+ {
+ false
+ }
+ NumberingStyle::All => true,
+ NumberingStyle::NonEmpty => !line.is_empty(),
+ NumberingStyle::None => false,
+ NumberingStyle::Regex(re) => re.is_match(&line),
+ };
+
+ if is_line_numbered {
+ let Some(line_number) = stats.line_number else {
+ return Err(USimpleError::new(1, "line number overflow"));
+ };
+ println!(
+ "{}{}{}",
+ settings
+ .number_format
+ .format(line_number, settings.number_width),
+ settings.number_separator,
+ line
+ );
+ // update line number for the potential next line
+ match line_number.checked_add(settings.line_increment) {
+ Some(new_line_number) => stats.line_number = Some(new_line_number),
+ None => stats.line_number = None, // overflow
+ }
+ } else {
+ let spaces = " ".repeat(settings.number_width + 1);
+ println!("{spaces}{line}");
+ }
}
}
Ok(())
}
-fn pass_regex(line: &str, re: ®ex::Regex) -> bool {
- re.is_match(line)
-}
+#[cfg(test)]
+mod test {
+ use super::*;
-fn pass_nonempty(line: &str, _: ®ex::Regex) -> bool {
- !line.is_empty()
-}
+ #[test]
+ #[allow(clippy::cognitive_complexity)]
+ fn test_format() {
+ assert_eq!(NumberFormat::Left.format(12, 1), "12");
+ assert_eq!(NumberFormat::Left.format(-12, 1), "-12");
+ assert_eq!(NumberFormat::Left.format(12, 4), "12 ");
+ assert_eq!(NumberFormat::Left.format(-12, 4), "-12 ");
-fn pass_none(_: &str, _: ®ex::Regex) -> bool {
- false
-}
+ assert_eq!(NumberFormat::Right.format(12, 1), "12");
+ assert_eq!(NumberFormat::Right.format(-12, 1), "-12");
+ assert_eq!(NumberFormat::Right.format(12, 4), " 12");
+ assert_eq!(NumberFormat::Right.format(-12, 4), " -12");
-fn pass_all(_: &str, _: ®ex::Regex) -> bool {
- true
+ assert_eq!(NumberFormat::RightZero.format(12, 1), "12");
+ assert_eq!(NumberFormat::RightZero.format(-12, 1), "-12");
+ assert_eq!(NumberFormat::RightZero.format(12, 4), "0012");
+ assert_eq!(NumberFormat::RightZero.format(-12, 4), "-012");
+ }
}
diff --git a/src/uu/nohup/Cargo.toml b/src/uu/nohup/Cargo.toml
index 4ad4952454164d74968223bcf1c3332c7ddabd1c..115a80345b9e5576d37d8f6966006564a0e45279 100644
--- a/src/uu/nohup/Cargo.toml
+++ b/src/uu/nohup/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_nohup"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "nohup ~ (uutils) run COMMAND, ignoring hangup signals"
@@ -15,10 +15,9 @@ edition = "2021"
path = "src/nohup.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-libc = "0.2.137"
-atty = "0.2"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["fs"] }
+clap = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true, features = ["fs"] }
[[bin]]
name = "nohup"
diff --git a/src/uu/nohup/nohup.md b/src/uu/nohup/nohup.md
new file mode 100644
index 0000000000000000000000000000000000000000..65ffaec873da7dde227738db98795bdee40d007b
--- /dev/null
+++ b/src/uu/nohup/nohup.md
@@ -0,0 +1,15 @@
+# nohup
+
+```
+nohup COMMAND [ARG]...
+nohup OPTION
+```
+
+Run COMMAND ignoring hangup signals.
+
+## After Help
+
+If standard input is terminal, it'll be replaced with /dev/null.
+If standard output is terminal, it'll be appended to nohup.out instead,
+or $HOME/nohup.out, if nohup.out open failed.
+If standard error is terminal, it'll be redirected to stdout.
diff --git a/src/uu/nohup/src/nohup.rs b/src/uu/nohup/src/nohup.rs
index 1dc1cbdd0108644a14551180010ea8ecdc0ed1a4..48651834233172da38a6e29fb42724af558948e1 100644
--- a/src/uu/nohup/src/nohup.rs
+++ b/src/uu/nohup/src/nohup.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) 2014 Vsevolod Velichko <torkvemada@sorokdva.net>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) execvp SIGHUP cproc vprocmgr cstrs homeout
@@ -14,23 +12,16 @@ use std::env;
use std::ffi::CString;
use std::fmt::{Display, Formatter};
use std::fs::{File, OpenOptions};
-use std::io::Error;
+use std::io::{Error, IsTerminal};
use std::os::unix::prelude::*;
use std::path::{Path, PathBuf};
use uucore::display::Quotable;
use uucore::error::{set_exit_code, UClapError, UError, UResult};
-use uucore::{format_usage, show_error};
-
-static ABOUT: &str = "Run COMMAND ignoring hangup signals.";
-static LONG_HELP: &str = "
-If standard input is terminal, it'll be replaced with /dev/null.
-If standard output is terminal, it'll be appended to nohup.out instead,
-or $HOME/nohup.out, if nohup.out open failed.
-If standard error is terminal, it'll be redirected to stdout.
-";
-const USAGE: &str = "\
- {} COMMAND [ARG]...
- {} FLAG";
+use uucore::{format_usage, help_about, help_section, help_usage, show_error};
+
+const ABOUT: &str = help_about!("nohup.md");
+const AFTER_HELP: &str = help_section!("after help", "nohup.md");
+const USAGE: &str = help_usage!("nohup.md");
static NOHUP_OUT: &str = "nohup.out";
// exit codes that match the GNU implementation
static EXIT_CANCELED: i32 = 125;
@@ -65,7 +56,7 @@ impl Display for NohupError {
fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
match self {
Self::CannotDetach => write!(f, "Cannot detach from console"),
- Self::CannotReplace(s, e) => write!(f, "Cannot replace {}: {}", s, e),
+ Self::CannotReplace(s, e) => write!(f, "Cannot replace {s}: {e}"),
Self::OpenFailed(_, e) => {
write!(f, "failed to open {}: {}", NOHUP_OUT.quote(), e)
}
@@ -83,8 +74,6 @@ impl Display for NohupError {
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_lossy();
-
let matches = uu_app().try_get_matches_from(args).with_exit_code(125)?;
replace_fds()?;
@@ -115,7 +104,7 @@ pub fn uu_app() -> Command {
Command::new(uucore::util_name())
.version(crate_version!())
.about(ABOUT)
- .after_help(LONG_HELP)
+ .after_help(AFTER_HELP)
.override_usage(format_usage(USAGE))
.arg(
Arg::new(options::CMD)
@@ -129,7 +118,7 @@ pub fn uu_app() -> Command {
}
fn replace_fds() -> UResult<()> {
- if atty::is(atty::Stream::Stdin) {
+ if std::io::stdin().is_terminal() {
let new_stdin = File::open(Path::new("/dev/null"))
.map_err(|e| NohupError::CannotReplace("STDIN", e))?;
if unsafe { dup2(new_stdin.as_raw_fd(), 0) } != 0 {
@@ -137,7 +126,7 @@ fn replace_fds() -> UResult<()> {
}
}
- if atty::is(atty::Stream::Stdout) {
+ if std::io::stdout().is_terminal() {
let new_stdout = find_stdout()?;
let fd = new_stdout.as_raw_fd();
@@ -146,7 +135,7 @@ fn replace_fds() -> UResult<()> {
}
}
- if atty::is(atty::Stream::Stderr) && unsafe { dup2(1, 2) } != 2 {
+ if std::io::stderr().is_terminal() && unsafe { dup2(1, 2) } != 2 {
return Err(NohupError::CannotReplace("STDERR", Error::last_os_error()).into());
}
Ok(())
@@ -159,7 +148,6 @@ fn find_stdout() -> UResult<File> {
};
match OpenOptions::new()
- .write(true)
.create(true)
.append(true)
.open(Path::new(NOHUP_OUT))
@@ -179,12 +167,7 @@ fn find_stdout() -> UResult<File> {
let mut homeout = PathBuf::from(home);
homeout.push(NOHUP_OUT);
let homeout_str = homeout.to_str().unwrap();
- match OpenOptions::new()
- .write(true)
- .create(true)
- .append(true)
- .open(&homeout)
- {
+ match OpenOptions::new().create(true).append(true).open(&homeout) {
Ok(t) => {
show_error!(
"ignoring input and appending output to {}",
@@ -209,7 +192,12 @@ extern "C" {
fn _vprocmgr_detach_from_console(flags: u32) -> *const libc::c_int;
}
-#[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd"))]
+#[cfg(any(
+ target_os = "linux",
+ target_os = "android",
+ target_os = "freebsd",
+ target_os = "openbsd"
+))]
unsafe fn _vprocmgr_detach_from_console(_: u32) -> *const libc::c_int {
std::ptr::null()
}
diff --git a/src/uu/nproc/Cargo.toml b/src/uu/nproc/Cargo.toml
index c720990b4308cd8e888040600dbcd34051080247..6e26e9536040e1dc1f30879c32637031602ddb87 100644
--- a/src/uu/nproc/Cargo.toml
+++ b/src/uu/nproc/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_nproc"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "nproc ~ (uutils) display the number of processing units available"
@@ -15,10 +15,9 @@ edition = "2021"
path = "src/nproc.rs"
[dependencies]
-libc = "0.2.137"
-num_cpus = "1.14"
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["fs"] }
+libc = { workspace = true }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["fs"] }
[[bin]]
name = "nproc"
diff --git a/src/uu/nproc/nproc.md b/src/uu/nproc/nproc.md
new file mode 100644
index 0000000000000000000000000000000000000000..fee958a92fcdab7bd07c3d3937c7b656e72737d1
--- /dev/null
+++ b/src/uu/nproc/nproc.md
@@ -0,0 +1,9 @@
+# nproc
+
+```
+nproc [OPTIONS]...
+```
+
+Print the number of cores available to the current process.
+If the `OMP_NUM_THREADS` or `OMP_THREAD_LIMIT` environment variables are set, then
+they will determine the minimum and maximum returned value respectively.
diff --git a/src/uu/nproc/src/nproc.rs b/src/uu/nproc/src/nproc.rs
index e74303dd888e496f50f31046bd701ff1b4d48e77..d0bd3083d77fe783518f45b9e7fa8de39d6e3ee2 100644
--- a/src/uu/nproc/src/nproc.rs
+++ b/src/uu/nproc/src/nproc.rs
@@ -1,17 +1,15 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Michael Gehring <mg@ebfe.org>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) NPROCESSORS nprocs numstr threadstr sysconf
use clap::{crate_version, Arg, ArgAction, Command};
-use std::env;
+use std::{env, thread};
use uucore::display::Quotable;
use uucore::error::{UResult, USimpleError};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
#[cfg(any(target_os = "linux", target_os = "android"))]
pub const _SC_NPROCESSORS_CONF: libc::c_int = 83;
@@ -25,10 +23,8 @@ pub const _SC_NPROCESSORS_CONF: libc::c_int = 1001;
static OPT_ALL: &str = "all";
static OPT_IGNORE: &str = "ignore";
-static ABOUT: &str = r#"Print the number of cores available to the current process.
-If the OMP_NUM_THREADS or OMP_THREAD_LIMIT environment variables are set, then
-they will determine the minimum and maximum returned value respectively."#;
-const USAGE: &str = "{} [OPTIONS]...";
+const ABOUT: &str = help_about!("nproc.md");
+const USAGE: &str = help_usage!("nproc.md");
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
@@ -73,16 +69,16 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
// If OMP_NUM_THREADS=0, rejects the value
let thread: Vec<&str> = threadstr.split_terminator(',').collect();
match &thread[..] {
- [] => num_cpus::get(),
+ [] => available_parallelism(),
[s, ..] => match s.parse() {
- Ok(0) | Err(_) => num_cpus::get(),
+ Ok(0) | Err(_) => available_parallelism(),
Ok(n) => n,
},
}
}
// the variable 'OMP_NUM_THREADS' doesn't exist
// fallback to the regular CPU detection
- Err(_) => num_cpus::get(),
+ Err(_) => available_parallelism(),
}
};
@@ -92,7 +88,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
} else {
cores -= ignore;
}
- println!("{}", cores);
+ println!("{cores}");
Ok(())
}
@@ -127,7 +123,7 @@ fn num_cpus_all() -> usize {
if nprocs == 1 {
// In some situation, /proc and /sys are not mounted, and sysconf returns 1.
// However, we want to guarantee that `nproc --all` >= `nproc`.
- num_cpus::get()
+ available_parallelism()
} else if nprocs > 0 {
nprocs as usize
} else {
@@ -135,7 +131,7 @@ fn num_cpus_all() -> usize {
}
}
-// Other platforms (e.g., windows), num_cpus::get() directly.
+// Other platforms (e.g., windows), available_parallelism() directly.
#[cfg(not(any(
target_os = "linux",
target_vendor = "apple",
@@ -143,5 +139,14 @@ fn num_cpus_all() -> usize {
target_os = "netbsd"
)))]
fn num_cpus_all() -> usize {
- num_cpus::get()
+ available_parallelism()
+}
+
+// In some cases, thread::available_parallelism() may return an Err
+// In this case, we will return 1 (like GNU)
+fn available_parallelism() -> usize {
+ match thread::available_parallelism() {
+ Ok(n) => n.get(),
+ Err(_) => 1,
+ }
}
diff --git a/src/uu/numfmt/Cargo.toml b/src/uu/numfmt/Cargo.toml
index c6358bd6fec34f3244625c648dd65aea0b130b7a..91dd9cadc8df1d2f2da70d824e0740a5e777fead 100644
--- a/src/uu/numfmt/Cargo.toml
+++ b/src/uu/numfmt/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_numfmt"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "numfmt ~ (uutils) reformat NUMBER"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/numfmt.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["ranges"] }
[[bin]]
name = "numfmt"
diff --git a/src/uu/numfmt/numfmt.md b/src/uu/numfmt/numfmt.md
index 3216d6eb7ccb4e230f79c40b9169605f94727023..7c75736c1155e9d3f180b333abcd73ec1f6c7458 100644
--- a/src/uu/numfmt/numfmt.md
+++ b/src/uu/numfmt/numfmt.md
@@ -1,36 +1,35 @@
-<!-- spell-checker:ignore N'th M'th -->
# numfmt
-## Usage
+<!-- spell-checker:ignore N'th M'th -->
+
```
numfmt [OPTION]... [NUMBER]...
```
-## About
-
Convert numbers from/to human-readable strings
## After Help
`UNIT` options:
- - `none`: no auto-scaling is done; suffixes will trigger an error
- - `auto`: accept optional single/two letter suffix:
- 1K = 1000, 1Ki = 1024, 1M = 1000000, 1Mi = 1048576,
+- `none`: no auto-scaling is done; suffixes will trigger an error
+- `auto`: accept optional single/two letter suffix:
+
+ 1K = 1000, 1Ki = 1024, 1M = 1000000, 1Mi = 1048576,
- - `si`: accept optional single letter suffix:
+- `si`: accept optional single letter suffix:
- 1K = 1000, 1M = 1000000, ...
+ 1K = 1000, 1M = 1000000, ...
- - `iec`: accept optional single letter suffix:
+- `iec`: accept optional single letter suffix:
- 1K = 1024, 1M = 1048576, ...
+ 1K = 1024, 1M = 1048576, ...
- `iec-i`: accept optional two-letter suffix:
- 1Ki = 1024, 1Mi = 1048576, ...
+ 1Ki = 1024, 1Mi = 1048576, ...
-`FIELDS` supports `cut(1)` style field ranges:
+- `FIELDS` supports `cut(1)` style field ranges:
N N'th field, counted from 1
N- from N'th field, to end of line
diff --git a/src/uu/numfmt/src/errors.rs b/src/uu/numfmt/src/errors.rs
index c9f63f92168d85f02443d9dc5bbcc47870f1cf8f..77dd6f0aade69aa05058f51d75dbbf4587561d02 100644
--- a/src/uu/numfmt/src/errors.rs
+++ b/src/uu/numfmt/src/errors.rs
@@ -1,7 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::{
error::Error,
@@ -32,7 +32,7 @@ impl Display for NumfmtError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::IoError(s) | Self::IllegalArgument(s) | Self::FormattingError(s) => {
- write!(f, "{}", s)
+ write!(f, "{s}")
}
}
}
diff --git a/src/uu/numfmt/src/format.rs b/src/uu/numfmt/src/format.rs
index b97993f214cba926906063d7db950695efb50fee..5933092f62fbe0059454fd8b86e2c3ccbc0e1dc1 100644
--- a/src/uu/numfmt/src/format.rs
+++ b/src/uu/numfmt/src/format.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore powf
use uucore::display::Quotable;
@@ -49,13 +53,9 @@ impl<'a> Iterator for WhitespaceSplitter<'a> {
.unwrap_or(haystack.len()),
);
- let (field, rest) = field.split_at(
- field
- .find(|c: char| c.is_whitespace())
- .unwrap_or(field.len()),
- );
+ let (field, rest) = field.split_at(field.find(char::is_whitespace).unwrap_or(field.len()));
- self.s = if !rest.is_empty() { Some(rest) } else { None };
+ self.s = if rest.is_empty() { None } else { Some(rest) };
Some((prefix, field))
}
@@ -103,7 +103,7 @@ fn parse_implicit_precision(s: &str) -> usize {
match s.split_once('.') {
Some((_, decimal_part)) => decimal_part
.chars()
- .take_while(|c| c.is_ascii_digit())
+ .take_while(char::is_ascii_digit)
.count(),
None => 0,
}
@@ -135,13 +135,11 @@ fn remove_suffix(i: f64, s: Option<Suffix>, u: &Unit) -> Result<f64> {
RawSuffix::Z => Ok(i * IEC_BASES[7]),
RawSuffix::Y => Ok(i * IEC_BASES[8]),
},
- (None, &Unit::Iec(true)) => Err(format!(
- "missing 'i' suffix in input: '{}' (e.g Ki/Mi/Gi)",
- i
- )),
+ (None, &Unit::Iec(true)) => {
+ Err(format!("missing 'i' suffix in input: '{i}' (e.g Ki/Mi/Gi)"))
+ }
(Some((raw_suffix, false)), &Unit::Iec(true)) => Err(format!(
- "missing 'i' suffix in input: '{}{:?}' (e.g Ki/Mi/Gi)",
- i, raw_suffix
+ "missing 'i' suffix in input: '{i}{raw_suffix:?}' (e.g Ki/Mi/Gi)"
)),
(Some((raw_suffix, with_i)), &Unit::None) => Err(format!(
"rejecting suffix in input: '{}{:?}{}' (consider using --from)",
@@ -320,7 +318,7 @@ fn format_string(
// bring back the suffix before applying padding
let number_with_suffix = match &options.suffix {
- Some(suffix) => format!("{}{}", number, suffix),
+ Some(suffix) => format!("{number}{suffix}"),
None => number,
};
@@ -362,14 +360,14 @@ fn format_and_print_delimited(s: &str, options: &NumfmtOptions) -> Result<()> {
// print delimiter before second and subsequent fields
if n > 1 {
- print!("{}", delimiter);
+ print!("{delimiter}");
}
if field_selected {
print!("{}", format_string(field.trim_start(), options, None)?);
} else {
// print unselected field without conversion
- print!("{}", field);
+ print!("{field}");
}
}
@@ -402,7 +400,7 @@ fn format_and_print_whitespace(s: &str, options: &NumfmtOptions) -> Result<()> {
print!("{}", format_string(field, options, implicit_padding)?);
} else {
// print unselected field without conversion
- print!("{}{}", prefix, field);
+ print!("{prefix}{field}");
}
}
@@ -428,6 +426,7 @@ mod tests {
use super::*;
#[test]
+ #[allow(clippy::cognitive_complexity)]
fn test_round_with_precision() {
let rm = RoundMethod::FromZero;
assert_eq!(1.0, round_with_precision(0.12345, rm, 0));
diff --git a/src/uu/numfmt/src/numfmt.rs b/src/uu/numfmt/src/numfmt.rs
index 80b604e6db011ab85d2cfd71cae2d60fdd9c3aaf..42cdb1bad7aa125e9a1e02b5374d6955f6c044bc 100644
--- a/src/uu/numfmt/src/numfmt.rs
+++ b/src/uu/numfmt/src/numfmt.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Yury Krivopalov <ykrivopalov@yandex.ru>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use crate::errors::*;
use crate::format::format_and_print;
@@ -11,30 +9,28 @@ use crate::options::*;
use crate::units::{Result, Unit};
use clap::{crate_version, parser::ValueSource, Arg, ArgAction, ArgMatches, Command};
use std::io::{BufRead, Write};
+use std::str::FromStr;
+
use units::{IEC_BASES, SI_BASES};
use uucore::display::Quotable;
use uucore::error::UResult;
-use uucore::format_usage;
use uucore::ranges::Range;
-use uucore::{help_section, help_usage};
+use uucore::shortcut_value_parser::ShortcutValueParser;
+use uucore::{format_usage, help_about, help_section, help_usage, show, show_error};
pub mod errors;
pub mod format;
pub mod options;
mod units;
-const ABOUT: &str = help_section!("about", "numfmt.md");
+const ABOUT: &str = help_about!("numfmt.md");
const AFTER_HELP: &str = help_section!("after help", "numfmt.md");
const USAGE: &str = help_usage!("numfmt.md");
fn handle_args<'a>(args: impl Iterator<Item = &'a str>, options: &NumfmtOptions) -> UResult<()> {
for l in args {
- match format_and_print(l, options) {
- Ok(_) => Ok(()),
- Err(e) => Err(NumfmtError::FormattingError(e.to_string())),
- }?;
+ format_and_handle_validation(l, options)?;
}
-
Ok(())
}
@@ -42,23 +38,41 @@ fn handle_buffer<R>(input: R, options: &NumfmtOptions) -> UResult<()>
where
R: BufRead,
{
- let mut lines = input.lines();
- for (idx, line) in lines.by_ref().enumerate() {
- match line {
- Ok(l) if idx < options.header => {
- println!("{}", l);
+ for (idx, line_result) in input.lines().by_ref().enumerate() {
+ match line_result {
+ Ok(line) if idx < options.header => {
+ println!("{line}");
Ok(())
}
- Ok(l) => match format_and_print(&l, options) {
- Ok(_) => Ok(()),
- Err(e) => Err(NumfmtError::FormattingError(e.to_string())),
- },
- Err(e) => Err(NumfmtError::IoError(e.to_string())),
+ Ok(line) => format_and_handle_validation(line.as_ref(), options),
+ Err(err) => return Err(Box::new(NumfmtError::IoError(err.to_string()))),
}?;
}
Ok(())
}
+fn format_and_handle_validation(input_line: &str, options: &NumfmtOptions) -> UResult<()> {
+ let handled_line = format_and_print(input_line, options);
+
+ if let Err(error_message) = handled_line {
+ match options.invalid {
+ InvalidModes::Abort => {
+ return Err(Box::new(NumfmtError::FormattingError(error_message)));
+ }
+ InvalidModes::Fail => {
+ show!(NumfmtError::FormattingError(error_message));
+ }
+ InvalidModes::Warn => {
+ show_error!("{}", error_message);
+ }
+ InvalidModes::Ignore => {}
+ };
+ println!("{}", input_line);
+ }
+
+ Ok(())
+}
+
fn parse_unit(s: &str) -> Result<Unit> {
match s {
"auto" => Ok(Unit::Auto),
@@ -163,7 +177,7 @@ fn parse_options(args: &ArgMatches) -> Result<NumfmtOptions> {
let fields = if fields.split(&[',', ' ']).any(|x| x == "-") {
vec![Range {
low: 1,
- high: std::usize::MAX,
+ high: usize::MAX,
}]
} else {
Range::from_list(fields)?
@@ -198,9 +212,10 @@ fn parse_options(args: &ArgMatches) -> Result<NumfmtOptions> {
_ => unreachable!("Should be restricted by clap"),
};
- let suffix = args
- .get_one::<String>(options::SUFFIX)
- .map(|s| s.to_owned());
+ let suffix = args.get_one::<String>(options::SUFFIX).cloned();
+
+ let invalid =
+ InvalidModes::from_str(args.get_one::<String>(options::INVALID).unwrap()).unwrap();
Ok(NumfmtOptions {
transform,
@@ -211,32 +226,13 @@ fn parse_options(args: &ArgMatches) -> Result<NumfmtOptions> {
round,
suffix,
format,
+ invalid,
})
}
-// If the --format argument and its value are provided separately, they are concatenated to avoid a
-// potential clap error. For example: "--format --%f--" is changed to "--format=--%f--".
-fn concat_format_arg_and_value(args: &[String]) -> Vec<String> {
- let mut processed_args: Vec<String> = Vec::with_capacity(args.len());
- let mut iter = args.iter().peekable();
-
- while let Some(arg) = iter.next() {
- if arg == "--format" && iter.peek().is_some() {
- processed_args.push(format!("--format={}", iter.peek().unwrap()));
- iter.next();
- } else {
- processed_args.push(arg.to_string());
- }
- }
-
- processed_args
-}
-
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_ignore();
-
- let matches = uu_app().try_get_matches_from(concat_format_arg_and_value(&args))?;
+ let matches = uu_app().try_get_matches_from(args)?;
let options = parse_options(&matches).map_err(NumfmtError::IllegalArgument)?;
@@ -285,7 +281,8 @@ pub fn uu_app() -> Command {
Arg::new(options::FORMAT)
.long(options::FORMAT)
.help("use printf style floating-point FORMAT; see FORMAT below for details")
- .value_name("FORMAT"),
+ .value_name("FORMAT")
+ .allow_hyphen_values(true),
)
.arg(
Arg::new(options::FROM)
@@ -341,13 +338,16 @@ pub fn uu_app() -> Command {
.arg(
Arg::new(options::ROUND)
.long(options::ROUND)
- .help(
- "use METHOD for rounding when scaling; METHOD can be: up,\
- down, from-zero, towards-zero, nearest",
- )
+ .help("use METHOD for rounding when scaling")
.value_name("METHOD")
.default_value("from-zero")
- .value_parser(["up", "down", "from-zero", "towards-zero", "nearest"]),
+ .value_parser(ShortcutValueParser::new([
+ "up",
+ "down",
+ "from-zero",
+ "towards-zero",
+ "nearest",
+ ])),
)
.arg(
Arg::new(options::SUFFIX)
@@ -358,6 +358,14 @@ pub fn uu_app() -> Command {
)
.value_name("SUFFIX"),
)
+ .arg(
+ Arg::new(options::INVALID)
+ .long(options::INVALID)
+ .help("set the failure mode for invalid input")
+ .default_value("abort")
+ .value_parser(["abort", "fail", "warn", "ignore"])
+ .value_name("INVALID"),
+ )
.arg(
Arg::new(options::NUMBER)
.hide(true)
@@ -367,9 +375,11 @@ pub fn uu_app() -> Command {
#[cfg(test)]
mod tests {
+ use uucore::error::get_exit_code;
+
use super::{
- handle_buffer, parse_unit_size, parse_unit_size_suffix, FormatOptions, NumfmtOptions,
- Range, RoundMethod, TransformOptions, Unit,
+ handle_args, handle_buffer, parse_unit_size, parse_unit_size_suffix, FormatOptions,
+ InvalidModes, NumfmtOptions, Range, RoundMethod, TransformOptions, Unit,
};
use std::io::{BufReader, Error, ErrorKind, Read};
struct MockBuffer {}
@@ -395,6 +405,7 @@ mod tests {
round: RoundMethod::Nearest,
suffix: None,
format: FormatOptions::default(),
+ invalid: InvalidModes::Abort,
}
}
@@ -403,6 +414,20 @@ mod tests {
let mock_buffer = MockBuffer {};
let result = handle_buffer(BufReader::new(mock_buffer), &get_valid_options())
.expect_err("returned Ok after receiving IO error");
+ let result_debug = format!("{result:?}");
+ let result_display = format!("{result}");
+ assert_eq!(result_debug, "IoError(\"broken pipe\")");
+ assert_eq!(result_display, "broken pipe");
+ assert_eq!(result.code(), 1);
+ }
+
+ #[test]
+ fn broken_buffer_returns_io_error_after_header() {
+ let mock_buffer = MockBuffer {};
+ let mut options = get_valid_options();
+ options.header = 0;
+ let result = handle_buffer(BufReader::new(mock_buffer), &options)
+ .expect_err("returned Ok after receiving IO error");
let result_debug = format!("{:?}", result);
let result_display = format!("{}", result);
assert_eq!(result_debug, "IoError(\"broken pipe\")");
@@ -415,8 +440,8 @@ mod tests {
let input_value = b"135\nhello";
let result = handle_buffer(BufReader::new(&input_value[..]), &get_valid_options())
.expect_err("returned Ok after receiving improperly formatted input");
- let result_debug = format!("{:?}", result);
- let result_display = format!("{}", result);
+ let result_debug = format!("{result:?}");
+ let result_display = format!("{result}");
assert_eq!(
result_debug,
"FormattingError(\"invalid suffix in input: 'hello'\")"
@@ -432,6 +457,66 @@ mod tests {
assert!(result.is_ok(), "did not return Ok for valid input");
}
+ #[test]
+ fn warn_returns_ok_for_invalid_input() {
+ let input_value = b"5\n4Q\n";
+ let mut options = get_valid_options();
+ options.invalid = InvalidModes::Warn;
+ let result = handle_buffer(BufReader::new(&input_value[..]), &options);
+ assert!(result.is_ok(), "did not return Ok for invalid input");
+ }
+
+ #[test]
+ fn ignore_returns_ok_for_invalid_input() {
+ let input_value = b"5\n4Q\n";
+ let mut options = get_valid_options();
+ options.invalid = InvalidModes::Ignore;
+ let result = handle_buffer(BufReader::new(&input_value[..]), &options);
+ assert!(result.is_ok(), "did not return Ok for invalid input");
+ }
+
+ #[test]
+ fn buffer_fail_returns_status_2_for_invalid_input() {
+ let input_value = b"5\n4Q\n";
+ let mut options = get_valid_options();
+ options.invalid = InvalidModes::Fail;
+ handle_buffer(BufReader::new(&input_value[..]), &options).unwrap();
+ assert!(
+ get_exit_code() == 2,
+ "should set exit code 2 for formatting errors"
+ );
+ }
+
+ #[test]
+ fn abort_returns_status_2_for_invalid_input() {
+ let input_value = b"5\n4Q\n";
+ let mut options = get_valid_options();
+ options.invalid = InvalidModes::Abort;
+ let result = handle_buffer(BufReader::new(&input_value[..]), &options);
+ assert!(result.is_err(), "did not return err for invalid input");
+ }
+
+ #[test]
+ fn args_fail_returns_status_2_for_invalid_input() {
+ let input_value = ["5", "4Q"].into_iter();
+ let mut options = get_valid_options();
+ options.invalid = InvalidModes::Fail;
+ handle_args(input_value, &options).unwrap();
+ assert!(
+ get_exit_code() == 2,
+ "should set exit code 2 for formatting errors"
+ );
+ }
+
+ #[test]
+ fn args_warn_returns_status_0_for_invalid_input() {
+ let input_value = ["5", "4Q"].into_iter();
+ let mut options = get_valid_options();
+ options.invalid = InvalidModes::Warn;
+ let result = handle_args(input_value, &options);
+ assert!(result.is_ok(), "did not return ok for invalid input");
+ }
+
#[test]
fn test_parse_unit_size() {
assert_eq!(1, parse_unit_size("1").unwrap());
diff --git a/src/uu/numfmt/src/options.rs b/src/uu/numfmt/src/options.rs
index dc2b7392580d9bf44816dcb3f0bd06a3d76a6a26..88e64e963e38651375e4028fea30b8eb57ee21aa 100644
--- a/src/uu/numfmt/src/options.rs
+++ b/src/uu/numfmt/src/options.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::str::FromStr;
use crate::units::Unit;
@@ -13,6 +17,7 @@ pub const FROM_UNIT: &str = "from-unit";
pub const FROM_UNIT_DEFAULT: &str = "1";
pub const HEADER: &str = "header";
pub const HEADER_DEFAULT: &str = "1";
+pub const INVALID: &str = "invalid";
pub const NUMBER: &str = "NUMBER";
pub const PADDING: &str = "padding";
pub const ROUND: &str = "round";
@@ -29,6 +34,14 @@ pub struct TransformOptions {
pub to_unit: usize,
}
+#[derive(Debug, PartialEq, Eq)]
+pub enum InvalidModes {
+ Abort,
+ Fail,
+ Warn,
+ Ignore,
+}
+
pub struct NumfmtOptions {
pub transform: TransformOptions,
pub padding: isize,
@@ -38,6 +51,7 @@ pub struct NumfmtOptions {
pub round: RoundMethod,
pub suffix: Option<String>,
pub format: FormatOptions,
+ pub invalid: InvalidModes,
}
#[derive(Clone, Copy)]
@@ -95,6 +109,7 @@ impl FromStr for FormatOptions {
// An optional zero (%010f) will zero pad the number.
// An optional negative value (%-10f) will left align.
// An optional precision (%.1f) determines the precision of the number.
+ #[allow(clippy::cognitive_complexity)]
fn from_str(s: &str) -> Result<Self, Self::Err> {
let mut iter = s.chars().peekable();
let mut options = Self::default();
@@ -128,9 +143,9 @@ impl FromStr for FormatOptions {
if iter.peek().is_none() {
return if options.prefix == s {
- Err(format!("format '{}' has no % directive", s))
+ Err(format!("format '{s}' has no % directive"))
} else {
- Err(format!("format '{}' ends in %", s))
+ Err(format!("format '{s}' ends in %"))
};
}
@@ -151,8 +166,7 @@ impl FromStr for FormatOptions {
Some(c) if c.is_ascii_digit() => padding.push('-'),
_ => {
return Err(format!(
- "invalid format '{}', directive must be %[0]['][-][N][.][N]f",
- s
+ "invalid format '{s}', directive must be %[0]['][-][N][.][N]f"
))
}
}
@@ -171,7 +185,7 @@ impl FromStr for FormatOptions {
if let Ok(p) = padding.parse() {
options.padding = Some(p);
} else {
- return Err(format!("invalid format '{}' (width overflow)", s));
+ return Err(format!("invalid format '{s}' (width overflow)"));
}
}
@@ -179,7 +193,7 @@ impl FromStr for FormatOptions {
iter.next();
if matches!(iter.peek(), Some(' ' | '+' | '-')) {
- return Err(format!("invalid precision in format '{}'", s));
+ return Err(format!("invalid precision in format '{s}'"));
}
while let Some(c) = iter.peek() {
@@ -191,14 +205,12 @@ impl FromStr for FormatOptions {
}
}
- if !precision.is_empty() {
- if let Ok(p) = precision.parse() {
- options.precision = Some(p);
- } else {
- return Err(format!("invalid precision in format '{}'", s));
- }
- } else {
+ if precision.is_empty() {
options.precision = Some(0);
+ } else if let Ok(p) = precision.parse() {
+ options.precision = Some(p);
+ } else {
+ return Err(format!("invalid precision in format '{s}'"));
}
}
@@ -206,8 +218,7 @@ impl FromStr for FormatOptions {
iter.next();
} else {
return Err(format!(
- "invalid format '{}', directive must be %[0]['][-][N][.][N]f",
- s
+ "invalid format '{s}', directive must be %[0]['][-][N][.][N]f"
));
}
@@ -222,7 +233,7 @@ impl FromStr for FormatOptions {
}
iter.next();
} else {
- return Err(format!("format '{}' has too many % directives", s));
+ return Err(format!("format '{s}' has too many % directives"));
}
}
@@ -230,6 +241,20 @@ impl FromStr for FormatOptions {
}
}
+impl FromStr for InvalidModes {
+ type Err = String;
+
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
+ match s.to_lowercase().as_str() {
+ "abort" => Ok(Self::Abort),
+ "fail" => Ok(Self::Fail),
+ "warn" => Ok(Self::Warn),
+ "ignore" => Ok(Self::Ignore),
+ unknown => Err(format!("Unknown invalid mode: {unknown}")),
+ }
+ }
+}
+
#[cfg(test)]
mod tests {
use super::*;
@@ -241,6 +266,7 @@ mod tests {
}
#[test]
+ #[allow(clippy::cognitive_complexity)]
fn test_parse_format_with_invalid_formats() {
assert!("".parse::<FormatOptions>().is_err());
assert!("hello".parse::<FormatOptions>().is_err());
@@ -339,4 +365,21 @@ mod tests {
assert_eq!(expected_options, "%0'0'0'f".parse().unwrap());
assert_eq!(expected_options, "%'0'0'0f".parse().unwrap());
}
+
+ #[test]
+ fn test_set_invalid_mode() {
+ assert_eq!(Ok(InvalidModes::Abort), InvalidModes::from_str("abort"));
+ assert_eq!(Ok(InvalidModes::Abort), InvalidModes::from_str("ABORT"));
+
+ assert_eq!(Ok(InvalidModes::Fail), InvalidModes::from_str("fail"));
+ assert_eq!(Ok(InvalidModes::Fail), InvalidModes::from_str("FAIL"));
+
+ assert_eq!(Ok(InvalidModes::Ignore), InvalidModes::from_str("ignore"));
+ assert_eq!(Ok(InvalidModes::Ignore), InvalidModes::from_str("IGNORE"));
+
+ assert_eq!(Ok(InvalidModes::Warn), InvalidModes::from_str("warn"));
+ assert_eq!(Ok(InvalidModes::Warn), InvalidModes::from_str("WARN"));
+
+ assert!(InvalidModes::from_str("something unknown").is_err());
+ }
}
diff --git a/src/uu/numfmt/src/units.rs b/src/uu/numfmt/src/units.rs
index 08c7e4d3bdd29a6c94fd957ae6b9f05a782e15ea..585bae46141ab1d22348886a86124f8c2781e5c2 100644
--- a/src/uu/numfmt/src/units.rs
+++ b/src/uu/numfmt/src/units.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::fmt;
pub const SI_BASES: [f64; 10] = [1., 1e3, 1e6, 1e9, 1e12, 1e15, 1e18, 1e21, 1e24, 1e27];
diff --git a/src/uu/od/Cargo.toml b/src/uu/od/Cargo.toml
index 827436354a0883766af8982c9828255ed33febe0..ee4a22098ad49771e483da881c134fc5b8dfcc2c 100644
--- a/src/uu/od/Cargo.toml
+++ b/src/uu/od/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_od"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "od ~ (uutils) display formatted representation of input"
@@ -15,10 +15,10 @@ edition = "2021"
path = "src/od.rs"
[dependencies]
-byteorder = "1.3.2"
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-half = "2.1"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+byteorder = { workspace = true }
+clap = { workspace = true }
+half = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "od"
diff --git a/src/uu/od/od.md b/src/uu/od/od.md
new file mode 100644
index 0000000000000000000000000000000000000000..5cd9ac3b5e72a73b3c57ed1ba87d21092ee0645d
--- /dev/null
+++ b/src/uu/od/od.md
@@ -0,0 +1,49 @@
+# od
+
+```
+od [OPTION]... [--] [FILENAME]...
+od [-abcdDefFhHiIlLoOsxX] [FILENAME] [[+][0x]OFFSET[.][b]]
+od --traditional [OPTION]... [FILENAME] [[+][0x]OFFSET[.][b] [[+][0x]LABEL[.][b]]]
+```
+
+Dump files in octal and other formats
+
+## After Help
+
+Displays data in various human-readable formats. If multiple formats are
+specified, the output will contain all formats in the order they appear on the
+command line. Each format will be printed on a new line. Only the line
+containing the first format will be prefixed with the offset.
+
+If no filename is specified, or it is "-", stdin will be used. After a "--", no
+more options will be recognized. This allows for filenames starting with a "-".
+
+If a filename is a valid number which can be used as an offset in the second
+form, you can force it to be recognized as a filename if you include an option
+like "-j0", which is only valid in the first form.
+
+RADIX is one of o,d,x,n for octal, decimal, hexadecimal or none.
+
+BYTES is decimal by default, octal if prefixed with a "0", or hexadecimal if
+prefixed with "0x". The suffixes b, KB, K, MB, M, GB, G, will multiply the
+number with 512, 1000, 1024, 1000^2, 1024^2, 1000^3, 1024^3, 1000^2, 1024^2.
+
+OFFSET and LABEL are octal by default, hexadecimal if prefixed with "0x" or
+decimal if a "." suffix is added. The "b" suffix will multiply with 512.
+
+TYPE contains one or more format specifications consisting of:
+ a for printable 7-bits ASCII
+ c for utf-8 characters or octal for undefined characters
+ d[SIZE] for signed decimal
+ f[SIZE] for floating point
+ o[SIZE] for octal
+ u[SIZE] for unsigned decimal
+ x[SIZE] for hexadecimal
+SIZE is the number of bytes which can be the number 1, 2, 4, 8 or 16,
+ or C, I, S, L for 1, 2, 4, 8 bytes for integer types,
+ or F, D, L for 4, 8, 16 bytes for floating point.
+Any type specification can have a "z" suffix, which will add a ASCII dump at
+ the end of the line.
+
+If an error occurred, a diagnostic message will be printed to stderr, and the
+exit code will be non-zero.
diff --git a/src/uu/od/src/byteorder_io.rs b/src/uu/od/src/byteorder_io.rs
index c22097da2c544489ebdd2a7f7142d54aab71c5ef..545016ff358fa9ec00c65ea5017845eac421822a 100644
--- a/src/uu/od/src/byteorder_io.rs
+++ b/src/uu/od/src/byteorder_io.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) byteorder
// workaround until https://github.com/BurntSushi/byteorder/issues/41 has been fixed
diff --git a/src/uu/od/src/formatteriteminfo.rs b/src/uu/od/src/formatteriteminfo.rs
index 6d51fa3a37198a8f02ecf0548c025336f9843cc9..9e3c2e836000988cae4641a59de8cf31cd4c9ca1 100644
--- a/src/uu/od/src/formatteriteminfo.rs
+++ b/src/uu/od/src/formatteriteminfo.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) formatteriteminfo
use std::fmt;
@@ -22,9 +26,9 @@ impl PartialEq for FormatWriter {
use crate::formatteriteminfo::FormatWriter::*;
match (self, other) {
- (&IntWriter(ref a), &IntWriter(ref b)) => a == b,
- (&FloatWriter(ref a), &FloatWriter(ref b)) => a == b,
- (&MultibyteWriter(ref a), &MultibyteWriter(ref b)) => *a as usize == *b as usize,
+ (IntWriter(a), IntWriter(b)) => a == b,
+ (FloatWriter(a), FloatWriter(b)) => a == b,
+ (MultibyteWriter(a), MultibyteWriter(b)) => *a as usize == *b as usize,
_ => false,
}
}
diff --git a/src/uu/od/src/inputdecoder.rs b/src/uu/od/src/inputdecoder.rs
index c347ccc105ab97caa08103c6e282cc6acf8e3d63..e63eaed148fc19104bfc2b956d7774f2105550ed 100644
--- a/src/uu/od/src/inputdecoder.rs
+++ b/src/uu/od/src/inputdecoder.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use half::f16;
use std::io;
@@ -56,7 +60,7 @@ where
I: PeekRead,
{
/// calls `peek_read` on the internal stream to (re)fill the buffer. Returns a
- /// MemoryDecoder providing access to the result or returns an i/o error.
+ /// `MemoryDecoder` providing access to the result or returns an i/o error.
pub fn peek_read(&mut self) -> io::Result<MemoryDecoder> {
match self
.input
@@ -81,7 +85,7 @@ impl<'a, I> HasError for InputDecoder<'a, I>
where
I: HasError,
{
- /// calls has_error on the internal stream.
+ /// calls `has_error` on the internal stream.
fn has_error(&self) -> bool {
self.input.has_error()
}
@@ -136,7 +140,7 @@ impl<'a> MemoryDecoder<'a> {
2 => u64::from(self.byte_order.read_u16(&self.data[start..start + 2])),
4 => u64::from(self.byte_order.read_u32(&self.data[start..start + 4])),
8 => self.byte_order.read_u64(&self.data[start..start + 8]),
- _ => panic!("Invalid byte_size: {}", byte_size),
+ _ => panic!("Invalid byte_size: {byte_size}"),
}
}
@@ -148,7 +152,7 @@ impl<'a> MemoryDecoder<'a> {
)),
4 => f64::from(self.byte_order.read_f32(&self.data[start..start + 4])),
8 => self.byte_order.read_f64(&self.data[start..start + 8]),
- _ => panic!("Invalid byte_size: {}", byte_size),
+ _ => panic!("Invalid byte_size: {byte_size}"),
}
}
}
@@ -162,6 +166,7 @@ mod tests {
#[test]
#[allow(clippy::float_cmp)]
+ #[allow(clippy::cognitive_complexity)]
fn smoke_test() {
let data = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xff, 0xff];
let mut input = PeekReader::new(Cursor::new(&data));
diff --git a/src/uu/od/src/inputoffset.rs b/src/uu/od/src/inputoffset.rs
index 8aadf969d2503933bbb394c3fd32f828687e01f1..a196000551fbad51f099fb54c6eafd7881cd9287 100644
--- a/src/uu/od/src/inputoffset.rs
+++ b/src/uu/od/src/inputoffset.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum Radix {
Decimal,
@@ -50,7 +54,7 @@ impl InputOffset {
(Radix::Octal, None) => format!("{:07o}", self.byte_pos),
(Radix::Octal, Some(l)) => format!("{:07o} ({:07o})", self.byte_pos, l),
(Radix::NoPrefix, None) => String::new(),
- (Radix::NoPrefix, Some(l)) => format!("({:07o})", l),
+ (Radix::NoPrefix, Some(l)) => format!("({l:07o})"),
}
}
diff --git a/src/uu/od/src/mockstream.rs b/src/uu/od/src/mockstream.rs
index a1ce0dd68957c2b729534a164767eb74fccd665c..9904fa9c1daf207b5c4f2de522c4780ba02c8a8c 100644
--- a/src/uu/od/src/mockstream.rs
+++ b/src/uu/od/src/mockstream.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// https://github.com/lazy-bitfield/rust-mockstream/pull/2
use std::io::{Cursor, Error, ErrorKind, Read, Result};
@@ -6,7 +10,7 @@ use std::io::{Cursor, Error, ErrorKind, Read, Result};
///
/// # Examples
///
-/// ```
+/// ```no_run
/// use std::io::{Cursor, Read};
///
/// struct CountIo {}
diff --git a/src/uu/od/src/multifilereader.rs b/src/uu/od/src/multifilereader.rs
index 38e192588725704902d6314d73473a8301e3d80f..813ef029f37ae79f9b769010d68a5e9cf3bb527a 100644
--- a/src/uu/od/src/multifilereader.rs
+++ b/src/uu/od/src/multifilereader.rs
@@ -1,9 +1,11 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) multifile curr fnames fname xfrd fillloop mockstream
use std::fs::File;
-use std::io;
-use std::io::BufReader;
-use std::vec::Vec;
+use std::io::{self, BufReader};
use uucore::display::Quotable;
use uucore::show_error;
diff --git a/src/uu/od/src/od.rs b/src/uu/od/src/od.rs
index 63641d671431ea0f0471cd91afe912a4ed6e91a5..1c9548f50f815877ad6bdab6c6af0eb65aac3a07 100644
--- a/src/uu/od/src/od.rs
+++ b/src/uu/od/src/od.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Ben Hirsch <benhirsch24@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (clap) dont
// spell-checker:ignore (ToDO) formatteriteminfo inputdecoder inputoffset mockstream nrofbytes partialreader odfunc multifile exitcode
@@ -28,73 +26,31 @@ mod prn_int;
use std::cmp;
use std::fmt::Write;
-use crate::byteorder_io::*;
-use crate::formatteriteminfo::*;
+use crate::byteorder_io::ByteOrder;
+use crate::formatteriteminfo::FormatWriter;
use crate::inputdecoder::{InputDecoder, MemoryDecoder};
use crate::inputoffset::{InputOffset, Radix};
-use crate::multifilereader::*;
+use crate::multifilereader::{HasError, InputSource, MultifileReader};
use crate::output_info::OutputInfo;
use crate::parse_formats::{parse_format_flags, ParsedFormatterItemInfo};
use crate::parse_inputs::{parse_inputs, CommandLineInputs};
use crate::parse_nrofbytes::parse_number_of_bytes;
-use crate::partialreader::*;
-use crate::peekreader::*;
+use crate::partialreader::PartialReader;
+use crate::peekreader::{PeekRead, PeekReader};
use crate::prn_char::format_ascii_dump;
use clap::ArgAction;
use clap::{crate_version, parser::ValueSource, Arg, ArgMatches, Command};
use uucore::display::Quotable;
use uucore::error::{UResult, USimpleError};
-use uucore::format_usage;
use uucore::parse_size::ParseSizeError;
-use uucore::show_error;
-use uucore::show_warning;
+use uucore::shortcut_value_parser::ShortcutValueParser;
+use uucore::{format_usage, help_about, help_section, help_usage, show_error, show_warning};
const PEEK_BUFFER_SIZE: usize = 4; // utf-8 can be 4 bytes
-static ABOUT: &str = "dump files in octal and other formats";
-
-static USAGE: &str = "\
- {} [OPTION]... [--] [FILENAME]...
- {} [-abcdDefFhHiIlLoOsxX] [FILENAME] [[+][0x]OFFSET[.][b]]
- {} --traditional [OPTION]... [FILENAME] [[+][0x]OFFSET[.][b] [[+][0x]LABEL[.][b]]]";
-
-static LONG_HELP: &str = r#"
-Displays data in various human-readable formats. If multiple formats are
-specified, the output will contain all formats in the order they appear on the
-command line. Each format will be printed on a new line. Only the line
-containing the first format will be prefixed with the offset.
-
-If no filename is specified, or it is "-", stdin will be used. After a "--", no
-more options will be recognized. This allows for filenames starting with a "-".
-
-If a filename is a valid number which can be used as an offset in the second
-form, you can force it to be recognized as a filename if you include an option
-like "-j0", which is only valid in the first form.
-
-RADIX is one of o,d,x,n for octal, decimal, hexadecimal or none.
-
-BYTES is decimal by default, octal if prefixed with a "0", or hexadecimal if
-prefixed with "0x". The suffixes b, KB, K, MB, M, GB, G, will multiply the
-number with 512, 1000, 1024, 1000^2, 1024^2, 1000^3, 1024^3, 1000^2, 1024^2.
-
-OFFSET and LABEL are octal by default, hexadecimal if prefixed with "0x" or
-decimal if a "." suffix is added. The "b" suffix will multiply with 512.
-
-TYPE contains one or more format specifications consisting of:
- a for printable 7-bits ASCII
- c for utf-8 characters or octal for undefined characters
- d[SIZE] for signed decimal
- f[SIZE] for floating point
- o[SIZE] for octal
- u[SIZE] for unsigned decimal
- x[SIZE] for hexadecimal
-SIZE is the number of bytes which can be the number 1, 2, 4, 8 or 16,
- or C, I, S, L for 1, 2, 4, 8 bytes for integer types,
- or F, D, L for 4, 8, 16 bytes for floating point.
-Any type specification can have a "z" suffix, which will add a ASCII dump at
- the end of the line.
-
-If an error occurred, a diagnostic message will be printed to stderr, and the
-exitcode will be non-zero."#;
+
+const ABOUT: &str = help_about!("od.md");
+const USAGE: &str = help_usage!("od.md");
+const AFTER_HELP: &str = help_section!("after help", "od.md");
pub(crate) mod options {
pub const HELP: &str = "help";
@@ -131,7 +87,7 @@ impl OdOptions {
_ => {
return Err(USimpleError::new(
1,
- format!("Invalid argument --endian={}", s),
+ format!("Invalid argument --endian={s}"),
))
}
}
@@ -155,7 +111,7 @@ impl OdOptions {
let mut label: Option<u64> = None;
let parsed_input = parse_inputs(matches)
- .map_err(|e| USimpleError::new(1, format!("Invalid inputs: {}", e)))?;
+ .map_err(|e| USimpleError::new(1, format!("Invalid inputs: {e}")))?;
let input_strings = match parsed_input {
CommandLineInputs::FileNames(v) => v,
CommandLineInputs::FileAndOffset((f, s, l)) => {
@@ -173,7 +129,7 @@ impl OdOptions {
if matches.value_source(options::WIDTH) == Some(ValueSource::CommandLine) {
match parse_number_of_bytes(s) {
Ok(n) => usize::try_from(n)
- .map_err(|_| USimpleError::new(1, format!("‘{}‘ is too large", s)))?,
+ .map_err(|_| USimpleError::new(1, format!("‘{s}‘ is too large")))?,
Err(e) => {
return Err(USimpleError::new(
1,
@@ -214,12 +170,7 @@ impl OdOptions {
None => Radix::Octal,
Some(s) => {
let st = s.as_bytes();
- if st.len() != 1 {
- return Err(USimpleError::new(
- 1,
- "Radix must be one of [d, o, n, x]".to_string(),
- ));
- } else {
+ if st.len() == 1 {
let radix: char = *(st
.first()
.expect("byte string of length 1 lacks a 0th elem"))
@@ -236,6 +187,11 @@ impl OdOptions {
))
}
}
+ } else {
+ return Err(USimpleError::new(
+ 1,
+ "Radix must be one of [d, o, n, x]".to_string(),
+ ));
}
}
};
@@ -295,7 +251,7 @@ pub fn uu_app() -> Command {
.version(crate_version!())
.about(ABOUT)
.override_usage(format_usage(USAGE))
- .after_help(LONG_HELP)
+ .after_help(AFTER_HELP)
.trailing_var_arg(true)
.dont_delimit_trailing_values(true)
.infer_long_args(true)
@@ -332,7 +288,7 @@ pub fn uu_app() -> Command {
Arg::new(options::ENDIAN)
.long(options::ENDIAN)
.help("byte order to use for multi-byte formats")
- .value_parser(["big", "little"])
+ .value_parser(ShortcutValueParser::new(["big", "little"]))
.value_name("big|little"),
)
.arg(
@@ -502,7 +458,7 @@ pub fn uu_app() -> Command {
)
}
-/// Loops through the input line by line, calling print_bytes to take care of the output.
+/// Loops through the input line by line, calling `print_bytes` to take care of the output.
fn odfunc<I>(
input_offset: &mut InputOffset,
input_decoder: &mut InputDecoder<I>,
@@ -625,15 +581,15 @@ fn print_bytes(prefix: &str, input_decoder: &MemoryDecoder, output_info: &Output
}
if first {
- print!("{}", prefix); // print offset
- // if printing in multiple formats offset is printed only once
+ print!("{prefix}"); // print offset
+ // if printing in multiple formats offset is printed only once
first = false;
} else {
// this takes the space of the file offset on subsequent
// lines of multi-format rasters.
print!("{:>width$}", "", width = prefix.chars().count());
}
- println!("{}", output_text);
+ println!("{output_text}");
}
}
diff --git a/src/uu/od/src/output_info.rs b/src/uu/od/src/output_info.rs
index 60cbaf5ab68a9e53b78f57ccfb9a5b24a516ff29..16329217200667029e1d53b8d5dc0d7cc6b8ca67 100644
--- a/src/uu/od/src/output_info.rs
+++ b/src/uu/od/src/output_info.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore formatteriteminfo blocksize thisblock
use std::cmp;
@@ -34,8 +38,6 @@ pub struct OutputInfo {
/// The number of bytes in a block. (This is the size of the largest datatype in `spaced_formatters`.)
pub byte_size_block: usize,
- /// The width of a block in human readable format. (The size of the largest format.)
- pub print_width_block: usize,
/// All formats.
spaced_formatters: Vec<SpacedFormatterItemInfo>,
/// determines if duplicate output lines should be printed, or
@@ -74,7 +76,6 @@ impl OutputInfo {
byte_size_line: line_bytes,
print_width_line,
byte_size_block,
- print_width_block,
spaced_formatters,
output_duplicates,
}
@@ -139,7 +140,7 @@ impl OutputInfo {
/// ```
///
/// This algorithm assumes the size of all types is a power of 2 (1, 2, 4, 8, 16, ...)
- /// Increase MAX_BYTES_PER_UNIT to allow larger types.
+ /// Increase `MAX_BYTES_PER_UNIT` to allow larger types.
fn calculate_alignment(
sf: &dyn TypeSizeInfo,
byte_size_block: usize,
@@ -204,6 +205,7 @@ impl TypeSizeInfo for TypeInfo {
}
#[test]
+#[allow(clippy::cognitive_complexity)]
fn test_calculate_alignment() {
// For this example `byte_size_block` is 8 and 'print_width_block' is 23:
// 1777777777777777777777 1777777777777777777777
diff --git a/src/uu/od/src/parse_formats.rs b/src/uu/od/src/parse_formats.rs
index 9614ed9c04be20a4fd268d1e03c3b645e25fdda3..2bb876d2b4b8678f201e9d5d42f1ddca343fdabe 100644
--- a/src/uu/od/src/parse_formats.rs
+++ b/src/uu/od/src/parse_formats.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore formatteriteminfo docopt fvox fvoxw vals acdx
use uucore::display::Quotable;
@@ -96,6 +100,7 @@ fn od_argument_with_option(ch: char) -> bool {
/// arguments with parameters like -w16 can only appear at the end: -fvoxw16
/// parameters of -t/--format specify 1 or more formats.
/// if -- appears on the command line, parsing should stop.
+#[allow(clippy::cognitive_complexity)]
pub fn parse_format_flags(args: &[String]) -> Result<Vec<ParsedFormatterItemInfo>, String> {
let mut formats = Vec::new();
diff --git a/src/uu/od/src/parse_inputs.rs b/src/uu/od/src/parse_inputs.rs
index 275ab8cfc583799bd3fa8ee7521f986e4e85675a..241d842af9f991d8a27a97bb2d7a9116148f3f4a 100644
--- a/src/uu/od/src/parse_inputs.rs
+++ b/src/uu/od/src/parse_inputs.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use super::options;
use clap::ArgMatches;
@@ -90,8 +94,8 @@ pub fn parse_inputs(matches: &dyn CommandLineOpts) -> Result<CommandLineInputs,
/// interprets inputs when --traditional is on the command line
///
-/// normally returns CommandLineInputs::FileAndOffset, but if no offset is found,
-/// it returns CommandLineInputs::FileNames (also to differentiate from the offset == 0)
+/// normally returns `CommandLineInputs::FileAndOffset`, but if no offset is found,
+/// it returns `CommandLineInputs::FileNames` (also to differentiate from the offset == 0)
pub fn parse_inputs_traditional(input_strings: &[&str]) -> Result<CommandLineInputs, String> {
match input_strings.len() {
0 => Ok(CommandLineInputs::FileNames(vec!["-".to_string()])),
@@ -209,6 +213,7 @@ mod tests {
}
#[test]
+ #[allow(clippy::cognitive_complexity)]
fn test_parse_inputs_with_offset() {
// offset is found without filename, so stdin will be used.
assert_eq!(
@@ -351,6 +356,7 @@ mod tests {
}
#[test]
+ #[allow(clippy::cognitive_complexity)]
fn test_parse_offset_operand() {
assert_eq!(8, parse_offset_operand_str("10").unwrap()); // default octal
assert_eq!(0, parse_offset_operand_str("0").unwrap());
diff --git a/src/uu/od/src/parse_nrofbytes.rs b/src/uu/od/src/parse_nrofbytes.rs
index 4c310755b38bc835e51bb669b599caf364b5e307..1aa69909f2b20bf9a0739e73b6bff710807362d0 100644
--- a/src/uu/od/src/parse_nrofbytes.rs
+++ b/src/uu/od/src/parse_nrofbytes.rs
@@ -1,4 +1,8 @@
-use uucore::parse_size::{parse_size, ParseSizeError};
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use uucore::parse_size::{parse_size_u64, ParseSizeError};
pub fn parse_number_of_bytes(s: &str) -> Result<u64, ParseSizeError> {
let mut start = 0;
@@ -11,7 +15,7 @@ pub fn parse_number_of_bytes(s: &str) -> Result<u64, ParseSizeError> {
} else if s.starts_with('0') {
radix = 8;
} else {
- return parse_size(&s[start..]);
+ return parse_size_u64(&s[start..]);
}
let mut ends_with = s.chars().rev();
@@ -43,7 +47,7 @@ pub fn parse_number_of_bytes(s: &str) -> Result<u64, ParseSizeError> {
len -= 1;
}
#[cfg(target_pointer_width = "64")]
- Some('E') => {
+ Some('E') if radix != 16 => {
multiply = 1024 * 1024 * 1024 * 1024 * 1024 * 1024;
len -= 1;
}
@@ -75,6 +79,7 @@ pub fn parse_number_of_bytes(s: &str) -> Result<u64, ParseSizeError> {
}
#[test]
+#[allow(clippy::cognitive_complexity)]
fn test_parse_number_of_bytes() {
// octal input
assert_eq!(8, parse_number_of_bytes("010").unwrap());
@@ -84,6 +89,7 @@ fn test_parse_number_of_bytes() {
// hex input
assert_eq!(15, parse_number_of_bytes("0xf").unwrap());
+ assert_eq!(14, parse_number_of_bytes("0XE").unwrap());
assert_eq!(15, parse_number_of_bytes("0XF").unwrap());
assert_eq!(27, parse_number_of_bytes("0x1b").unwrap());
assert_eq!(16 * 1024, parse_number_of_bytes("0x10k").unwrap());
diff --git a/src/uu/od/src/partialreader.rs b/src/uu/od/src/partialreader.rs
index 8b51d8dee736284013350e0ff5db48886b807f0d..6825f1ae4b9f665ab4d893d316cbb44a1d53370c 100644
--- a/src/uu/od/src/partialreader.rs
+++ b/src/uu/od/src/partialreader.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore mockstream abcdefgh bcdefgh
use std::cmp;
@@ -145,11 +149,7 @@ mod tests {
fn test_read_skipping_huge_number() {
let mut v = [0; 10];
// test if it does not eat all memory....
- let mut sut = PartialReader::new(
- Cursor::new(&b"abcdefgh"[..]),
- usize::max_value() as u64,
- None,
- );
+ let mut sut = PartialReader::new(Cursor::new(&b"abcdefgh"[..]), u64::MAX, None);
sut.read(v.as_mut()).unwrap_err();
}
diff --git a/src/uu/od/src/peekreader.rs b/src/uu/od/src/peekreader.rs
index 45cd554d0844077960a20c54beedf7dcd74d6e84..82f139c726e830b98a7fc372a66e30b5abbd8605 100644
--- a/src/uu/od/src/peekreader.rs
+++ b/src/uu/od/src/peekreader.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) tempbuffer abcdefgh abcdefghij
//! Contains the trait `PeekRead` and type `PeekReader` implementing it.
@@ -182,6 +186,7 @@ mod tests {
}
#[test]
+ #[allow(clippy::cognitive_complexity)]
fn test_peek_read_with_smaller_buffer() {
let mut sut = PeekReader::new(Cursor::new(&b"abcdefghij"[..]));
diff --git a/src/uu/od/src/prn_char.rs b/src/uu/od/src/prn_char.rs
index 742229dd772edfddd3d4451ac94ecc66921684bb..36a00a67bb3f23a0972b8279516c1440866fbe63 100644
--- a/src/uu/od/src/prn_char.rs
+++ b/src/uu/od/src/prn_char.rs
@@ -1,6 +1,10 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::str::from_utf8;
-use crate::formatteriteminfo::*;
+use crate::formatteriteminfo::{FormatWriter, FormatterItemInfo};
pub static FORMAT_ITEM_A: FormatterItemInfo = FormatterItemInfo {
byte_size: 1,
@@ -48,8 +52,8 @@ fn format_item_c(bytes: &[u8]) -> String {
if b & 0x80 == 0x00 {
match C_CHARS.get(b as usize) {
- Some(s) => format!("{:>4}", s),
- None => format!("{:>4}", b),
+ Some(s) => format!("{s:>4}"),
+ None => format!("{b:>4}"),
}
} else if (b & 0xc0) == 0x80 {
// second or subsequent octet of an utf-8 sequence
@@ -57,24 +61,24 @@ fn format_item_c(bytes: &[u8]) -> String {
} else if ((b & 0xe0) == 0xc0) && (bytes.len() >= 2) {
// start of a 2 octet utf-8 sequence
match from_utf8(&bytes[0..2]) {
- Ok(s) => format!("{:>4}", s),
- Err(_) => format!(" {:03o}", b),
+ Ok(s) => format!("{s:>4}"),
+ Err(_) => format!(" {b:03o}"),
}
} else if ((b & 0xf0) == 0xe0) && (bytes.len() >= 3) {
// start of a 3 octet utf-8 sequence
match from_utf8(&bytes[0..3]) {
- Ok(s) => format!("{:>4}", s),
- Err(_) => format!(" {:03o}", b),
+ Ok(s) => format!("{s:>4}"),
+ Err(_) => format!(" {b:03o}"),
}
} else if ((b & 0xf8) == 0xf0) && (bytes.len() >= 4) {
// start of a 4 octet utf-8 sequence
match from_utf8(&bytes[0..4]) {
- Ok(s) => format!("{:>4}", s),
- Err(_) => format!(" {:03o}", b),
+ Ok(s) => format!("{s:>4}"),
+ Err(_) => format!(" {b:03o}"),
}
} else {
// invalid utf-8
- format!(" {:03o}", b)
+ format!(" {b:03o}")
}
}
@@ -82,7 +86,7 @@ pub fn format_ascii_dump(bytes: &[u8]) -> String {
let mut result = String::new();
result.push('>');
- for c in bytes.iter() {
+ for c in bytes {
if *c >= 0x20 && *c <= 0x7e {
result.push_str(C_CHARS[*c as usize]);
} else {
@@ -95,6 +99,7 @@ pub fn format_ascii_dump(bytes: &[u8]) -> String {
}
#[test]
+#[allow(clippy::cognitive_complexity)]
fn test_format_item_a() {
assert_eq!(" nul", format_item_a(0x00));
assert_eq!(" soh", format_item_a(0x01));
@@ -110,6 +115,7 @@ fn test_format_item_a() {
}
#[test]
+#[allow(clippy::cognitive_complexity)]
fn test_format_item_c() {
assert_eq!(" \\0", format_item_c(&[0x00]));
assert_eq!(" 001", format_item_c(&[0x01]));
diff --git a/src/uu/od/src/prn_float.rs b/src/uu/od/src/prn_float.rs
index a9bf1279e2fb06ab10f4364bc1f132cabb45f0c3..f44abf7c41c189870b0649c72fd2fd8aedae589c 100644
--- a/src/uu/od/src/prn_float.rs
+++ b/src/uu/od/src/prn_float.rs
@@ -1,9 +1,13 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use half::f16;
use std::f32;
use std::f64;
use std::num::FpCategory;
-use crate::formatteriteminfo::*;
+use crate::formatteriteminfo::{FormatWriter, FormatterItemInfo};
pub static FORMAT_ITEM_F16: FormatterItemInfo = FormatterItemInfo {
byte_size: 2,
@@ -47,7 +51,7 @@ fn format_flo32(f: f32) -> String {
if f.classify() == FpCategory::Subnormal {
// subnormal numbers will be normal as f64, so will print with a wrong precision
- format!("{:width$e}", f, width = width) // subnormal numbers
+ format!("{f:width$e}") // subnormal numbers
} else {
format_float(f64::from(f), width, precision)
}
@@ -60,12 +64,12 @@ fn format_flo64(f: f64) -> String {
fn format_float(f: f64, width: usize, precision: usize) -> String {
if !f.is_normal() {
if f == -0.0 && f.is_sign_negative() {
- return format!("{:>width$}", "-0", width = width);
+ return format!("{:>width$}", "-0");
}
if f == 0.0 || !f.is_finite() {
- return format!("{:width$}", f, width = width);
+ return format!("{f:width$}");
}
- return format!("{:width$e}", f, width = width); // subnormal numbers
+ return format!("{f:width$e}"); // subnormal numbers
}
let mut l = f.abs().log10().floor() as i32;
@@ -77,21 +81,17 @@ fn format_float(f: f64, width: usize, precision: usize) -> String {
}
if l >= 0 && l <= (precision as i32 - 1) {
- format!(
- "{:width$.dec$}",
- f,
- width = width,
- dec = (precision - 1) - l as usize
- )
+ format!("{:width$.dec$}", f, dec = (precision - 1) - l as usize)
} else if l == -1 {
- format!("{:width$.dec$}", f, width = width, dec = precision)
+ format!("{f:width$.precision$}")
} else {
- format!("{:width$.dec$e}", f, width = width, dec = precision - 1)
+ format!("{:width$.dec$e}", f, dec = precision - 1)
}
}
#[test]
#[allow(clippy::excessive_precision)]
+#[allow(clippy::cognitive_complexity)]
fn test_format_flo32() {
assert_eq!(format_flo32(1.0), " 1.0000000");
assert_eq!(format_flo32(9.9999990), " 9.9999990");
@@ -168,6 +168,7 @@ fn test_format_flo32() {
}
#[test]
+#[allow(clippy::cognitive_complexity)]
fn test_format_flo64() {
assert_eq!(format_flo64(1.0), " 1.0000000000000000");
assert_eq!(format_flo64(10.0), " 10.000000000000000");
@@ -197,6 +198,7 @@ fn test_format_flo64() {
}
#[test]
+#[allow(clippy::cognitive_complexity)]
fn test_format_flo16() {
assert_eq!(format_flo16(f16::from_bits(0x8400u16)), "-6.104e-5");
assert_eq!(format_flo16(f16::from_bits(0x8401u16)), "-6.109e-5");
diff --git a/src/uu/od/src/prn_int.rs b/src/uu/od/src/prn_int.rs
index 0946824c14cf0f19095370368e36b4bbfe29ae51..f843ff77ca2029059ce249bdeaaf46d5f085fdf1 100644
--- a/src/uu/od/src/prn_int.rs
+++ b/src/uu/od/src/prn_int.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use crate::formatteriteminfo::*;
/// format string to print octal using `int_writer_unsigned`
@@ -85,6 +89,7 @@ int_writer_signed!(FORMAT_ITEM_DEC32S, 4, 12, format_item_dec_s32, DEC!()); // m
int_writer_signed!(FORMAT_ITEM_DEC64S, 8, 21, format_item_dec_s64, DEC!()); // max: -9223372036854775808
#[test]
+#[allow(clippy::cognitive_complexity)]
fn test_sign_extend() {
assert_eq!(
0xffff_ffff_ffff_ff80u64 as i64,
@@ -175,6 +180,7 @@ fn test_format_item_dec_u() {
}
#[test]
+#[allow(clippy::cognitive_complexity)]
fn test_format_item_dec_s() {
assert_eq!(" 0", format_item_dec_s8(0));
assert_eq!(" 127", format_item_dec_s8(0x7f));
diff --git a/src/uu/paste/Cargo.toml b/src/uu/paste/Cargo.toml
index 4012f14ff515711b5bed2eda8dc4dec2c178fedf..8eeb2de0e6094fbf7b20c3c5cd6f53a5f504de32 100644
--- a/src/uu/paste/Cargo.toml
+++ b/src/uu/paste/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_paste"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "paste ~ (uutils) merge lines from inputs"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/paste.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "paste"
diff --git a/src/uu/paste/paste.md b/src/uu/paste/paste.md
new file mode 100644
index 0000000000000000000000000000000000000000..74160588894d197f697ccd4bdb8880375762bad2
--- /dev/null
+++ b/src/uu/paste/paste.md
@@ -0,0 +1,8 @@
+# paste
+
+```
+paste [OPTIONS] [FILE]...
+```
+
+Write lines consisting of the sequentially corresponding lines from each
+`FILE`, separated by `TAB`s, to standard output.
diff --git a/src/uu/paste/src/paste.rs b/src/uu/paste/src/paste.rs
index 3635ae967e2c341092d15be47d0b5866b744ff27..118a66b81c28dcd02a7863fe542206e6cad0062c 100644
--- a/src/uu/paste/src/paste.rs
+++ b/src/uu/paste/src/paste.rs
@@ -1,21 +1,20 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Alex Lyon <arcterus@mail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) delim
use clap::{crate_version, Arg, ArgAction, Command};
-use std::fmt::Display;
use std::fs::File;
use std::io::{stdin, stdout, BufRead, BufReader, Read, Write};
use std::path::Path;
-use uucore::error::{FromIo, UResult};
+use uucore::error::{FromIo, UResult, USimpleError};
+use uucore::line_ending::LineEnding;
+use uucore::{format_usage, help_about, help_usage};
-static ABOUT: &str = "Write lines consisting of the sequentially corresponding lines from each
-FILE, separated by TABs, to standard output.";
+const ABOUT: &str = help_about!("paste.md");
+const USAGE: &str = help_usage!("paste.md");
mod options {
pub const DELIMITER: &str = "delimiters";
@@ -24,22 +23,6 @@ mod options {
pub const ZERO_TERMINATED: &str = "zero-terminated";
}
-#[repr(u8)]
-#[derive(Clone, Copy)]
-enum LineEnding {
- Newline = b'\n',
- Nul = 0,
-}
-
-impl Display for LineEnding {
- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- match self {
- Self::Newline => writeln!(f),
- Self::Nul => write!(f, "\0"),
- }
- }
-}
-
// Wraps BufReader and stdin
fn read_until<R: Read>(
reader: Option<&mut BufReader<R>>,
@@ -61,13 +44,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let files = matches
.get_many::<String>(options::FILE)
.unwrap()
- .map(|s| s.to_owned())
+ .cloned()
.collect();
- let line_ending = if matches.get_flag(options::ZERO_TERMINATED) {
- LineEnding::Nul
- } else {
- LineEnding::Newline
- };
+ let line_ending = LineEnding::from_zero_flag(matches.get_flag(options::ZERO_TERMINATED));
paste(files, serial, delimiters, line_ending)
}
@@ -76,6 +55,7 @@ pub fn uu_app() -> Command {
Command::new(uucore::util_name())
.version(crate_version!())
.about(ABOUT)
+ .override_usage(format_usage(USAGE))
.infer_long_args(true)
.arg(
Arg::new(options::SERIAL)
@@ -109,6 +89,7 @@ pub fn uu_app() -> Command {
)
}
+#[allow(clippy::cognitive_complexity)]
fn paste(
filenames: Vec<String>,
serial: bool,
@@ -127,6 +108,16 @@ fn paste(
files.push(file);
}
+ if delimiters.ends_with('\\') && !delimiters.ends_with("\\\\") {
+ return Err(USimpleError::new(
+ 1,
+ format!(
+ "delimiter list ends with an unescaped backslash: {}",
+ delimiters
+ ),
+ ));
+ }
+
let delimiters: Vec<char> = unescape(delimiters).chars().collect();
let mut delim_count = 0;
let mut delim_length = 1;
@@ -220,10 +211,8 @@ fn paste(
}
// Unescape all special characters
-// TODO: this will need work to conform to GNU implementation
fn unescape(s: &str) -> String {
s.replace("\\n", "\n")
.replace("\\t", "\t")
.replace("\\\\", "\\")
- .replace('\\', "")
}
diff --git a/src/uu/pathchk/Cargo.toml b/src/uu/pathchk/Cargo.toml
index f8a203a3f3838d427709e5b922112a55c2647eca..9cf9088cc41a75c1d213a2821d25bcc3d06ec700 100644
--- a/src/uu/pathchk/Cargo.toml
+++ b/src/uu/pathchk/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_pathchk"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "pathchk ~ (uutils) diagnose invalid or non-portable PATHNAME"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/pathchk.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-libc = "0.2.137"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "pathchk"
diff --git a/src/uu/pathchk/pathchk.md b/src/uu/pathchk/pathchk.md
new file mode 100644
index 0000000000000000000000000000000000000000..2e5eca95953eb71cc0411f909e8e4caff6ba563e
--- /dev/null
+++ b/src/uu/pathchk/pathchk.md
@@ -0,0 +1,7 @@
+# pathchk
+
+```
+pathchk [OPTION]... NAME...
+```
+
+Check whether file names are valid or portable
diff --git a/src/uu/pathchk/src/pathchk.rs b/src/uu/pathchk/src/pathchk.rs
index 626596ab0493da62f189b8f06eddeac384da9117..ffb214e2ebf2d40b3261c111691f6ec178601ab3 100644
--- a/src/uu/pathchk/src/pathchk.rs
+++ b/src/uu/pathchk/src/pathchk.rs
@@ -1,19 +1,16 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
#![allow(unused_must_use)] // because we of writeln!
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Inokentiy Babushkin <inokentiy.babushkin@googlemail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
-
// spell-checker:ignore (ToDO) lstat
use clap::{crate_version, Arg, ArgAction, Command};
use std::fs;
use std::io::{ErrorKind, Write};
use uucore::display::Quotable;
use uucore::error::{set_exit_code, UResult, UUsageError};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
// operating mode
enum Mode {
@@ -23,8 +20,8 @@ enum Mode {
Both, // a combination of `Basic` and `Extra`
}
-static ABOUT: &str = "Check whether file names are valid or portable";
-const USAGE: &str = "{} [OPTION]... NAME...";
+const ABOUT: &str = help_about!("pathchk.md");
+const USAGE: &str = help_usage!("pathchk.md");
mod options {
pub const POSIX: &str = "posix";
@@ -39,8 +36,6 @@ const POSIX_NAME_MAX: usize = 14;
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_lossy();
-
let matches = uu_app().try_get_matches_from(args)?;
// set working mode
@@ -132,10 +127,7 @@ fn check_basic(path: &[String]) -> bool {
if total_len > POSIX_PATH_MAX {
writeln!(
std::io::stderr(),
- "limit {} exceeded by length {} of file name {}",
- POSIX_PATH_MAX,
- total_len,
- joined_path
+ "limit {POSIX_PATH_MAX} exceeded by length {total_len} of file name {joined_path}"
);
return false;
} else if total_len == 0 {
@@ -199,6 +191,17 @@ fn check_default(path: &[String]) -> bool {
);
return false;
}
+ if total_len == 0 {
+ // Check whether a file name component is in a directory that is not searchable,
+ // or has some other serious problem. POSIX does not allow "" as a file name,
+ // but some non-POSIX hosts do (as an alias for "."),
+ // so allow "" if `symlink_metadata` (corresponds to `lstat`) does.
+ if fs::symlink_metadata(&joined_path).is_err() {
+ writeln!(std::io::stderr(), "pathchk: '': No such file or directory",);
+ return false;
+ }
+ }
+
// components: length
for p in path {
let component_len = p.len();
@@ -226,7 +229,7 @@ fn check_searchable(path: &str) -> bool {
if e.kind() == ErrorKind::NotFound {
true
} else {
- writeln!(std::io::stderr(), "{}", e);
+ writeln!(std::io::stderr(), "{e}");
false
}
}
diff --git a/src/uu/pinky/Cargo.toml b/src/uu/pinky/Cargo.toml
index 136ab48fc215717f0db777be53720f5d65a672d0..a3fc80f644e9b008a8f8aaf4e1d4a5668dad333d 100644
--- a/src/uu/pinky/Cargo.toml
+++ b/src/uu/pinky/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_pinky"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "pinky ~ (uutils) display user information"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/pinky.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["utmpx", "entries"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["utmpx", "entries"] }
[[bin]]
name = "pinky"
diff --git a/src/uu/pinky/pinky.md b/src/uu/pinky/pinky.md
new file mode 100644
index 0000000000000000000000000000000000000000..965ae4cd0904ff385fb9f74fd1544654fc3b9388
--- /dev/null
+++ b/src/uu/pinky/pinky.md
@@ -0,0 +1,7 @@
+# pinky
+
+```
+pinky [OPTION]... [USER]...
+```
+
+Displays brief user information on Unix-based systems
diff --git a/src/uu/pinky/src/pinky.rs b/src/uu/pinky/src/pinky.rs
index c4e68705ef7a675236045e3435547b63d670fbdb..6b393b905d641b7236eb2f85b280b4070494c7aa 100644
--- a/src/uu/pinky/src/pinky.rs
+++ b/src/uu/pinky/src/pinky.rs
@@ -1,29 +1,17 @@
// This file is part of the uutils coreutils package.
//
-// (c) Jian Zeng <anonymousknight96@gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
// spell-checker:ignore (ToDO) BUFSIZE gecos fullname, mesg iobuf
-use uucore::entries::{Locate, Passwd};
-use uucore::error::{FromIo, UResult};
-use uucore::libc::S_IWGRP;
-use uucore::utmpx::{self, time, Utmpx};
-
-use std::io::prelude::*;
-use std::io::BufReader;
-
-use std::fs::File;
-use std::os::unix::fs::MetadataExt;
-
use clap::{crate_version, Arg, ArgAction, Command};
-use std::path::PathBuf;
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
-static ABOUT: &str = "lightweight finger";
-const USAGE: &str = "{} [OPTION]... [USER]...";
+mod platform;
+
+const ABOUT: &str = help_about!("pinky.md");
+const USAGE: &str = help_usage!("pinky.md");
mod options {
pub const LONG_FORMAT: &str = "long_format";
@@ -39,88 +27,8 @@ mod options {
pub const HELP: &str = "help";
}
-fn get_long_usage() -> String {
- format!(
- "A lightweight 'finger' program; print user information.\n\
- The utmp file will be {}.",
- utmpx::DEFAULT_FILE
- )
-}
-
#[uucore::main]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_ignore();
-
- let matches = uu_app()
- .after_help(get_long_usage())
- .try_get_matches_from(args)?;
-
- let users: Vec<String> = matches
- .get_many::<String>(options::USER)
- .map(|v| v.map(ToString::to_string).collect())
- .unwrap_or_default();
-
- // If true, display the hours:minutes since each user has touched
- // the keyboard, or blank if within the last minute, or days followed
- // by a 'd' if not within the last day.
- let mut include_idle = true;
-
- // If true, display a line at the top describing each field.
- let include_heading = !matches.get_flag(options::OMIT_HEADINGS);
-
- // if true, display the user's full name from pw_gecos.
- let mut include_fullname = true;
-
- // if true, display the user's ~/.project file when doing long format.
- let include_project = !matches.get_flag(options::OMIT_PROJECT_FILE);
-
- // if true, display the user's ~/.plan file when doing long format.
- let include_plan = !matches.get_flag(options::OMIT_PLAN_FILE);
-
- // if true, display the user's home directory and shell
- // when doing long format.
- let include_home_and_shell = !matches.get_flag(options::OMIT_HOME_DIR);
-
- // if true, use the "short" output format.
- let do_short_format = !matches.get_flag(options::LONG_FORMAT);
-
- /* if true, display the ut_host field. */
- let mut include_where = true;
-
- if matches.get_flag(options::OMIT_NAME) {
- include_fullname = false;
- }
- if matches.get_flag(options::OMIT_NAME_HOST) {
- include_fullname = false;
- include_where = false;
- }
- if matches.get_flag(options::OMIT_NAME_HOST_TIME) {
- include_fullname = false;
- include_idle = false;
- include_where = false;
- }
-
- let pk = Pinky {
- include_idle,
- include_heading,
- include_fullname,
- include_project,
- include_plan,
- include_home_and_shell,
- include_where,
- names: users,
- };
-
- if do_short_format {
- match pk.short_pinky() {
- Ok(_) => Ok(()),
- Err(e) => Err(e.map_err_context(String::new)),
- }
- } else {
- pk.long_pinky();
- Ok(())
- }
-}
+use platform::uumain;
pub fn uu_app() -> Command {
Command::new(uucore::util_name())
@@ -199,17 +107,6 @@ pub fn uu_app() -> Command {
)
}
-struct Pinky {
- include_idle: bool,
- include_heading: bool,
- include_fullname: bool,
- include_project: bool,
- include_plan: bool,
- include_where: bool,
- include_home_and_shell: bool,
- names: Vec<String>,
-}
-
pub trait Capitalize {
fn capitalize(&self) -> String;
}
@@ -218,189 +115,12 @@ impl Capitalize for str {
fn capitalize(&self) -> String {
self.char_indices()
.fold(String::with_capacity(self.len()), |mut acc, x| {
- if x.0 != 0 {
- acc.push(x.1);
- } else {
+ if x.0 == 0 {
acc.push(x.1.to_ascii_uppercase());
+ } else {
+ acc.push(x.1);
}
acc
})
}
}
-
-fn idle_string(when: i64) -> String {
- thread_local! {
- static NOW: time::OffsetDateTime = time::OffsetDateTime::now_local().unwrap();
- }
- NOW.with(|n| {
- let duration = n.unix_timestamp() - when;
- if duration < 60 {
- // less than 1min
- " ".to_owned()
- } else if duration < 24 * 3600 {
- // less than 1day
- let hours = duration / (60 * 60);
- let minutes = (duration % (60 * 60)) / 60;
- format!("{:02}:{:02}", hours, minutes)
- } else {
- // more than 1day
- let days = duration / (24 * 3600);
- format!("{}d", days)
- }
- })
-}
-
-fn time_string(ut: &Utmpx) -> String {
- // "%b %e %H:%M"
- let time_format: Vec<time::format_description::FormatItem> =
- time::format_description::parse("[month repr:short] [day padding:space] [hour]:[minute]")
- .unwrap();
- ut.login_time().format(&time_format).unwrap() // LC_ALL=C
-}
-
-fn gecos_to_fullname(pw: &Passwd) -> Option<String> {
- let mut gecos = if let Some(gecos) = &pw.user_info {
- gecos.clone()
- } else {
- return None;
- };
- if let Some(n) = gecos.find(',') {
- gecos.truncate(n);
- }
- Some(gecos.replace('&', &pw.name.capitalize()))
-}
-
-impl Pinky {
- fn print_entry(&self, ut: &Utmpx) -> std::io::Result<()> {
- let mut pts_path = PathBuf::from("/dev");
- pts_path.push(ut.tty_device().as_str());
-
- let mesg;
- let last_change;
-
- match pts_path.metadata() {
- #[allow(clippy::unnecessary_cast)]
- Ok(meta) => {
- mesg = if meta.mode() & S_IWGRP as u32 != 0 {
- ' '
- } else {
- '*'
- };
- last_change = meta.atime();
- }
- _ => {
- mesg = '?';
- last_change = 0;
- }
- }
-
- print!("{1:<8.0$}", utmpx::UT_NAMESIZE, ut.user());
-
- if self.include_fullname {
- let fullname = if let Ok(pw) = Passwd::locate(ut.user().as_ref()) {
- gecos_to_fullname(&pw)
- } else {
- None
- };
- if let Some(fullname) = fullname {
- print!(" {:<19.19}", fullname);
- } else {
- print!(" {:19}", " ???");
- }
- }
-
- print!(" {}{:<8.*}", mesg, utmpx::UT_LINESIZE, ut.tty_device());
-
- if self.include_idle {
- if last_change != 0 {
- print!(" {:<6}", idle_string(last_change));
- } else {
- print!(" {:<6}", "?????");
- }
- }
-
- print!(" {}", time_string(ut));
-
- let mut s = ut.host();
- if self.include_where && !s.is_empty() {
- s = ut.canon_host()?;
- print!(" {}", s);
- }
-
- println!();
- Ok(())
- }
-
- fn print_heading(&self) {
- print!("{:<8}", "Login");
- if self.include_fullname {
- print!(" {:<19}", "Name");
- }
- print!(" {:<9}", " TTY");
- if self.include_idle {
- print!(" {:<6}", "Idle");
- }
- print!(" {:<16}", "When");
- if self.include_where {
- print!(" Where");
- }
- println!();
- }
-
- fn short_pinky(&self) -> std::io::Result<()> {
- if self.include_heading {
- self.print_heading();
- }
- for ut in Utmpx::iter_all_records() {
- if ut.is_user_process()
- && (self.names.is_empty() || self.names.iter().any(|n| n.as_str() == ut.user()))
- {
- self.print_entry(&ut)?;
- }
- }
- Ok(())
- }
-
- fn long_pinky(&self) {
- for u in &self.names {
- print!("Login name: {:<28}In real life: ", u);
- if let Ok(pw) = Passwd::locate(u.as_str()) {
- let fullname = gecos_to_fullname(&pw).unwrap_or_default();
- let user_dir = pw.user_dir.unwrap_or_default();
- let user_shell = pw.user_shell.unwrap_or_default();
- println!(" {}", fullname);
- if self.include_home_and_shell {
- print!("Directory: {:<29}", user_dir);
- println!("Shell: {}", user_shell);
- }
- if self.include_project {
- let mut p = PathBuf::from(&user_dir);
- p.push(".project");
- if let Ok(f) = File::open(p) {
- print!("Project: ");
- read_to_console(f);
- }
- }
- if self.include_plan {
- let mut p = PathBuf::from(&user_dir);
- p.push(".plan");
- if let Ok(f) = File::open(p) {
- println!("Plan:");
- read_to_console(f);
- }
- }
- println!();
- } else {
- println!(" ???");
- }
- }
- }
-}
-
-fn read_to_console<F: Read>(f: F) {
- let mut reader = BufReader::new(f);
- let mut iobuf = Vec::new();
- if reader.read_to_end(&mut iobuf).is_ok() {
- print!("{}", String::from_utf8_lossy(&iobuf));
- }
-}
diff --git a/src/uu/pinky/src/platform/mod.rs b/src/uu/pinky/src/platform/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e0e87dca1bffedbe7294e28e91972aabbe174c11
--- /dev/null
+++ b/src/uu/pinky/src/platform/mod.rs
@@ -0,0 +1,14 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+#[cfg(not(target_os = "openbsd"))]
+mod unix;
+#[cfg(not(target_os = "openbsd"))]
+pub use self::unix::*;
+
+#[cfg(target_os = "openbsd")]
+mod openbsd;
+#[cfg(target_os = "openbsd")]
+pub use self::openbsd::*;
diff --git a/src/uu/pinky/src/platform/openbsd.rs b/src/uu/pinky/src/platform/openbsd.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7e6970c1f0992b3954bcb9b7548e371adcef6d30
--- /dev/null
+++ b/src/uu/pinky/src/platform/openbsd.rs
@@ -0,0 +1,17 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// Specific implementation for OpenBSD: tool unsupported (utmpx not supported)
+
+use crate::uu_app;
+
+use uucore::error::UResult;
+
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+ let _matches = uu_app().try_get_matches_from(args)?;
+
+ println!("unsupported command on OpenBSD");
+ Ok(())
+}
diff --git a/src/uu/pinky/src/platform/unix.rs b/src/uu/pinky/src/platform/unix.rs
new file mode 100644
index 0000000000000000000000000000000000000000..aa6d57b3f6ad7170028062e92cb0d1261408bc0e
--- /dev/null
+++ b/src/uu/pinky/src/platform/unix.rs
@@ -0,0 +1,291 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore (ToDO) BUFSIZE gecos fullname, mesg iobuf
+
+use crate::options;
+use crate::uu_app;
+use crate::Capitalize;
+
+use uucore::entries::{Locate, Passwd};
+use uucore::error::{FromIo, UResult};
+use uucore::libc::S_IWGRP;
+use uucore::utmpx::{self, time, Utmpx};
+
+use std::io::prelude::*;
+use std::io::BufReader;
+
+use std::fs::File;
+use std::os::unix::fs::MetadataExt;
+
+use std::path::PathBuf;
+
+fn get_long_usage() -> String {
+ format!(
+ "A lightweight 'finger' program; print user information.\n\
+ The utmp file will be {}.",
+ utmpx::DEFAULT_FILE
+ )
+}
+
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+ let matches = uu_app()
+ .after_help(get_long_usage())
+ .try_get_matches_from(args)?;
+
+ let users: Vec<String> = matches
+ .get_many::<String>(options::USER)
+ .map(|v| v.map(ToString::to_string).collect())
+ .unwrap_or_default();
+
+ // If true, display the hours:minutes since each user has touched
+ // the keyboard, or blank if within the last minute, or days followed
+ // by a 'd' if not within the last day.
+ let mut include_idle = true;
+
+ // If true, display a line at the top describing each field.
+ let include_heading = !matches.get_flag(options::OMIT_HEADINGS);
+
+ // if true, display the user's full name from pw_gecos.
+ let mut include_fullname = true;
+
+ // if true, display the user's ~/.project file when doing long format.
+ let include_project = !matches.get_flag(options::OMIT_PROJECT_FILE);
+
+ // if true, display the user's ~/.plan file when doing long format.
+ let include_plan = !matches.get_flag(options::OMIT_PLAN_FILE);
+
+ // if true, display the user's home directory and shell
+ // when doing long format.
+ let include_home_and_shell = !matches.get_flag(options::OMIT_HOME_DIR);
+
+ // if true, use the "short" output format.
+ let do_short_format = !matches.get_flag(options::LONG_FORMAT);
+
+ /* if true, display the ut_host field. */
+ let mut include_where = true;
+
+ if matches.get_flag(options::OMIT_NAME) {
+ include_fullname = false;
+ }
+ if matches.get_flag(options::OMIT_NAME_HOST) {
+ include_fullname = false;
+ include_where = false;
+ }
+ if matches.get_flag(options::OMIT_NAME_HOST_TIME) {
+ include_fullname = false;
+ include_idle = false;
+ include_where = false;
+ }
+
+ let pk = Pinky {
+ include_idle,
+ include_heading,
+ include_fullname,
+ include_project,
+ include_plan,
+ include_home_and_shell,
+ include_where,
+ names: users,
+ };
+
+ if do_short_format {
+ match pk.short_pinky() {
+ Ok(_) => Ok(()),
+ Err(e) => Err(e.map_err_context(String::new)),
+ }
+ } else {
+ pk.long_pinky();
+ Ok(())
+ }
+}
+
+struct Pinky {
+ include_idle: bool,
+ include_heading: bool,
+ include_fullname: bool,
+ include_project: bool,
+ include_plan: bool,
+ include_where: bool,
+ include_home_and_shell: bool,
+ names: Vec<String>,
+}
+
+fn idle_string(when: i64) -> String {
+ thread_local! {
+ static NOW: time::OffsetDateTime = time::OffsetDateTime::now_local().unwrap_or_else(|_| time::OffsetDateTime::now_utc());
+ }
+ NOW.with(|n| {
+ let duration = n.unix_timestamp() - when;
+ if duration < 60 {
+ // less than 1min
+ " ".to_owned()
+ } else if duration < 24 * 3600 {
+ // less than 1day
+ let hours = duration / (60 * 60);
+ let minutes = (duration % (60 * 60)) / 60;
+ format!("{hours:02}:{minutes:02}")
+ } else {
+ // more than 1day
+ let days = duration / (24 * 3600);
+ format!("{days}d")
+ }
+ })
+}
+
+fn time_string(ut: &Utmpx) -> String {
+ // "%b %e %H:%M"
+ let time_format: Vec<time::format_description::FormatItem> =
+ time::format_description::parse("[month repr:short] [day padding:space] [hour]:[minute]")
+ .unwrap();
+ ut.login_time().format(&time_format).unwrap() // LC_ALL=C
+}
+
+fn gecos_to_fullname(pw: &Passwd) -> Option<String> {
+ let mut gecos = if let Some(gecos) = &pw.user_info {
+ gecos.clone()
+ } else {
+ return None;
+ };
+ if let Some(n) = gecos.find(',') {
+ gecos.truncate(n);
+ }
+ Some(gecos.replace('&', &pw.name.capitalize()))
+}
+
+impl Pinky {
+ fn print_entry(&self, ut: &Utmpx) -> std::io::Result<()> {
+ let mut pts_path = PathBuf::from("/dev");
+ pts_path.push(ut.tty_device().as_str());
+
+ let mesg;
+ let last_change;
+
+ match pts_path.metadata() {
+ #[allow(clippy::unnecessary_cast)]
+ Ok(meta) => {
+ mesg = if meta.mode() & S_IWGRP as u32 == 0 {
+ '*'
+ } else {
+ ' '
+ };
+ last_change = meta.atime();
+ }
+ _ => {
+ mesg = '?';
+ last_change = 0;
+ }
+ }
+
+ print!("{1:<8.0$}", utmpx::UT_NAMESIZE, ut.user());
+
+ if self.include_fullname {
+ let fullname = if let Ok(pw) = Passwd::locate(ut.user().as_ref()) {
+ gecos_to_fullname(&pw)
+ } else {
+ None
+ };
+ if let Some(fullname) = fullname {
+ print!(" {fullname:<19.19}");
+ } else {
+ print!(" {:19}", " ???");
+ }
+ }
+
+ print!(" {}{:<8.*}", mesg, utmpx::UT_LINESIZE, ut.tty_device());
+
+ if self.include_idle {
+ if last_change == 0 {
+ print!(" {:<6}", "?????");
+ } else {
+ print!(" {:<6}", idle_string(last_change));
+ }
+ }
+
+ print!(" {}", time_string(ut));
+
+ let mut s = ut.host();
+ if self.include_where && !s.is_empty() {
+ s = ut.canon_host()?;
+ print!(" {s}");
+ }
+
+ println!();
+ Ok(())
+ }
+
+ fn print_heading(&self) {
+ print!("{:<8}", "Login");
+ if self.include_fullname {
+ print!(" {:<19}", "Name");
+ }
+ print!(" {:<9}", " TTY");
+ if self.include_idle {
+ print!(" {:<6}", "Idle");
+ }
+ print!(" {:<16}", "When");
+ if self.include_where {
+ print!(" Where");
+ }
+ println!();
+ }
+
+ fn short_pinky(&self) -> std::io::Result<()> {
+ if self.include_heading {
+ self.print_heading();
+ }
+ for ut in Utmpx::iter_all_records() {
+ if ut.is_user_process()
+ && (self.names.is_empty() || self.names.iter().any(|n| n.as_str() == ut.user()))
+ {
+ self.print_entry(&ut)?;
+ }
+ }
+ Ok(())
+ }
+
+ fn long_pinky(&self) {
+ for u in &self.names {
+ print!("Login name: {u:<28}In real life: ");
+ if let Ok(pw) = Passwd::locate(u.as_str()) {
+ let fullname = gecos_to_fullname(&pw).unwrap_or_default();
+ let user_dir = pw.user_dir.unwrap_or_default();
+ let user_shell = pw.user_shell.unwrap_or_default();
+ println!(" {fullname}");
+ if self.include_home_and_shell {
+ print!("Directory: {user_dir:<29}");
+ println!("Shell: {user_shell}");
+ }
+ if self.include_project {
+ let mut p = PathBuf::from(&user_dir);
+ p.push(".project");
+ if let Ok(f) = File::open(p) {
+ print!("Project: ");
+ read_to_console(f);
+ }
+ }
+ if self.include_plan {
+ let mut p = PathBuf::from(&user_dir);
+ p.push(".plan");
+ if let Ok(f) = File::open(p) {
+ println!("Plan:");
+ read_to_console(f);
+ }
+ }
+ println!();
+ } else {
+ println!(" ???");
+ }
+ }
+ }
+}
+
+fn read_to_console<F: Read>(f: F) {
+ let mut reader = BufReader::new(f);
+ let mut iobuf = Vec::new();
+ if reader.read_to_end(&mut iobuf).is_ok() {
+ print!("{}", String::from_utf8_lossy(&iobuf));
+ }
+}
diff --git a/src/uu/pr/Cargo.toml b/src/uu/pr/Cargo.toml
index 310ce07a27cebb24f1c9066515d57d70c5b33579..d7391dd134949708541baadfdfa3b762a0137cd6 100644
--- a/src/uu/pr/Cargo.toml
+++ b/src/uu/pr/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_pr"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "pr ~ (uutils) convert text files for printing"
@@ -15,12 +15,12 @@ edition = "2021"
path = "src/pr.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-time = { version = "0.3", features = ["local-offset", "macros", "formatting"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["entries"] }
-quick-error = "2.0.1"
-itertools = "0.10.0"
-regex = "1.7"
+clap = { workspace = true }
+uucore = { workspace = true, features = ["entries"] }
+quick-error = { workspace = true }
+itertools = { workspace = true }
+regex = { workspace = true }
+chrono = { workspace = true }
[[bin]]
name = "pr"
diff --git a/src/uu/pr/pr.md b/src/uu/pr/pr.md
new file mode 100644
index 0000000000000000000000000000000000000000..cd2f552f3de22d634bb055ce6d1fbd22c5fcfe5a
--- /dev/null
+++ b/src/uu/pr/pr.md
@@ -0,0 +1,27 @@
+# pr
+
+```
+pr [OPTION]... [FILE]...
+```
+
+Write content of given file or standard input to standard output with pagination filter
+
+## After help
+
+`+PAGE` Begin output at page number page of the formatted input.
+`-COLUMN` Produce multi-column output. See `--column`
+
+The pr utility is a printing and pagination filter for text files.
+When multiple input files are specified, each is read, formatted, and written to standard output.
+By default, the input is separated into 66-line pages, each with
+
+* A 5-line header with the page number, date, time, and the pathname of the file.
+* A 5-line trailer consisting of blank lines.
+
+If standard output is associated with a terminal, diagnostic messages are suppressed until the pr
+utility has completed processing.
+
+When multiple column output is specified, text columns are of equal width.
+By default, text columns are separated by at least one `<blank>`.
+Input lines that do not fit into a text column are truncated.
+Lines are not truncated under single column output.
diff --git a/src/uu/pr/src/pr.rs b/src/uu/pr/src/pr.rs
index 231e07766846294c20f948807cdb18f4a3448be3..41bf5d416311a6014547e87a71a1e9db0ecf58b8 100644
--- a/src/uu/pr/src/pr.rs
+++ b/src/uu/pr/src/pr.rs
@@ -1,53 +1,29 @@
// This file is part of the uutils coreutils package.
//
-// For the full copyright and license information, please view the LICENSE file
-// that was distributed with this source code.
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//
// spell-checker:ignore (ToDO) adFfmprt, kmerge
+use chrono::{DateTime, Local};
use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
use itertools::Itertools;
use quick_error::ResultExt;
use regex::Regex;
-use std::convert::From;
use std::fs::{metadata, File};
use std::io::{stdin, stdout, BufRead, BufReader, Lines, Read, Write};
#[cfg(unix)]
use std::os::unix::fs::FileTypeExt;
-use time::macros::format_description;
-use time::OffsetDateTime;
use quick_error::quick_error;
use uucore::display::Quotable;
use uucore::error::UResult;
+use uucore::{format_usage, help_about, help_section, help_usage};
-const ABOUT: &str =
- "Write content of given file or standard input to standard output with pagination filter";
-const AFTER_HELP: &str =
- " +PAGE\n Begin output at page number page of the formatted input.
- -COLUMN\n Produce multi-column output. See --column
-
-The pr utility is a printing and pagination filter
-for text files. When multiple input files are specified,
-each is read, formatted, and written to standard
-output. By default, the input is separated
-into 66-line pages, each with
-
-o A 5-line header with the page number, date,
- time, and the pathname of the file.
-
-o A 5-line trailer consisting of blank lines.
-
-If standard output is associated with a terminal,
-diagnostic messages are suppressed until the pr
-utility has completed processing.
-
-When multiple column output is specified, text columns
-are of equal width. By default text columns
-are separated by at least one <blank>. Input lines
-that do not fit into a text column are truncated.
-Lines are not truncated under single column output.";
+const ABOUT: &str = help_about!("pr.md");
+const USAGE: &str = help_usage!("pr.md");
+const AFTER_HELP: &str = help_section!("after help", "pr.md");
const TAB: char = '\t';
const LINES_PER_PAGE: usize = 66;
const LINES_PER_PAGE_FOR_FORM_FEED: usize = 63;
@@ -59,8 +35,7 @@ const DEFAULT_COLUMN_WIDTH: usize = 72;
const DEFAULT_COLUMN_WIDTH_WITH_S_OPTION: usize = 512;
const DEFAULT_COLUMN_SEPARATOR: &char = &TAB;
const FF: u8 = 0x0C_u8;
-const DATE_TIME_FORMAT: &[time::format_description::FormatItem] =
- format_description!("[month repr:short] [day] [hour]:[minute] [year]");
+const DATE_TIME_FORMAT: &str = "%b %d %H:%M %Y";
mod options {
pub const HEADER: &str = "header";
@@ -195,6 +170,7 @@ pub fn uu_app() -> Command {
.version(crate_version!())
.about(ABOUT)
.after_help(AFTER_HELP)
+ .override_usage(format_usage(USAGE))
.infer_long_args(true)
.args_override_self(true)
.disable_help_flag(true)
@@ -410,13 +386,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let opt_args = recreate_arguments(&args);
let mut command = uu_app();
- let matches = match command.try_get_matches_from_mut(opt_args) {
- Ok(m) => m,
- Err(e) => {
- e.print()?;
- return Ok(());
- }
- };
+ let matches = command.try_get_matches_from_mut(opt_args)?;
let mut files = matches
.get_many::<String>(options::FILES)
@@ -491,7 +461,7 @@ fn recreate_arguments(args: &[String]) -> Vec<String> {
fn print_error(matches: &ArgMatches, err: &PrError) {
if !matches.get_flag(options::NO_FILE_WARNINGS) {
- eprintln!("{}", err);
+ eprintln!("{err}");
}
}
@@ -505,10 +475,11 @@ fn parse_usize(matches: &ArgMatches, opt: &str) -> Option<Result<usize, PrError>
};
matches
.get_one::<String>(opt)
- .map(|i| (i.to_string(), format!("-{}", opt)))
+ .map(|i| (i.to_string(), format!("-{opt}")))
.map(from_parse_error_to_pr_error)
}
+#[allow(clippy::cognitive_complexity)]
fn build_options(
matches: &ArgMatches,
paths: &[&str],
@@ -591,28 +562,27 @@ fn build_options(
let line_separator = "\n".to_string();
let last_modified_time = if is_merge_mode || paths[0].eq(FILE_STDIN) {
- // let date_time = Local::now();
- // date_time.format("%b %d %H:%M %Y").to_string()
- let date_time = OffsetDateTime::now_local().unwrap();
- date_time.format(&DATE_TIME_FORMAT).unwrap()
+ let date_time = Local::now();
+ date_time.format(DATE_TIME_FORMAT).to_string()
} else {
file_last_modified_time(paths.first().unwrap())
};
// +page option is less priority than --pages
let page_plus_re = Regex::new(r"\s*\+(\d+:*\d*)\s*").unwrap();
- let start_page_in_plus_option = match page_plus_re.captures(free_args).map(|i| {
+ let res = page_plus_re.captures(free_args).map(|i| {
let unparsed_num = i.get(1).unwrap().as_str().trim();
let x: Vec<_> = unparsed_num.split(':').collect();
x[0].to_string().parse::<usize>().map_err(|_e| {
PrError::EncounteredErrors(format!("invalid {} argument {}", "+", unparsed_num.quote()))
})
- }) {
+ });
+ let start_page_in_plus_option = match res {
Some(res) => res?,
None => 1,
};
- let end_page_in_plus_option = match page_plus_re
+ let res = page_plus_re
.captures(free_args)
.map(|i| i.get(1).unwrap().as_str().trim())
.filter(|i| i.contains(':'))
@@ -625,7 +595,8 @@ fn build_options(
unparsed_num.quote()
))
})
- }) {
+ });
+ let end_page_in_plus_option = match res {
Some(res) => Some(res?),
None => None,
};
@@ -640,27 +611,27 @@ fn build_options(
})
};
- let start_page = match matches
+ let res = matches
.get_one::<String>(options::PAGES)
.map(|i| {
let x: Vec<_> = i.split(':').collect();
x[0].to_string()
})
- .map(invalid_pages_map)
- {
+ .map(invalid_pages_map);
+ let start_page = match res {
Some(res) => res?,
None => start_page_in_plus_option,
};
- let end_page = match matches
+ let res = matches
.get_one::<String>(options::PAGES)
.filter(|i| i.contains(':'))
.map(|i| {
let x: Vec<_> = i.split(':').collect();
x[1].to_string()
})
- .map(invalid_pages_map)
- {
+ .map(invalid_pages_map);
+ let end_page = match res {
Some(res) => Some(res?),
None => end_page_in_plus_option,
};
@@ -668,8 +639,7 @@ fn build_options(
if let Some(end_page) = end_page {
if start_page > end_page {
return Err(PrError::EncounteredErrors(format!(
- "invalid --pages argument '{}:{}'",
- start_page, end_page
+ "invalid --pages argument '{start_page}:{end_page}'"
)));
}
}
@@ -732,12 +702,13 @@ fn build_options(
let re_col = Regex::new(r"\s*-(\d+)\s*").unwrap();
- let start_column_option = match re_col.captures(free_args).map(|i| {
+ let res = re_col.captures(free_args).map(|i| {
let unparsed_num = i.get(1).unwrap().as_str().trim();
unparsed_num.parse::<usize>().map_err(|_e| {
PrError::EncounteredErrors(format!("invalid {} argument {}", "-", unparsed_num.quote()))
})
- }) {
+ });
+ let start_column_option = match res {
Some(res) => Some(res?),
None => None,
};
@@ -985,7 +956,7 @@ fn mpr(paths: &[&str], options: &OutputOptions) -> Result<i32, PrError> {
a.group_key < b.group_key
}
})
- .group_by(|file_line| file_line.group_key);
+ .chunk_by(|file_line| file_line.group_key);
let start_page = options.start_page;
let mut lines = Vec::new();
@@ -1043,6 +1014,7 @@ fn print_page(
Ok(lines_written)
}
+#[allow(clippy::cognitive_complexity)]
fn write_columns(
lines: &[FileLine],
options: &OutputOptions,
@@ -1203,7 +1175,7 @@ fn get_formatted_line_number(opts: &OutputOptions, line_number: usize, index: us
separator
)
} else {
- format!("{:>width$}{}", line_str, separator)
+ format!("{line_str:>width$}{separator}")
}
} else {
String::new()
@@ -1235,12 +1207,8 @@ fn file_last_modified_time(path: &str) -> String {
.map(|i| {
i.modified()
.map(|x| {
- let date_time: OffsetDateTime = x.into();
- let offset = OffsetDateTime::now_local().unwrap().offset();
- date_time
- .to_offset(offset)
- .format(&DATE_TIME_FORMAT)
- .unwrap()
+ let date_time: DateTime<Local> = x.into();
+ date_time.format(DATE_TIME_FORMAT).to_string()
})
.unwrap_or_default()
})
diff --git a/src/uu/printenv/Cargo.toml b/src/uu/printenv/Cargo.toml
index b81c3906de8c53385ac6586654d4c0a0f934007a..5e2f3409174ad35cd1ad504a503bcf7c9a5add59 100644
--- a/src/uu/printenv/Cargo.toml
+++ b/src/uu/printenv/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_printenv"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "printenv ~ (uutils) display value of environment VAR"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/printenv.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "printenv"
diff --git a/src/uu/printenv/printenv.md b/src/uu/printenv/printenv.md
new file mode 100644
index 0000000000000000000000000000000000000000..f67d46a23dd6d5b679749ca97e4d5ec8e975b8c1
--- /dev/null
+++ b/src/uu/printenv/printenv.md
@@ -0,0 +1,7 @@
+# printenv
+
+```
+printenv [OPTION]... [VARIABLE]...
+```
+
+Display the values of the specified environment VARIABLE(s), or (with no VARIABLE) display name and value pairs for them all.
diff --git a/src/uu/printenv/src/printenv.rs b/src/uu/printenv/src/printenv.rs
index 3e7a7c5f91d114917aadf5c17526d4c4e192424c..47bd7c259b6278447e2a0cac8f89983788ad33c3 100644
--- a/src/uu/printenv/src/printenv.rs
+++ b/src/uu/printenv/src/printenv.rs
@@ -1,18 +1,14 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Jordi Boggiano <j.boggiano@seld.be>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
-
-/* last synced with: printenv (GNU coreutils) 8.13 */
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use clap::{crate_version, Arg, ArgAction, Command};
use std::env;
-use uucore::{error::UResult, format_usage};
+use uucore::{error::UResult, format_usage, help_about, help_usage};
-static ABOUT: &str = "Display the values of the specified environment VARIABLE(s), or (with no VARIABLE) display name and value pairs for them all.";
-const USAGE: &str = "{} [VARIABLE]... [OPTION]...";
+const ABOUT: &str = help_about!("printenv.md");
+const USAGE: &str = help_usage!("printenv.md");
static OPT_NULL: &str = "null";
@@ -35,7 +31,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
if variables.is_empty() {
for (env_var, value) in env::vars() {
- print!("{}={}{}", env_var, value, separator);
+ print!("{env_var}={value}{separator}");
}
return Ok(());
}
@@ -48,7 +44,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
continue;
}
if let Ok(var) = env::var(env_var) {
- print!("{}{}", var, separator);
+ print!("{var}{separator}");
} else {
error_found = true;
}
diff --git a/src/uu/printf/Cargo.toml b/src/uu/printf/Cargo.toml
index 548641b76f7e890fd3174350c122d488c7d00740..9f8d7334383d7f7ecb49a5215f0842fdb5711b22 100644
--- a/src/uu/printf/Cargo.toml
+++ b/src/uu/printf/Cargo.toml
@@ -1,10 +1,7 @@
[package]
name = "uu_printf"
-version = "0.0.17"
-authors = [
- "Nathan Ross",
- "uutils developers",
-]
+version = "0.0.27"
+authors = ["Nathan Ross", "uutils developers"]
license = "MIT"
description = "printf ~ (uutils) FORMAT and display ARGUMENTS"
@@ -18,8 +15,8 @@ edition = "2021"
path = "src/printf.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["memo"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["format", "quoting-style"] }
[[bin]]
name = "printf"
diff --git a/src/uu/printf/printf.md b/src/uu/printf/printf.md
new file mode 100644
index 0000000000000000000000000000000000000000..fad5d01e30b86385ee0c9ecc9f05f694f862b970
--- /dev/null
+++ b/src/uu/printf/printf.md
@@ -0,0 +1,274 @@
+<!-- spell-checker:ignore formatstring templating parameterizing each's -->
+
+# printf
+
+```
+printf FORMATSTRING [ARGUMENT]...
+printf FORMAT [ARGUMENT]...
+printf OPTION
+```
+
+Print output based off of the format string and proceeding arguments.
+
+## After Help
+
+basic anonymous string templating:
+
+prints format string at least once, repeating as long as there are remaining arguments
+output prints escaped literals in the format string as character literals
+output replaces anonymous fields with the next unused argument, formatted according to the field.
+
+Prints the `,` replacing escaped character sequences with character literals
+and substitution field sequences with passed arguments
+
+literally, with the exception of the below
+escaped character sequences, and the substitution sequences described further down.
+
+### ESCAPE SEQUENCES
+
+The following escape sequences, organized here in alphabetical order,
+will print the corresponding character literal:
+
+* `\"` double quote
+
+* `\\\\` backslash
+
+* `\\a` alert (BEL)
+
+* `\\b` backspace
+
+* `\\c` End-of-Input
+
+* `\\e` escape
+
+* `\\f` form feed
+
+* `\\n` new line
+
+* `\\r` carriage return
+
+* `\\t` horizontal tab
+
+* `\\v` vertical tab
+
+* `\\NNN` byte with value expressed in octal value NNN (1 to 3 digits)
+ values greater than 256 will be treated
+
+* `\\xHH` byte with value expressed in hexadecimal value NN (1 to 2 digits)
+
+* `\\uHHHH` Unicode (IEC 10646) character with value expressed in hexadecimal value HHHH (4 digits)
+
+* `\\uHHHH` Unicode character with value expressed in hexadecimal value HHHH (8 digits)
+
+* `%%` a single %
+
+### SUBSTITUTIONS
+
+#### SUBSTITUTION QUICK REFERENCE
+
+Fields
+
+* `%s`: string
+* `%b`: string parsed for literals second parameter is max length
+
+* `%c`: char no second parameter
+
+* `%i` or `%d`: 64-bit integer
+* `%u`: 64 bit unsigned integer
+* `%x` or `%X`: 64-bit unsigned integer as hex
+* `%o`: 64-bit unsigned integer as octal
+ second parameter is min-width, integer
+ output below that width is padded with leading zeroes
+
+* `%q`: ARGUMENT is printed in a format that can be reused as shell input, escaping non-printable
+ characters with the proposed POSIX $'' syntax.
+
+* `%f` or `%F`: decimal floating point value
+* `%e` or `%E`: scientific notation floating point value
+* `%g` or `%G`: shorter of specially interpreted decimal or SciNote floating point value.
+ second parameter is
+ `-max` places after decimal point for floating point output
+ `-max` number of significant digits for scientific notation output
+
+parameterizing fields
+
+examples:
+
+```
+printf '%4.3i' 7
+```
+
+It has a first parameter of 4 and a second parameter of 3 and will result in ' 007'
+
+```
+printf '%.1s' abcde
+```
+
+It has no first parameter and a second parameter of 1 and will result in 'a'
+
+```
+printf '%4c' q
+```
+
+It has a first parameter of 4 and no second parameter and will result in ' q'
+
+The first parameter of a field is the minimum width to pad the output to
+if the output is less than this absolute value of this width,
+it will be padded with leading spaces, or, if the argument is negative,
+with trailing spaces. the default is zero.
+
+The second parameter of a field is particular to the output field type.
+defaults can be found in the full substitution help below
+
+special prefixes to numeric arguments
+
+* `0`: (e.g. 010) interpret argument as octal (integer output fields only)
+* `0x`: (e.g. 0xABC) interpret argument as hex (numeric output fields only)
+* `\'`: (e.g. \'a) interpret argument as a character constant
+
+#### HOW TO USE SUBSTITUTIONS
+
+Substitutions are used to pass additional argument(s) into the FORMAT string, to be formatted a
+particular way. E.g.
+
+```
+printf 'the letter %X comes before the letter %X' 10 11
+```
+
+will print
+
+```
+the letter A comes before the letter B
+```
+
+because the substitution field `%X` means
+'take an integer argument and write it as a hexadecimal number'
+
+Passing more arguments than are in the format string will cause the format string to be
+repeated for the remaining substitutions
+
+```
+printf 'it is %i F in %s \n' 22 Portland 25 Boston 27 New York
+```
+
+will print
+
+```
+it is 22 F in Portland
+it is 25 F in Boston
+it is 27 F in Boston
+```
+
+If a format string is printed but there are less arguments remaining
+than there are substitution fields, substitution fields without
+an argument will default to empty strings, or for numeric fields
+the value 0
+
+#### AVAILABLE SUBSTITUTIONS
+
+This program, like GNU coreutils printf,
+interprets a modified subset of the POSIX C printf spec,
+a quick reference to substitutions is below.
+
+#### STRING SUBSTITUTIONS
+
+All string fields have a 'max width' parameter
+`%.3s` means 'print no more than three characters of the original input'
+
+* `%s`: string
+
+* `%b`: escaped string - the string will be checked for any escaped literals from
+ the escaped literal list above, and translate them to literal characters.
+ e.g. `\\n` will be transformed into a newline character.
+ One special rule about `%b` mode is that octal literals are interpreted differently
+ In arguments passed by `%b`, pass octal-interpreted literals must be in the form of `\\0NNN`
+ instead of `\\NNN`. (Although, for legacy reasons, octal literals in the form of `\\NNN` will
+ still be interpreted and not throw a warning, you will have problems if you use this for a
+ literal whose code begins with zero, as it will be viewed as in `\\0NNN` form.)
+
+* `%q`: escaped string - the string in a format that can be reused as input by most shells.
+ Non-printable characters are escaped with the POSIX proposed ‘$''’ syntax,
+ and shell meta-characters are quoted appropriately.
+ This is an equivalent format to ls --quoting=shell-escape output.
+
+#### CHAR SUBSTITUTIONS
+
+The character field does not have a secondary parameter.
+
+* `%c`: a single character
+
+#### INTEGER SUBSTITUTIONS
+
+All integer fields have a 'pad with zero' parameter
+`%.4i` means an integer which if it is less than 4 digits in length,
+is padded with leading zeros until it is 4 digits in length.
+
+* `%d` or `%i`: 64-bit integer
+
+* `%u`: 64-bit unsigned integer
+
+* `%x` or `%X`: 64-bit unsigned integer printed in Hexadecimal (base 16)
+ `%X` instead of `%x` means to use uppercase letters for 'a' through 'f'
+
+* `%o`: 64-bit unsigned integer printed in octal (base 8)
+
+#### FLOATING POINT SUBSTITUTIONS
+
+All floating point fields have a 'max decimal places / max significant digits' parameter
+`%.10f` means a decimal floating point with 7 decimal places past 0
+`%.10e` means a scientific notation number with 10 significant digits
+`%.10g` means the same behavior for decimal and Sci. Note, respectively, and provides the shortest
+of each's output.
+
+Like with GNU coreutils, the value after the decimal point is these outputs is parsed as a
+double first before being rendered to text. For both implementations do not expect meaningful
+precision past the 18th decimal place. When using a number of decimal places that is 18 or
+higher, you can expect variation in output between GNU coreutils printf and this printf at the
+18th decimal place of +/- 1
+
+* `%f`: floating point value presented in decimal, truncated and displayed to 6 decimal places by
+ default. There is not past-double behavior parity with Coreutils printf, values are not
+ estimated or adjusted beyond input values.
+
+* `%e` or `%E`: floating point value presented in scientific notation
+ 7 significant digits by default
+ `%E` means use to use uppercase E for the mantissa.
+
+* `%g` or `%G`: floating point value presented in the shortest of decimal and scientific notation
+ behaves differently from `%f` and `%E`, please see posix printf spec for full details,
+ some examples of different behavior:
+ Sci Note has 6 significant digits by default
+ Trailing zeroes are removed
+ Instead of being truncated, digit after last is rounded
+
+Like other behavior in this utility, the design choices of floating point
+behavior in this utility is selected to reproduce in exact
+the behavior of GNU coreutils' printf from an inputs and outputs standpoint.
+
+### USING PARAMETERS
+
+Most substitution fields can be parameterized using up to 2 numbers that can
+be passed to the field, between the % sign and the field letter.
+
+The 1st parameter always indicates the minimum width of output, it is useful for creating
+columnar output. Any output that would be less than this minimum width is padded with
+leading spaces
+The 2nd parameter is proceeded by a dot.
+You do not have to use parameters
+
+### SPECIAL FORMS OF INPUT
+
+For numeric input, the following additional forms of input are accepted besides decimal:
+
+Octal (only with integer): if the argument begins with a 0 the proceeding characters
+will be interpreted as octal (base 8) for integer fields
+
+Hexadecimal: if the argument begins with 0x the proceeding characters will be interpreted
+will be interpreted as hex (base 16) for any numeric fields
+for float fields, hexadecimal input results in a precision
+limit (in converting input past the decimal point) of 10^-15
+
+Character Constant: if the argument begins with a single quote character, the first byte
+of the next character will be interpreted as an 8-bit unsigned integer. If there are
+additional bytes, they will throw an error (unless the environment variable POSIXLY_CORRECT
+is set)
diff --git a/src/uu/printf/src/mod.rs b/src/uu/printf/src/mod.rs
index 26710c101cbcf91c9013ac22c796aa8f9cf3ee18..759b823ccda1f026f248ed88c0e37ecd771f4179 100644
--- a/src/uu/printf/src/mod.rs
+++ b/src/uu/printf/src/mod.rs
@@ -1 +1,5 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
mod cli;
diff --git a/src/uu/printf/src/printf.rs b/src/uu/printf/src/printf.rs
index 2592f212d1fdcd3a42c202ea1a7e316576ef89dc..c98bb59a1e46bad264eb528f8c0e2ba660fc8345 100644
--- a/src/uu/printf/src/printf.rs
+++ b/src/uu/printf/src/printf.rs
@@ -1,268 +1,24 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
#![allow(dead_code)]
// spell-checker:ignore (change!) each's
// spell-checker:ignore (ToDO) LONGHELP FORMATSTRING templating parameterizing formatstr
+use std::io::stdout;
+use std::ops::ControlFlow;
+
use clap::{crate_version, Arg, ArgAction, Command};
use uucore::error::{UResult, UUsageError};
-use uucore::format_usage;
-use uucore::memo::printf;
+use uucore::format::{parse_spec_and_escape, FormatArgument, FormatItem};
+use uucore::{format_usage, help_about, help_section, help_usage};
const VERSION: &str = "version";
const HELP: &str = "help";
-const USAGE: &str = "{} FORMATSTRING [ARGUMENT]...";
-const ABOUT: &str = "Print output based off of the format string and proceeding arguments.";
-const AFTER_HELP: &str = "
-basic anonymous string templating:
-
-prints format string at least once, repeating as long as there are remaining arguments
-output prints escaped literals in the format string as character literals
-output replaces anonymous fields with the next unused argument, formatted according to the field.
-
-Prints the , replacing escaped character sequences with character literals
- and substitution field sequences with passed arguments
-
-literally, with the exception of the below
- escaped character sequences, and the substitution sequences described further down.
-
-ESCAPE SEQUENCES
-
-The following escape sequences, organized here in alphabetical order,
-will print the corresponding character literal:
-
-\" double quote
-
-\\\\ backslash
-
-\\a alert (BEL)
-
-\\b backspace
-
-\\c End-of-Input
-
-\\e escape
-
-\\f form feed
-
-\\n new line
-
-\\r carriage return
-
-\\t horizontal tab
-
-\\v vertical tab
-
-\\NNN byte with value expressed in octal value NNN (1 to 3 digits)
- values greater than 256 will be treated
-
-\\xHH byte with value expressed in hexadecimal value NN (1 to 2 digits)
-
-\\uHHHH Unicode (IEC 10646) character with value expressed in hexadecimal value HHHH (4 digits)
-
-\\uHHHH Unicode character with value expressed in hexadecimal value HHHH (8 digits)
-
-%% a single %
-
-SUBSTITUTIONS
-
-SUBSTITUTION QUICK REFERENCE
-
-Fields
-
-%s - string
-%b - string parsed for literals
- second parameter is max length
-
-%c - char
- no second parameter
-
-%i or %d - 64-bit integer
-%u - 64 bit unsigned integer
-%x or %X - 64-bit unsigned integer as hex
-%o - 64-bit unsigned integer as octal
- second parameter is min-width, integer
- output below that width is padded with leading zeroes
-
-%f or %F - decimal floating point value
-%e or %E - scientific notation floating point value
-%g or %G - shorter of specially interpreted decimal or SciNote floating point value.
- second parameter is
- -max places after decimal point for floating point output
- -max number of significant digits for scientific notation output
-
-parameterizing fields
-
-examples:
-
-printf '%4.3i' 7
-has a first parameter of 4
- and a second parameter of 3
-will result in ' 007'
-
-printf '%.1s' abcde
-has no first parameter
- and a second parameter of 1
-will result in 'a'
-
-printf '%4c' q
-has a first parameter of 4
- and no second parameter
-will result in ' q'
-
-The first parameter of a field is the minimum width to pad the output to
- if the output is less than this absolute value of this width,
- it will be padded with leading spaces, or, if the argument is negative,
- with trailing spaces. the default is zero.
-
-The second parameter of a field is particular to the output field type.
- defaults can be found in the full substitution help below
-
-special prefixes to numeric arguments
- 0 (e.g. 010) - interpret argument as octal (integer output fields only)
- 0x (e.g. 0xABC) - interpret argument as hex (numeric output fields only)
- \' (e.g. \'a) - interpret argument as a character constant
-
-HOW TO USE SUBSTITUTIONS
-
-Substitutions are used to pass additional argument(s) into the FORMAT string, to be formatted a
-particular way. E.g.
-
- printf 'the letter %X comes before the letter %X' 10 11
-
-will print
-
- 'the letter A comes before the letter B'
-
-because the substitution field %X means
-'take an integer argument and write it as a hexadecimal number'
-
-Passing more arguments than are in the format string will cause the format string to be
- repeated for the remaining substitutions
-
- printf 'it is %i F in %s \n' 22 Portland 25 Boston 27 New York
-
-will print
-
- 'it is 22 F in Portland
- it is 25 F in Boston
- it is 27 F in Boston
- '
-If a format string is printed but there are less arguments remaining
- than there are substitution fields, substitution fields without
- an argument will default to empty strings, or for numeric fields
- the value 0
-
-AVAILABLE SUBSTITUTIONS
-
-This program, like GNU coreutils printf,
-interprets a modified subset of the POSIX C printf spec,
-a quick reference to substitutions is below.
-
- STRING SUBSTITUTIONS
- All string fields have a 'max width' parameter
- %.3s means 'print no more than three characters of the original input'
-
- %s - string
-
- %b - escaped string - the string will be checked for any escaped literals from
- the escaped literal list above, and translate them to literal characters.
- e.g. \\n will be transformed into a newline character.
-
- One special rule about %b mode is that octal literals are interpreted differently
- In arguments passed by %b, pass octal-interpreted literals must be in the form of \\0NNN
- instead of \\NNN. (Although, for legacy reasons, octal literals in the form of \\NNN will
- still be interpreted and not throw a warning, you will have problems if you use this for a
- literal whose code begins with zero, as it will be viewed as in \\0NNN form.)
-
- CHAR SUBSTITUTIONS
- The character field does not have a secondary parameter.
-
- %c - a single character
-
- INTEGER SUBSTITUTIONS
- All integer fields have a 'pad with zero' parameter
- %.4i means an integer which if it is less than 4 digits in length,
- is padded with leading zeros until it is 4 digits in length.
-
- %d or %i - 64-bit integer
-
- %u - 64 bit unsigned integer
-
- %x or %X - 64 bit unsigned integer printed in Hexadecimal (base 16)
- %X instead of %x means to use uppercase letters for 'a' through 'f'
-
- %o - 64 bit unsigned integer printed in octal (base 8)
-
- FLOATING POINT SUBSTITUTIONS
-
- All floating point fields have a 'max decimal places / max significant digits' parameter
- %.10f means a decimal floating point with 7 decimal places past 0
- %.10e means a scientific notation number with 10 significant digits
- %.10g means the same behavior for decimal and Sci. Note, respectively, and provides the shorter
- of each's output.
-
- Like with GNU coreutils, the value after the decimal point is these outputs is parsed as a
- double first before being rendered to text. For both implementations do not expect meaningful
- precision past the 18th decimal place. When using a number of decimal places that is 18 or
- higher, you can expect variation in output between GNU coreutils printf and this printf at the
- 18th decimal place of +/- 1
-
- %f - floating point value presented in decimal, truncated and displayed to 6 decimal places by
- default. There is not past-double behavior parity with Coreutils printf, values are not
- estimated or adjusted beyond input values.
-
- %e or %E - floating point value presented in scientific notation
- 7 significant digits by default
- %E means use to use uppercase E for the mantissa.
-
- %g or %G - floating point value presented in the shorter of decimal and scientific notation
- behaves differently from %f and %E, please see posix printf spec for full details,
- some examples of different behavior:
-
- Sci Note has 6 significant digits by default
- Trailing zeroes are removed
- Instead of being truncated, digit after last is rounded
-
- Like other behavior in this utility, the design choices of floating point
- behavior in this utility is selected to reproduce in exact
- the behavior of GNU coreutils' printf from an inputs and outputs standpoint.
-
-USING PARAMETERS
- Most substitution fields can be parameterized using up to 2 numbers that can
- be passed to the field, between the % sign and the field letter.
-
- The 1st parameter always indicates the minimum width of output, it is useful for creating
- columnar output. Any output that would be less than this minimum width is padded with
- leading spaces
- The 2nd parameter is proceeded by a dot.
- You do not have to use parameters
-
-SPECIAL FORMS OF INPUT
- For numeric input, the following additional forms of input are accepted besides decimal:
-
- Octal (only with integer): if the argument begins with a 0 the proceeding characters
- will be interpreted as octal (base 8) for integer fields
-
- Hexadecimal: if the argument begins with 0x the proceeding characters will be interpreted
- will be interpreted as hex (base 16) for any numeric fields
- for float fields, hexadecimal input results in a precision
- limit (in converting input past the decimal point) of 10^-15
-
- Character Constant: if the argument begins with a single quote character, the first byte
- of the next character will be interpreted as an 8-bit unsigned integer. If there are
- additional bytes, they will throw an error (unless the environment variable POSIXLY_CORRECT
- is set)
-
-WRITTEN BY :
- Nathan E. Ross, et al. for the uutils project
-
-MORE INFO :
- https://github.com/uutils/coreutils
-
-COPYRIGHT :
- Copyright 2015 uutils project.
- Licensed under the MIT License, please see LICENSE file for details
-
-";
+const USAGE: &str = help_usage!("printf.md");
+const ABOUT: &str = help_about!("printf.md");
+const AFTER_HELP: &str = help_section!("after help", "printf.md");
mod options {
pub const FORMATSTRING: &str = "FORMATSTRING";
@@ -271,18 +27,43 @@ mod options {
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_ignore();
let matches = uu_app().get_matches_from(args);
let format_string = matches
.get_one::<String>(options::FORMATSTRING)
.ok_or_else(|| UUsageError::new(1, "missing operand"))?;
- let values: Vec<String> = match matches.get_many::<String>(options::ARGUMENT) {
- Some(s) => s.map(|s| s.to_string()).collect(),
+
+ let values: Vec<_> = match matches.get_many::<String>(options::ARGUMENT) {
+ Some(s) => s.map(|s| FormatArgument::Unparsed(s.to_string())).collect(),
None => vec![],
};
- printf(format_string, &values[..])?;
+ let mut format_seen = false;
+ let mut args = values.iter().peekable();
+ for item in parse_spec_and_escape(format_string.as_ref()) {
+ if let Ok(FormatItem::Spec(_)) = item {
+ format_seen = true;
+ }
+ match item?.write(stdout(), &mut args)? {
+ ControlFlow::Continue(()) => {}
+ ControlFlow::Break(()) => return Ok(()),
+ };
+ }
+
+ // Without format specs in the string, the iter would not consume any args,
+ // leading to an infinite loop. Thus, we exit early.
+ if !format_seen {
+ return Ok(());
+ }
+
+ while args.peek().is_some() {
+ for item in parse_spec_and_escape(format_string.as_ref()) {
+ match item?.write(stdout(), &mut args)? {
+ ControlFlow::Continue(()) => {}
+ ControlFlow::Break(()) => return Ok(()),
+ };
+ }
+ }
Ok(())
}
diff --git a/src/uu/ptx/Cargo.toml b/src/uu/ptx/Cargo.toml
index d26c54d4673ea388f2298390a546d84268bf9cb8..613329f6e9294f72d900e781d48cc639f088a318 100644
--- a/src/uu/ptx/Cargo.toml
+++ b/src/uu/ptx/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_ptx"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "ptx ~ (uutils) display a permuted index of input"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/ptx.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-regex = "1.7.0"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+regex = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "ptx"
diff --git a/src/uu/ptx/ptx.md b/src/uu/ptx/ptx.md
new file mode 100644
index 0000000000000000000000000000000000000000..b8717776cb68cb6e5de584d987ae2e2d0961edf5
--- /dev/null
+++ b/src/uu/ptx/ptx.md
@@ -0,0 +1,11 @@
+# ptx
+
+```
+ptx [OPTION]... [INPUT]...
+ptx -G [OPTION]... [INPUT [OUTPUT]]
+```
+
+Produce a permuted index of file contents
+Output a permuted index, including context, of the words in the input files.
+Mandatory arguments to long options are mandatory for short options too.
+With no FILE, or when FILE is -, read standard input. Default is '-F /'.
\ No newline at end of file
diff --git a/src/uu/ptx/src/ptx.rs b/src/uu/ptx/src/ptx.rs
index 5d8bc73142c81dd766df7df3656506f3a30cae26..0fb711798d0558ba3ec8aca2c1d371898a8aae82 100644
--- a/src/uu/ptx/src/ptx.rs
+++ b/src/uu/ptx/src/ptx.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Dorota Kapturkiewicz <dokaptur@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDOs) corasick memchr Roff trunc oset iset CHARCLASS
@@ -11,7 +9,6 @@ use clap::{crate_version, Arg, ArgAction, Command};
use regex::Regex;
use std::cmp;
use std::collections::{BTreeSet, HashMap, HashSet};
-use std::default::Default;
use std::error::Error;
use std::fmt::{Display, Formatter, Write as FmtWrite};
use std::fs::File;
@@ -19,16 +16,10 @@ use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Write};
use std::num::ParseIntError;
use uucore::display::Quotable;
use uucore::error::{FromIo, UError, UResult};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
-const USAGE: &str = "\
- {} [OPTION]... [INPUT]...
- {} -G [OPTION]... [INPUT [OUTPUT]]";
-
-const ABOUT: &str = "\
- Output a permuted index, including context, of the words in the input files. \n\n\
- Mandatory arguments to long options are mandatory for short options too.\n\
- With no FILE, or when FILE is -, read standard input. Default is '-F /'.";
+const USAGE: &str = help_usage!("ptx.md");
+const ABOUT: &str = help_about!("ptx.md");
const REGEX_CHARCLASS: &str = "^-]\\";
@@ -113,6 +104,7 @@ struct WordFilter {
}
impl WordFilter {
+ #[allow(clippy::cognitive_complexity)]
fn new(matches: &clap::ArgMatches, config: &Config) -> UResult<Self> {
let (o, oset): (bool, HashSet<String>) = if matches.contains_id(options::ONLY_FILE) {
let words =
@@ -170,12 +162,11 @@ impl WordFilter {
.unwrap()
.into_iter()
.map(|c| if REGEX_CHARCLASS.contains(c) {
- format!("\\{}", c)
+ format!("\\{c}")
} else {
c.to_string()
})
- .collect::<Vec<String>>()
- .join("")
+ .collect::<String>()
)
} else if config.gnu_ext {
"\\w+".to_owned()
@@ -220,7 +211,7 @@ impl Display for PtxError {
Self::DumbFormat => {
write!(f, "There is no dumb format with GNU extensions disabled")
}
- Self::NotImplemented(s) => write!(f, "{} not implemented yet", s),
+ Self::NotImplemented(s) => write!(f, "{s} not implemented yet"),
Self::ParseError(e) => e.fmt(f),
}
}
@@ -232,7 +223,7 @@ fn get_config(matches: &clap::ArgMatches) -> UResult<Config> {
if matches.get_flag(options::TRADITIONAL) {
config.gnu_ext = false;
config.format = OutFormat::Roff;
- config.context_regex = "[^ \t\n]+".to_owned();
+ "[^ \t\n]+".clone_into(&mut config.context_regex);
} else {
return Err(PtxError::NotImplemented("GNU extensions").into());
}
@@ -330,7 +321,7 @@ fn create_word_set(config: &Config, filter: &WordFilter, file_map: &FileMap) ->
let reg = Regex::new(&filter.word_regex).unwrap();
let ref_reg = Regex::new(&config.context_regex).unwrap();
let mut word_set: BTreeSet<WordRef> = BTreeSet::new();
- for (file, lines) in file_map.iter() {
+ for (file, lines) in file_map {
let mut count: usize = 0;
let offs = lines.offset;
for line in &lines.lines {
@@ -553,8 +544,8 @@ fn get_output_chunks(
fn tex_mapper(x: char) -> String {
match x {
'\\' => "\\backslash{}".to_owned(),
- '$' | '%' | '#' | '&' | '_' => format!("\\{}", x),
- '}' | '{' => format!("$\\{}$", x),
+ '$' | '%' | '#' | '&' | '_' => format!("\\{x}"),
+ '}' | '{' => format!("$\\{x}$"),
_ => x.to_string(),
}
}
@@ -662,7 +653,7 @@ fn write_traditional_output(
let context_reg = Regex::new(&config.context_regex).unwrap();
- for word_ref in words.iter() {
+ for word_ref in words {
let file_map_value: &FileContent = file_map
.get(&(word_ref.filename))
.expect("Missing file in file map");
@@ -696,7 +687,7 @@ fn write_traditional_output(
return Err(PtxError::DumbFormat.into());
}
};
- writeln!(writer, "{}", output_line).map_err_context(String::new)?;
+ writeln!(writer, "{output_line}").map_err_context(String::new)?;
}
Ok(())
}
@@ -723,12 +714,10 @@ mod options {
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_ignore();
-
let matches = uu_app().try_get_matches_from(args)?;
let mut input_files: Vec<String> = match &matches.get_many::<String>(options::FILE) {
- Some(v) => v.clone().map(|v| v.to_owned()).collect(),
+ Some(v) => v.clone().cloned().collect(),
None => vec!["-".to_string()],
};
diff --git a/src/uu/pwd/Cargo.toml b/src/uu/pwd/Cargo.toml
index 1886ddeac4267878964aa3b226e422f0b5517969..7f8b04eae8712c12161dc33591134c60706a9065 100644
--- a/src/uu/pwd/Cargo.toml
+++ b/src/uu/pwd/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_pwd"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "pwd ~ (uutils) display current working directory"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/pwd.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "pwd"
diff --git a/src/uu/pwd/pwd.md b/src/uu/pwd/pwd.md
new file mode 100644
index 0000000000000000000000000000000000000000..89ccee2db8ee2ebb93b73866594d51413dd525f3
--- /dev/null
+++ b/src/uu/pwd/pwd.md
@@ -0,0 +1,7 @@
+# pwd
+
+```
+pwd [OPTION]... [FILE]...
+```
+
+Display the full filename of the current working directory.
diff --git a/src/uu/pwd/src/pwd.rs b/src/uu/pwd/src/pwd.rs
index 029ba66251635848163c526c25db3b9c0aa3cf55..fde2357e212f6987e10c1751033ae5a1b10ab975 100644
--- a/src/uu/pwd/src/pwd.rs
+++ b/src/uu/pwd/src/pwd.rs
@@ -1,24 +1,22 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Derek Chiang <derekchiang93@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use clap::ArgAction;
use clap::{crate_version, Arg, Command};
use std::env;
use std::io;
use std::path::PathBuf;
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
use uucore::display::println_verbatim;
use uucore::error::{FromIo, UResult};
-static ABOUT: &str = "Display the full filename of the current working directory.";
-const USAGE: &str = "{} [OPTION]... FILE...";
-static OPT_LOGICAL: &str = "logical";
-static OPT_PHYSICAL: &str = "physical";
+const ABOUT: &str = help_about!("pwd.md");
+const USAGE: &str = help_usage!("pwd.md");
+const OPT_LOGICAL: &str = "logical";
+const OPT_PHYSICAL: &str = "physical";
fn physical_path() -> io::Result<PathBuf> {
// std::env::current_dir() is a thin wrapper around libc::getcwd().
@@ -84,36 +82,22 @@ fn logical_path() -> io::Result<PathBuf> {
{
use std::fs::metadata;
use std::os::unix::fs::MetadataExt;
- let path_info = match metadata(path) {
- Ok(info) => info,
- Err(_) => return false,
- };
- let real_info = match metadata(".") {
- Ok(info) => info,
- Err(_) => return false,
- };
- if path_info.dev() != real_info.dev() || path_info.ino() != real_info.ino() {
- return false;
+ match (metadata(path), metadata(".")) {
+ (Ok(info1), Ok(info2)) => {
+ info1.dev() == info2.dev() && info1.ino() == info2.ino()
+ }
+ _ => false,
}
}
#[cfg(not(unix))]
{
use std::fs::canonicalize;
- let canon_path = match canonicalize(path) {
- Ok(path) => path,
- Err(_) => return false,
- };
- let real_path = match canonicalize(".") {
- Ok(path) => path,
- Err(_) => return false,
- };
- if canon_path != real_path {
- return false;
+ match (canonicalize(path), canonicalize(".")) {
+ (Ok(path1), Ok(path2)) => path1 == path2,
+ _ => false,
}
}
-
- true
}
match env::var_os("PWD").map(PathBuf::from) {
@@ -129,7 +113,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
// if POSIXLY_CORRECT is set, we want to a logical resolution.
// This produces a different output when doing mkdir -p a/b && ln -s a/b c && cd c && pwd
// We should get c in this case instead of a/b at the end of the path
- let cwd = if matches.get_flag(OPT_LOGICAL) || env::var("POSIXLY_CORRECT").is_ok() {
+ let cwd = if matches.get_flag(OPT_PHYSICAL) {
+ physical_path()
+ } else if matches.get_flag(OPT_LOGICAL) || env::var("POSIXLY_CORRECT").is_ok() {
logical_path()
} else {
physical_path()
diff --git a/src/uu/readlink/Cargo.toml b/src/uu/readlink/Cargo.toml
index a7a28b1d6d1ae7ba4c73d4de87a6d25e39ace3f4..0ba6d1d0aaa91cb5e467379e58da95900c9fe75a 100644
--- a/src/uu/readlink/Cargo.toml
+++ b/src/uu/readlink/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_readlink"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "readlink ~ (uutils) display resolved path of PATHNAME"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/readlink.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["fs"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["fs"] }
[[bin]]
name = "readlink"
diff --git a/src/uu/readlink/readlink.md b/src/uu/readlink/readlink.md
new file mode 100644
index 0000000000000000000000000000000000000000..7215acbec0967032cb5c3021e15772855f30f89f
--- /dev/null
+++ b/src/uu/readlink/readlink.md
@@ -0,0 +1,7 @@
+# readlink
+
+```
+readlink [OPTION]... [FILE]...
+```
+
+Print value of a symbolic link or canonical file name.
diff --git a/src/uu/readlink/src/readlink.rs b/src/uu/readlink/src/readlink.rs
index a0be0d270eeec01153c9de7c0efe4917780d6803..2febe51af4847018828f28cf986044e5423b7e1e 100644
--- a/src/uu/readlink/src/readlink.rs
+++ b/src/uu/readlink/src/readlink.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Haitao Li <lihaitao@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) errno
@@ -14,10 +12,11 @@ use std::path::{Path, PathBuf};
use uucore::display::Quotable;
use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
use uucore::fs::{canonicalize, MissingHandling, ResolveMode};
-use uucore::{format_usage, show_error};
+use uucore::line_ending::LineEnding;
+use uucore::{format_usage, help_about, help_usage, show_error};
-const ABOUT: &str = "Print value of a symbolic link or canonical file name.";
-const USAGE: &str = "{} [OPTION]... [FILE]...";
+const ABOUT: &str = help_about!("readlink.md");
+const USAGE: &str = help_usage!("readlink.md");
const OPT_CANONICALIZE: &str = "canonicalize";
const OPT_CANONICALIZE_MISSING: &str = "canonicalize-missing";
const OPT_CANONICALIZE_EXISTING: &str = "canonicalize-existing";
@@ -67,6 +66,11 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
show_error!("ignoring --no-newline with multiple arguments");
no_trailing_delimiter = false;
}
+ let line_ending = if no_trailing_delimiter {
+ None
+ } else {
+ Some(LineEnding::from_zero_flag(use_zero))
+ };
for f in &files {
let p = PathBuf::from(f);
@@ -77,7 +81,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
};
match path_result {
Ok(path) => {
- show(&path, no_trailing_delimiter, use_zero).map_err_context(String::new)?;
+ show(&path, line_ending).map_err_context(String::new)?;
}
Err(err) => {
if verbose {
@@ -99,7 +103,7 @@ pub fn uu_app() -> Command {
Command::new(uucore::util_name())
.version(crate_version!())
.about(ABOUT)
- .override_help(format_usage(USAGE))
+ .override_usage(format_usage(USAGE))
.infer_long_args(true)
.arg(
Arg::new(OPT_CANONICALIZE)
@@ -173,14 +177,11 @@ pub fn uu_app() -> Command {
)
}
-fn show(path: &Path, no_trailing_delimiter: bool, use_zero: bool) -> std::io::Result<()> {
+fn show(path: &Path, line_ending: Option<LineEnding>) -> std::io::Result<()> {
let path = path.to_str().unwrap();
- if no_trailing_delimiter {
- print!("{}", path);
- } else if use_zero {
- print!("{}\0", path);
- } else {
- println!("{}", path);
+ print!("{path}");
+ if let Some(line_ending) = line_ending {
+ print!("{line_ending}");
}
stdout().flush()
}
diff --git a/src/uu/realpath/Cargo.toml b/src/uu/realpath/Cargo.toml
index a077778e4e294a2fa97379209c5dc6810cf6c8f7..940bcd54981732bf5bc3c61559fbf60b445f65f9 100644
--- a/src/uu/realpath/Cargo.toml
+++ b/src/uu/realpath/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_realpath"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "realpath ~ (uutils) display resolved absolute path of PATHNAME"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/realpath.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["fs"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["fs"] }
[[bin]]
name = "realpath"
diff --git a/src/uu/realpath/realpath.md b/src/uu/realpath/realpath.md
new file mode 100644
index 0000000000000000000000000000000000000000..25e4a37260d5c8efb0de78b5f3c15bef1297ba56
--- /dev/null
+++ b/src/uu/realpath/realpath.md
@@ -0,0 +1,7 @@
+# realpath
+
+```
+realpath [OPTION]... FILE...
+```
+
+Print the resolved path
diff --git a/src/uu/realpath/src/realpath.rs b/src/uu/realpath/src/realpath.rs
index 7b8ac9e38d86b4a3214e3609b2c4dbf174a739fa..b099a5f377c8d9ee0a9849bc67f1459f3103b6cf 100644
--- a/src/uu/realpath/src/realpath.rs
+++ b/src/uu/realpath/src/realpath.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) 2014 Vsevolod Velichko <torkvemada@sorokdva.net>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) retcode
@@ -17,14 +15,16 @@ use std::{
use uucore::fs::make_path_relative_to;
use uucore::{
display::{print_verbatim, Quotable},
- error::{FromIo, UResult},
+ error::{FromIo, UClapError, UResult},
format_usage,
fs::{canonicalize, MissingHandling, ResolveMode},
+ help_about, help_usage,
+ line_ending::LineEnding,
+ show_if_err,
};
-use uucore::{error::UClapError, show, show_if_err};
-static ABOUT: &str = "print the resolved path";
-const USAGE: &str = "{} [OPTION]... FILE...";
+static ABOUT: &str = help_about!("realpath.md");
+const USAGE: &str = help_usage!("realpath.md");
static OPT_QUIET: &str = "quiet";
static OPT_STRIP: &str = "strip";
@@ -51,7 +51,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
.collect();
let strip = matches.get_flag(OPT_STRIP);
- let zero = matches.get_flag(OPT_ZERO);
+ let line_ending = LineEnding::from_zero_flag(matches.get_flag(OPT_ZERO));
let quiet = matches.get_flag(OPT_QUIET);
let logical = matches.get_flag(OPT_LOGICAL);
let can_mode = if matches.get_flag(OPT_CANONICALIZE_EXISTING) {
@@ -72,7 +72,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
for path in &paths {
let result = resolve_path(
path,
- zero,
+ line_ending,
resolve_mode,
can_mode,
relative_to.as_deref(),
@@ -248,19 +248,18 @@ fn canonicalize_relative(
/// symbolic links.
fn resolve_path(
p: &Path,
- zero: bool,
+ line_ending: LineEnding,
resolve: ResolveMode,
can_mode: MissingHandling,
relative_to: Option<&Path>,
relative_base: Option<&Path>,
) -> std::io::Result<()> {
let abs = canonicalize(p, can_mode, resolve)?;
- let line_ending = if zero { b'\0' } else { b'\n' };
let abs = process_relative(abs, relative_base, relative_to);
print_verbatim(abs)?;
- stdout().write_all(&[line_ending])?;
+ stdout().write_all(&[line_ending.into()])?;
Ok(())
}
diff --git a/src/uu/relpath/Cargo.toml b/src/uu/relpath/Cargo.toml
deleted file mode 100644
index c37e98d862d86e50d1aaf52257233034c64ebd61..0000000000000000000000000000000000000000
--- a/src/uu/relpath/Cargo.toml
+++ /dev/null
@@ -1,23 +0,0 @@
-[package]
-name = "uu_relpath"
-version = "0.0.17"
-authors = ["uutils developers"]
-license = "MIT"
-description = "relpath ~ (uutils) display relative path of PATHNAME_TO from PATHNAME_FROM"
-
-homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/main/src/uu/relpath"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
-
-[lib]
-path = "src/relpath.rs"
-
-[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["fs"] }
-
-[[bin]]
-name = "relpath"
-path = "src/main.rs"
diff --git a/src/uu/relpath/LICENSE b/src/uu/relpath/LICENSE
deleted file mode 120000
index 5853aaea53bc07801e8ee3af2e700849e30fb6a0..0000000000000000000000000000000000000000
--- a/src/uu/relpath/LICENSE
+++ /dev/null
@@ -1 +0,0 @@
-../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/relpath/src/main.rs b/src/uu/relpath/src/main.rs
deleted file mode 100644
index b7dba76ce4dd929a058f160277fbf851d12abfd8..0000000000000000000000000000000000000000
--- a/src/uu/relpath/src/main.rs
+++ /dev/null
@@ -1 +0,0 @@
-uucore::bin!(uu_relpath);
diff --git a/src/uu/relpath/src/relpath.rs b/src/uu/relpath/src/relpath.rs
deleted file mode 100644
index 522cc54e565dac0d2f07c275b3c9b0d0cdd0c92a..0000000000000000000000000000000000000000
--- a/src/uu/relpath/src/relpath.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) 2014 Vsevolod Velichko <torkvemada@sorokdva.net>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
-
-// spell-checker:ignore (ToDO) subpath absto absfrom absbase
-
-use clap::{crate_version, Arg, Command};
-use std::env;
-use std::path::{Path, PathBuf};
-use uucore::display::println_verbatim;
-use uucore::error::{FromIo, UResult};
-use uucore::format_usage;
-use uucore::fs::{canonicalize, MissingHandling, ResolveMode};
-
-static ABOUT: &str = "Convert TO destination to the relative path from the FROM dir.
-If FROM path is omitted, current working dir will be used.";
-const USAGE: &str = "{} [-d DIR] TO [FROM]";
-
-mod options {
- pub const DIR: &str = "DIR";
- pub const TO: &str = "TO";
- pub const FROM: &str = "FROM";
-}
-
-#[uucore::main]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_lossy();
-
- let matches = uu_app().get_matches_from(args);
-
- let to = Path::new(matches.get_one::<String>(options::TO).unwrap()).to_path_buf(); // required
- let from = match matches.get_one::<String>(options::FROM) {
- Some(p) => Path::new(p).to_path_buf(),
- None => env::current_dir().unwrap(),
- };
- let absto = canonicalize(to, MissingHandling::Normal, ResolveMode::Logical)
- .map_err_context(String::new)?;
- let absfrom = canonicalize(from, MissingHandling::Normal, ResolveMode::Logical)
- .map_err_context(String::new)?;
-
- if matches.contains_id(options::DIR) {
- let base = Path::new(&matches.get_one::<String>(options::DIR).unwrap()).to_path_buf();
- let absbase = canonicalize(base, MissingHandling::Normal, ResolveMode::Logical)
- .map_err_context(String::new)?;
- if !absto.as_path().starts_with(absbase.as_path())
- || !absfrom.as_path().starts_with(absbase.as_path())
- {
- return println_verbatim(absto).map_err_context(String::new);
- }
- }
-
- let mut suffix_pos = 0;
- for (f, t) in absfrom.components().zip(absto.components()) {
- if f == t {
- suffix_pos += 1;
- } else {
- break;
- }
- }
-
- let mut result = PathBuf::new();
- absfrom
- .components()
- .skip(suffix_pos)
- .map(|_| result.push(".."))
- .last();
- absto
- .components()
- .skip(suffix_pos)
- .map(|x| result.push(x.as_os_str()))
- .last();
-
- println_verbatim(result).map_err_context(String::new)
-}
-
-pub fn uu_app() -> Command {
- Command::new(uucore::util_name())
- .version(crate_version!())
- .about(ABOUT)
- .override_usage(format_usage(USAGE))
- .infer_long_args(true)
- .arg(Arg::new(options::DIR).short('d').help(
- "If any of FROM and TO is not subpath of DIR, output absolute path instead of relative",
- ))
- .arg(Arg::new(options::TO).value_hint(clap::ValueHint::AnyPath))
- .arg(Arg::new(options::FROM).value_hint(clap::ValueHint::AnyPath))
-}
diff --git a/src/uu/rm/BENCHMARKING.md b/src/uu/rm/BENCHMARKING.md
new file mode 100644
index 0000000000000000000000000000000000000000..507906d497e0cfffaaaf9ab625d02440dc9fcfeb
--- /dev/null
+++ b/src/uu/rm/BENCHMARKING.md
@@ -0,0 +1,61 @@
+<!-- spell-checker:ignore samply flamegraph flamegraphs -->
+# Benchmarking rm
+
+Run `cargo build --release` before benchmarking after you make a change!
+
+## Simple recursive rm
+
+- Get a large tree, for example linux kernel source tree.
+- We'll need to pass a `--prepare` argument, since `rm` deletes the dir each time.
+- Benchmark simple recursive rm with hyperfine: `hyperfine --prepare "cp -r tree tree-tmp" "target/release/coreutils rm -r tree-tmp"`.
+
+## Comparing with GNU rm
+
+Hyperfine accepts multiple commands to run and will compare them. To compare performance with GNU rm
+duplicate the string you passed to hyperfine but remove the `target/release/coreutils` bit from it.
+
+Example: `hyperfine --prepare "cp -r tree tree-tmp" "target/release/coreutils rm -rf tree-tmp"` becomes
+`hyperfine --prepare "cp -r tree tree-tmp" "target/release/coreutils rm -rf tree-tmp" "rm -rf tree-tmp"`
+(This assumes GNU rm is installed as `rm`)
+
+This can also be used to compare with version of rm built before your changes to ensure your change does not regress this.
+
+Here is a `bash` script for doing this comparison:
+
+```shell
+#!/bin/bash
+cargo build --no-default-features --features rm --release
+test_dir="$1"
+hyperfine --prepare "cp -r $test_dir tmp_d" "rm -rf tmp_d" "target/release/coreutils rm -rf tmp_d"
+```
+
+## Checking system call count
+
+- Another thing to look at would be system calls count using strace (on linux) or equivalent on other operating systems.
+- Example: `strace -c target/release/coreutils rm -rf tree`
+
+## Flamegraph
+
+### samply
+
+[samply](https://github.com/mstange/samply) is one option for simply creating flamegraphs. It uses the Firefox profiler as a UI.
+
+To install:
+```bash
+cargo install samply
+```
+
+To run:
+
+```bash
+samply record target/release/coreutils rm -rf ../linux
+```
+
+### Cargo Flamegraph
+
+With Cargo Flamegraph you can easily make a flamegraph of `rm`:
+
+```shell
+cargo flamegraph --cmd coreutils -- rm [additional parameters]
+```
+
diff --git a/src/uu/rm/Cargo.toml b/src/uu/rm/Cargo.toml
index 9f169b1c0246a3fc0fcdc99ac1a35eb0df9da4d0..2b6b7584690c514c6bf9c4679f2c14e33812878f 100644
--- a/src/uu/rm/Cargo.toml
+++ b/src/uu/rm/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_rm"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "rm ~ (uutils) remove PATHNAME"
@@ -15,16 +15,15 @@ edition = "2021"
path = "src/rm.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-walkdir = "2.2"
-remove_dir_all = "0.7.0"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["fs"] }
+clap = { workspace = true }
+walkdir = { workspace = true }
+uucore = { workspace = true, features = ["fs"] }
[target.'cfg(unix)'.dependencies]
-libc = "0.2.137"
+libc = { workspace = true }
[target.'cfg(windows)'.dependencies]
-windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_Storage_FileSystem"] }
+windows-sys = { workspace = true, features = ["Win32_Storage_FileSystem"] }
[[bin]]
name = "rm"
diff --git a/src/uu/rm/benchmark.sh b/src/uu/rm/benchmark.sh
new file mode 100755
index 0000000000000000000000000000000000000000..5feaea4e8f1545e6dbba3585d9946f594b9d230e
--- /dev/null
+++ b/src/uu/rm/benchmark.sh
@@ -0,0 +1,8 @@
+#!/bin/bash
+
+# Exit on any failures
+set +x
+
+cargo build --no-default-features --features rm --release
+test_dir="$1"
+hyperfine --prepare "cp -r $test_dir tmp_d" "rm -rf tmp_d" "target/release/coreutils rm -rf tmp_d"
diff --git a/src/uu/rm/rm.md b/src/uu/rm/rm.md
new file mode 100644
index 0000000000000000000000000000000000000000..7acc46363b89337342c9315f19da6296b81010e1
--- /dev/null
+++ b/src/uu/rm/rm.md
@@ -0,0 +1,22 @@
+# rm
+
+```
+rm [OPTION]... FILE...
+```
+
+Remove (unlink) the FILE(s)
+
+## After Help
+
+By default, rm does not remove directories. Use the --recursive (-r or -R)
+option to remove each listed directory, too, along with all of its contents
+
+To remove a file whose name starts with a '-', for example '-foo',
+use one of these commands:
+rm -- -foo
+
+rm ./-foo
+
+Note that if you use rm to remove a file, it might be possible to recover
+some of its contents, given sufficient expertise and/or time. For greater
+assurance that the contents are truly unrecoverable, consider using shred.
diff --git a/src/uu/rm/src/rm.rs b/src/uu/rm/src/rm.rs
index 08d7f0ac5e8f10188e52cdfd8a8f2418a77ef10a..a89ba6db67fd823b950060c7edd71fb25c4a3fe8 100644
--- a/src/uu/rm/src/rm.rs
+++ b/src/uu/rm/src/rm.rs
@@ -1,45 +1,75 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Alex Lyon <arcterus@mail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-// spell-checker:ignore (path) eacces
+// spell-checker:ignore (path) eacces inacc
-use clap::{crate_version, parser::ValueSource, Arg, ArgAction, Command};
-use remove_dir_all::remove_dir_all;
+use clap::{builder::ValueParser, crate_version, parser::ValueSource, Arg, ArgAction, Command};
use std::collections::VecDeque;
+use std::ffi::{OsStr, OsString};
use std::fs::{self, File, Metadata};
use std::io::ErrorKind;
use std::ops::BitOr;
use std::path::{Path, PathBuf};
use uucore::display::Quotable;
use uucore::error::{UResult, USimpleError, UUsageError};
-use uucore::{format_usage, prompt_yes, show_error};
+use uucore::{format_usage, help_about, help_section, help_usage, prompt_yes, show_error};
use walkdir::{DirEntry, WalkDir};
#[derive(Eq, PartialEq, Clone, Copy)]
-enum InteractiveMode {
+/// Enum, determining when the `rm` will prompt the user about the file deletion
+pub enum InteractiveMode {
+ /// Never prompt
Never,
+ /// Prompt once before removing more than three files, or when removing
+ /// recursively.
Once,
+ /// Prompt before every removal
Always,
+ /// Prompt only on write-protected files
PromptProtected,
}
-struct Options {
- force: bool,
- interactive: InteractiveMode,
+/// Options for the `rm` command
+///
+/// All options are public so that the options can be programmatically
+/// constructed by other crates, such as Nushell. That means that this struct
+/// is part of our public API. It should therefore not be changed without good
+/// reason.
+///
+/// The fields are documented with the arguments that determine their value.
+pub struct Options {
+ /// `-f`, `--force`
+ pub force: bool,
+ /// Iterative mode, determines when the command will prompt.
+ ///
+ /// Set by the following arguments:
+ /// - `-i`: [`InteractiveMode::Always`]
+ /// - `-I`: [`InteractiveMode::Once`]
+ /// - `--interactive`: sets one of the above or [`InteractiveMode::Never`]
+ /// - `-f`: implicitly sets [`InteractiveMode::Never`]
+ ///
+ /// If no other option sets this mode, [`InteractiveMode::PromptProtected`]
+ /// is used
+ pub interactive: InteractiveMode,
#[allow(dead_code)]
- one_fs: bool,
- preserve_root: bool,
- recursive: bool,
- dir: bool,
- verbose: bool,
+ /// `--one-file-system`
+ pub one_fs: bool,
+ /// `--preserve-root`/`--no-preserve-root`
+ pub preserve_root: bool,
+ /// `-r`, `--recursive`
+ pub recursive: bool,
+ /// `-d`, `--dir`
+ pub dir: bool,
+ /// `-v`, `--verbose`
+ pub verbose: bool,
}
-static ABOUT: &str = "Remove (unlink) the FILE(s)";
-const USAGE: &str = "{} [OPTION]... FILE...";
+const ABOUT: &str = help_about!("rm.md");
+const USAGE: &str = help_usage!("rm.md");
+const AFTER_HELP: &str = help_section!("after help", "rm.md");
+
static OPT_DIR: &str = "dir";
static OPT_INTERACTIVE: &str = "interactive";
static OPT_FORCE: &str = "force";
@@ -54,32 +84,13 @@ static PRESUME_INPUT_TTY: &str = "-presume-input-tty";
static ARG_FILES: &str = "files";
-fn get_long_usage() -> String {
- String::from(
- "By default, rm does not remove directories. Use the --recursive (-r or -R)
- option to remove each listed directory, too, along with all of its contents
-
- To remove a file whose name starts with a '-', for example '-foo',
- use one of these commands:
- rm -- -foo
-
- rm ./-foo
-
- Note that if you use rm to remove a file, it might be possible to recover
- some of its contents, given sufficient expertise and/or time. For greater
- assurance that the contents are truly unrecoverable, consider using shred.",
- )
-}
-
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let matches = uu_app()
- .after_help(get_long_usage())
- .try_get_matches_from(args)?;
+ let matches = uu_app().after_help(AFTER_HELP).try_get_matches_from(args)?;
- let files: Vec<String> = matches
- .get_many::<String>(ARG_FILES)
- .map(|v| v.map(ToString::to_string).collect())
+ let files: Vec<&OsStr> = matches
+ .get_many::<OsString>(ARG_FILES)
+ .map(|v| v.map(OsString::as_os_str).collect())
.unwrap_or_default();
let force_flag = matches.get_flag(OPT_FORCE);
@@ -117,7 +128,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
val => {
return Err(USimpleError::new(
1,
- format!("Invalid argument to interactive ({})", val),
+ format!("Invalid argument to interactive ({val})"),
))
}
}
@@ -132,11 +143,20 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
verbose: matches.get_flag(OPT_VERBOSE),
};
if options.interactive == InteractiveMode::Once && (options.recursive || files.len() > 3) {
- let msg = if options.recursive {
- "Remove all arguments recursively?"
- } else {
- "Remove all arguments?"
- };
+ let msg: String = format!(
+ "remove {} {}{}",
+ files.len(),
+ if files.len() > 1 {
+ "arguments"
+ } else {
+ "argument"
+ },
+ if options.recursive {
+ " recursively?"
+ } else {
+ "?"
+ }
+ );
if !prompt_yes!("{}", msg) {
return Ok(());
}
@@ -186,6 +206,9 @@ pub fn uu_app() -> Command {
prompts always",
)
.value_name("WHEN")
+ .num_args(0..=1)
+ .require_equals(true)
+ .default_missing_value("always")
.overrides_with_all([OPT_PROMPT, OPT_PROMPT_MORE]),
)
.arg(
@@ -249,13 +272,20 @@ pub fn uu_app() -> Command {
.arg(
Arg::new(ARG_FILES)
.action(ArgAction::Append)
+ .value_parser(ValueParser::os_string())
.num_args(1..)
.value_hint(clap::ValueHint::AnyPath),
)
}
// TODO: implement one-file-system (this may get partially implemented in walkdir)
-fn remove(files: &[String], options: &Options) -> bool {
+/// Remove (or unlink) the given files
+///
+/// Returns true if it has encountered an error.
+///
+/// Behavior is determined by the `options` parameter, see [`Options`] for
+/// details.
+pub fn remove(files: &[&OsStr], options: &Options) -> bool {
let mut had_err = false;
for filename in files {
@@ -274,15 +304,15 @@ fn remove(files: &[String], options: &Options) -> bool {
// TODO: actually print out the specific error
// TODO: When the error is not about missing files
// (e.g., permission), even rm -f should fail with
- // outputting the error, but there's no easy eay.
- if !options.force {
+ // outputting the error, but there's no easy way.
+ if options.force {
+ false
+ } else {
show_error!(
"cannot remove {}: No such file or directory",
filename.quote()
);
true
- } else {
- false
}
}
}
@@ -292,23 +322,28 @@ fn remove(files: &[String], options: &Options) -> bool {
had_err
}
+#[allow(clippy::cognitive_complexity)]
fn handle_dir(path: &Path, options: &Options) -> bool {
let mut had_err = false;
let is_root = path.has_root() && path.parent().is_none();
if options.recursive && (!is_root || !options.preserve_root) {
if options.interactive != InteractiveMode::Always && !options.verbose {
- // we need the extra crate because apparently fs::remove_dir_all() does not function
- // correctly on Windows
- if let Err(e) = remove_dir_all(path) {
- had_err = true;
- if e.kind() == std::io::ErrorKind::PermissionDenied {
- // GNU compatibility (rm/fail-eacces.sh)
- // here, GNU doesn't use some kind of remove_dir_all
- // It will show directory+file
- show_error!("cannot remove {}: {}", path.quote(), "Permission denied");
- } else {
- show_error!("cannot remove {}: {}", path.quote(), e);
+ if let Err(e) = fs::remove_dir_all(path) {
+ // GNU compatibility (rm/empty-inacc.sh)
+ // remove_dir_all failed. maybe it is because of the permissions
+ // but if the directory is empty, remove_dir might work.
+ // So, let's try that before failing for real
+ if fs::remove_dir(path).is_err() {
+ had_err = true;
+ if e.kind() == std::io::ErrorKind::PermissionDenied {
+ // GNU compatibility (rm/fail-eacces.sh)
+ // here, GNU doesn't use some kind of remove_dir_all
+ // It will show directory+file
+ show_error!("cannot remove {}: {}", path.quote(), "Permission denied");
+ } else {
+ show_error!("cannot remove {}: {}", path.quote(), e);
+ }
}
}
} else {
@@ -375,7 +410,7 @@ fn handle_dir(path: &Path, options: &Options) -> bool {
}
fn remove_dir(path: &Path, options: &Options) -> bool {
- if prompt_file(path, options, true) {
+ if prompt_dir(path, options) {
if let Ok(mut read_dir) = fs::read_dir(path) {
if options.dir || options.recursive {
if read_dir.next().is_none() {
@@ -420,7 +455,7 @@ fn remove_dir(path: &Path, options: &Options) -> bool {
}
fn remove_file(path: &Path, options: &Options) -> bool {
- if prompt_file(path, options, false) {
+ if prompt_file(path, options) {
match fs::remove_file(path) {
Ok(_) => {
if options.verbose {
@@ -442,7 +477,22 @@ fn remove_file(path: &Path, options: &Options) -> bool {
false
}
-fn prompt_file(path: &Path, options: &Options, is_dir: bool) -> bool {
+fn prompt_dir(path: &Path, options: &Options) -> bool {
+ // If interactive is Never we never want to send prompts
+ if options.interactive == InteractiveMode::Never {
+ return true;
+ }
+
+ // We can't use metadata.permissions.readonly for directories because it only works on files
+ // So we have to handle whether a directory is writable manually
+ if let Ok(metadata) = fs::metadata(path) {
+ handle_writable_directory(path, options, &metadata)
+ } else {
+ true
+ }
+}
+
+fn prompt_file(path: &Path, options: &Options) -> bool {
// If interactive is Never we never want to send prompts
if options.interactive == InteractiveMode::Never {
return true;
@@ -455,61 +505,40 @@ fn prompt_file(path: &Path, options: &Options, is_dir: bool) -> bool {
}
}
}
- if is_dir {
- // We can't use metadata.permissions.readonly for directories because it only works on files
- // So we have to handle wether a directory is writable on not manually
- if let Ok(metadata) = fs::metadata(path) {
- handle_writable_directory(path, options, &metadata)
- } else {
- true
- }
- } else {
- // File::open(path) doesn't open the file in write mode so we need to use file options to open it in also write mode to check if it can written too
- match File::options().read(true).write(true).open(path) {
- Ok(file) => {
- if let Ok(metadata) = file.metadata() {
- if metadata.permissions().readonly() {
- if metadata.len() == 0 {
- prompt_yes!(
- "remove write-protected regular empty file {}?",
- path.quote()
- )
- } else {
- prompt_yes!("remove write-protected regular file {}?", path.quote())
- }
- } else if options.interactive == InteractiveMode::Always {
- if metadata.len() == 0 {
- prompt_yes!("remove regular empty file {}?", path.quote())
- } else {
- prompt_yes!("remove file {}?", path.quote())
- }
- } else {
- true
- }
+ // File::open(path) doesn't open the file in write mode so we need to use file options to open it in also write mode to check if it can written too
+ match File::options().read(true).write(true).open(path) {
+ Ok(file) => {
+ let Ok(metadata) = file.metadata() else {
+ return true;
+ };
+
+ if options.interactive == InteractiveMode::Always && !metadata.permissions().readonly()
+ {
+ return if metadata.len() == 0 {
+ prompt_yes!("remove regular empty file {}?", path.quote())
} else {
- true
- }
+ prompt_yes!("remove file {}?", path.quote())
+ };
}
- Err(err) => {
- if err.kind() == ErrorKind::PermissionDenied {
- if let Ok(metadata) = fs::metadata(path) {
- if metadata.len() == 0 {
- prompt_yes!(
- "remove write-protected regular empty file {}?",
- path.quote()
- )
- } else {
- prompt_yes!("remove write-protected regular file {}?", path.quote())
- }
- } else {
- prompt_yes!("remove write-protected regular file {}?", path.quote())
- }
- } else {
- true
- }
+ }
+ Err(err) => {
+ if err.kind() != ErrorKind::PermissionDenied {
+ return true;
}
}
}
+ prompt_file_permission_readonly(path)
+}
+
+fn prompt_file_permission_readonly(path: &Path) -> bool {
+ match fs::metadata(path) {
+ Ok(metadata) if !metadata.permissions().readonly() => true,
+ Ok(metadata) if metadata.len() == 0 => prompt_yes!(
+ "remove write-protected regular empty file {}?",
+ path.quote()
+ ),
+ _ => prompt_yes!("remove write-protected regular file {}?", path.quote()),
+ }
}
// For directories finding if they are writable or not is a hassle. In Unix we can use the built-in rust crate to to check mode bits. But other os don't have something similar afaik
diff --git a/src/uu/rmdir/Cargo.toml b/src/uu/rmdir/Cargo.toml
index e804f7fa5bf60c53c405b38e88fb0e2554ee1c7b..6e4ad1e314130202b3239b6bd1bf60bd8439622f 100644
--- a/src/uu/rmdir/Cargo.toml
+++ b/src/uu/rmdir/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_rmdir"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "rmdir ~ (uutils) remove empty DIRECTORY"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/rmdir.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["fs"] }
-libc = "0.2.137"
+clap = { workspace = true }
+uucore = { workspace = true, features = ["fs"] }
+libc = { workspace = true }
[[bin]]
name = "rmdir"
diff --git a/src/uu/rmdir/rmdir.md b/src/uu/rmdir/rmdir.md
new file mode 100644
index 0000000000000000000000000000000000000000..16f7bf82bea53a6a39b3acd5bf6b86f59f7eca21
--- /dev/null
+++ b/src/uu/rmdir/rmdir.md
@@ -0,0 +1,7 @@
+# rmdir
+
+```
+rmdir [OPTION]... DIRECTORY...
+```
+
+Remove the DIRECTORY(ies), if they are empty.
diff --git a/src/uu/rmdir/src/rmdir.rs b/src/uu/rmdir/src/rmdir.rs
index 51240b5ad3cacd0e82ac0570713de628e25a53ff..ef152f01a7b0305b7f84930d81cfee9aa4e9ef38 100644
--- a/src/uu/rmdir/src/rmdir.rs
+++ b/src/uu/rmdir/src/rmdir.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Alex Lyon <arcterus@mail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) ENOTDIR
@@ -16,10 +14,10 @@ use std::path::Path;
use uucore::display::Quotable;
use uucore::error::{set_exit_code, strip_errno, UResult};
-use uucore::{format_usage, show_error, util_name};
+use uucore::{format_usage, help_about, help_usage, show_error, util_name};
-static ABOUT: &str = "Remove the DIRECTORY(ies), if they are empty.";
-const USAGE: &str = "{} [OPTION]... DIRECTORY...";
+static ABOUT: &str = help_about!("rmdir.md");
+const USAGE: &str = help_usage!("rmdir.md");
static OPT_IGNORE_FAIL_NON_EMPTY: &str = "ignore-fail-on-non-empty";
static OPT_PARENTS: &str = "parents";
static OPT_VERBOSE: &str = "verbose";
@@ -100,7 +98,7 @@ fn remove(mut path: &Path, opts: Opts) -> Result<(), Error<'_>> {
if opts.parents {
while let Some(new) = path.parent() {
path = new;
- if path.as_os_str() == "" {
+ if path.as_os_str().is_empty() {
break;
}
remove_single(path, opts)?;
diff --git a/src/uu/runcon/Cargo.toml b/src/uu/runcon/Cargo.toml
index 74fcdf2cf46e61492ccd6e91414d5269cde87db5..da77140de0e467b63909e34cbf3da205a7e0ff1e 100644
--- a/src/uu/runcon/Cargo.toml
+++ b/src/uu/runcon/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_runcon"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "runcon ~ (uutils) run command with specified security context"
@@ -14,11 +14,11 @@ edition = "2021"
path = "src/runcon.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version = ">=0.0.9", package="uucore", path="../../uucore", features=["entries", "fs", "perms"] }
-selinux = { version = "0.3" }
-thiserror = { version = "1.0" }
-libc = { version = "0.2" }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["entries", "fs", "perms"] }
+selinux = { workspace = true }
+thiserror = { workspace = true }
+libc = { workspace = true }
[[bin]]
name = "runcon"
diff --git a/src/uu/runcon/runcon.md b/src/uu/runcon/runcon.md
new file mode 100644
index 0000000000000000000000000000000000000000..155ea7dc0f71476d6070c2c95d11ef5bd9c93ef8
--- /dev/null
+++ b/src/uu/runcon/runcon.md
@@ -0,0 +1,18 @@
+# runcon
+
+```
+runcon [CONTEXT COMMAND [ARG...]]
+runcon [-c] [-u USER] [-r ROLE] [-t TYPE] [-l RANGE] COMMAND [ARG...]
+```
+
+Run command with specified security context under SELinux enabled systems.
+
+## After Help
+
+Run COMMAND with completely-specified CONTEXT, or with current or transitioned security context modified by one or more of LEVEL, ROLE, TYPE, and USER.
+
+If none of --compute, --type, --user, --role or --range is specified, then the first argument is used as the complete context.
+
+Note that only carefully-chosen contexts are likely to successfully run.
+
+With neither CONTEXT nor COMMAND are specified, then this prints the current security context.
diff --git a/src/uu/runcon/src/errors.rs b/src/uu/runcon/src/errors.rs
index 18f06deb936d0b1cef3f31ee802219bc57a9e899..b2bfcad959803e449637cfb8100b07d6135084c3 100644
--- a/src/uu/runcon/src/errors.rs
+++ b/src/uu/runcon/src/errors.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::ffi::OsString;
use std::fmt::{Display, Formatter, Write};
use std::io;
@@ -22,7 +26,7 @@ pub(crate) enum Error {
#[error("No command is specified")]
MissingCommand,
- #[error("SELinux is not enabled")]
+ #[error("runcon may be used only on a SELinux kernel")]
SELinuxNotEnabled,
#[error(transparent)]
@@ -77,13 +81,12 @@ pub(crate) fn write_full_error<W>(writer: &mut W, err: &dyn std::error::Error) -
where
W: Write,
{
- write!(writer, "{}", err)?;
+ write!(writer, "{err}")?;
let mut err = err;
while let Some(source) = err.source() {
err = source;
- write!(writer, ": {}", err)?;
+ write!(writer, ": {err}")?;
}
- write!(writer, ".")?;
Ok(())
}
diff --git a/src/uu/runcon/src/runcon.rs b/src/uu/runcon/src/runcon.rs
index 101cd3bee03d7a92058439cf7bd3f9cdc751db55..a802542b2a2e767d5555fb61e85c5817b78a8988 100644
--- a/src/uu/runcon/src/runcon.rs
+++ b/src/uu/runcon/src/runcon.rs
@@ -1,11 +1,15 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (vars) RFILE
use clap::builder::ValueParser;
use uucore::error::{UResult, UUsageError};
-use clap::{Arg, ArgAction, Command};
+use clap::{crate_version, Arg, ArgAction, Command};
use selinux::{OpaqueSecurityContext, SecurityClass, SecurityContext};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_section, help_usage};
use std::borrow::Cow;
use std::ffi::{CStr, CString, OsStr, OsString};
@@ -18,19 +22,9 @@ mod errors;
use errors::error_exit_status;
use errors::{Error, Result, RunconError};
-const VERSION: &str = env!("CARGO_PKG_VERSION");
-const ABOUT: &str = "Run command with specified security context.";
-const USAGE: &str = "\
- {} [CONTEXT COMMAND [ARG...]]
- {} [-c] [-u USER] [-r ROLE] [-t TYPE] [-l RANGE] COMMAND [ARG...]";
-const DESCRIPTION: &str = "Run COMMAND with completely-specified CONTEXT, or with current or \
- transitioned security context modified by one or more of \
- LEVEL, ROLE, TYPE, and USER.\n\n\
- If none of --compute, --type, --user, --role or --range is specified, \
- then the first argument is used as the complete context.\n\n\
- Note that only carefully-chosen contexts are likely to successfully run.\n\n\
- With neither CONTEXT nor COMMAND are specified, \
- then this prints the current security context.";
+const ABOUT: &str = help_about!("runcon.md");
+const USAGE: &str = help_usage!("runcon.md");
+const DESCRIPTION: &str = help_section!("after help", "runcon.md");
pub mod options {
pub const COMPUTE: &str = "compute";
@@ -52,7 +46,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
match r.kind() {
clap::error::ErrorKind::DisplayHelp
| clap::error::ErrorKind::DisplayVersion => {
- println!("{}", r);
+ println!("{r}");
return Ok(());
}
_ => {}
@@ -60,7 +54,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
}
return Err(UUsageError::new(
error_exit_status::ANOTHER_ERROR,
- format!("{}", r),
+ format!("{r}"),
));
}
};
@@ -107,7 +101,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
pub fn uu_app() -> Command {
Command::new(uucore::util_name())
- .version(VERSION)
+ .version(crate_version!())
.about(ABOUT)
.after_help(DESCRIPTION)
.override_usage(format_usage(USAGE))
@@ -264,7 +258,7 @@ fn print_current_context() -> Result<()> {
if let Some(context) = context {
let context = context.as_ref().to_str()?;
- println!("{}", context);
+ println!("{context}");
} else {
println!();
}
diff --git a/src/uu/seq/BENCHMARKING.md b/src/uu/seq/BENCHMARKING.md
index 4d2f82afe9150e0bd7a0ee75e58fd8649f7b5382..a633d509c3b36e6dabe3dd0d7c0bcd975b8cfa70 100644
--- a/src/uu/seq/BENCHMARKING.md
+++ b/src/uu/seq/BENCHMARKING.md
@@ -5,15 +5,21 @@ GNU version of `seq`, you can use a benchmarking tool like
[hyperfine][0]. On Ubuntu 18.04 or later, you can install `hyperfine` by
running
- sudo apt-get install hyperfine
+```shell
+sudo apt-get install hyperfine
+```
Next, build the `seq` binary under the release profile:
- cargo build --release -p uu_seq
+```shell
+cargo build --release -p uu_seq
+```
-Finally, you can compare the performance of the two versions of `head`
+Finally, you can compare the performance of the two versions of `seq`
by running, for example,
- hyperfine "seq 1000000" "target/release/seq 1000000"
+```shell
+hyperfine "seq 1000000" "target/release/seq 1000000"
+```
[0]: https://github.com/sharkdp/hyperfine
diff --git a/src/uu/seq/Cargo.toml b/src/uu/seq/Cargo.toml
index 07f88fb00e9c600d3db9fc264fe7ce18200ca676..4b571e7a2925043863e899a4faa876cdf5f2cd67 100644
--- a/src/uu/seq/Cargo.toml
+++ b/src/uu/seq/Cargo.toml
@@ -1,7 +1,7 @@
# spell-checker:ignore bigdecimal
[package]
name = "uu_seq"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "seq ~ (uutils) display a sequence of numbers"
@@ -16,11 +16,11 @@ edition = "2021"
path = "src/seq.rs"
[dependencies]
-bigdecimal = "0.3"
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-num-bigint = "0.4.0"
-num-traits = "0.2.15"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["memo"] }
+bigdecimal = { workspace = true }
+clap = { workspace = true }
+num-bigint = { workspace = true }
+num-traits = { workspace = true }
+uucore = { workspace = true, features = ["format", "quoting-style"] }
[[bin]]
name = "seq"
diff --git a/src/uu/seq/seq.md b/src/uu/seq/seq.md
new file mode 100644
index 0000000000000000000000000000000000000000..d747e4a0263f9f46854d8cf098e855d9dc74c228
--- /dev/null
+++ b/src/uu/seq/seq.md
@@ -0,0 +1,9 @@
+# seq
+
+```
+seq [OPTION]... LAST
+seq [OPTION]... FIRST LAST
+seq [OPTION]... FIRST INCREMENT LAST
+```
+
+Display numbers from FIRST to LAST, in steps of INCREMENT.
diff --git a/src/uu/seq/src/error.rs b/src/uu/seq/src/error.rs
index ae641a978c504dece05a8c9b93b88d9f5b8fc517..e81c30fe67325caaa0bb87a0e78707f521f233a1 100644
--- a/src/uu/seq/src/error.rs
+++ b/src/uu/seq/src/error.rs
@@ -1,8 +1,8 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
-// spell-checker:ignore numberparse argtype
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore numberparse
//! Errors returned by seq.
use std::error::Error;
use std::fmt::Display;
@@ -25,29 +25,11 @@ pub enum SeqError {
/// The parameter is the increment argument as a [`String`] as read
/// from the command line.
ZeroIncrement(String),
-}
-
-impl SeqError {
- /// The [`String`] argument as read from the command-line.
- fn arg(&self) -> &str {
- match self {
- Self::ParseError(s, _) => s,
- Self::ZeroIncrement(s) => s,
- }
- }
- /// The type of argument that is causing the error.
- fn argtype(&self) -> &str {
- match self {
- Self::ParseError(_, e) => match e {
- ParseNumberError::Float => "floating point argument",
- ParseNumberError::Nan => "'not-a-number' argument",
- ParseNumberError::Hex => "hexadecimal argument",
- },
- Self::ZeroIncrement(_) => "Zero increment value",
- }
- }
+ /// No arguments were passed to this function, 1 or more is required
+ NoArguments,
}
+
impl UError for SeqError {
/// Always return 1.
fn code(&self) -> i32 {
@@ -63,6 +45,17 @@ impl Error for SeqError {}
impl Display for SeqError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- write!(f, "invalid {}: {}", self.argtype(), self.arg().quote())
+ match self {
+ Self::ParseError(s, e) => {
+ let error_type = match e {
+ ParseNumberError::Float => "floating point",
+ ParseNumberError::Nan => "'not-a-number'",
+ ParseNumberError::Hex => "hexadecimal",
+ };
+ write!(f, "invalid {error_type} argument: {}", s.quote())
+ }
+ Self::ZeroIncrement(s) => write!(f, "invalid Zero increment value: {}", s.quote()),
+ Self::NoArguments => write!(f, "missing operand"),
+ }
}
}
diff --git a/src/uu/seq/src/extendedbigdecimal.rs b/src/uu/seq/src/extendedbigdecimal.rs
index 253fadfd5a335d290450a15a2b00a471993e808c..4f9a0415218e8172f810c6dc8dfc8edd8e5d14e2 100644
--- a/src/uu/seq/src/extendedbigdecimal.rs
+++ b/src/uu/seq/src/extendedbigdecimal.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore bigdecimal extendedbigdecimal extendedbigint
//! An arbitrary precision float that can also represent infinity, NaN, etc.
//!
@@ -21,13 +25,8 @@ use std::fmt::Display;
use std::ops::Add;
use bigdecimal::BigDecimal;
-use num_bigint::BigInt;
-use num_bigint::ToBigInt;
-use num_traits::One;
use num_traits::Zero;
-use crate::extendedbigint::ExtendedBigInt;
-
#[derive(Debug, Clone)]
pub enum ExtendedBigDecimal {
/// Arbitrary precision floating point number.
@@ -68,53 +67,14 @@ pub enum ExtendedBigDecimal {
Nan,
}
-/// The smallest integer greater than or equal to this number.
-fn ceil(x: BigDecimal) -> BigInt {
- if x.is_integer() {
- // Unwrapping the Option because it always returns Some
- x.to_bigint().unwrap()
- } else {
- (x + BigDecimal::one().half()).round(0).to_bigint().unwrap()
- }
-}
-
-/// The largest integer less than or equal to this number.
-fn floor(x: BigDecimal) -> BigInt {
- if x.is_integer() {
- // Unwrapping the Option because it always returns Some
- x.to_bigint().unwrap()
- } else {
- (x - BigDecimal::one().half()).round(0).to_bigint().unwrap()
- }
-}
-
impl ExtendedBigDecimal {
- /// The smallest integer greater than or equal to this number.
- pub fn ceil(self) -> ExtendedBigInt {
- match self {
- Self::BigDecimal(x) => ExtendedBigInt::BigInt(ceil(x)),
- other => From::from(other),
- }
+ #[cfg(test)]
+ pub fn zero() -> Self {
+ Self::BigDecimal(0.into())
}
- /// The largest integer less than or equal to this number.
- pub fn floor(self) -> ExtendedBigInt {
- match self {
- Self::BigDecimal(x) => ExtendedBigInt::BigInt(floor(x)),
- other => From::from(other),
- }
- }
-}
-
-impl From<ExtendedBigInt> for ExtendedBigDecimal {
- fn from(big_int: ExtendedBigInt) -> Self {
- match big_int {
- ExtendedBigInt::BigInt(n) => Self::BigDecimal(BigDecimal::from(n)),
- ExtendedBigInt::Infinity => Self::Infinity,
- ExtendedBigInt::MinusInfinity => Self::MinusInfinity,
- ExtendedBigInt::MinusZero => Self::MinusZero,
- ExtendedBigInt::Nan => Self::Nan,
- }
+ pub fn one() -> Self {
+ Self::BigDecimal(1.into())
}
}
diff --git a/src/uu/seq/src/extendedbigint.rs b/src/uu/seq/src/extendedbigint.rs
deleted file mode 100644
index bbe64300a9835be359f1b5b68e4e1e0345526276..0000000000000000000000000000000000000000
--- a/src/uu/seq/src/extendedbigint.rs
+++ /dev/null
@@ -1,218 +0,0 @@
-// spell-checker:ignore bigint extendedbigint extendedbigdecimal
-//! An arbitrary precision integer that can also represent infinity, NaN, etc.
-//!
-//! Usually infinity, NaN, and negative zero are only represented for
-//! floating point numbers. The [`ExtendedBigInt`] enumeration provides
-//! a representation of those things with the set of integers. The
-//! finite values are stored as [`BigInt`] instances.
-//!
-//! # Examples
-//!
-//! Addition works for [`ExtendedBigInt`] as it does for floats. For
-//! example, adding infinity to any finite value results in infinity:
-//!
-//! ```rust,ignore
-//! let summand1 = ExtendedBigInt::BigInt(BigInt::zero());
-//! let summand2 = ExtendedBigInt::Infinity;
-//! assert_eq!(summand1 + summand2, ExtendedBigInt::Infinity);
-//! ```
-use std::cmp::Ordering;
-use std::fmt::Display;
-use std::ops::Add;
-
-use num_bigint::BigInt;
-use num_bigint::ToBigInt;
-use num_traits::One;
-use num_traits::Zero;
-
-use crate::extendedbigdecimal::ExtendedBigDecimal;
-
-#[derive(Debug, Clone)]
-pub enum ExtendedBigInt {
- BigInt(BigInt),
- Infinity,
- MinusInfinity,
- MinusZero,
- Nan,
-}
-
-impl ExtendedBigInt {
- /// The integer number one.
- pub fn one() -> Self {
- // We would like to implement `num_traits::One`, but it requires
- // a multiplication implementation, and we don't want to
- // implement that here.
- Self::BigInt(BigInt::one())
- }
-}
-
-impl From<ExtendedBigDecimal> for ExtendedBigInt {
- fn from(big_decimal: ExtendedBigDecimal) -> Self {
- match big_decimal {
- // TODO When can this fail?
- ExtendedBigDecimal::BigDecimal(x) => Self::BigInt(x.to_bigint().unwrap()),
- ExtendedBigDecimal::Infinity => Self::Infinity,
- ExtendedBigDecimal::MinusInfinity => Self::MinusInfinity,
- ExtendedBigDecimal::MinusZero => Self::MinusZero,
- ExtendedBigDecimal::Nan => Self::Nan,
- }
- }
-}
-
-impl Display for ExtendedBigInt {
- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- match self {
- Self::BigInt(n) => n.fmt(f),
- Self::Infinity => f32::INFINITY.fmt(f),
- Self::MinusInfinity => f32::NEG_INFINITY.fmt(f),
- Self::MinusZero => {
- // FIXME Come up with a way of formatting this with a
- // "-" prefix.
- 0.fmt(f)
- }
- Self::Nan => "nan".fmt(f),
- }
- }
-}
-
-impl Zero for ExtendedBigInt {
- fn zero() -> Self {
- Self::BigInt(BigInt::zero())
- }
- fn is_zero(&self) -> bool {
- match self {
- Self::BigInt(n) => n.is_zero(),
- Self::MinusZero => true,
- _ => false,
- }
- }
-}
-
-impl Add for ExtendedBigInt {
- type Output = Self;
-
- fn add(self, other: Self) -> Self {
- match (self, other) {
- (Self::BigInt(m), Self::BigInt(n)) => Self::BigInt(m.add(n)),
- (Self::BigInt(_), Self::MinusInfinity) => Self::MinusInfinity,
- (Self::BigInt(_), Self::Infinity) => Self::Infinity,
- (Self::BigInt(_), Self::Nan) => Self::Nan,
- (Self::BigInt(m), Self::MinusZero) => Self::BigInt(m),
- (Self::Infinity, Self::BigInt(_)) => Self::Infinity,
- (Self::Infinity, Self::Infinity) => Self::Infinity,
- (Self::Infinity, Self::MinusZero) => Self::Infinity,
- (Self::Infinity, Self::MinusInfinity) => Self::Nan,
- (Self::Infinity, Self::Nan) => Self::Nan,
- (Self::MinusInfinity, Self::BigInt(_)) => Self::MinusInfinity,
- (Self::MinusInfinity, Self::MinusInfinity) => Self::MinusInfinity,
- (Self::MinusInfinity, Self::MinusZero) => Self::MinusInfinity,
- (Self::MinusInfinity, Self::Infinity) => Self::Nan,
- (Self::MinusInfinity, Self::Nan) => Self::Nan,
- (Self::Nan, _) => Self::Nan,
- (Self::MinusZero, other) => other,
- }
- }
-}
-
-impl PartialEq for ExtendedBigInt {
- fn eq(&self, other: &Self) -> bool {
- match (self, other) {
- (Self::BigInt(m), Self::BigInt(n)) => m.eq(n),
- (Self::BigInt(_), Self::MinusInfinity) => false,
- (Self::BigInt(_), Self::Infinity) => false,
- (Self::BigInt(_), Self::Nan) => false,
- (Self::BigInt(_), Self::MinusZero) => false,
- (Self::Infinity, Self::BigInt(_)) => false,
- (Self::Infinity, Self::Infinity) => true,
- (Self::Infinity, Self::MinusZero) => false,
- (Self::Infinity, Self::MinusInfinity) => false,
- (Self::Infinity, Self::Nan) => false,
- (Self::MinusInfinity, Self::BigInt(_)) => false,
- (Self::MinusInfinity, Self::Infinity) => false,
- (Self::MinusInfinity, Self::MinusZero) => false,
- (Self::MinusInfinity, Self::MinusInfinity) => true,
- (Self::MinusInfinity, Self::Nan) => false,
- (Self::Nan, _) => false,
- (Self::MinusZero, Self::BigInt(_)) => false,
- (Self::MinusZero, Self::Infinity) => false,
- (Self::MinusZero, Self::MinusZero) => true,
- (Self::MinusZero, Self::MinusInfinity) => false,
- (Self::MinusZero, Self::Nan) => false,
- }
- }
-}
-
-impl PartialOrd for ExtendedBigInt {
- fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
- match (self, other) {
- (Self::BigInt(m), Self::BigInt(n)) => m.partial_cmp(n),
- (Self::BigInt(_), Self::MinusInfinity) => Some(Ordering::Greater),
- (Self::BigInt(_), Self::Infinity) => Some(Ordering::Less),
- (Self::BigInt(_), Self::Nan) => None,
- (Self::BigInt(m), Self::MinusZero) => m.partial_cmp(&BigInt::zero()),
- (Self::Infinity, Self::BigInt(_)) => Some(Ordering::Greater),
- (Self::Infinity, Self::Infinity) => Some(Ordering::Equal),
- (Self::Infinity, Self::MinusZero) => Some(Ordering::Greater),
- (Self::Infinity, Self::MinusInfinity) => Some(Ordering::Greater),
- (Self::Infinity, Self::Nan) => None,
- (Self::MinusInfinity, Self::BigInt(_)) => Some(Ordering::Less),
- (Self::MinusInfinity, Self::Infinity) => Some(Ordering::Less),
- (Self::MinusInfinity, Self::MinusZero) => Some(Ordering::Less),
- (Self::MinusInfinity, Self::MinusInfinity) => Some(Ordering::Equal),
- (Self::MinusInfinity, Self::Nan) => None,
- (Self::Nan, _) => None,
- (Self::MinusZero, Self::BigInt(n)) => BigInt::zero().partial_cmp(n),
- (Self::MinusZero, Self::Infinity) => Some(Ordering::Less),
- (Self::MinusZero, Self::MinusZero) => Some(Ordering::Equal),
- (Self::MinusZero, Self::MinusInfinity) => Some(Ordering::Greater),
- (Self::MinusZero, Self::Nan) => None,
- }
- }
-}
-
-#[cfg(test)]
-mod tests {
-
- use num_bigint::BigInt;
- use num_traits::Zero;
-
- use crate::extendedbigint::ExtendedBigInt;
-
- #[test]
- fn test_addition_infinity() {
- let summand1 = ExtendedBigInt::BigInt(BigInt::zero());
- let summand2 = ExtendedBigInt::Infinity;
- assert_eq!(summand1 + summand2, ExtendedBigInt::Infinity);
- }
-
- #[test]
- fn test_addition_minus_infinity() {
- let summand1 = ExtendedBigInt::BigInt(BigInt::zero());
- let summand2 = ExtendedBigInt::MinusInfinity;
- assert_eq!(summand1 + summand2, ExtendedBigInt::MinusInfinity);
- }
-
- #[test]
- fn test_addition_nan() {
- let summand1 = ExtendedBigInt::BigInt(BigInt::zero());
- let summand2 = ExtendedBigInt::Nan;
- let sum = summand1 + summand2;
- match sum {
- ExtendedBigInt::Nan => (),
- _ => unreachable!(),
- }
- }
-
- #[test]
- fn test_display() {
- assert_eq!(format!("{}", ExtendedBigInt::BigInt(BigInt::zero())), "0");
- assert_eq!(format!("{}", ExtendedBigInt::Infinity), "inf");
- assert_eq!(format!("{}", ExtendedBigInt::MinusInfinity), "-inf");
- assert_eq!(format!("{}", ExtendedBigInt::Nan), "nan");
- // FIXME Come up with a way of displaying negative zero as
- // "-0". Currently it displays as just "0".
- //
- // assert_eq!(format!("{}", ExtendedBigInt::MinusZero), "-0");
- //
- }
-}
diff --git a/src/uu/seq/src/number.rs b/src/uu/seq/src/number.rs
index 1bab62b143a72c3a3f69c88d0b2c883c60e12f13..314c842ba15b6bad404af507c473dadc5a4233eb 100644
--- a/src/uu/seq/src/number.rs
+++ b/src/uu/seq/src/number.rs
@@ -1,77 +1,11 @@
-// spell-checker:ignore extendedbigdecimal extendedbigint
-//! A type to represent the possible start, increment, and end values for seq.
-//!
-//! The [`Number`] enumeration represents the possible values for the
-//! start, increment, and end values for `seq`. These may be integers,
-//! floating point numbers, negative zero, etc. A [`Number`] can be
-//! parsed from a string by calling [`str::parse`].
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore extendedbigdecimal
use num_traits::Zero;
use crate::extendedbigdecimal::ExtendedBigDecimal;
-use crate::extendedbigint::ExtendedBigInt;
-
-/// An integral or floating point number.
-#[derive(Debug, PartialEq)]
-pub enum Number {
- Int(ExtendedBigInt),
- Float(ExtendedBigDecimal),
-}
-
-impl Number {
- /// Decide whether this number is zero (either positive or negative).
- pub fn is_zero(&self) -> bool {
- // We would like to implement `num_traits::Zero`, but it
- // requires an addition implementation, and we don't want to
- // implement that here.
- match self {
- Self::Int(n) => n.is_zero(),
- Self::Float(x) => x.is_zero(),
- }
- }
-
- /// Convert this number into an `ExtendedBigDecimal`.
- pub fn into_extended_big_decimal(self) -> ExtendedBigDecimal {
- match self {
- Self::Int(n) => ExtendedBigDecimal::from(n),
- Self::Float(x) => x,
- }
- }
-
- /// The integer number one.
- pub fn one() -> Self {
- // We would like to implement `num_traits::One`, but it requires
- // a multiplication implementation, and we don't want to
- // implement that here.
- Self::Int(ExtendedBigInt::one())
- }
-
- /// Round this number towards the given other number.
- ///
- /// If `other` is greater, then round up. If `other` is smaller,
- /// then round down.
- pub fn round_towards(self, other: &ExtendedBigInt) -> ExtendedBigInt {
- match self {
- // If this number is already an integer, it is already
- // rounded to the nearest integer in the direction of
- // `other`.
- Self::Int(num) => num,
- // Otherwise, if this number is a float, we need to decide
- // whether `other` is larger or smaller than it, and thus
- // whether to round up or round down, respectively.
- Self::Float(num) => {
- let other: ExtendedBigDecimal = From::from(other.clone());
- if other > num {
- num.ceil()
- } else {
- // If they are equal, then `self` is already an
- // integer, so calling `floor()` does no harm and
- // will just return that integer anyway.
- num.floor()
- }
- }
- }
- }
-}
/// A number with a specified number of integer and fractional digits.
///
@@ -83,13 +17,17 @@ impl Number {
/// You can get an instance of this struct by calling [`str::parse`].
#[derive(Debug)]
pub struct PreciseNumber {
- pub number: Number,
+ pub number: ExtendedBigDecimal,
pub num_integral_digits: usize,
pub num_fractional_digits: usize,
}
impl PreciseNumber {
- pub fn new(number: Number, num_integral_digits: usize, num_fractional_digits: usize) -> Self {
+ pub fn new(
+ number: ExtendedBigDecimal,
+ num_integral_digits: usize,
+ num_fractional_digits: usize,
+ ) -> Self {
Self {
number,
num_integral_digits,
@@ -102,7 +40,7 @@ impl PreciseNumber {
// We would like to implement `num_traits::One`, but it requires
// a multiplication implementation, and we don't want to
// implement that here.
- Self::new(Number::one(), 1, 0)
+ Self::new(ExtendedBigDecimal::one(), 1, 0)
}
/// Decide whether this number is zero (either positive or negative).
diff --git a/src/uu/seq/src/numberparse.rs b/src/uu/seq/src/numberparse.rs
index 23d94ea2b7964bc30da13634a9a76f0eaf8c20c6..5a5c64bb991c4c8d2a80c7f065945447dfc79f9c 100644
--- a/src/uu/seq/src/numberparse.rs
+++ b/src/uu/seq/src/numberparse.rs
@@ -1,4 +1,8 @@
-// spell-checker:ignore extendedbigdecimal extendedbigint bigdecimal numberparse
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore extendedbigdecimal bigdecimal numberparse
//! Parsing numbers for use in `seq`.
//!
//! This module provides an implementation of [`FromStr`] for the
@@ -12,8 +16,6 @@ use num_traits::Num;
use num_traits::Zero;
use crate::extendedbigdecimal::ExtendedBigDecimal;
-use crate::extendedbigint::ExtendedBigInt;
-use crate::number::Number;
use crate::number::PreciseNumber;
/// An error returned when parsing a number fails.
@@ -25,8 +27,8 @@ pub enum ParseNumberError {
}
/// Decide whether a given string and its parsed `BigInt` is negative zero.
-fn is_minus_zero_int(s: &str, n: &BigInt) -> bool {
- s.starts_with('-') && n == &BigInt::zero()
+fn is_minus_zero_int(s: &str, n: &BigDecimal) -> bool {
+ s.starts_with('-') && n == &BigDecimal::zero()
}
/// Decide whether a given string and its parsed `BigDecimal` is negative zero.
@@ -49,19 +51,19 @@ fn is_minus_zero_float(s: &str, x: &BigDecimal) -> bool {
/// assert_eq!(actual, expected);
/// ```
fn parse_no_decimal_no_exponent(s: &str) -> Result<PreciseNumber, ParseNumberError> {
- match s.parse::<BigInt>() {
+ match s.parse::<BigDecimal>() {
Ok(n) => {
// If `s` is '-0', then `parse()` returns `BigInt::zero()`,
// but we need to return `Number::MinusZeroInt` instead.
if is_minus_zero_int(s, &n) {
Ok(PreciseNumber::new(
- Number::Int(ExtendedBigInt::MinusZero),
+ ExtendedBigDecimal::MinusZero,
s.len(),
0,
))
} else {
Ok(PreciseNumber::new(
- Number::Int(ExtendedBigInt::BigInt(n)),
+ ExtendedBigDecimal::BigDecimal(n),
s.len(),
0,
))
@@ -69,30 +71,13 @@ fn parse_no_decimal_no_exponent(s: &str) -> Result<PreciseNumber, ParseNumberErr
}
Err(_) => {
// Possibly "NaN" or "inf".
- //
- // TODO In Rust v1.53.0, this change
- // https://github.com/rust-lang/rust/pull/78618 improves the
- // parsing of floats to include being able to parse "NaN"
- // and "inf". So when the minimum version of this crate is
- // increased to 1.53.0, we should just use the built-in
- // `f32` parsing instead.
- if s.eq_ignore_ascii_case("inf") {
- Ok(PreciseNumber::new(
- Number::Float(ExtendedBigDecimal::Infinity),
- 0,
- 0,
- ))
- } else if s.eq_ignore_ascii_case("-inf") {
- Ok(PreciseNumber::new(
- Number::Float(ExtendedBigDecimal::MinusInfinity),
- 0,
- 0,
- ))
- } else if s.eq_ignore_ascii_case("nan") || s.eq_ignore_ascii_case("-nan") {
- Err(ParseNumberError::Nan)
- } else {
- Err(ParseNumberError::Float)
- }
+ let float_val = match s.to_ascii_lowercase().as_str() {
+ "inf" | "infinity" => ExtendedBigDecimal::Infinity,
+ "-inf" | "-infinity" => ExtendedBigDecimal::MinusInfinity,
+ "nan" | "-nan" => return Err(ParseNumberError::Nan),
+ _ => return Err(ParseNumberError::Float),
+ };
+ Ok(PreciseNumber::new(float_val, 0, 0))
}
}
}
@@ -118,8 +103,13 @@ fn parse_exponent_no_decimal(s: &str, j: usize) -> Result<PreciseNumber, ParseNu
// displayed as "0.01", but "1e2" will be displayed as "100",
// without a decimal point.
let x: BigDecimal = s.parse().map_err(|_| ParseNumberError::Float)?;
+
let num_integral_digits = if is_minus_zero_float(s, &x) {
- 2
+ if exponent > 0 {
+ 2usize + exponent as usize
+ } else {
+ 2usize
+ }
} else {
let total = j as i64 + exponent;
let result = if total < 1 {
@@ -135,24 +125,18 @@ fn parse_exponent_no_decimal(s: &str, j: usize) -> Result<PreciseNumber, ParseNu
};
let num_fractional_digits = if exponent < 0 { -exponent as usize } else { 0 };
- if exponent < 0 {
- if is_minus_zero_float(s, &x) {
- Ok(PreciseNumber::new(
- Number::Float(ExtendedBigDecimal::MinusZero),
- num_integral_digits,
- num_fractional_digits,
- ))
- } else {
- Ok(PreciseNumber::new(
- Number::Float(ExtendedBigDecimal::BigDecimal(x)),
- num_integral_digits,
- num_fractional_digits,
- ))
- }
+ if is_minus_zero_float(s, &x) {
+ Ok(PreciseNumber::new(
+ ExtendedBigDecimal::MinusZero,
+ num_integral_digits,
+ num_fractional_digits,
+ ))
} else {
- let zeros = "0".repeat(exponent.try_into().unwrap());
- let expanded = [&s[0..j], &zeros].concat();
- parse_no_decimal_no_exponent(&expanded)
+ Ok(PreciseNumber::new(
+ ExtendedBigDecimal::BigDecimal(x),
+ num_integral_digits,
+ num_fractional_digits,
+ ))
}
}
@@ -182,13 +166,13 @@ fn parse_decimal_no_exponent(s: &str, i: usize) -> Result<PreciseNumber, ParseNu
let num_fractional_digits = s.len() - (i + 1);
if is_minus_zero_float(s, &x) {
Ok(PreciseNumber::new(
- Number::Float(ExtendedBigDecimal::MinusZero),
+ ExtendedBigDecimal::MinusZero,
num_integral_digits,
num_fractional_digits,
))
} else {
Ok(PreciseNumber::new(
- Number::Float(ExtendedBigDecimal::BigDecimal(x)),
+ ExtendedBigDecimal::BigDecimal(x),
num_integral_digits,
num_fractional_digits,
))
@@ -222,7 +206,11 @@ fn parse_decimal_and_exponent(
let minimum: usize = {
let integral_part: f64 = s[..j].parse().map_err(|_| ParseNumberError::Float)?;
if integral_part.is_sign_negative() {
- 2
+ if exponent > 0 {
+ 2usize + exponent as usize
+ } else {
+ 2usize
+ }
} else {
1
}
@@ -249,38 +237,15 @@ fn parse_decimal_and_exponent(
.unwrap()
};
- if num_digits_between_decimal_point_and_e <= exponent {
- if is_minus_zero_float(s, &val) {
- Ok(PreciseNumber::new(
- Number::Int(ExtendedBigInt::MinusZero),
- num_integral_digits,
- num_fractional_digits,
- ))
- } else {
- let zeros: String = "0".repeat(
- (exponent - num_digits_between_decimal_point_and_e)
- .try_into()
- .unwrap(),
- );
- let expanded = [&s[0..i], &s[i + 1..j], &zeros].concat();
- let n = expanded
- .parse::<BigInt>()
- .map_err(|_| ParseNumberError::Float)?;
- Ok(PreciseNumber::new(
- Number::Int(ExtendedBigInt::BigInt(n)),
- num_integral_digits,
- num_fractional_digits,
- ))
- }
- } else if is_minus_zero_float(s, &val) {
+ if is_minus_zero_float(s, &val) {
Ok(PreciseNumber::new(
- Number::Float(ExtendedBigDecimal::MinusZero),
+ ExtendedBigDecimal::MinusZero,
num_integral_digits,
num_fractional_digits,
))
} else {
Ok(PreciseNumber::new(
- Number::Float(ExtendedBigDecimal::BigDecimal(val)),
+ ExtendedBigDecimal::BigDecimal(val),
num_integral_digits,
num_fractional_digits,
))
@@ -316,20 +281,17 @@ fn parse_hexadecimal(s: &str) -> Result<PreciseNumber, ParseNumberError> {
}
let num = BigInt::from_str_radix(s, 16).map_err(|_| ParseNumberError::Hex)?;
+ let num = BigDecimal::from(num);
- match (is_neg, num == BigInt::zero()) {
- (true, true) => Ok(PreciseNumber::new(
- Number::Int(ExtendedBigInt::MinusZero),
- 2,
- 0,
- )),
+ match (is_neg, num == BigDecimal::zero()) {
+ (true, true) => Ok(PreciseNumber::new(ExtendedBigDecimal::MinusZero, 2, 0)),
(true, false) => Ok(PreciseNumber::new(
- Number::Int(ExtendedBigInt::BigInt(-num)),
+ ExtendedBigDecimal::BigDecimal(-num),
0,
0,
)),
(false, _) => Ok(PreciseNumber::new(
- Number::Int(ExtendedBigInt::BigInt(num)),
+ ExtendedBigDecimal::BigDecimal(num),
0,
0,
)),
@@ -377,19 +339,14 @@ impl FromStr for PreciseNumber {
#[cfg(test)]
mod tests {
-
use bigdecimal::BigDecimal;
- use num_bigint::BigInt;
- use num_traits::Zero;
use crate::extendedbigdecimal::ExtendedBigDecimal;
- use crate::extendedbigint::ExtendedBigInt;
- use crate::number::Number;
use crate::number::PreciseNumber;
use crate::numberparse::ParseNumberError;
/// Convenience function for parsing a [`Number`] and unwrapping.
- fn parse(s: &str) -> Number {
+ fn parse(s: &str) -> ExtendedBigDecimal {
s.parse::<PreciseNumber>().unwrap().number
}
@@ -405,40 +362,37 @@ mod tests {
#[test]
fn test_parse_minus_zero_int() {
- assert_eq!(parse("-0e0"), Number::Int(ExtendedBigInt::MinusZero));
- assert_eq!(parse("-0e-0"), Number::Int(ExtendedBigInt::MinusZero));
- assert_eq!(parse("-0e1"), Number::Int(ExtendedBigInt::MinusZero));
- assert_eq!(parse("-0e+1"), Number::Int(ExtendedBigInt::MinusZero));
- assert_eq!(parse("-0.0e1"), Number::Int(ExtendedBigInt::MinusZero));
- assert_eq!(parse("-0x0"), Number::Int(ExtendedBigInt::MinusZero));
+ assert_eq!(parse("-0e0"), ExtendedBigDecimal::MinusZero);
+ assert_eq!(parse("-0e-0"), ExtendedBigDecimal::MinusZero);
+ assert_eq!(parse("-0e1"), ExtendedBigDecimal::MinusZero);
+ assert_eq!(parse("-0e+1"), ExtendedBigDecimal::MinusZero);
+ assert_eq!(parse("-0.0e1"), ExtendedBigDecimal::MinusZero);
+ assert_eq!(parse("-0x0"), ExtendedBigDecimal::MinusZero);
}
#[test]
fn test_parse_minus_zero_float() {
- assert_eq!(parse("-0.0"), Number::Float(ExtendedBigDecimal::MinusZero));
- assert_eq!(parse("-0e-1"), Number::Float(ExtendedBigDecimal::MinusZero));
- assert_eq!(
- parse("-0.0e-1"),
- Number::Float(ExtendedBigDecimal::MinusZero)
- );
+ assert_eq!(parse("-0.0"), ExtendedBigDecimal::MinusZero);
+ assert_eq!(parse("-0e-1"), ExtendedBigDecimal::MinusZero);
+ assert_eq!(parse("-0.0e-1"), ExtendedBigDecimal::MinusZero);
}
#[test]
fn test_parse_big_int() {
- assert_eq!(parse("0"), Number::Int(ExtendedBigInt::zero()));
- assert_eq!(parse("0.1e1"), Number::Int(ExtendedBigInt::one()));
+ assert_eq!(parse("0"), ExtendedBigDecimal::zero());
+ assert_eq!(parse("0.1e1"), ExtendedBigDecimal::one());
assert_eq!(
parse("1.0e1"),
- Number::Int(ExtendedBigInt::BigInt("10".parse::<BigInt>().unwrap()))
+ ExtendedBigDecimal::BigDecimal("10".parse::<BigDecimal>().unwrap())
);
}
#[test]
fn test_parse_hexadecimal_big_int() {
- assert_eq!(parse("0x0"), Number::Int(ExtendedBigInt::zero()));
+ assert_eq!(parse("0x0"), ExtendedBigDecimal::zero());
assert_eq!(
parse("0x10"),
- Number::Int(ExtendedBigInt::BigInt("16".parse::<BigInt>().unwrap()))
+ ExtendedBigDecimal::BigDecimal("16".parse::<BigDecimal>().unwrap())
);
}
@@ -446,44 +400,34 @@ mod tests {
fn test_parse_big_decimal() {
assert_eq!(
parse("0.0"),
- Number::Float(ExtendedBigDecimal::BigDecimal(
- "0.0".parse::<BigDecimal>().unwrap()
- ))
+ ExtendedBigDecimal::BigDecimal("0.0".parse::<BigDecimal>().unwrap())
);
assert_eq!(
parse(".0"),
- Number::Float(ExtendedBigDecimal::BigDecimal(
- "0.0".parse::<BigDecimal>().unwrap()
- ))
+ ExtendedBigDecimal::BigDecimal("0.0".parse::<BigDecimal>().unwrap())
);
assert_eq!(
parse("1.0"),
- Number::Float(ExtendedBigDecimal::BigDecimal(
- "1.0".parse::<BigDecimal>().unwrap()
- ))
+ ExtendedBigDecimal::BigDecimal("1.0".parse::<BigDecimal>().unwrap())
);
assert_eq!(
parse("10e-1"),
- Number::Float(ExtendedBigDecimal::BigDecimal(
- "1.0".parse::<BigDecimal>().unwrap()
- ))
+ ExtendedBigDecimal::BigDecimal("1.0".parse::<BigDecimal>().unwrap())
);
assert_eq!(
parse("-1e-3"),
- Number::Float(ExtendedBigDecimal::BigDecimal(
- "-0.001".parse::<BigDecimal>().unwrap()
- ))
+ ExtendedBigDecimal::BigDecimal("-0.001".parse::<BigDecimal>().unwrap())
);
}
#[test]
fn test_parse_inf() {
- assert_eq!(parse("inf"), Number::Float(ExtendedBigDecimal::Infinity));
- assert_eq!(parse("+inf"), Number::Float(ExtendedBigDecimal::Infinity));
- assert_eq!(
- parse("-inf"),
- Number::Float(ExtendedBigDecimal::MinusInfinity)
- );
+ assert_eq!(parse("inf"), ExtendedBigDecimal::Infinity);
+ assert_eq!(parse("infinity"), ExtendedBigDecimal::Infinity);
+ assert_eq!(parse("+inf"), ExtendedBigDecimal::Infinity);
+ assert_eq!(parse("+infinity"), ExtendedBigDecimal::Infinity);
+ assert_eq!(parse("-inf"), ExtendedBigDecimal::MinusInfinity);
+ assert_eq!(parse("-infinity"), ExtendedBigDecimal::MinusInfinity);
}
#[test]
@@ -539,6 +483,7 @@ mod tests {
}
#[test]
+ #[allow(clippy::cognitive_complexity)]
fn test_num_integral_digits() {
// no decimal, no exponent
assert_eq!(num_integral_digits("123"), 3);
@@ -579,6 +524,7 @@ mod tests {
}
#[test]
+ #[allow(clippy::cognitive_complexity)]
fn test_num_fractional_digits() {
// no decimal, no exponent
assert_eq!(num_fractional_digits("123"), 0);
diff --git a/src/uu/seq/src/seq.rs b/src/uu/seq/src/seq.rs
index e5784d7714025dd6749429a40106b22ccffdd153..96ae83ba0a69dd4c17e1ad39ead20075aa0631eb 100644
--- a/src/uu/seq/src/seq.rs
+++ b/src/uu/seq/src/seq.rs
@@ -1,57 +1,47 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
-// TODO: Support -f flag
-// spell-checker:ignore (ToDO) istr chiter argptr ilen extendedbigdecimal extendedbigint numberparse
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore (ToDO) extendedbigdecimal numberparse
use std::io::{stdout, ErrorKind, Write};
-use std::process::exit;
use clap::{crate_version, Arg, ArgAction, Command};
-use num_traits::Zero;
+use num_traits::{ToPrimitive, Zero};
-use uucore::error::FromIo;
-use uucore::error::UResult;
-use uucore::format_usage;
-use uucore::memo::printf;
-use uucore::show;
+use uucore::error::{FromIo, UResult};
+use uucore::format::{num_format, Format};
+use uucore::{format_usage, help_about, help_usage};
mod error;
mod extendedbigdecimal;
-mod extendedbigint;
+// public to allow fuzzing
+#[cfg(fuzzing)]
+pub mod number;
+#[cfg(not(fuzzing))]
mod number;
mod numberparse;
use crate::error::SeqError;
use crate::extendedbigdecimal::ExtendedBigDecimal;
-use crate::extendedbigint::ExtendedBigInt;
-use crate::number::Number;
use crate::number::PreciseNumber;
-static ABOUT: &str = "Display numbers from FIRST to LAST, in steps of INCREMENT.";
-const USAGE: &str = "\
- {} [OPTION]... LAST
- {} [OPTION]... FIRST LAST
- {} [OPTION]... FIRST INCREMENT LAST";
-static OPT_SEPARATOR: &str = "separator";
-static OPT_TERMINATOR: &str = "terminator";
-static OPT_WIDTHS: &str = "widths";
-static OPT_FORMAT: &str = "format";
+const ABOUT: &str = help_about!("seq.md");
+const USAGE: &str = help_usage!("seq.md");
-static ARG_NUMBERS: &str = "numbers";
+const OPT_SEPARATOR: &str = "separator";
+const OPT_TERMINATOR: &str = "terminator";
+const OPT_EQUAL_WIDTH: &str = "equal-width";
+const OPT_FORMAT: &str = "format";
+
+const ARG_NUMBERS: &str = "numbers";
#[derive(Clone)]
struct SeqOptions<'a> {
separator: String,
terminator: String,
- widths: bool,
+ equal_width: bool,
format: Option<&'a str>,
}
-/// A range of integers.
-///
-/// The elements are (first, increment, last).
-type RangeInt = (ExtendedBigInt, ExtendedBigInt, ExtendedBigInt);
-
/// A range of floats.
///
/// The elements are (first, increment, last).
@@ -61,10 +51,13 @@ type RangeFloat = (ExtendedBigDecimal, ExtendedBigDecimal, ExtendedBigDecimal);
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let matches = uu_app().try_get_matches_from(args)?;
- let numbers = matches
- .get_many::<String>(ARG_NUMBERS)
- .unwrap()
- .collect::<Vec<_>>();
+ let numbers_option = matches.get_many::<String>(ARG_NUMBERS);
+
+ if numbers_option.is_none() {
+ return Err(SeqError::NoArguments.into());
+ }
+
+ let numbers = numbers_option.unwrap().collect::<Vec<_>>();
let options = SeqOptions {
separator: matches
@@ -77,7 +70,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
.map(|s| s.as_str())
.unwrap_or("\n")
.to_string(),
- widths: matches.get_flag(OPT_WIDTHS),
+ equal_width: matches.get_flag(OPT_EQUAL_WIDTH),
format: matches.get_one::<String>(OPT_FORMAT).map(|s| s.as_str()),
};
@@ -119,32 +112,22 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
.num_fractional_digits
.max(increment.num_fractional_digits);
- let result = match (first.number, increment.number, last.number) {
- (Number::Int(first), Number::Int(increment), last) => {
- let last = last.round_towards(&first);
- print_seq_integers(
- (first, increment, last),
- &options.separator,
- &options.terminator,
- options.widths,
- padding,
- options.format,
- )
+ let format = match options.format {
+ Some(f) => {
+ let f = Format::<num_format::Float>::parse(f)?;
+ Some(f)
}
- (first, increment, last) => print_seq(
- (
- first.into_extended_big_decimal(),
- increment.into_extended_big_decimal(),
- last.into_extended_big_decimal(),
- ),
- largest_dec,
- &options.separator,
- &options.terminator,
- options.widths,
- padding,
- options.format,
- ),
+ None => None,
};
+ let result = print_seq(
+ (first.number, increment.number, last.number),
+ largest_dec,
+ &options.separator,
+ &options.terminator,
+ options.equal_width,
+ padding,
+ &format,
+ );
match result {
Ok(_) => Ok(()),
Err(err) if err.kind() == ErrorKind::BrokenPipe => Ok(()),
@@ -173,9 +156,9 @@ pub fn uu_app() -> Command {
.help("Terminator character (defaults to \\n)"),
)
.arg(
- Arg::new(OPT_WIDTHS)
+ Arg::new(OPT_EQUAL_WIDTH)
.short('w')
- .long("widths")
+ .long("equal-width")
.help("Equalize widths of all numbers by padding with zeros")
.action(ArgAction::SetTrue),
)
@@ -206,7 +189,6 @@ fn write_value_float(
value: &ExtendedBigDecimal,
width: usize,
precision: usize,
- _is_first_iteration: bool,
) -> std::io::Result<()> {
let value_as_str =
if *value == ExtendedBigDecimal::Infinity || *value == ExtendedBigDecimal::MinusInfinity {
@@ -214,34 +196,9 @@ fn write_value_float(
} else {
format!("{value:>0width$.precision$}")
};
- write!(writer, "{}", value_as_str)
+ write!(writer, "{value_as_str}")
}
-/// Write a big int formatted according to the given parameters.
-fn write_value_int(
- writer: &mut impl Write,
- value: &ExtendedBigInt,
- width: usize,
- pad: bool,
- is_first_iteration: bool,
-) -> std::io::Result<()> {
- let value_as_str = if pad {
- if *value == ExtendedBigInt::MinusZero && is_first_iteration {
- format!("-{value:>0width$}", width = width - 1)
- } else {
- format!("{value:>0width$}")
- }
- } else if *value == ExtendedBigInt::MinusZero && is_first_iteration {
- format!("-{}", value)
- } else {
- format!("{}", value)
- };
- write!(writer, "{}", value_as_str)
-}
-
-// TODO `print_seq()` and `print_seq_integers()` are nearly identical,
-// they could be refactored into a single more general function.
-
/// Floating point based code path
fn print_seq(
range: RangeFloat,
@@ -250,17 +207,21 @@ fn print_seq(
terminator: &str,
pad: bool,
padding: usize,
- format: Option<&str>,
+ format: &Option<Format<num_format::Float>>,
) -> std::io::Result<()> {
let stdout = stdout();
let mut stdout = stdout.lock();
let (first, increment, last) = range;
let mut value = first;
- let padding = if pad { padding + 1 + largest_dec } else { 0 };
+ let padding = if pad {
+ padding + if largest_dec > 0 { largest_dec + 1 } else { 0 }
+ } else {
+ 0
+ };
let mut is_first_iteration = true;
while !done_printing(&value, &increment, &last) {
if !is_first_iteration {
- write!(stdout, "{}", separator)?;
+ write!(stdout, "{separator}")?;
}
// If there was an argument `-f FORMAT`, then use that format
// template instead of the default formatting strategy.
@@ -274,88 +235,26 @@ fn print_seq(
// it as a string and ultimately writing to `stdout`. We
// shouldn't have to do so much converting back and forth via
// strings.
- match format {
+ match &format {
Some(f) => {
- let s = format!("{}", value);
- if let Err(x) = printf(f, &[s]) {
- show!(x);
- exit(1);
- }
+ let float = match &value {
+ ExtendedBigDecimal::BigDecimal(bd) => bd.to_f64().unwrap(),
+ ExtendedBigDecimal::Infinity => f64::INFINITY,
+ ExtendedBigDecimal::MinusInfinity => f64::NEG_INFINITY,
+ ExtendedBigDecimal::MinusZero => -0.0,
+ ExtendedBigDecimal::Nan => f64::NAN,
+ };
+ f.fmt(&mut stdout, float)?;
}
- None => write_value_float(
- &mut stdout,
- &value,
- padding,
- largest_dec,
- is_first_iteration,
- )?,
+ None => write_value_float(&mut stdout, &value, padding, largest_dec)?,
}
// TODO Implement augmenting addition.
value = value + increment.clone();
is_first_iteration = false;
}
if !is_first_iteration {
- write!(stdout, "{}", terminator)?;
+ write!(stdout, "{terminator}")?;
}
stdout.flush()?;
Ok(())
}
-
-/// Print an integer sequence.
-///
-/// This function prints a sequence of integers defined by `range`,
-/// which defines the first integer, last integer, and increment of the
-/// range. The `separator` is inserted between each integer and
-/// `terminator` is inserted at the end.
-///
-/// The `pad` parameter indicates whether to pad numbers to the width
-/// given in `padding`.
-///
-/// If `is_first_minus_zero` is `true`, then the `first` parameter is
-/// printed as if it were negative zero, even though no such number
-/// exists as an integer (negative zero only exists for floating point
-/// numbers). Only set this to `true` if `first` is actually zero.
-fn print_seq_integers(
- range: RangeInt,
- separator: &str,
- terminator: &str,
- pad: bool,
- padding: usize,
- format: Option<&str>,
-) -> std::io::Result<()> {
- let stdout = stdout();
- let mut stdout = stdout.lock();
- let (first, increment, last) = range;
- let mut value = first;
- let mut is_first_iteration = true;
- while !done_printing(&value, &increment, &last) {
- if !is_first_iteration {
- write!(stdout, "{}", separator)?;
- }
- // If there was an argument `-f FORMAT`, then use that format
- // template instead of the default formatting strategy.
- //
- // The `printf()` function takes in the template and
- // the current value and writes the result to `stdout`.
- //
- // TODO See similar comment about formatting in `print_seq()`.
- match format {
- Some(f) => {
- let s = format!("{}", value);
- if let Err(x) = printf(f, &[s]) {
- show!(x);
- exit(1);
- }
- }
- None => write_value_int(&mut stdout, &value, padding, pad, is_first_iteration)?,
- }
- // TODO Implement augmenting addition.
- value = value + increment.clone();
- is_first_iteration = false;
- }
-
- if !is_first_iteration {
- write!(stdout, "{}", terminator)?;
- }
- Ok(())
-}
diff --git a/src/uu/shred/Cargo.toml b/src/uu/shred/Cargo.toml
index 957abf766e3dc34f2060aa75840923bbd9c01e58..0c84aa2cbcc2f926b09b08ae7be06c1fade63357 100644
--- a/src/uu/shred/Cargo.toml
+++ b/src/uu/shred/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_shred"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "shred ~ (uutils) hide former FILE contents with repeated overwrites"
@@ -15,9 +15,10 @@ edition = "2021"
path = "src/shred.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-rand = "0.8"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+rand = { workspace = true }
+uucore = { workspace = true }
+libc = { workspace = true }
[[bin]]
name = "shred"
diff --git a/src/uu/shred/shred.md b/src/uu/shred/shred.md
new file mode 100644
index 0000000000000000000000000000000000000000..6d6398cce1039c355ab53d40327f2dc1ac1e8816
--- /dev/null
+++ b/src/uu/shred/shred.md
@@ -0,0 +1,47 @@
+# shred
+
+<!-- spell-checker:ignore writeback -->
+
+```
+shred [OPTION]... FILE...
+```
+
+Overwrite the specified FILE(s) repeatedly, in order to make it harder for even
+very expensive hardware probing to recover the data.
+
+## After help
+
+Delete `FILE(s)` if `--remove` (`-u`) is specified. The default is not to remove
+the files because it is common to operate on device files like `/dev/hda`, and
+those files usually should not be removed.
+
+CAUTION: Note that shred relies on a very important assumption: that the file
+system overwrites data in place. This is the traditional way to do things, but
+many modern file system designs do not satisfy this assumption. The following
+are examples of file systems on which shred is not effective, or is not
+guaranteed to be effective in all file system modes:
+
+ * log-structured or journal file systems, such as those supplied with
+ AIX and Solaris (and JFS, ReiserFS, XFS, Ext3, etc.)
+
+ * file systems that write redundant data and carry on even if some writes
+ fail, such as RAID-based file systems
+
+ * file systems that make snapshots, such as Network Appliance's NFS server
+
+ * file systems that cache in temporary locations, such as NFS
+ version 3 clients
+
+ * compressed file systems
+
+In the case of ext3 file systems, the above disclaimer applies (and shred is
+thus of limited effectiveness) only in `data=journal` mode, which journals file
+data in addition to just metadata. In both the `data=ordered` (default) and
+`data=writeback` modes, shred works as usual. Ext3 journal modes can be changed
+by adding the `data=something` option to the mount options for a particular
+file system in the `/etc/fstab` file, as documented in the mount man page (`man
+mount`).
+
+In addition, file system backups and remote mirrors may contain copies of
+the file that cannot be removed, and that will allow a shredded file to be
+recovered later.
diff --git a/src/uu/shred/src/shred.rs b/src/uu/shred/src/shred.rs
index de1af9e30a08ed651b17694ce368bdc789bf4214..763d6cfd4bf802f7ffa2f35da1dd064d97da75fc 100644
--- a/src/uu/shred/src/shred.rs
+++ b/src/uu/shred/src/shred.rs
@@ -1,270 +1,221 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Michael Rosenberg <42micro@gmail.com>
-// * (c) Fort <forticulous@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-// spell-checker:ignore (words) writeback wipesync
+// spell-checker:ignore (words) wipesync prefill
use clap::{crate_version, Arg, ArgAction, Command};
-use rand::prelude::SliceRandom;
-use rand::Rng;
-use std::cell::{Cell, RefCell};
-use std::fs;
-use std::fs::{File, OpenOptions};
-use std::io;
-use std::io::prelude::*;
-use std::io::SeekFrom;
+#[cfg(unix)]
+use libc::S_IWUSR;
+use rand::{rngs::StdRng, seq::SliceRandom, Rng, SeedableRng};
+use std::fs::{self, File, OpenOptions};
+use std::io::{self, Seek, Write};
+#[cfg(unix)]
+use std::os::unix::prelude::PermissionsExt;
use std::path::{Path, PathBuf};
use uucore::display::Quotable;
use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
-use uucore::{format_usage, show, show_if_err, util_name};
+use uucore::parse_size::parse_size_u64;
+use uucore::shortcut_value_parser::ShortcutValueParser;
+use uucore::{format_usage, help_about, help_section, help_usage, show_error, show_if_err};
-const BLOCK_SIZE: usize = 512;
+const ABOUT: &str = help_about!("shred.md");
+const USAGE: &str = help_usage!("shred.md");
+const AFTER_HELP: &str = help_section!("after help", "shred.md");
+
+pub mod options {
+ pub const FORCE: &str = "force";
+ pub const FILE: &str = "file";
+ pub const ITERATIONS: &str = "iterations";
+ pub const SIZE: &str = "size";
+ pub const WIPESYNC: &str = "u";
+ pub const REMOVE: &str = "remove";
+ pub const VERBOSE: &str = "verbose";
+ pub const EXACT: &str = "exact";
+ pub const ZERO: &str = "zero";
+
+ pub mod remove {
+ pub const UNLINK: &str = "unlink";
+ pub const WIPE: &str = "wipe";
+ pub const WIPESYNC: &str = "wipesync";
+ }
+}
+
+// This block size seems to match GNU (2^16 = 65536)
+const BLOCK_SIZE: usize = 1 << 16;
const NAME_CHARSET: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_.";
-// Patterns as shown in the GNU coreutils shred implementation
-const PATTERNS: [&[u8]; 22] = [
- b"\x00",
- b"\xFF",
- b"\x55",
- b"\xAA",
- b"\x24\x92\x49",
- b"\x49\x24\x92",
- b"\x6D\xB6\xDB",
- b"\x92\x49\x24",
- b"\xB6\xDB\x6D",
- b"\xDB\x6D\xB6",
- b"\x11",
- b"\x22",
- b"\x33",
- b"\x44",
- b"\x66",
- b"\x77",
- b"\x88",
- b"\x99",
- b"\xBB",
- b"\xCC",
- b"\xDD",
- b"\xEE",
+const PATTERN_LENGTH: usize = 3;
+const PATTERN_BUFFER_SIZE: usize = BLOCK_SIZE + PATTERN_LENGTH - 1;
+
+/// Patterns that appear in order for the passes
+///
+/// They are all extended to 3 bytes for consistency, even though some could be
+/// expressed as single bytes.
+const PATTERNS: [Pattern; 22] = [
+ Pattern::Single(b'\x00'),
+ Pattern::Single(b'\xFF'),
+ Pattern::Single(b'\x55'),
+ Pattern::Single(b'\xAA'),
+ Pattern::Multi([b'\x24', b'\x92', b'\x49']),
+ Pattern::Multi([b'\x49', b'\x24', b'\x92']),
+ Pattern::Multi([b'\x6D', b'\xB6', b'\xDB']),
+ Pattern::Multi([b'\x92', b'\x49', b'\x24']),
+ Pattern::Multi([b'\xB6', b'\xDB', b'\x6D']),
+ Pattern::Multi([b'\xDB', b'\x6D', b'\xB6']),
+ Pattern::Single(b'\x11'),
+ Pattern::Single(b'\x22'),
+ Pattern::Single(b'\x33'),
+ Pattern::Single(b'\x44'),
+ Pattern::Single(b'\x66'),
+ Pattern::Single(b'\x77'),
+ Pattern::Single(b'\x88'),
+ Pattern::Single(b'\x99'),
+ Pattern::Single(b'\xBB'),
+ Pattern::Single(b'\xCC'),
+ Pattern::Single(b'\xDD'),
+ Pattern::Single(b'\xEE'),
];
#[derive(Clone, Copy)]
-enum PassType<'a> {
- Pattern(&'a [u8]),
+enum Pattern {
+ Single(u8),
+ Multi([u8; 3]),
+}
+
+enum PassType {
+ Pattern(Pattern),
Random,
}
-// Used to generate all possible filenames of a certain length using NAME_CHARSET as an alphabet
-struct FilenameGenerator {
- name_len: usize,
- name_charset_indices: RefCell<Vec<usize>>, // Store the indices of the letters of our filename in NAME_CHARSET
- exhausted: Cell<bool>,
+#[derive(PartialEq, Clone, Copy)]
+enum RemoveMethod {
+ None, // Default method. Only obfuscate the file data
+ Unlink, // The same as 'None' + unlink the file
+ Wipe, // The same as 'Unlink' + obfuscate the file name before unlink
+ WipeSync, // The same as 'Wipe' sync the file name changes
}
-impl FilenameGenerator {
+/// Iterates over all possible filenames of a certain length using NAME_CHARSET as an alphabet
+struct FilenameIter {
+ // Store the indices of the letters of our filename in NAME_CHARSET
+ name_charset_indices: Vec<usize>,
+ exhausted: bool,
+}
+
+impl FilenameIter {
fn new(name_len: usize) -> Self {
- let indices: Vec<usize> = vec![0; name_len];
Self {
- name_len,
- name_charset_indices: RefCell::new(indices),
- exhausted: Cell::new(false),
+ name_charset_indices: vec![0; name_len],
+ exhausted: false,
}
}
}
-impl Iterator for FilenameGenerator {
+impl Iterator for FilenameIter {
type Item = String;
fn next(&mut self) -> Option<String> {
- if self.exhausted.get() {
+ if self.exhausted {
return None;
}
- let mut name_charset_indices = self.name_charset_indices.borrow_mut();
-
- // Make the return value, then increment
- let mut ret = String::new();
- for i in name_charset_indices.iter() {
- let c = char::from(NAME_CHARSET[*i]);
- ret.push(c);
- }
-
- if name_charset_indices[0] == NAME_CHARSET.len() - 1 {
- self.exhausted.set(true);
- }
- // Now increment the least significant index
- for i in (0..self.name_len).rev() {
- if name_charset_indices[i] == NAME_CHARSET.len() - 1 {
- name_charset_indices[i] = 0; // Carry the 1
+ // First, make the return value using the current state
+ let ret: String = self
+ .name_charset_indices
+ .iter()
+ .map(|i| char::from(NAME_CHARSET[*i]))
+ .collect();
+
+ // Now increment the least significant index and possibly each next
+ // index if necessary.
+ for index in self.name_charset_indices.iter_mut().rev() {
+ if *index == NAME_CHARSET.len() - 1 {
+ // Carry the 1
+ *index = 0;
continue;
} else {
- name_charset_indices[i] += 1;
- break;
+ *index += 1;
+ return Some(ret);
}
}
+ // If we get here, we flipped all bits back to 0, so we exhausted all options.
+ self.exhausted = true;
Some(ret)
}
}
-// Used to generate blocks of bytes of size <= BLOCK_SIZE based on either a give pattern
-// or randomness
-struct BytesGenerator<'a> {
- total_bytes: u64,
- bytes_generated: Cell<u64>,
- block_size: usize,
- exact: bool, // if false, every block's size is block_size
- gen_type: PassType<'a>,
- rng: Option<RefCell<rand::rngs::ThreadRng>>,
- bytes: [u8; BLOCK_SIZE],
+/// Used to generate blocks of bytes of size <= BLOCK_SIZE based on either a give pattern
+/// or randomness
+// The lint warns about a large difference because StdRng is big, but the buffers are much
+// larger anyway, so it's fine.
+#[allow(clippy::large_enum_variant)]
+enum BytesWriter {
+ Random {
+ rng: StdRng,
+ buffer: [u8; BLOCK_SIZE],
+ },
+ // To write patterns we only write to the buffer once. To be able to do
+ // this, we need to extend the buffer with 2 bytes. We can then easily
+ // obtain a buffer starting with any character of the pattern that we
+ // want with an offset of either 0, 1 or 2.
+ //
+ // For example, if we have the pattern ABC, but we want to write a block
+ // of BLOCK_SIZE starting with B, we just pick the slice [1..BLOCK_SIZE+1]
+ // This means that we only have to fill the buffer once and can just reuse
+ // it afterwards.
+ Pattern {
+ offset: usize,
+ buffer: [u8; PATTERN_BUFFER_SIZE],
+ },
}
-impl<'a> BytesGenerator<'a> {
- fn new(total_bytes: u64, gen_type: PassType<'a>, exact: bool) -> BytesGenerator {
- let rng = match gen_type {
- PassType::Random => Some(RefCell::new(rand::thread_rng())),
- PassType::Pattern(_) => None,
- };
-
- let bytes = [0; BLOCK_SIZE];
-
- BytesGenerator {
- total_bytes,
- bytes_generated: Cell::new(0u64),
- block_size: BLOCK_SIZE,
- exact,
- gen_type,
- rng,
- bytes,
- }
- }
-
- pub fn reset(&mut self, total_bytes: u64, gen_type: PassType<'a>) {
- if let PassType::Random = gen_type {
- if self.rng.is_none() {
- self.rng = Some(RefCell::new(rand::thread_rng()));
+impl BytesWriter {
+ fn from_pass_type(pass: &PassType) -> Self {
+ match pass {
+ PassType::Random => Self::Random {
+ rng: StdRng::from_entropy(),
+ buffer: [0; BLOCK_SIZE],
+ },
+ PassType::Pattern(pattern) => {
+ // Copy the pattern in chunks rather than simply one byte at a time
+ // We prefill the pattern so that the buffer can be reused at each
+ // iteration as a small optimization.
+ let buffer = match pattern {
+ Pattern::Single(byte) => [*byte; PATTERN_BUFFER_SIZE],
+ Pattern::Multi(bytes) => {
+ let mut buf = [0; PATTERN_BUFFER_SIZE];
+ for chunk in buf.chunks_exact_mut(PATTERN_LENGTH) {
+ chunk.copy_from_slice(bytes);
+ }
+ buf
+ }
+ };
+ Self::Pattern { offset: 0, buffer }
}
}
-
- self.total_bytes = total_bytes;
- self.gen_type = gen_type;
-
- self.bytes_generated.set(0);
}
- pub fn next(&mut self) -> Option<&[u8]> {
- // We go over the total_bytes limit when !self.exact and total_bytes isn't a multiple
- // of self.block_size
- if self.bytes_generated.get() >= self.total_bytes {
- return None;
- }
-
- let this_block_size = if !self.exact {
- self.block_size
- } else {
- let bytes_left = self.total_bytes - self.bytes_generated.get();
- if bytes_left >= self.block_size as u64 {
- self.block_size
- } else {
- (bytes_left % self.block_size as u64) as usize
- }
- };
-
- let bytes = &mut self.bytes[..this_block_size];
-
- match self.gen_type {
- PassType::Random => {
- let mut rng = self.rng.as_ref().unwrap().borrow_mut();
+ fn bytes_for_pass(&mut self, size: usize) -> &[u8] {
+ match self {
+ Self::Random { rng, buffer } => {
+ let bytes = &mut buffer[..size];
rng.fill(bytes);
+ bytes
}
- PassType::Pattern(pattern) => {
- let skip = if self.bytes_generated.get() == 0 {
- 0
- } else {
- (pattern.len() as u64 % self.bytes_generated.get()) as usize
- };
-
- // Copy the pattern in chunks rather than simply one byte at a time
- let mut i = 0;
- while i < this_block_size {
- let start = (i + skip) % pattern.len();
- let end = (this_block_size - i).min(pattern.len());
- let len = end - start;
-
- bytes[i..i + len].copy_from_slice(&pattern[start..end]);
-
- i += len;
- }
+ Self::Pattern { offset, buffer } => {
+ let bytes = &buffer[*offset..size + *offset];
+ *offset = (*offset + size) % PATTERN_LENGTH;
+ bytes
}
- };
-
- let new_bytes_generated = self.bytes_generated.get() + this_block_size as u64;
- self.bytes_generated.set(new_bytes_generated);
-
- Some(bytes)
+ }
}
}
-static ABOUT: &str = "Overwrite the specified FILE(s) repeatedly, in order to make it harder\n\
-for even very expensive hardware probing to recover the data.
-";
-const USAGE: &str = "{} [OPTION]... FILE...";
-
-static AFTER_HELP: &str =
- "Delete FILE(s) if --remove (-u) is specified. The default is not to remove\n\
- the files because it is common to operate on device files like /dev/hda,\n\
- and those files usually should not be removed.\n\
- \n\
- CAUTION: Note that shred relies on a very important assumption:\n\
- that the file system overwrites data in place. This is the traditional\n\
- way to do things, but many modern file system designs do not satisfy this\n\
- assumption. The following are examples of file systems on which shred is\n\
- not effective, or is not guaranteed to be effective in all file system modes:\n\
- \n\
- * log-structured or journal file systems, such as those supplied with\n\
- AIX and Solaris (and JFS, ReiserFS, XFS, Ext3, etc.)\n\
- \n\
- * file systems that write redundant data and carry on even if some writes\n\
- fail, such as RAID-based file systems\n\
- \n\
- * file systems that make snapshots, such as Network Appliance's NFS server\n\
- \n\
- * file systems that cache in temporary locations, such as NFS\n\
- version 3 clients\n\
- \n\
- * compressed file systems\n\
- \n\
- In the case of ext3 file systems, the above disclaimer applies\n\
- and shred is thus of limited effectiveness) only in data=journal mode,\n\
- which journals file data in addition to just metadata. In both the\n\
- data=ordered (default) and data=writeback modes, shred works as usual.\n\
- Ext3 journal modes can be changed by adding the data=something option\n\
- to the mount options for a particular file system in the /etc/fstab file,\n\
- as documented in the mount man page (man mount).\n\
- \n\
- In addition, file system backups and remote mirrors may contain copies\n\
- of the file that cannot be removed, and that will allow a shredded file\n\
- to be recovered later.\n\
- ";
-
-pub mod options {
- pub const FORCE: &str = "force";
- pub const FILE: &str = "file";
- pub const ITERATIONS: &str = "iterations";
- pub const SIZE: &str = "size";
- pub const REMOVE: &str = "remove";
- pub const VERBOSE: &str = "verbose";
- pub const EXACT: &str = "exact";
- pub const ZERO: &str = "zero";
-}
-
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_ignore();
-
let matches = uu_app().try_get_matches_from(args)?;
if !matches.contains_id(options::FILE) {
@@ -284,28 +235,43 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
None => unreachable!(),
};
- // TODO: implement --remove HOW
- // The optional HOW parameter indicates how to remove a directory entry:
- // - 'unlink' => use a standard unlink call.
- // - 'wipe' => also first obfuscate bytes in the name.
- // - 'wipesync' => also sync each obfuscated byte to disk.
- // The default mode is 'wipesync', but note it can be expensive.
-
// TODO: implement --random-source
+ let remove_method = if matches.get_flag(options::WIPESYNC) {
+ RemoveMethod::WipeSync
+ } else if matches.contains_id(options::REMOVE) {
+ match matches
+ .get_one::<String>(options::REMOVE)
+ .map(AsRef::as_ref)
+ {
+ Some(options::remove::UNLINK) => RemoveMethod::Unlink,
+ Some(options::remove::WIPE) => RemoveMethod::Wipe,
+ Some(options::remove::WIPESYNC) => RemoveMethod::WipeSync,
+ _ => unreachable!("should be caught by clap"),
+ }
+ } else {
+ RemoveMethod::None
+ };
+
let force = matches.get_flag(options::FORCE);
- let remove = matches.get_flag(options::REMOVE);
let size_arg = matches
.get_one::<String>(options::SIZE)
.map(|s| s.to_string());
let size = get_size(size_arg);
- let exact = matches.get_flag(options::EXACT) && size.is_none(); // if -s is given, ignore -x
+ let exact = matches.get_flag(options::EXACT) || size.is_some();
let zero = matches.get_flag(options::ZERO);
let verbose = matches.get_flag(options::VERBOSE);
for path_str in matches.get_many::<String>(options::FILE).unwrap() {
show_if_err!(wipe_file(
- path_str, iterations, remove, size, exact, zero, verbose, force,
+ path_str,
+ iterations,
+ remove_method,
+ size,
+ exact,
+ zero,
+ verbose,
+ force,
));
}
Ok(())
@@ -341,12 +307,26 @@ pub fn uu_app() -> Command {
.help("shred this many bytes (suffixes like K, M, G accepted)"),
)
.arg(
- Arg::new(options::REMOVE)
+ Arg::new(options::WIPESYNC)
.short('u')
- .long(options::REMOVE)
- .help("truncate and remove file after overwriting; See below")
+ .help("deallocate and remove file after overwriting")
.action(ArgAction::SetTrue),
)
+ .arg(
+ Arg::new(options::REMOVE)
+ .long(options::REMOVE)
+ .value_name("HOW")
+ .value_parser(ShortcutValueParser::new([
+ options::remove::UNLINK,
+ options::remove::WIPE,
+ options::remove::WIPESYNC,
+ ]))
+ .num_args(0..=1)
+ .require_equals(true)
+ .default_missing_value(options::remove::WIPESYNC)
+ .help("like -u but give control on HOW to delete; See below")
+ .action(ArgAction::Set),
+ )
.arg(
Arg::new(options::VERBOSE)
.long(options::VERBOSE)
@@ -379,65 +359,34 @@ pub fn uu_app() -> Command {
)
}
-// TODO: Add support for all postfixes here up to and including EiB
-// http://www.gnu.org/software/coreutils/manual/coreutils.html#Block-size
fn get_size(size_str_opt: Option<String>) -> Option<u64> {
- size_str_opt.as_ref()?;
-
- let mut size_str = size_str_opt.as_ref().unwrap().clone();
- // Immutably look at last character of size string
- let unit = match size_str.chars().last().unwrap() {
- 'K' => {
- size_str.pop();
- 1024u64
- }
- 'M' => {
- size_str.pop();
- (1024 * 1024) as u64
- }
- 'G' => {
- size_str.pop();
- (1024 * 1024 * 1024) as u64
- }
- _ => 1u64,
- };
-
- let coefficient = match size_str.parse::<u64>() {
- Ok(u) => u,
- Err(_) => {
- println!(
- "{}: {}: Invalid file size",
- util_name(),
- size_str_opt.unwrap().maybe_quote()
- );
- std::process::exit(1);
- }
- };
-
- Some(coefficient * unit)
+ size_str_opt
+ .as_ref()
+ .and_then(|size| parse_size_u64(size.as_str()).ok())
+ .or_else(|| {
+ if let Some(size) = size_str_opt {
+ show_error!("invalid file size: {}", size.quote());
+ // TODO: replace with our error management
+ std::process::exit(1);
+ }
+ None
+ })
}
-fn pass_name(pass_type: PassType) -> String {
+fn pass_name(pass_type: &PassType) -> String {
match pass_type {
PassType::Random => String::from("random"),
- PassType::Pattern(bytes) => {
- let mut s: String = String::new();
- while s.len() < 6 {
- for b in bytes {
- let readable: String = format!("{:x}", b);
- s.push_str(&readable);
- }
- }
- s
- }
+ PassType::Pattern(Pattern::Single(byte)) => format!("{byte:x}{byte:x}{byte:x}"),
+ PassType::Pattern(Pattern::Multi([a, b, c])) => format!("{a:x}{b:x}{c:x}"),
}
}
#[allow(clippy::too_many_arguments)]
+#[allow(clippy::cognitive_complexity)]
fn wipe_file(
path_str: &str,
n_passes: usize,
- remove: bool,
+ remove_method: RemoveMethod,
size: Option<u64>,
exact: bool,
zero: bool,
@@ -445,7 +394,7 @@ fn wipe_file(
force: bool,
) -> UResult<()> {
// Get these potential errors out of the way first
- let path: &Path = Path::new(path_str);
+ let path = Path::new(path_str);
if !path.exists() {
return Err(USimpleError::new(
1,
@@ -459,115 +408,125 @@ fn wipe_file(
));
}
+ let metadata = fs::metadata(path).map_err_context(String::new)?;
+
// If force is true, set file permissions to not-readonly.
if force {
- let metadata = fs::metadata(path).map_err_context(String::new)?;
let mut perms = metadata.permissions();
+ #[cfg(unix)]
+ #[allow(clippy::useless_conversion, clippy::unnecessary_cast)]
+ {
+ // NOTE: set_readonly(false) makes the file world-writable on Unix.
+ // NOTE: S_IWUSR type is u16 on macOS, i32 on Redox.
+ if (perms.mode() & (S_IWUSR as u32)) == 0 {
+ perms.set_mode(S_IWUSR as u32);
+ }
+ }
+ #[cfg(not(unix))]
+ // TODO: Remove the following once https://github.com/rust-lang/rust-clippy/issues/10477 is resolved.
+ #[allow(clippy::permissions_set_readonly_false)]
perms.set_readonly(false);
fs::set_permissions(path, perms).map_err_context(String::new)?;
}
// Fill up our pass sequence
- let mut pass_sequence: Vec<PassType> = Vec::new();
+ let mut pass_sequence = Vec::new();
+ if metadata.len() != 0 {
+ // Only add passes if the file is non-empty
+
+ if n_passes <= 3 {
+ // Only random passes if n_passes <= 3
+ for _ in 0..n_passes {
+ pass_sequence.push(PassType::Random);
+ }
+ } else {
+ // First fill it with Patterns, shuffle it, then evenly distribute Random
+ let n_full_arrays = n_passes / PATTERNS.len(); // How many times can we go through all the patterns?
+ let remainder = n_passes % PATTERNS.len(); // How many do we get through on our last time through?
- if n_passes <= 3 {
- // Only random passes if n_passes <= 3
- for _ in 0..n_passes {
- pass_sequence.push(PassType::Random);
- }
- }
- // First fill it with Patterns, shuffle it, then evenly distribute Random
- else {
- let n_full_arrays = n_passes / PATTERNS.len(); // How many times can we go through all the patterns?
- let remainder = n_passes % PATTERNS.len(); // How many do we get through on our last time through?
-
- for _ in 0..n_full_arrays {
- for p in &PATTERNS {
- pass_sequence.push(PassType::Pattern(p));
+ for _ in 0..n_full_arrays {
+ for p in PATTERNS {
+ pass_sequence.push(PassType::Pattern(p));
+ }
+ }
+ for pattern in PATTERNS.into_iter().take(remainder) {
+ pass_sequence.push(PassType::Pattern(pattern));
+ }
+ let mut rng = rand::thread_rng();
+ pass_sequence.shuffle(&mut rng); // randomize the order of application
+
+ let n_random = 3 + n_passes / 10; // Minimum 3 random passes; ratio of 10 after
+ // Evenly space random passes; ensures one at the beginning and end
+ for i in 0..n_random {
+ pass_sequence[i * (n_passes - 1) / (n_random - 1)] = PassType::Random;
}
}
- for pattern in PATTERNS.iter().take(remainder) {
- pass_sequence.push(PassType::Pattern(pattern));
- }
- let mut rng = rand::thread_rng();
- pass_sequence.shuffle(&mut rng); // randomize the order of application
- let n_random = 3 + n_passes / 10; // Minimum 3 random passes; ratio of 10 after
- // Evenly space random passes; ensures one at the beginning and end
- for i in 0..n_random {
- pass_sequence[i * (n_passes - 1) / (n_random - 1)] = PassType::Random;
+ // --zero specifies whether we want one final pass of 0x00 on our file
+ if zero {
+ pass_sequence.push(PassType::Pattern(PATTERNS[0]));
}
}
- // --zero specifies whether we want one final pass of 0x00 on our file
- if zero {
- pass_sequence.push(PassType::Pattern(b"\x00"));
- }
+ let total_passes = pass_sequence.len();
+ let mut file = OpenOptions::new()
+ .write(true)
+ .truncate(false)
+ .open(path)
+ .map_err_context(|| format!("{}: failed to open for writing", path.maybe_quote()))?;
- {
- let total_passes: usize = pass_sequence.len();
- let mut file: File = OpenOptions::new()
- .write(true)
- .truncate(false)
- .open(path)
- .map_err_context(|| format!("{}: failed to open for writing", path.maybe_quote()))?;
-
- // NOTE: it does not really matter what we set for total_bytes and gen_type here, so just
- // use bogus values
- let mut generator = BytesGenerator::new(0, PassType::Pattern(&[]), exact);
-
- for (i, pass_type) in pass_sequence.iter().enumerate() {
- if verbose {
- let pass_name: String = pass_name(*pass_type);
- if total_passes.to_string().len() == 1 {
- println!(
- "{}: {}: pass {}/{} ({})... ",
- util_name(),
- path.maybe_quote(),
- i + 1,
- total_passes,
- pass_name
- );
- } else {
- println!(
- "{}: {}: pass {:2.0}/{:2.0} ({})... ",
- util_name(),
- path.maybe_quote(),
- i + 1,
- total_passes,
- pass_name
- );
- }
- }
- // size is an optional argument for exactly how many bytes we want to shred
- show_if_err!(do_pass(&mut file, path, &mut generator, *pass_type, size)
- .map_err_context(|| format!("{}: File write pass failed", path.maybe_quote())));
- // Ignore failed writes; just keep trying
+ let size = match size {
+ Some(size) => size,
+ None => metadata.len(),
+ };
+
+ for (i, pass_type) in pass_sequence.into_iter().enumerate() {
+ if verbose {
+ let pass_name = pass_name(&pass_type);
+ show_error!(
+ "{}: pass {:2}/{} ({})...",
+ path.maybe_quote(),
+ i + 1,
+ total_passes,
+ pass_name
+ );
}
+ // size is an optional argument for exactly how many bytes we want to shred
+ // Ignore failed writes; just keep trying
+ show_if_err!(do_pass(&mut file, &pass_type, exact, size)
+ .map_err_context(|| format!("{}: File write pass failed", path.maybe_quote())));
}
- if remove {
- do_remove(path, path_str, verbose)
+ if remove_method != RemoveMethod::None {
+ do_remove(path, path_str, verbose, remove_method)
.map_err_context(|| format!("{}: failed to remove file", path.maybe_quote()))?;
}
Ok(())
}
-fn do_pass<'a>(
+fn do_pass(
file: &mut File,
- path: &Path,
- generator: &mut BytesGenerator<'a>,
- generator_type: PassType<'a>,
- given_file_size: Option<u64>,
+ pass_type: &PassType,
+ exact: bool,
+ file_size: u64,
) -> Result<(), io::Error> {
- file.seek(SeekFrom::Start(0))?;
+ // We might be at the end of the file due to a previous iteration, so rewind.
+ file.rewind()?;
- // Use the given size or the whole file if not specified
- let size: u64 = given_file_size.unwrap_or(get_file_size(path)?);
+ let mut writer = BytesWriter::from_pass_type(pass_type);
- generator.reset(size, generator_type);
+ // We start by writing BLOCK_SIZE times as many time as possible.
+ for _ in 0..(file_size / BLOCK_SIZE as u64) {
+ let block = writer.bytes_for_pass(BLOCK_SIZE);
+ file.write_all(block)?;
+ }
- while let Some(block) = generator.next() {
+ // Now we might have some bytes left, so we write either that
+ // many bytes if exact is true, or BLOCK_SIZE bytes if not.
+ let bytes_left = (file_size % BLOCK_SIZE as u64) as usize;
+ if bytes_left > 0 {
+ let size = if exact { bytes_left } else { BLOCK_SIZE };
+ let block = writer.bytes_for_pass(size);
file.write_all(block)?;
}
@@ -576,22 +535,18 @@ fn do_pass<'a>(
Ok(())
}
-fn get_file_size(path: &Path) -> Result<u64, io::Error> {
- let size: u64 = fs::metadata(path)?.len();
-
- Ok(size)
-}
-
// Repeatedly renames the file with strings of decreasing length (most likely all 0s)
// Return the path of the file after its last renaming or None if error
-fn wipe_name(orig_path: &Path, verbose: bool) -> Option<PathBuf> {
- let file_name_len: usize = orig_path.file_name().unwrap().to_str().unwrap().len();
+fn wipe_name(orig_path: &Path, verbose: bool, remove_method: RemoveMethod) -> Option<PathBuf> {
+ let file_name_len = orig_path.file_name().unwrap().to_str().unwrap().len();
- let mut last_path: PathBuf = PathBuf::from(orig_path);
+ let mut last_path = PathBuf::from(orig_path);
for length in (1..=file_name_len).rev() {
- for name in FilenameGenerator::new(length) {
- let new_path: PathBuf = orig_path.with_file_name(name);
+ // Try all filenames of a given length.
+ // If every possible filename already exists, just reduce the length and try again
+ for name in FilenameIter::new(length) {
+ let new_path = orig_path.with_file_name(name);
// We don't want the filename to already exist (don't overwrite)
// If it does, find another name that doesn't
if new_path.exists() {
@@ -600,17 +555,18 @@ fn wipe_name(orig_path: &Path, verbose: bool) -> Option<PathBuf> {
match fs::rename(&last_path, &new_path) {
Ok(()) => {
if verbose {
- println!(
- "{}: {}: renamed to {}",
- util_name(),
+ show_error!(
+ "{}: renamed to {}",
last_path.maybe_quote(),
- new_path.quote()
+ new_path.display()
);
}
- // Sync every file rename
- {
- let new_file: File = File::open(new_path.clone())
+ if remove_method == RemoveMethod::WipeSync {
+ // Sync every file rename
+ let new_file = OpenOptions::new()
+ .write(true)
+ .open(new_path.clone())
.expect("Failed to open renamed file for syncing");
new_file.sync_all().expect("Failed to sync renamed file");
}
@@ -619,34 +575,44 @@ fn wipe_name(orig_path: &Path, verbose: bool) -> Option<PathBuf> {
break;
}
Err(e) => {
- println!(
- "{}: {}: Couldn't rename to {}: {}",
- util_name(),
+ show_error!(
+ "{}: Couldn't rename to {}: {}",
last_path.maybe_quote(),
new_path.quote(),
e
);
- return None;
+ // TODO: replace with our error management
+ std::process::exit(1);
}
}
- } // If every possible filename already exists, just reduce the length and try again
+ }
}
Some(last_path)
}
-fn do_remove(path: &Path, orig_filename: &str, verbose: bool) -> Result<(), io::Error> {
+fn do_remove(
+ path: &Path,
+ orig_filename: &str,
+ verbose: bool,
+ remove_method: RemoveMethod,
+) -> Result<(), io::Error> {
if verbose {
- println!("{}: {}: removing", util_name(), orig_filename.maybe_quote());
+ show_error!("{}: removing", orig_filename.maybe_quote());
}
- let renamed_path: Option<PathBuf> = wipe_name(path, verbose);
- if let Some(rp) = renamed_path {
+ let remove_path = if remove_method == RemoveMethod::Unlink {
+ Some(path.with_file_name(orig_filename))
+ } else {
+ wipe_name(path, verbose, remove_method)
+ };
+
+ if let Some(rp) = remove_path {
fs::remove_file(rp)?;
}
if verbose {
- println!("{}: {}: removed", util_name(), orig_filename.maybe_quote());
+ show_error!("{}: removed", orig_filename.maybe_quote());
}
Ok(())
diff --git a/src/uu/shuf/BENCHMARKING.md b/src/uu/shuf/BENCHMARKING.md
index 23f647e9e65fa2f06a72b64646522a9c1d26a8de..d16b1afb03b355562e98b66c82adde49ad1f1528 100644
--- a/src/uu/shuf/BENCHMARKING.md
+++ b/src/uu/shuf/BENCHMARKING.md
@@ -3,7 +3,7 @@
# Benchmarking shuf
`shuf` is a simple utility, but there are at least two important cases
-benchmark: with and without repetition.
+to benchmark: with and without repetition.
When benchmarking changes, make sure to always build with the `--release` flag.
You can compare with another branch by compiling on that branch and then
@@ -21,18 +21,18 @@ To avoid distortions from IO, it is recommended to store input data in tmpfs.
## Without repetition
-By default, `shuf` samples without repetition.
+By default, `shuf` samples without repetition.
-To benchmark only the randomization and not IO, we can pass the `-i` flag with
-a range of numbers to randomly sample from. An example of a command that works
+To benchmark only the randomization and not IO, we can pass the `-i` flag with
+a range of numbers to randomly sample from. An example of a command that works
well for testing:
```shell
-hyperfine --warmup 10 "target/release/shuf -i 0-10000000"
+hyperfine --warmup 10 "target/release/shuf -i 0-10000000 > /dev/null"
```
To measure the time taken by shuffling an input file, the following command can
-be used::
+be used:
```shell
hyperfine --warmup 10 "target/release/shuf input.txt > /dev/null"
@@ -49,5 +49,14 @@ should be benchmarked separately. In this case, we have to pass the `-n` flag or
the command will run forever. An example of a hyperfine command is
```shell
-hyperfine --warmup 10 "target/release/shuf -r -n 10000000 -i 0-1000"
+hyperfine --warmup 10 "target/release/shuf -r -n 10000000 -i 0-1000 > /dev/null"
+```
+
+## With huge interval ranges
+
+When `shuf` runs with huge interval ranges, special care must be taken, so it
+should be benchmarked separately also. An example of a hyperfine command is
+
+```shell
+hyperfine --warmup 10 "target/release/shuf -n 100 -i 1000-2000000000 > /dev/null"
```
diff --git a/src/uu/shuf/Cargo.toml b/src/uu/shuf/Cargo.toml
index 98159b8c3a6a57bf5facb7fd2d1bce06d68fa2ae..d317ac986e6594b1f17916bf381fef30a66cd25d 100644
--- a/src/uu/shuf/Cargo.toml
+++ b/src/uu/shuf/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_shuf"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "shuf ~ (uutils) display random permutations of input lines"
@@ -15,11 +15,11 @@ edition = "2021"
path = "src/shuf.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-memchr = "2.5.0"
-rand = "0.8"
-rand_core = "0.6"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+memchr = { workspace = true }
+rand = { workspace = true }
+rand_core = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "shuf"
diff --git a/src/uu/shuf/shuf.md b/src/uu/shuf/shuf.md
new file mode 100644
index 0000000000000000000000000000000000000000..7bc1e0a6d600e2f2d91dfaac983c6cfb746e03ec
--- /dev/null
+++ b/src/uu/shuf/shuf.md
@@ -0,0 +1,11 @@
+# shuf
+
+```
+shuf [OPTION]... [FILE]
+shuf -e [OPTION]... [ARG]...
+shuf -i LO-HI [OPTION]...
+```
+
+Shuffle the input by outputting a random permutation of input lines.
+Each output permutation is equally likely.
+With no FILE, or when FILE is -, read standard input.
diff --git a/src/uu/shuf/src/rand_read_adapter.rs b/src/uu/shuf/src/rand_read_adapter.rs
index fd8998c10f5c0bb2cf350c8a265e50d93849061e..728bc0cfbbdfb8294134250aac006129459fc913 100644
--- a/src/uu/shuf/src/rand_read_adapter.rs
+++ b/src/uu/shuf/src/rand_read_adapter.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// Copyright 2018 Developers of the Rand project.
// Copyright 2013 The Rust Project Developers.
//
@@ -54,10 +58,7 @@ impl<R: Read> RngCore for ReadRng<R> {
fn fill_bytes(&mut self, dest: &mut [u8]) {
self.try_fill_bytes(dest).unwrap_or_else(|err| {
- panic!(
- "reading random bytes from Read implementation failed; error: {}",
- err
- );
+ panic!("reading random bytes from Read implementation failed; error: {err}");
});
}
diff --git a/src/uu/shuf/src/shuf.rs b/src/uu/shuf/src/shuf.rs
index b9e29668609bf25113dde008c803d873f9b43d48..260b5130c537040a88317794a9478d62f9d90388 100644
--- a/src/uu/shuf/src/shuf.rs
+++ b/src/uu/shuf/src/shuf.rs
@@ -1,38 +1,32 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Alex Lyon <arcterus@mail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-// spell-checker:ignore (ToDO) cmdline evec seps rvec fdata
+// spell-checker:ignore (ToDO) cmdline evec nonrepeating seps shufable rvec fdata
use clap::{crate_version, Arg, ArgAction, Command};
use memchr::memchr_iter;
use rand::prelude::SliceRandom;
-use rand::RngCore;
+use rand::{Rng, RngCore};
+use std::collections::HashSet;
use std::fs::File;
-use std::io::{stdin, stdout, BufReader, BufWriter, Read, Write};
+use std::io::{stdin, stdout, BufReader, BufWriter, Error, Read, Write};
+use std::ops::RangeInclusive;
use uucore::display::Quotable;
-use uucore::error::{FromIo, UResult, USimpleError};
-use uucore::format_usage;
+use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
+use uucore::{format_usage, help_about, help_usage};
mod rand_read_adapter;
enum Mode {
Default(String),
Echo(Vec<String>),
- InputRange((usize, usize)),
+ InputRange(RangeInclusive<usize>),
}
-static USAGE: &str = "\
- {} [OPTION]... [FILE]
- {} -e [OPTION]... [ARG]...
- {} -i LO-HI [OPTION]...";
-static ABOUT: &str = "\
- Shuffle the input by outputting a random permutation of input lines. \
- Each output permutation is equally likely. \
- With no FILE, or when FILE is -, read standard input.";
+static USAGE: &str = help_usage!("shuf.md");
+static ABOUT: &str = help_about!("shuf.md");
struct Options {
head_count: usize,
@@ -50,17 +44,21 @@ mod options {
pub static RANDOM_SOURCE: &str = "random-source";
pub static REPEAT: &str = "repeat";
pub static ZERO_TERMINATED: &str = "zero-terminated";
- pub static FILE: &str = "file";
+ pub static FILE_OR_ARGS: &str = "file-or-args";
}
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_lossy();
-
let matches = uu_app().try_get_matches_from(args)?;
- let mode = if let Some(args) = matches.get_many::<String>(options::ECHO) {
- Mode::Echo(args.map(String::from).collect())
+ let mode = if matches.get_flag(options::ECHO) {
+ Mode::Echo(
+ matches
+ .get_many::<String>(options::FILE_OR_ARGS)
+ .unwrap_or_default()
+ .map(String::from)
+ .collect(),
+ )
} else if let Some(range) = matches.get_one::<String>(options::INPUT_RANGE) {
match parse_range(range) {
Ok(m) => Mode::InputRange(m),
@@ -69,13 +67,17 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
}
}
} else {
- Mode::Default(
- matches
- .get_one::<String>(options::FILE)
- .map(|s| s.as_str())
- .unwrap_or("-")
- .to_string(),
- )
+ let mut operands = matches
+ .get_many::<String>(options::FILE_OR_ARGS)
+ .unwrap_or_default();
+ let file = operands.next().cloned().unwrap_or("-".into());
+ if let Some(second_file) = operands.next() {
+ return Err(UUsageError::new(
+ 1,
+ format!("unexpected argument '{second_file}' found"),
+ ));
+ };
+ Mode::Default(file)
};
let options = Options {
@@ -83,7 +85,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let headcounts = matches
.get_many::<String>(options::HEAD_COUNT)
.unwrap_or_default()
- .map(|s| s.to_owned())
+ .cloned()
.collect();
match parse_head_count(headcounts) {
Ok(val) => val,
@@ -102,22 +104,30 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
},
};
+ if options.head_count == 0 {
+ // Do not attempt to read the random source or the input file.
+ // However, we must touch the output file, if given:
+ if let Some(s) = options.output {
+ File::create(&s[..])
+ .map_err_context(|| format!("failed to open {} for writing", s.quote()))?;
+ }
+ return Ok(());
+ }
+
match mode {
Mode::Echo(args) => {
let mut evec = args.iter().map(String::as_bytes).collect::<Vec<_>>();
find_seps(&mut evec, options.sep);
- shuf_bytes(&mut evec, options)?;
+ shuf_exec(&mut evec, options)?;
}
- Mode::InputRange((b, e)) => {
- let rvec = (b..e).map(|x| format!("{}", x)).collect::<Vec<String>>();
- let mut rvec = rvec.iter().map(String::as_bytes).collect::<Vec<&[u8]>>();
- shuf_bytes(&mut rvec, options)?;
+ Mode::InputRange(mut range) => {
+ shuf_exec(&mut range, options)?;
}
Mode::Default(filename) => {
let fdata = read_input_file(&filename)?;
let mut fdata = vec![&fdata[..]];
find_seps(&mut fdata, options.sep);
- shuf_bytes(&mut fdata, options)?;
+ shuf_exec(&mut fdata, options)?;
}
}
@@ -130,15 +140,13 @@ pub fn uu_app() -> Command {
.version(crate_version!())
.override_usage(format_usage(USAGE))
.infer_long_args(true)
- .args_override_self(true)
.arg(
Arg::new(options::ECHO)
.short('e')
.long(options::ECHO)
- .value_name("ARG")
.help("treat each ARG as an input line")
- .use_value_delimiter(false)
- .num_args(0..)
+ .action(clap::ArgAction::SetTrue)
+ .overrides_with(options::ECHO)
.conflicts_with(options::INPUT_RANGE),
)
.arg(
@@ -147,13 +155,14 @@ pub fn uu_app() -> Command {
.long(options::INPUT_RANGE)
.value_name("LO-HI")
.help("treat each number LO through HI as an input line")
- .conflicts_with(options::FILE),
+ .conflicts_with(options::FILE_OR_ARGS),
)
.arg(
Arg::new(options::HEAD_COUNT)
.short('n')
.long(options::HEAD_COUNT)
.value_name("COUNT")
+ .action(clap::ArgAction::Append)
.help("output at most COUNT lines"),
)
.arg(
@@ -176,16 +185,22 @@ pub fn uu_app() -> Command {
.short('r')
.long(options::REPEAT)
.help("output lines can be repeated")
- .action(ArgAction::SetTrue),
+ .action(ArgAction::SetTrue)
+ .overrides_with(options::REPEAT),
)
.arg(
Arg::new(options::ZERO_TERMINATED)
.short('z')
.long(options::ZERO_TERMINATED)
.help("line delimiter is NUL, not newline")
- .action(ArgAction::SetTrue),
+ .action(ArgAction::SetTrue)
+ .overrides_with(options::ZERO_TERMINATED),
+ )
+ .arg(
+ Arg::new(options::FILE_OR_ARGS)
+ .action(clap::ArgAction::Append)
+ .value_hint(clap::ValueHint::FilePath),
)
- .arg(Arg::new(options::FILE).value_hint(clap::ValueHint::FilePath))
}
fn read_input_file(filename: &str) -> UResult<Vec<u8>> {
@@ -205,6 +220,13 @@ fn read_input_file(filename: &str) -> UResult<Vec<u8>> {
}
fn find_seps(data: &mut Vec<&[u8]>, sep: u8) {
+ // Special case: If data is empty (and does not even contain a single 'sep'
+ // to indicate the presence of the empty element), then behave as if the input contained no elements at all.
+ if data.len() == 1 && data[0].is_empty() {
+ data.clear();
+ return;
+ }
+
// need to use for loop so we don't borrow the vector as we modify it in place
// basic idea:
// * We don't care about the order of the result. This lets us slice the slices
@@ -229,7 +251,169 @@ fn find_seps(data: &mut Vec<&[u8]>, sep: u8) {
}
}
-fn shuf_bytes(input: &mut Vec<&[u8]>, opts: Options) -> UResult<()> {
+trait Shufable {
+ type Item: Writable;
+ fn is_empty(&self) -> bool;
+ fn choose(&self, rng: &mut WrappedRng) -> Self::Item;
+ // This type shouldn't even be known. However, because we want to support
+ // Rust 1.70, it is not possible to return "impl Iterator".
+ // TODO: When the MSRV is raised, rewrite this to return "impl Iterator".
+ type PartialShuffleIterator<'b>: Iterator<Item = Self::Item>
+ where
+ Self: 'b;
+ fn partial_shuffle<'b>(
+ &'b mut self,
+ rng: &'b mut WrappedRng,
+ amount: usize,
+ ) -> Self::PartialShuffleIterator<'b>;
+}
+
+impl<'a> Shufable for Vec<&'a [u8]> {
+ type Item = &'a [u8];
+ fn is_empty(&self) -> bool {
+ (**self).is_empty()
+ }
+ fn choose(&self, rng: &mut WrappedRng) -> Self::Item {
+ // Note: "copied()" only copies the reference, not the entire [u8].
+ // Returns None if the slice is empty. We checked this before, so
+ // this is safe.
+ (**self).choose(rng).unwrap()
+ }
+ type PartialShuffleIterator<'b> = std::iter::Copied<std::slice::Iter<'b, &'a [u8]>> where Self: 'b;
+ fn partial_shuffle<'b>(
+ &'b mut self,
+ rng: &'b mut WrappedRng,
+ amount: usize,
+ ) -> Self::PartialShuffleIterator<'b> {
+ // Note: "copied()" only copies the reference, not the entire [u8].
+ (**self).partial_shuffle(rng, amount).0.iter().copied()
+ }
+}
+
+impl Shufable for RangeInclusive<usize> {
+ type Item = usize;
+ fn is_empty(&self) -> bool {
+ self.is_empty()
+ }
+ fn choose(&self, rng: &mut WrappedRng) -> usize {
+ rng.gen_range(self.clone())
+ }
+ type PartialShuffleIterator<'b> = NonrepeatingIterator<'b> where Self: 'b;
+ fn partial_shuffle<'b>(
+ &'b mut self,
+ rng: &'b mut WrappedRng,
+ amount: usize,
+ ) -> Self::PartialShuffleIterator<'b> {
+ NonrepeatingIterator::new(self.clone(), rng, amount)
+ }
+}
+
+enum NumberSet {
+ AlreadyListed(HashSet<usize>),
+ Remaining(Vec<usize>),
+}
+
+struct NonrepeatingIterator<'a> {
+ range: RangeInclusive<usize>,
+ rng: &'a mut WrappedRng,
+ remaining_count: usize,
+ buf: NumberSet,
+}
+
+impl<'a> NonrepeatingIterator<'a> {
+ fn new(range: RangeInclusive<usize>, rng: &'a mut WrappedRng, amount: usize) -> Self {
+ let capped_amount = if range.start() > range.end() {
+ 0
+ } else if *range.start() == 0 && *range.end() == usize::MAX {
+ amount
+ } else {
+ amount.min(range.end() - range.start() + 1)
+ };
+ NonrepeatingIterator {
+ range,
+ rng,
+ remaining_count: capped_amount,
+ buf: NumberSet::AlreadyListed(HashSet::default()),
+ }
+ }
+
+ fn produce(&mut self) -> usize {
+ debug_assert!(self.range.start() <= self.range.end());
+ match &mut self.buf {
+ NumberSet::AlreadyListed(already_listed) => {
+ let chosen = loop {
+ let guess = self.rng.gen_range(self.range.clone());
+ let newly_inserted = already_listed.insert(guess);
+ if newly_inserted {
+ break guess;
+ }
+ };
+ // Once a significant fraction of the interval has already been enumerated,
+ // the number of attempts to find a number that hasn't been chosen yet increases.
+ // Therefore, we need to switch at some point from "set of already returned values" to "list of remaining values".
+ let range_size = (self.range.end() - self.range.start()).saturating_add(1);
+ if number_set_should_list_remaining(already_listed.len(), range_size) {
+ let mut remaining = self
+ .range
+ .clone()
+ .filter(|n| !already_listed.contains(n))
+ .collect::<Vec<_>>();
+ assert!(remaining.len() >= self.remaining_count);
+ remaining.partial_shuffle(&mut self.rng, self.remaining_count);
+ remaining.truncate(self.remaining_count);
+ self.buf = NumberSet::Remaining(remaining);
+ }
+ chosen
+ }
+ NumberSet::Remaining(remaining_numbers) => {
+ debug_assert!(!remaining_numbers.is_empty());
+ // We only enter produce() when there is at least one actual element remaining, so popping must always return an element.
+ remaining_numbers.pop().unwrap()
+ }
+ }
+ }
+}
+
+impl<'a> Iterator for NonrepeatingIterator<'a> {
+ type Item = usize;
+
+ fn next(&mut self) -> Option<usize> {
+ if self.range.is_empty() || self.remaining_count == 0 {
+ return None;
+ }
+ self.remaining_count -= 1;
+ Some(self.produce())
+ }
+}
+
+// This could be a method, but it is much easier to test as a stand-alone function.
+fn number_set_should_list_remaining(listed_count: usize, range_size: usize) -> bool {
+ // Arbitrarily determine the switchover point to be around 25%. This is because:
+ // - HashSet has a large space overhead for the hash table load factor.
+ // - This means that somewhere between 25-40%, the memory required for a "positive" HashSet and a "negative" Vec should be the same.
+ // - HashSet has a small but non-negligible overhead for each lookup, so we have a slight preference for Vec anyway.
+ // - At 25%, on average 1.33 attempts are needed to find a number that hasn't been taken yet.
+ // - Finally, "24%" is computationally the simplest:
+ listed_count >= range_size / 4
+}
+
+trait Writable {
+ fn write_all_to(&self, output: &mut impl Write) -> Result<(), Error>;
+}
+
+impl<'a> Writable for &'a [u8] {
+ fn write_all_to(&self, output: &mut impl Write) -> Result<(), Error> {
+ output.write_all(self)
+ }
+}
+
+impl Writable for usize {
+ fn write_all_to(&self, output: &mut impl Write) -> Result<(), Error> {
+ output.write_all(format!("{self}").as_bytes())
+ }
+}
+
+fn shuf_exec(input: &mut impl Shufable, opts: Options) -> UResult<()> {
let mut output = BufWriter::new(match opts.output {
None => Box::new(stdout()) as Box<dyn Write>,
Some(s) => {
@@ -248,28 +432,23 @@ fn shuf_bytes(input: &mut Vec<&[u8]>, opts: Options) -> UResult<()> {
None => WrappedRng::RngDefault(rand::thread_rng()),
};
- if input.is_empty() {
- return Ok(());
- }
-
if opts.repeat {
+ if input.is_empty() {
+ return Err(USimpleError::new(1, "no lines to repeat"));
+ }
for _ in 0..opts.head_count {
- // Returns None is the slice is empty. We checked this before, so
- // this is safe.
- let r = input.choose(&mut rng).unwrap();
+ let r = input.choose(&mut rng);
- output
- .write_all(r)
+ r.write_all_to(&mut output)
.map_err_context(|| "write failed".to_string())?;
output
.write_all(&[opts.sep])
.map_err_context(|| "write failed".to_string())?;
}
} else {
- let (shuffled, _) = input.partial_shuffle(&mut rng, opts.head_count);
+ let shuffled = input.partial_shuffle(&mut rng, opts.head_count);
for r in shuffled {
- output
- .write_all(r)
+ r.write_all_to(&mut output)
.map_err_context(|| "write failed".to_string())?;
output
.write_all(&[opts.sep])
@@ -280,7 +459,7 @@ fn shuf_bytes(input: &mut Vec<&[u8]>, opts: Options) -> UResult<()> {
Ok(())
}
-fn parse_range(input_range: &str) -> Result<(usize, usize), String> {
+fn parse_range(input_range: &str) -> Result<RangeInclusive<usize>, String> {
if let Some((from, to)) = input_range.split_once('-') {
let begin = from
.parse::<usize>()
@@ -288,14 +467,18 @@ fn parse_range(input_range: &str) -> Result<(usize, usize), String> {
let end = to
.parse::<usize>()
.map_err(|_| format!("invalid input range: {}", to.quote()))?;
- Ok((begin, end + 1))
+ if begin <= end || begin == end + 1 {
+ Ok(begin..=end)
+ } else {
+ Err(format!("invalid input range: {}", input_range.quote()))
+ }
} else {
Err(format!("invalid input range: {}", input_range.quote()))
}
}
fn parse_head_count(headcounts: Vec<String>) -> Result<usize, String> {
- let mut result = std::usize::MAX;
+ let mut result = usize::MAX;
for count in headcounts {
match count.parse::<usize>() {
Ok(pv) => result = std::cmp::min(result, pv),
@@ -339,3 +522,85 @@ impl RngCore for WrappedRng {
}
}
}
+
+#[cfg(test)]
+// Since the computed value is a bool, it is more readable to write the expected value out:
+#[allow(clippy::bool_assert_comparison)]
+mod test_number_set_decision {
+ use super::number_set_should_list_remaining;
+
+ #[test]
+ fn test_stay_positive_large_remaining_first() {
+ assert_eq!(false, number_set_should_list_remaining(0, usize::MAX));
+ }
+
+ #[test]
+ fn test_stay_positive_large_remaining_second() {
+ assert_eq!(false, number_set_should_list_remaining(1, usize::MAX));
+ }
+
+ #[test]
+ fn test_stay_positive_large_remaining_tenth() {
+ assert_eq!(false, number_set_should_list_remaining(9, usize::MAX));
+ }
+
+ #[test]
+ fn test_stay_positive_smallish_range_first() {
+ assert_eq!(false, number_set_should_list_remaining(0, 12345));
+ }
+
+ #[test]
+ fn test_stay_positive_smallish_range_second() {
+ assert_eq!(false, number_set_should_list_remaining(1, 12345));
+ }
+
+ #[test]
+ fn test_stay_positive_smallish_range_tenth() {
+ assert_eq!(false, number_set_should_list_remaining(9, 12345));
+ }
+
+ #[test]
+ fn test_stay_positive_small_range_not_too_early() {
+ assert_eq!(false, number_set_should_list_remaining(1, 10));
+ }
+
+ // Don't want to test close to the border, in case we decide to change the threshold.
+ // However, at 50% coverage, we absolutely should switch:
+ #[test]
+ fn test_switch_half() {
+ assert_eq!(true, number_set_should_list_remaining(1234, 2468));
+ }
+
+ // Ensure that the decision is monotonous:
+ #[test]
+ fn test_switch_late1() {
+ assert_eq!(true, number_set_should_list_remaining(12340, 12345));
+ }
+
+ #[test]
+ fn test_switch_late2() {
+ assert_eq!(true, number_set_should_list_remaining(12344, 12345));
+ }
+
+ // Ensure that we are overflow-free:
+ #[test]
+ fn test_no_crash_exceed_max_size1() {
+ assert_eq!(false, number_set_should_list_remaining(12345, usize::MAX));
+ }
+
+ #[test]
+ fn test_no_crash_exceed_max_size2() {
+ assert_eq!(
+ true,
+ number_set_should_list_remaining(usize::MAX - 1, usize::MAX)
+ );
+ }
+
+ #[test]
+ fn test_no_crash_exceed_max_size3() {
+ assert_eq!(
+ true,
+ number_set_should_list_remaining(usize::MAX, usize::MAX)
+ );
+ }
+}
diff --git a/src/uu/sleep/Cargo.toml b/src/uu/sleep/Cargo.toml
index 8c21c895e6af97d08cb243c9ef9230e2ce4369c9..9cde3793d13934b20aeb8e4a5d5cd95d63772fae 100644
--- a/src/uu/sleep/Cargo.toml
+++ b/src/uu/sleep/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_sleep"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "sleep ~ (uutils) pause for DURATION"
@@ -15,8 +15,9 @@ edition = "2021"
path = "src/sleep.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+fundu = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "sleep"
diff --git a/src/uu/sleep/sleep.md b/src/uu/sleep/sleep.md
new file mode 100644
index 0000000000000000000000000000000000000000..b5c07fb493ef2bba49b32290f92c19695905e92f
--- /dev/null
+++ b/src/uu/sleep/sleep.md
@@ -0,0 +1,16 @@
+# sleep
+
+```
+sleep NUMBER[SUFFIX]...
+sleep OPTION
+```
+
+Pause for NUMBER seconds.
+
+## After Help
+
+Pause for NUMBER seconds. SUFFIX may be 's' for seconds (the default),
+'m' for minutes, 'h' for hours or 'd' for days. Unlike most implementations
+that require NUMBER be an integer, here NUMBER may be an arbitrary floating
+point number. Given two or more arguments, pause for the amount of time
+specified by the sum of their values.
diff --git a/src/uu/sleep/src/sleep.rs b/src/uu/sleep/src/sleep.rs
index d34cbe9422989f1455a92f5a58a0d41a96407f4a..36e3adfee1ed6728b03397648593aeaffca47423 100644
--- a/src/uu/sleep/src/sleep.rs
+++ b/src/uu/sleep/src/sleep.rs
@@ -1,29 +1,22 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Alex Lyon <arcterus@mail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::thread;
use std::time::Duration;
use uucore::{
error::{UResult, USimpleError, UUsageError},
- format_usage, show,
+ format_usage, help_about, help_section, help_usage, show_error,
};
use clap::{crate_version, Arg, ArgAction, Command};
+use fundu::{DurationParser, ParseError, SaturatingInto};
-static ABOUT: &str = "Pause for NUMBER seconds.";
-const USAGE: &str = "\
- {} NUMBER[SUFFIX]...
- {} OPTION";
-static LONG_HELP: &str = "Pause for NUMBER seconds. SUFFIX may be 's' for seconds (the default),
-'m' for minutes, 'h' for hours or 'd' for days. Unlike most implementations
-that require NUMBER be an integer, here NUMBER may be an arbitrary floating
-point number. Given two or more arguments, pause for the amount of time
-specified by the sum of their values.";
+static ABOUT: &str = help_about!("sleep.md");
+const USAGE: &str = help_usage!("sleep.md");
+static AFTER_HELP: &str = help_section!("after help", "sleep.md");
mod options {
pub const NUMBER: &str = "NUMBER";
@@ -47,14 +40,14 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
.map(|s| s.as_str())
.collect::<Vec<_>>();
- return sleep(&numbers);
+ sleep(&numbers)
}
pub fn uu_app() -> Command {
Command::new(uucore::util_name())
.version(crate_version!())
.about(ABOUT)
- .after_help(LONG_HELP)
+ .after_help(AFTER_HELP)
.override_usage(format_usage(USAGE))
.infer_long_args(true)
.arg(
@@ -67,15 +60,39 @@ pub fn uu_app() -> Command {
fn sleep(args: &[&str]) -> UResult<()> {
let mut arg_error = false;
- let intervals = args.iter().map(|s| match uucore::parse_time::from_str(s) {
- Ok(result) => result,
- Err(err) => {
- arg_error = true;
- show!(USimpleError::new(1, err));
- Duration::new(0, 0)
- }
- });
- let sleep_dur = intervals.fold(Duration::new(0, 0), |acc, n| acc + n);
+
+ use fundu::TimeUnit::{Day, Hour, Minute, Second};
+ let parser = DurationParser::with_time_units(&[Second, Minute, Hour, Day]);
+
+ let sleep_dur = args
+ .iter()
+ .filter_map(|input| match parser.parse(input.trim()) {
+ Ok(duration) => Some(duration),
+ Err(error) => {
+ arg_error = true;
+
+ let reason = match error {
+ ParseError::Empty if input.is_empty() => "Input was empty".to_string(),
+ ParseError::Empty => "Found only whitespace in input".to_string(),
+ ParseError::Syntax(pos, description)
+ | ParseError::TimeUnit(pos, description) => {
+ format!("{description} at position {}", pos.saturating_add(1))
+ }
+ ParseError::NegativeExponentOverflow | ParseError::PositiveExponentOverflow => {
+ "Exponent was out of bounds".to_string()
+ }
+ ParseError::NegativeNumber => "Number was negative".to_string(),
+ error => error.to_string(),
+ };
+ show_error!("invalid time interval '{input}': {reason}");
+
+ None
+ }
+ })
+ .fold(Duration::ZERO, |acc, n| {
+ acc.saturating_add(SaturatingInto::<std::time::Duration>::saturating_into(n))
+ });
+
if arg_error {
return Err(UUsageError::new(1, ""));
};
diff --git a/src/uu/sort/BENCHMARKING.md b/src/uu/sort/BENCHMARKING.md
index 77186318a047710de0b5d771acd749e41b928945..0cc344c3118e000fc9a813662327dcf0b66de840 100644
--- a/src/uu/sort/BENCHMARKING.md
+++ b/src/uu/sort/BENCHMARKING.md
@@ -12,64 +12,59 @@ Run `cargo build --release` before benchmarking after you make a change!
## Sorting a wordlist
-- Get a wordlist, for example with [words](<https://en.wikipedia.org/wiki/Words_(Unix)>) on Linux. The exact wordlist
+- Get a wordlist, for example with [words](<https://en.wikipedia.org/wiki/Words_(Unix)>) on Linux. The exact wordlist
doesn't matter for performance comparisons. In this example I'm using `/usr/share/dict/american-english` as the wordlist.
-- Shuffle the wordlist by running `sort -R /usr/share/dict/american-english > shuffled_wordlist.txt`.
-- Benchmark sorting the wordlist with hyperfine: `hyperfine "target/release/coreutils sort shuffled_wordlist.txt -o output.txt"`.
+- Shuffle the wordlist by running `sort -R /usr/share/dict/american-english > shuffled_wordlist.txt`.
+- Benchmark sorting the wordlist with hyperfine: `hyperfine "target/release/coreutils sort shuffled_wordlist.txt -o output.txt"`.
## Sorting a wordlist with ignore_case
-- Same wordlist as above
-- Benchmark sorting the wordlist ignoring the case with hyperfine: `hyperfine "target/release/coreutils sort shuffled_wordlist.txt -f -o output.txt"`.
+- Same wordlist as above
+- Benchmark sorting the wordlist ignoring the case with hyperfine: `hyperfine "target/release/coreutils sort shuffled_wordlist.txt -f -o output.txt"`.
## Sorting numbers
-- Generate a list of numbers: `seq 0 100000 | sort -R > shuffled_numbers.txt`.
-- Benchmark numeric sorting with hyperfine: `hyperfine "target/release/coreutils sort shuffled_numbers.txt -n -o output.txt"`.
+- Generate a list of numbers: `seq 0 100000 | sort -R > shuffled_numbers.txt`.
+- Benchmark numeric sorting with hyperfine: `hyperfine "target/release/coreutils sort shuffled_numbers.txt -n -o output.txt"`.
## Sorting numbers with -g
-- Same list of numbers as above.
-- Benchmark numeric sorting with hyperfine: `hyperfine "target/release/coreutils sort shuffled_numbers.txt -g -o output.txt"`.
+- Same list of numbers as above.
+- Benchmark numeric sorting with hyperfine: `hyperfine "target/release/coreutils sort shuffled_numbers.txt -g -o output.txt"`.
## Sorting numbers with SI prefixes
-- Generate a list of numbers:
- <details>
- <summary>Rust script</summary>
-
- ## Cargo.toml
-
- ```toml
- [dependencies]
- rand = "0.8.3"
- ```
-
- ## main.rs
-
- ```rust
- use rand::prelude::*;
- fn main() {
- let suffixes = ['k', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
- let mut rng = thread_rng();
- for _ in 0..100000 {
- println!(
- "{}{}",
- rng.gen_range(0..1000000),
- suffixes.choose(&mut rng).unwrap()
- )
- }
- }
+- Generate a list of numbers:
+
+## Cargo.toml
- ```
+```toml
+[dependencies]
+rand = "0.8.3"
+```
- ## running
+## main.rs
+
+```rust
+use rand::prelude::*;
+fn main() {
+ let suffixes = ['k', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
+ let mut rng = thread_rng();
+ for _ in 0..100000 {
+ println!(
+ "{}{}",
+ rng.gen_range(0..1000000),
+ suffixes.choose(&mut rng).unwrap()
+ )
+ }
+}
+```
- `cargo run > shuffled_numbers_si.txt`
+## running
- </details>
+`cargo run > shuffled_numbers_si.txt`
-- Benchmark numeric sorting with hyperfine: `hyperfine "target/release/coreutils sort shuffled_numbers_si.txt -h -o output.txt"`.
+- Benchmark numeric sorting with hyperfine: `hyperfine "target/release/coreutils sort shuffled_numbers_si.txt -h -o output.txt"`.
## External sorting
@@ -83,28 +78,28 @@ Example: Run `hyperfine './target/release/coreutils sort shuffled_wordlist.txt -
"Merge" sort merges already sorted files. It is a sub-step of external sorting, so benchmarking it separately may be helpful.
-- Splitting `shuffled_wordlist.txt` can be achieved by running `split shuffled_wordlist.txt shuffled_wordlist_slice_ --additional-suffix=.txt`
-- Sort each part by running `for f in shuffled_wordlist_slice_*; do sort $f -o $f; done`
-- Benchmark merging by running `hyperfine "target/release/coreutils sort -m shuffled_wordlist_slice_*"`
+- Splitting `shuffled_wordlist.txt` can be achieved by running `split shuffled_wordlist.txt shuffled_wordlist_slice_ --additional-suffix=.txt`
+- Sort each part by running `for f in shuffled_wordlist_slice_*; do sort $f -o $f; done`
+- Benchmark merging by running `hyperfine "target/release/coreutils sort -m shuffled_wordlist_slice_*"`
## Check
When invoked with -c, we simply check if the input is already ordered. The input for benchmarking should be an already sorted file.
-- Benchmark checking by running `hyperfine "target/release/coreutils sort -c sorted_wordlist.txt"`
+- Benchmark checking by running `hyperfine "target/release/coreutils sort -c sorted_wordlist.txt"`
## Stdout and stdin performance
Try to run the above benchmarks by piping the input through stdin (standard input) and redirect the
output through stdout (standard output):
-- Remove the input file from the arguments and add `cat [input_file] | ` at the beginning.
-- Remove `-o output.txt` and add `> output.txt` at the end.
+- Remove the input file from the arguments and add ```cat [input_file] |``` at the beginning.
+- Remove `-o output.txt` and add `> output.txt` at the end.
Example: `hyperfine "target/release/coreutils sort shuffled_numbers.txt -n -o output.txt"` becomes
`hyperfine "cat shuffled_numbers.txt | target/release/coreutils sort -n > output.txt`
-- Check that performance is similar to the original benchmark.
+- Check that performance is similar to the original benchmark.
## Comparing with GNU sort
@@ -121,37 +116,34 @@ The above benchmarks use hyperfine to measure the speed of sorting. There are ho
resource usage. One way to measure them is the `time` command. This is not to be confused with the `time` that is built in to the bash shell.
You may have to install `time` first, then you have to run it with `/bin/time -v` to give it precedence over the built in `time`.
-<details>
- <summary>Example output</summary>
-
- Command being timed: "target/release/coreutils sort shuffled_numbers.txt"
- User time (seconds): 0.10
- System time (seconds): 0.00
- Percent of CPU this job got: 365%
- Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.02
- Average shared text size (kbytes): 0
- Average unshared data size (kbytes): 0
- Average stack size (kbytes): 0
- Average total size (kbytes): 0
- Maximum resident set size (kbytes): 25360
- Average resident set size (kbytes): 0
- Major (requiring I/O) page faults: 0
- Minor (reclaiming a frame) page faults: 5802
- Voluntary context switches: 462
- Involuntary context switches: 73
- Swaps: 0
- File system inputs: 1184
- File system outputs: 0
- Socket messages sent: 0
- Socket messages received: 0
- Signals delivered: 0
- Page size (bytes): 4096
- Exit status: 0
-
-</details>
+```plain
+Command being timed: "target/release/coreutils sort shuffled_numbers.txt"
+User time (seconds): 0.10
+System time (seconds): 0.00
+Percent of CPU this job got: 365%
+Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.02
+Average shared text size (kbytes): 0
+Average unshared data size (kbytes): 0
+Average stack size (kbytes): 0
+Average total size (kbytes): 0
+Maximum resident set size (kbytes): 25360
+Average resident set size (kbytes): 0
+Major (requiring I/O) page faults: 0
+Minor (reclaiming a frame) page faults: 5802
+Voluntary context switches: 462
+Involuntary context switches: 73
+Swaps: 0
+File system inputs: 1184
+File system outputs: 0
+Socket messages sent: 0
+Socket messages received: 0
+Signals delivered: 0
+Page size (bytes): 4096
+Exit status: 0
+```
Useful metrics to look at could be:
-- User time
-- Percent of CPU this job got
-- Maximum resident set size
+- User time
+- Percent of CPU this job got
+- Maximum resident set size
diff --git a/src/uu/sort/Cargo.toml b/src/uu/sort/Cargo.toml
index d12dd57cfca895f1cf2aeb3d98962bf4d5dc1843..b13a1c528b25e5e04bec377785d1be19377e7d5c 100644
--- a/src/uu/sort/Cargo.toml
+++ b/src/uu/sort/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_sort"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "sort ~ (uutils) sort input lines"
@@ -15,19 +15,19 @@ edition = "2021"
path = "src/sort.rs"
[dependencies]
-binary-heap-plus = "0.5.0"
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-compare = "0.1.0"
-ctrlc = { version = "3.0", features = ["termination"] }
-fnv = "1.0.7"
-itertools = "0.10.0"
-memchr = "2.5.0"
-ouroboros = "0.15.5"
-rand = "0.8"
-rayon = "1.5"
-tempfile = "3"
-unicode-width = "0.1.8"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["fs"] }
+binary-heap-plus = { workspace = true }
+clap = { workspace = true }
+compare = { workspace = true }
+ctrlc = { workspace = true }
+fnv = { workspace = true }
+itertools = { workspace = true }
+memchr = { workspace = true }
+rand = { workspace = true }
+rayon = { workspace = true }
+self_cell = { workspace = true }
+tempfile = { workspace = true }
+unicode-width = { workspace = true }
+uucore = { workspace = true, features = ["fs", "version-cmp"] }
[[bin]]
name = "sort"
diff --git a/src/uu/sort/sort.md b/src/uu/sort/sort.md
new file mode 100644
index 0000000000000000000000000000000000000000..1d1aa5d5ffe56573d62ba63629cfe1321f67ff8a
--- /dev/null
+++ b/src/uu/sort/sort.md
@@ -0,0 +1,21 @@
+<!-- spell-checker:ignore MbdfhnRrV -->
+
+# sort
+
+```
+sort [OPTION]... [FILE]...
+```
+
+Display sorted concatenation of all FILE(s). With no FILE, or when FILE is -, read standard input.
+
+## After help
+
+The key format is `FIELD[.CHAR][OPTIONS][,FIELD[.CHAR]][OPTIONS]`.
+
+Fields by default are separated by the first whitespace after a non-whitespace character. Use `-t` to specify a custom separator.
+In the default case, whitespace is appended at the beginning of each field. Custom separators however are not included in fields.
+
+`FIELD` and `CHAR` both start at 1 (i.e. they are 1-indexed). If there is no end specified after a comma, the end will be the end of the line.
+If `CHAR` is set 0, it means the end of the field. `CHAR` defaults to 1 for the start position and to 0 for the end position.
+
+Valid options are: `MbdfhnRrV`. They override the global options for this key.
diff --git a/src/uu/sort/src/check.rs b/src/uu/sort/src/check.rs
index 3f02a4c3153b47992f6db70ec4b0b7f2de5f442b..763b6deb733580cc866587a14c23e5bfcf0e12a1 100644
--- a/src/uu/sort/src/check.rs
+++ b/src/uu/sort/src/check.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Michael Debertol <michael.debertol..AT..gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//! Check if a file is ordered
@@ -54,7 +52,7 @@ pub fn check(path: &OsStr, settings: &GlobalSettings) -> UResult<()> {
let mut prev_chunk: Option<Chunk> = None;
let mut line_idx = 0;
- for chunk in loaded_receiver.iter() {
+ for chunk in loaded_receiver {
line_idx += 1;
if let Some(prev_chunk) = prev_chunk.take() {
// Check if the first element of the new chunk is greater than the last
@@ -107,7 +105,7 @@ fn reader(
settings: &GlobalSettings,
) -> UResult<()> {
let mut carry_over = vec![];
- for recycled_chunk in receiver.iter() {
+ for recycled_chunk in receiver {
let should_continue = chunks::read(
sender,
recycled_chunk,
@@ -115,11 +113,7 @@ fn reader(
&mut carry_over,
&mut file,
&mut iter::empty(),
- if settings.zero_terminated {
- b'\0'
- } else {
- b'\n'
- },
+ settings.line_ending.into(),
settings,
)?;
if !should_continue {
diff --git a/src/uu/sort/src/chunks.rs b/src/uu/sort/src/chunks.rs
index 9b60d5f5bbee604acb040f4c476877ede2613f63..525a9f66b1d1c8d0e4c2efc8203523b163f323ad 100644
--- a/src/uu/sort/src/chunks.rs
+++ b/src/uu/sort/src/chunks.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Michael Debertol <michael.debertol..AT..gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//! Utilities for reading files as chunks.
@@ -16,21 +14,22 @@ use std::{
};
use memchr::memchr_iter;
-use ouroboros::self_referencing;
+use self_cell::self_cell;
use uucore::error::{UResult, USimpleError};
use crate::{numeric_str_cmp::NumInfo, GeneralF64ParseResult, GlobalSettings, Line, SortError};
-/// The chunk that is passed around between threads.
-/// `lines` consist of slices into `buffer`.
-#[self_referencing(pub_extras)]
-#[derive(Debug)]
-pub struct Chunk {
- pub buffer: Vec<u8>,
- #[borrows(buffer)]
- #[covariant]
- pub contents: ChunkContents<'this>,
-}
+self_cell!(
+ /// The chunk that is passed around between threads.
+ pub struct Chunk {
+ owner: Vec<u8>,
+
+ #[covariant]
+ dependent: ChunkContents,
+ }
+
+ impl {Debug}
+);
#[derive(Debug)]
pub struct ChunkContents<'a> {
@@ -48,7 +47,7 @@ pub struct LineData<'a> {
impl Chunk {
/// Destroy this chunk and return its components to be reused.
pub fn recycle(mut self) -> RecycledChunk {
- let recycled_contents = self.with_contents_mut(|contents| {
+ let recycled_contents = self.with_dependent_mut(|_, contents| {
contents.lines.clear();
contents.line_data.selections.clear();
contents.line_data.num_infos.clear();
@@ -81,15 +80,15 @@ impl Chunk {
selections: recycled_contents.1,
num_infos: recycled_contents.2,
parsed_floats: recycled_contents.3,
- buffer: self.into_heads().buffer,
+ buffer: self.into_owner(),
}
}
pub fn lines(&self) -> &Vec<Line> {
- &self.borrow_contents().lines
+ &self.borrow_dependent().lines
}
pub fn line_data(&self) -> &LineData {
- &self.borrow_contents().line_data
+ &self.borrow_dependent().line_data
}
}
diff --git a/src/uu/sort/src/custom_str_cmp.rs b/src/uu/sort/src/custom_str_cmp.rs
index 089d33bc49540b32c1e561249280f284e1317d18..fb128d9af139bf6a0ae885e2abd132ceddb8beef 100644
--- a/src/uu/sort/src/custom_str_cmp.rs
+++ b/src/uu/sort/src/custom_str_cmp.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Michael Debertol <michael.debertol..AT..gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//! Custom string comparisons.
//!
diff --git a/src/uu/sort/src/ext_sort.rs b/src/uu/sort/src/ext_sort.rs
index fbb9c16d712ddb918a82e697a283627b88952566..18309881229b2b7ccff370b44741032ed61ba5ce 100644
--- a/src/uu/sort/src/ext_sort.rs
+++ b/src/uu/sort/src/ext_sort.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Michael Debertol <michael.debertol..AT..gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//! Sort big files by using auxiliary files for storing intermediate chunks.
//!
@@ -84,11 +82,7 @@ fn reader_writer<
output: Output,
tmp_dir: &mut TmpDirWrapper,
) -> UResult<()> {
- let separator = if settings.zero_terminated {
- b'\0'
- } else {
- b'\n'
- };
+ let separator = settings.line_ending.into();
// Heuristically chosen: Dividing by 10 seems to keep our memory usage roughly
// around settings.buffer_size as a whole.
@@ -158,7 +152,7 @@ fn reader_writer<
/// The function that is executed on the sorter thread.
fn sorter(receiver: &Receiver<Chunk>, sender: &SyncSender<Chunk>, settings: &GlobalSettings) {
while let Ok(mut payload) = receiver.recv() {
- payload.with_contents_mut(|contents| {
+ payload.with_dependent_mut(|_, contents| {
sort_by(&mut contents.lines, settings, &contents.line_data);
});
if sender.send(payload).is_err() {
@@ -230,7 +224,7 @@ fn read_write_loop<I: WriteableTmpFile>(
let mut sender_option = Some(sender);
let mut tmp_files = vec![];
loop {
- let mut chunk = match receiver.recv() {
+ let chunk = match receiver.recv() {
Ok(it) => it,
_ => {
return Ok(ReadResult::WroteChunksToFile { tmp_files });
@@ -238,7 +232,7 @@ fn read_write_loop<I: WriteableTmpFile>(
};
let tmp_file = write::<I>(
- &mut chunk,
+ &chunk,
tmp_dir.next_file()?,
settings.compress_prog.as_deref(),
separator,
@@ -268,7 +262,7 @@ fn read_write_loop<I: WriteableTmpFile>(
/// Write the lines in `chunk` to `file`, separated by `separator`.
/// `compress_prog` is used to optionally compress file contents.
fn write<I: WriteableTmpFile>(
- chunk: &mut Chunk,
+ chunk: &Chunk,
file: (File, PathBuf),
compress_prog: Option<&str>,
separator: u8,
@@ -278,7 +272,7 @@ fn write<I: WriteableTmpFile>(
tmp_file.finished_writing()
}
-fn write_lines<'a, T: Write>(lines: &[Line<'a>], writer: &mut T, separator: u8) {
+fn write_lines<T: Write>(lines: &[Line], writer: &mut T, separator: u8) {
for s in lines {
writer.write_all(s.line.as_bytes()).unwrap();
writer.write_all(&[separator]).unwrap();
diff --git a/src/uu/sort/src/merge.rs b/src/uu/sort/src/merge.rs
index a7b4417e3469d5aeed493e2c5a00df32e0e73eca..c0457ffa4dcbb9b2e629dd36ebb243d989a6b464 100644
--- a/src/uu/sort/src/merge.rs
+++ b/src/uu/sort/src/merge.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//! Merge already sorted files.
//!
//! We achieve performance by splitting the tasks of sorting and writing, and reading and parsing between two threads.
@@ -169,11 +173,7 @@ fn merge_without_limit<M: MergeInput + 'static, F: Iterator<Item = UResult<M>>>(
&request_receiver,
&mut reader_files,
&settings,
- if settings.zero_terminated {
- b'\0'
- } else {
- b'\n'
- },
+ settings.line_ending.into(),
)
}
});
@@ -215,7 +215,7 @@ fn reader(
settings: &GlobalSettings,
separator: u8,
) -> UResult<()> {
- for (file_idx, recycled_chunk) in recycled_receiver.iter() {
+ for (file_idx, recycled_chunk) in recycled_receiver {
if let Some(ReaderFile {
file,
sender,
@@ -288,7 +288,7 @@ impl<'a> FileMerger<'a> {
file_number: file.file_number,
});
- file.current_chunk.with_contents(|contents| {
+ file.current_chunk.with_dependent(|_, contents| {
let current_line = &contents.lines[file.line_idx];
if settings.unique {
if let Some(prev) = &prev {
@@ -362,16 +362,16 @@ impl<'a> Compare<MergeableFile> for FileComparator<'a> {
// Wait for the child to exit and check its exit code.
fn check_child_success(mut child: Child, program: &str) -> UResult<()> {
- if !matches!(
+ if matches!(
child.wait().map(|e| e.code()),
Ok(Some(0)) | Ok(None) | Err(_)
) {
+ Ok(())
+ } else {
Err(SortError::CompressProgTerminatedAbnormally {
prog: program.to_owned(),
}
.into())
- } else {
- Ok(())
}
}
diff --git a/src/uu/sort/src/numeric_str_cmp.rs b/src/uu/sort/src/numeric_str_cmp.rs
index 70f8c2cd8eb88c6d4cba1c5371ae93c59fc04d9a..54950f2dbfe6900be46b47557e9db856a3c3bfda 100644
--- a/src/uu/sort/src/numeric_str_cmp.rs
+++ b/src/uu/sort/src/numeric_str_cmp.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Michael Debertol <michael.debertol..AT..gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//! Fast comparison for strings representing a base 10 number without precision loss.
//!
@@ -52,6 +50,7 @@ impl NumInfo {
/// an empty range (idx..idx) is returned so that idx is the char after the last zero.
/// If the input is not a number (which has to be treated as zero), the returned empty range
/// will be 0..0.
+ #[allow(clippy::cognitive_complexity)]
pub fn parse(num: &str, parse_settings: &NumInfoParseSettings) -> (Self, Range<usize>) {
let mut exponent = -1;
let mut had_decimal_pt = false;
@@ -198,15 +197,13 @@ pub fn human_numeric_str_cmp(
let a_unit = get_unit(a.chars().next_back());
let b_unit = get_unit(b.chars().next_back());
let ordering = a_unit.cmp(&b_unit);
- if ordering != Ordering::Equal {
- if a_info.sign == Sign::Negative {
- ordering.reverse()
- } else {
- ordering
- }
- } else {
+ if ordering == Ordering::Equal {
// 3. Number
numeric_str_cmp((a, a_info), (b, b_info))
+ } else if a_info.sign == Sign::Negative {
+ ordering.reverse()
+ } else {
+ ordering
}
}
@@ -224,8 +221,8 @@ pub fn numeric_str_cmp((a, a_info): (&str, &NumInfo), (b, b_info): (&str, &NumIn
a_info.exponent.cmp(&b_info.exponent)
} else {
// walk the characters from the front until we find a difference
- let mut a_chars = a.chars().filter(|c| c.is_ascii_digit());
- let mut b_chars = b.chars().filter(|c| c.is_ascii_digit());
+ let mut a_chars = a.chars().filter(char::is_ascii_digit);
+ let mut b_chars = b.chars().filter(char::is_ascii_digit);
loop {
let a_next = a_chars.next();
let b_next = b_chars.next();
@@ -270,7 +267,7 @@ mod tests {
fn parses_exp() {
let n = "1";
assert_eq!(
- NumInfo::parse(n, &Default::default()),
+ NumInfo::parse(n, &NumInfoParseSettings::default()),
(
NumInfo {
exponent: 0,
@@ -281,7 +278,7 @@ mod tests {
);
let n = "100";
assert_eq!(
- NumInfo::parse(n, &Default::default()),
+ NumInfo::parse(n, &NumInfoParseSettings::default()),
(
NumInfo {
exponent: 2,
@@ -309,7 +306,7 @@ mod tests {
);
let n = "1,000";
assert_eq!(
- NumInfo::parse(n, &Default::default()),
+ NumInfo::parse(n, &NumInfoParseSettings::default()),
(
NumInfo {
exponent: 0,
@@ -320,7 +317,7 @@ mod tests {
);
let n = "1000.00";
assert_eq!(
- NumInfo::parse(n, &Default::default()),
+ NumInfo::parse(n, &NumInfoParseSettings::default()),
(
NumInfo {
exponent: 3,
@@ -334,7 +331,7 @@ mod tests {
fn parses_negative_exp() {
let n = "0.00005";
assert_eq!(
- NumInfo::parse(n, &Default::default()),
+ NumInfo::parse(n, &NumInfoParseSettings::default()),
(
NumInfo {
exponent: -5,
@@ -345,7 +342,7 @@ mod tests {
);
let n = "00000.00005";
assert_eq!(
- NumInfo::parse(n, &Default::default()),
+ NumInfo::parse(n, &NumInfoParseSettings::default()),
(
NumInfo {
exponent: -5,
@@ -360,7 +357,7 @@ mod tests {
fn parses_sign() {
let n = "5";
assert_eq!(
- NumInfo::parse(n, &Default::default()),
+ NumInfo::parse(n, &NumInfoParseSettings::default()),
(
NumInfo {
exponent: 0,
@@ -371,7 +368,7 @@ mod tests {
);
let n = "-5";
assert_eq!(
- NumInfo::parse(n, &Default::default()),
+ NumInfo::parse(n, &NumInfoParseSettings::default()),
(
NumInfo {
exponent: 0,
@@ -382,7 +379,7 @@ mod tests {
);
let n = " -5";
assert_eq!(
- NumInfo::parse(n, &Default::default()),
+ NumInfo::parse(n, &NumInfoParseSettings::default()),
(
NumInfo {
exponent: 0,
@@ -394,11 +391,11 @@ mod tests {
}
fn test_helper(a: &str, b: &str, expected: Ordering) {
- let (a_info, a_range) = NumInfo::parse(a, &Default::default());
- let (b_info, b_range) = NumInfo::parse(b, &Default::default());
+ let (a_info, a_range) = NumInfo::parse(a, &NumInfoParseSettings::default());
+ let (b_info, b_range) = NumInfo::parse(b, &NumInfoParseSettings::default());
let ordering = numeric_str_cmp(
- (&a[a_range.to_owned()], &a_info),
- (&b[b_range.to_owned()], &b_info),
+ (&a[a_range.clone()], &a_info),
+ (&b[b_range.clone()], &b_info),
);
assert_eq!(ordering, expected);
let ordering = numeric_str_cmp((&b[b_range], &b_info), (&a[a_range], &a_info));
@@ -470,7 +467,7 @@ mod tests {
}
#[test]
fn single_minus() {
- let info = NumInfo::parse("-", &Default::default());
+ let info = NumInfo::parse("-", &NumInfoParseSettings::default());
assert_eq!(
info,
(
diff --git a/src/uu/sort/src/sort.rs b/src/uu/sort/src/sort.rs
index 99f824982a49160c61333a3a4a636e63ad715998..b04eecc911e3c5c313eaccf4c20a3fce1f2b39d3 100644
--- a/src/uu/sort/src/sort.rs
+++ b/src/uu/sort/src/sort.rs
@@ -1,11 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Michael Yin <mikeyin@mikeyin.org>
-// * (c) Robert Swinford <robert.swinford..AT..gmail.com>
-// * (c) Michael Debertol <michael.debertol..AT..gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// Although these links don't always seem to describe reality, check out the POSIX and GNU specs:
// https://pubs.opengroup.org/onlinepubs/9699919799/utilities/sort.html
@@ -45,26 +41,17 @@ use std::str::Utf8Error;
use unicode_width::UnicodeWidthStr;
use uucore::display::Quotable;
use uucore::error::{set_exit_code, strip_errno, UError, UResult, USimpleError, UUsageError};
-use uucore::format_usage;
+use uucore::line_ending::LineEnding;
use uucore::parse_size::{ParseSizeError, Parser};
+use uucore::shortcut_value_parser::ShortcutValueParser;
use uucore::version_cmp::version_cmp;
+use uucore::{format_usage, help_about, help_section, help_usage};
use crate::tmp_dir::TmpDirWrapper;
-const ABOUT: &str = "\
- Display sorted concatenation of all FILE(s). \
- With no FILE, or when FILE is -, read standard input.";
-const USAGE: &str = "{} [OPTION]... [FILE]...";
-
-const LONG_HELP_KEYS: &str = "The key format is FIELD[.CHAR][OPTIONS][,FIELD[.CHAR]][OPTIONS].
-
-Fields by default are separated by the first whitespace after a non-whitespace character. Use -t to specify a custom separator.
-In the default case, whitespace is appended at the beginning of each field. Custom separators however are not included in fields.
-
-FIELD and CHAR both start at 1 (i.e. they are 1-indexed). If there is no end specified after a comma, the end will be the end of the line.
-If CHAR is set 0, it means the end of the field. CHAR defaults to 1 for the start position and to 0 for the end position.
-
-Valid options are: MbdfhnRrV. They override the global options for this key.";
+const ABOUT: &str = help_about!("sort.md");
+const USAGE: &str = help_usage!("sort.md");
+const AFTER_HELP: &str = help_section!("after help", "sort.md");
mod options {
pub mod modes {
@@ -185,7 +172,9 @@ impl Display for SortError {
line,
silent,
} => {
- if !silent {
+ if *silent {
+ Ok(())
+ } else {
write!(
f,
"{}:{}: disorder: {}",
@@ -193,8 +182,6 @@ impl Display for SortError {
line_number,
line
)
- } else {
- Ok(())
}
}
Self::OpenFailed { path, error } => {
@@ -220,13 +207,13 @@ impl Display for SortError {
write!(f, "failed to open temporary file: {}", strip_errno(error))
}
Self::CompressProgExecutionFailed { code } => {
- write!(f, "couldn't execute compress program: errno {}", code)
+ write!(f, "couldn't execute compress program: errno {code}")
}
Self::CompressProgTerminatedAbnormally { prog } => {
write!(f, "{} terminated abnormally", prog.quote())
}
Self::TmpDirCreationFailed => write!(f, "could not create temporary directory"),
- Self::Uft8Error { error } => write!(f, "{}", error),
+ Self::Uft8Error { error } => write!(f, "{error}"),
}
}
}
@@ -265,6 +252,9 @@ impl Output {
let file = if let Some(name) = name {
// This is different from `File::create()` because we don't truncate the output yet.
// This allows using the output file as an input file.
+ // clippy::suspicious_open_options supported only for Rust >= 1.77.0
+ // Rust version = 1.76 on OpenBSD stable/7.5
+ #[cfg_attr(not(target_os = "openbsd"), allow(clippy::suspicious_open_options))]
let file = OpenOptions::new()
.write(true)
.create(true)
@@ -317,7 +307,7 @@ pub struct GlobalSettings {
selectors: Vec<FieldSelector>,
separator: Option<char>,
threads: String,
- zero_terminated: bool,
+ line_ending: LineEnding,
buffer_size: usize,
compress_prog: Option<String>,
merge_batch_size: usize,
@@ -351,10 +341,7 @@ impl GlobalSettings {
.parse(input.trim())?;
usize::try_from(size).map_err(|_| {
- ParseSizeError::SizeTooBig(format!(
- "Buffer size {} does not fit in address space",
- size
- ))
+ ParseSizeError::SizeTooBig(format!("Buffer size {size} does not fit in address space"))
})
}
@@ -397,7 +384,7 @@ impl Default for GlobalSettings {
selectors: vec![],
separator: None,
threads: String::new(),
- zero_terminated: false,
+ line_ending: LineEnding::Newline,
buffer_size: DEFAULT_BUF_SIZE,
compress_prog: None,
merge_batch_size: 32,
@@ -540,14 +527,11 @@ impl<'a> Line<'a> {
}
fn print(&self, writer: &mut impl Write, settings: &GlobalSettings) {
- if settings.zero_terminated && !settings.debug {
- writer.write_all(self.line.as_bytes()).unwrap();
- writer.write_all(b"\0").unwrap();
- } else if !settings.debug {
- writer.write_all(self.line.as_bytes()).unwrap();
- writer.write_all(b"\n").unwrap();
- } else {
+ if settings.debug {
self.print_debug(settings, writer).unwrap();
+ } else {
+ writer.write_all(self.line.as_bytes()).unwrap();
+ writer.write_all(&[settings.line_ending.into()]).unwrap();
}
}
@@ -563,7 +547,7 @@ impl<'a> Line<'a> {
// optimizations here.
let line = self.line.replace('\t', ">");
- writeln!(writer, "{}", line)?;
+ writeln!(writer, "{line}")?;
let mut fields = vec![];
tokenize(self.line, settings.separator, &mut fields);
@@ -585,7 +569,15 @@ impl<'a> Line<'a> {
selection.start += num_range.start;
selection.end = selection.start + num_range.len();
- if num_range != (0..0) {
+ if num_range == (0..0) {
+ // This was not a valid number.
+ // Report no match at the first non-whitespace character.
+ let leading_whitespace = self.line[selection.clone()]
+ .find(|c: char| !c.is_whitespace())
+ .unwrap_or(0);
+ selection.start += leading_whitespace;
+ selection.end += leading_whitespace;
+ } else {
// include a trailing si unit
if selector.settings.mode == SortMode::HumanNumeric
&& self.line[selection.end..initial_selection.end]
@@ -600,14 +592,6 @@ impl<'a> Line<'a> {
{
selection.start -= 1;
}
- } else {
- // This was not a valid number.
- // Report no match at the first non-whitespace character.
- let leading_whitespace = self.line[selection.clone()]
- .find(|c: char| !c.is_whitespace())
- .unwrap_or(0);
- selection.start += leading_whitespace;
- selection.end += leading_whitespace;
}
}
SortMode::GeneralNumeric => {
@@ -866,7 +850,7 @@ impl FieldSelector {
'R' => key_settings.set_sort_mode(SortMode::Random)?,
'r' => key_settings.reverse = true,
'V' => key_settings.set_sort_mode(SortMode::Version)?,
- c => return Err(format!("invalid option: '{}'", c)),
+ c => return Err(format!("invalid option: '{c}'")),
}
}
Ok(ignore_blanks)
@@ -942,7 +926,7 @@ impl FieldSelector {
/// Look up the range in the line that corresponds to this selector.
/// If needs_fields returned false, tokens must be None.
- fn get_range<'a>(&self, line: &'a str, tokens: Option<&[Field]>) -> Range<usize> {
+ fn get_range(&self, line: &str, tokens: Option<&[Field]>) -> Range<usize> {
enum Resolution {
// The start index of the resolved character, inclusive
StartOfChar(usize),
@@ -1005,7 +989,7 @@ impl FieldSelector {
let mut range = match to {
Some(Resolution::StartOfChar(mut to)) => {
// We need to include the character at `to`.
- to += line[to..].chars().next().map_or(1, |c| c.len_utf8());
+ to += line[to..].chars().next().map_or(1, char::len_utf8);
from..to
}
Some(Resolution::EndOfChar(to)) => from..to,
@@ -1047,8 +1031,8 @@ fn make_sort_mode_arg(mode: &'static str, short: char, help: &'static str) -> Ar
}
#[uucore::main]
+#[allow(clippy::cognitive_complexity)]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_ignore();
let mut settings = GlobalSettings::default();
let matches = match uu_app().try_get_matches_from(args) {
@@ -1182,7 +1166,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
})?;
}
- settings.zero_terminated = matches.get_flag(options::ZERO_TERMINATED);
+ settings.line_ending = LineEnding::from_zero_flag(matches.get_flag(options::ZERO_TERMINATED));
settings.merge = matches.get_flag(options::MERGE);
settings.check = matches.contains_id(options::check::CHECK);
@@ -1295,11 +1279,12 @@ pub fn uu_app() -> Command {
Command::new(uucore::util_name())
.version(crate_version!())
.about(ABOUT)
- .after_help(LONG_HELP_KEYS)
+ .after_help(AFTER_HELP)
.override_usage(format_usage(USAGE))
.infer_long_args(true)
.disable_help_flag(true)
.disable_version_flag(true)
+ .args_override_self(true)
.arg(
Arg::new(options::HELP)
.long(options::HELP)
@@ -1315,14 +1300,14 @@ pub fn uu_app() -> Command {
.arg(
Arg::new(options::modes::SORT)
.long(options::modes::SORT)
- .value_parser([
+ .value_parser(ShortcutValueParser::new([
"general-numeric",
"human-numeric",
"month",
"numeric",
"version",
"random",
- ])
+ ]))
.conflicts_with_all(options::modes::ALL_SORT_MODES),
)
.arg(make_sort_mode_arg(
@@ -1381,11 +1366,11 @@ pub fn uu_app() -> Command {
.long(options::check::CHECK)
.require_equals(true)
.num_args(0..)
- .value_parser([
+ .value_parser(ShortcutValueParser::new([
options::check::SILENT,
options::check::QUIET,
options::check::DIAGNOSE_FIRST,
- ])
+ ]))
.conflicts_with(options::OUTPUT)
.help("check for sorted input; do not sort"),
)
@@ -1575,10 +1560,7 @@ fn compare_by<'a>(
let mut num_info_index = 0;
let mut parsed_float_index = 0;
for selector in &global_settings.selectors {
- let (a_str, b_str) = if !selector.needs_selection {
- // We can select the whole line.
- (a.line, b.line)
- } else {
+ let (a_str, b_str) = if selector.needs_selection {
let selections = (
a_line_data.selections
[a.index * global_settings.precomputed.selections_per_line + selection_index],
@@ -1587,6 +1569,9 @@ fn compare_by<'a>(
);
selection_index += 1;
selections
+ } else {
+ // We can select the whole line.
+ (a.line, b.line)
};
let settings = &selector.settings;
@@ -1668,6 +1653,7 @@ fn compare_by<'a>(
// In contrast to numeric compare, GNU general numeric/FP sort *should* recognize positive signs and
// scientific notation, so we strip those lines only after the end of the following numeric string.
// For example, 5e10KFD would be 5e10 or 5x10^10 and +10000HFKJFK would become 10000.
+#[allow(clippy::cognitive_complexity)]
fn get_leading_gen(input: &str) -> Range<usize> {
let trimmed = input.trim_start();
let leading_whitespace_len = input.len() - trimmed.len();
@@ -1742,8 +1728,8 @@ fn general_f64_parse(a: &str) -> GeneralF64ParseResult {
// TODO: Once our minimum supported Rust version is 1.53 or above, we should add tests for those cases.
match a.parse::<f64>() {
Ok(a) if a.is_nan() => GeneralF64ParseResult::NaN,
- Ok(a) if a == std::f64::NEG_INFINITY => GeneralF64ParseResult::NegInfinity,
- Ok(a) if a == std::f64::INFINITY => GeneralF64ParseResult::Infinity,
+ Ok(a) if a == f64::NEG_INFINITY => GeneralF64ParseResult::NegInfinity,
+ Ok(a) if a == f64::INFINITY => GeneralF64ParseResult::Infinity,
Ok(a) => GeneralF64ParseResult::Number(a),
Err(_) => GeneralF64ParseResult::Invalid,
}
@@ -2001,7 +1987,6 @@ mod tests {
// SizeTooBig
let invalid_input = ["500E", "1Y"];
for input in &invalid_input {
- #[cfg(not(target_pointer_width = "128"))]
assert!(GlobalSettings::parse_byte_count(input).is_err());
}
diff --git a/src/uu/sort/src/tmp_dir.rs b/src/uu/sort/src/tmp_dir.rs
index 0f6c76677e8d47d8edc1d259f1ab210255218bfb..14e17a0d64a9f054e79b32a63a2271644c194879 100644
--- a/src/uu/sort/src/tmp_dir.rs
+++ b/src/uu/sort/src/tmp_dir.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::{
fs::File,
path::{Path, PathBuf},
@@ -56,7 +60,7 @@ impl TmpDirWrapper {
}
std::process::exit(2)
})
- .map_err(|e| USimpleError::new(2, format!("failed to set up signal handler: {}", e)))
+ .map_err(|e| USimpleError::new(2, format!("failed to set up signal handler: {e}")))
}
pub fn next_file(&mut self) -> UResult<(File, PathBuf)> {
diff --git a/src/uu/split/BENCHMARKING.md b/src/uu/split/BENCHMARKING.md
index 9c8d5d17c870ea643501a5f6712a7d43c616780b..1495891ba7f5201cd3ea765df6c9210775a2ae1b 100644
--- a/src/uu/split/BENCHMARKING.md
+++ b/src/uu/split/BENCHMARKING.md
@@ -7,11 +7,15 @@ GNU version of `split`, you can use a benchmarking tool like
[hyperfine][0]. On Ubuntu 18.04 or later, you can install `hyperfine` by
running
- sudo apt-get install hyperfine
+```
+sudo apt-get install hyperfine
+```
Next, build the `split` binary under the release profile:
- cargo build --release -p uu_split
+```
+cargo build --release -p uu_split
+```
Now, get a text file to test `split` on. The `split` program has three
main modes of operation: chunk by lines, chunk by bytes, and chunk by
@@ -21,7 +25,9 @@ operation. For example, to test chunking by bytes on a large input file,
you can create a file named `testfile.txt` containing one million null
bytes like this:
- printf "%0.s\0" {1..1000000} > testfile.txt
+```
+printf "%0.s\0" {1..1000000} > testfile.txt
+```
For another example, to test chunking by bytes on a large real-world
input file, you could download a [database dump of Wikidata][1] or some
@@ -31,10 +37,12 @@ file][2] contains about 130 million lines.
Finally, you can compare the performance of the two versions of `split`
by running, for example,
- cd /tmp && hyperfine \
- --prepare 'rm x* || true' \
- "split -b 1000 testfile.txt" \
- "target/release/split -b 1000 testfile.txt"
+```
+cd /tmp && hyperfine \
+ --prepare 'rm x* || true' \
+ "split -b 1000 testfile.txt" \
+ "target/release/split -b 1000 testfile.txt"
+```
Since `split` creates a lot of files on the filesystem, I recommend
changing to the `/tmp` directory before running the benchmark. The
diff --git a/src/uu/split/Cargo.toml b/src/uu/split/Cargo.toml
index 9d5a9e3bad990cb85baa983641ade8187f082eed..696f26f403e3f41540878fcbe15155c72df85c1f 100644
--- a/src/uu/split/Cargo.toml
+++ b/src/uu/split/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_split"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "split ~ (uutils) split input into output files"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/split.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-memchr = "2"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["fs"] }
+clap = { workspace = true }
+memchr = { workspace = true }
+uucore = { workspace = true, features = ["fs"] }
[[bin]]
name = "split"
diff --git a/src/uu/split/README.md b/src/uu/split/README.md
index 112a4416f4c482d896443bc3935b4c967a9e1b6b..902c4a597efe4d59bff5a3b423137bed3381e686 100644
--- a/src/uu/split/README.md
+++ b/src/uu/split/README.md
@@ -4,7 +4,8 @@
### Flags
-* [ ] `--verbose` - created file printing is implemented, don't know if there is anything else
+* [ ] `--verbose` - created file printing is implemented, don't know
+ if there is anything else
## Possible Optimizations
diff --git a/src/uu/split/split.md b/src/uu/split/split.md
new file mode 100644
index 0000000000000000000000000000000000000000..836e3a0c69ab3cd6a55bcba6c80bd3d58e656d71
--- /dev/null
+++ b/src/uu/split/split.md
@@ -0,0 +1,26 @@
+<!-- spell-checker:ignore PREFI -->
+
+# split
+
+```
+split [OPTION]... [INPUT [PREFIX]]
+```
+
+Create output files containing consecutive or interleaved sections of input
+
+## After Help
+
+Output fixed-size pieces of INPUT to PREFIXaa, PREFIXab, ...; default size is 1000, and default PREFIX is 'x'. With no INPUT, or when INPUT is -, read standard input.
+
+The SIZE argument is an integer and optional unit (example: 10K is 10*1024).
+Units are K,M,G,T,P,E,Z,Y,R,Q (powers of 1024) or KB,MB,... (powers of 1000).
+Binary prefixes can be used, too: KiB=K, MiB=M, and so on.
+
+CHUNKS may be:
+
+- N split into N files based on size of input
+- K/N output Kth of N to stdout
+- l/N split into N files without splitting lines/records
+- l/K/N output Kth of N to stdout without splitting lines/records
+- r/N like 'l' but use round robin distribution
+- r/K/N likewise but only output Kth of N to stdout
diff --git a/src/uu/split/src/filenames.rs b/src/uu/split/src/filenames.rs
index 6bec4105f84b3a118c472c2c9c345915d1ab03a6..d2ce1beb3165f49dccbe77f2eaf3585c372eb8a7 100644
--- a/src/uu/split/src/filenames.rs
+++ b/src/uu/split/src/filenames.rs
@@ -1,8 +1,8 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
-// spell-checker:ignore zaaa zaab
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore zaaa zaab stype
//! Compute filenames from a given index.
//!
//! The [`FilenameIterator`] yields filenames for use with ``split``.
@@ -16,18 +16,32 @@
//! use crate::filenames::SuffixType;
//!
//! let prefix = "chunk_".to_string();
-//! let suffix = ".txt".to_string();
-//! let width = 2;
-//! let suffix_type = SuffixType::Alphabetic;
-//! let it = FilenameIterator::new(prefix, suffix, width, suffix_type);
+//! let suffix = Suffix {
+//! stype: SuffixType::Alphabetic,
+//! length: 2,
+//! start: 0,
+//! auto_widening: true,
+//! additional: ".txt".to_string(),
+//! };
+//! let it = FilenameIterator::new(prefix, suffix);
//!
//! assert_eq!(it.next().unwrap(), "chunk_aa.txt");
//! assert_eq!(it.next().unwrap(), "chunk_ab.txt");
//! assert_eq!(it.next().unwrap(), "chunk_ac.txt");
//! ```
+
use crate::number::DynamicWidthNumber;
use crate::number::FixedWidthNumber;
use crate::number::Number;
+use crate::strategy::Strategy;
+use crate::{
+ OPT_ADDITIONAL_SUFFIX, OPT_HEX_SUFFIXES, OPT_HEX_SUFFIXES_SHORT, OPT_NUMERIC_SUFFIXES,
+ OPT_NUMERIC_SUFFIXES_SHORT, OPT_SUFFIX_LENGTH,
+};
+use clap::ArgMatches;
+use std::fmt;
+use std::path::is_separator;
+use uucore::display::Quotable;
use uucore::error::{UResult, USimpleError};
/// The format to use for suffixes in the filename for each output chunk.
@@ -54,21 +68,200 @@ impl SuffixType {
}
}
+/// Filename suffix parameters
+#[derive(Clone)]
+pub struct Suffix {
+ stype: SuffixType,
+ length: usize,
+ start: usize,
+ auto_widening: bool,
+ additional: String,
+}
+
+/// An error when parsing suffix parameters from command-line arguments.
+pub enum SuffixError {
+ /// Invalid suffix length parameter.
+ NotParsable(String),
+
+ /// Suffix contains a directory separator, which is not allowed.
+ ContainsSeparator(String),
+
+ /// Suffix is not large enough to split into specified chunks
+ TooSmall(usize),
+}
+
+impl fmt::Display for SuffixError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self {
+ Self::NotParsable(s) => write!(f, "invalid suffix length: {}", s.quote()),
+ Self::TooSmall(i) => write!(f, "the suffix length needs to be at least {i}"),
+ Self::ContainsSeparator(s) => write!(
+ f,
+ "invalid suffix {}, contains directory separator",
+ s.quote()
+ ),
+ }
+ }
+}
+
+impl Suffix {
+ /// Parse the suffix type, start, length and additional suffix from the command-line arguments
+ /// as well process suffix length auto-widening and auto-width scenarios
+ ///
+ /// Suffix auto-widening: Determine if the output file names suffix is allowed to dynamically auto-widen,
+ /// i.e. change (increase) suffix length dynamically as more files need to be written into.
+ /// Suffix length auto-widening rules are (in the order they are applied):
+ /// - ON by default
+ /// - OFF when suffix start N is specified via long option with a value
+ /// `--numeric-suffixes=N` or `--hex-suffixes=N`
+ /// - OFF when suffix length N is specified, except for N=0 (see edge cases below)
+ /// `-a N` or `--suffix-length=N`
+ /// - OFF if suffix length is auto pre-calculated (auto-width)
+ ///
+ /// Suffix auto-width: Determine if the the output file names suffix length should be automatically pre-calculated
+ /// based on number of files that need to written into, having number of files known upfront
+ /// Suffix length auto pre-calculation rules:
+ /// - Pre-calculate new suffix length when `-n`/`--number` option (N, K/N, l/N, l/K/N, r/N, r/K/N)
+ /// is used, where N is number of chunks = number of files to write into
+ /// and suffix start < N number of files
+ /// as in `split --numeric-suffixes=1 --number=r/100 file`
+ /// - Do NOT pre-calculate new suffix length otherwise, i.e. when
+ /// suffix start >= N number of files
+ /// as in `split --numeric-suffixes=100 --number=r/100 file`
+ /// OR when suffix length N is specified, except for N=0 (see edge cases below)
+ /// `-a N` or `--suffix-length=N`
+ ///
+ /// Edge case:
+ /// - If suffix length is specified as 0 in a command line,
+ /// first apply auto-width calculations and if still 0
+ /// set it to default value.
+ /// Do NOT change auto-widening value
+ ///
+ pub fn from(matches: &ArgMatches, strategy: &Strategy) -> Result<Self, SuffixError> {
+ let stype: SuffixType;
+
+ // Defaults
+ let mut start = 0;
+ let mut auto_widening = true;
+ let default_length: usize = 2;
+
+ // Check if the user is specifying one or more than one suffix
+ // Any combination of suffixes is allowed
+ // Since all suffixes are setup with 'overrides_with_all()' against themselves and each other,
+ // last one wins, all others are ignored
+ match (
+ matches.contains_id(OPT_NUMERIC_SUFFIXES),
+ matches.contains_id(OPT_HEX_SUFFIXES),
+ matches.get_flag(OPT_NUMERIC_SUFFIXES_SHORT),
+ matches.get_flag(OPT_HEX_SUFFIXES_SHORT),
+ ) {
+ (true, _, _, _) => {
+ stype = SuffixType::Decimal;
+ // if option was specified, but without value - this will return None as there is no default value
+ if let Some(opt) = matches.get_one::<String>(OPT_NUMERIC_SUFFIXES) {
+ start = opt
+ .parse::<usize>()
+ .map_err(|_| SuffixError::NotParsable(opt.to_string()))?;
+ auto_widening = false;
+ }
+ }
+ (_, true, _, _) => {
+ stype = SuffixType::Hexadecimal;
+ // if option was specified, but without value - this will return None as there is no default value
+ if let Some(opt) = matches.get_one::<String>(OPT_HEX_SUFFIXES) {
+ start = usize::from_str_radix(opt, 16)
+ .map_err(|_| SuffixError::NotParsable(opt.to_string()))?;
+ auto_widening = false;
+ }
+ }
+ (_, _, true, _) => stype = SuffixType::Decimal, // short numeric suffix '-d'
+ (_, _, _, true) => stype = SuffixType::Hexadecimal, // short hex suffix '-x'
+ _ => stype = SuffixType::Alphabetic, // no numeric/hex suffix, using default alphabetic
+ }
+
+ // Get suffix length and a flag to indicate if it was specified with command line option
+ let (mut length, is_length_cmd_opt) =
+ if let Some(v) = matches.get_one::<String>(OPT_SUFFIX_LENGTH) {
+ // suffix length was specified in command line
+ (
+ v.parse::<usize>()
+ .map_err(|_| SuffixError::NotParsable(v.to_string()))?,
+ true,
+ )
+ } else {
+ // no suffix length option was specified in command line
+ // set to default value
+ (default_length, false)
+ };
+
+ // Disable dynamic auto-widening if suffix length was specified in command line with value > 0
+ if is_length_cmd_opt && length > 0 {
+ auto_widening = false;
+ }
+
+ // Auto pre-calculate new suffix length (auto-width) if necessary
+ if let Strategy::Number(ref number_type) = strategy {
+ let chunks = number_type.num_chunks();
+ let required_length = ((start as u64 + chunks) as f64)
+ .log(stype.radix() as f64)
+ .ceil() as usize;
+
+ if (start as u64) < chunks && !(is_length_cmd_opt && length > 0) {
+ // with auto-width ON the auto-widening is OFF
+ auto_widening = false;
+
+ // do not reduce suffix length with auto-width
+ if length < required_length {
+ length = required_length;
+ }
+ }
+
+ if length < required_length {
+ return Err(SuffixError::TooSmall(required_length));
+ }
+ }
+
+ // Check edge case when suffix length == 0 was specified in command line
+ // Set it to default value
+ if is_length_cmd_opt && length == 0 {
+ length = default_length;
+ }
+
+ let additional = matches
+ .get_one::<String>(OPT_ADDITIONAL_SUFFIX)
+ .unwrap()
+ .to_string();
+ if additional.chars().any(is_separator) {
+ return Err(SuffixError::ContainsSeparator(additional));
+ }
+
+ let result = Self {
+ stype,
+ length,
+ start,
+ auto_widening,
+ additional,
+ };
+
+ Ok(result)
+ }
+}
+
/// Compute filenames from a given index.
///
/// This iterator yields filenames for use with ``split``.
///
/// The `prefix` is prepended to each filename and the
-/// `additional_suffix1` is appended to each filename.
+/// `suffix.additional` is appended to each filename.
///
-/// If `suffix_length` is 0, then the variable portion of the filename
+/// If `suffix.auto_widening` is true, then the variable portion of the filename
/// that identifies the current chunk will have a dynamically
-/// increasing width. If `suffix_length` is greater than zero, then
-/// the variable portion of the filename will always be exactly that
+/// increasing width. If `suffix.auto_widening` is false, then
+/// the variable portion of the filename will always be exactly `suffix.length`
/// width in characters. In that case, after the iterator yields each
/// string of that width, the iterator is exhausted.
///
-/// Finally, `suffix_type` controls which type of suffix to produce,
+/// Finally, `suffix.stype` controls which type of suffix to produce,
/// alphabetic or numeric.
///
/// # Examples
@@ -81,10 +274,14 @@ impl SuffixType {
/// use crate::filenames::SuffixType;
///
/// let prefix = "chunk_".to_string();
-/// let suffix = ".txt".to_string();
-/// let width = 2;
-/// let suffix_type = SuffixType::Alphabetic;
-/// let it = FilenameIterator::new(prefix, suffix, width, suffix_type);
+/// let suffix = Suffix {
+/// stype: SuffixType::Alphabetic,
+/// length: 2,
+/// start: 0,
+/// auto_widening: true,
+/// additional: ".txt".to_string(),
+/// };
+/// let it = FilenameIterator::new(prefix, suffix);
///
/// assert_eq!(it.next().unwrap(), "chunk_aa.txt");
/// assert_eq!(it.next().unwrap(), "chunk_ab.txt");
@@ -98,36 +295,34 @@ impl SuffixType {
/// use crate::filenames::SuffixType;
///
/// let prefix = "chunk_".to_string();
-/// let suffix = ".txt".to_string();
-/// let width = 2;
-/// let suffix_type = SuffixType::Decimal;
-/// let it = FilenameIterator::new(prefix, suffix, width, suffix_type);
+/// let suffix = Suffix {
+/// stype: SuffixType::Decimal,
+/// length: 2,
+/// start: 0,
+/// auto_widening: true,
+/// additional: ".txt".to_string(),
+/// };
+/// let it = FilenameIterator::new(prefix, suffix);
///
/// assert_eq!(it.next().unwrap(), "chunk_00.txt");
/// assert_eq!(it.next().unwrap(), "chunk_01.txt");
/// assert_eq!(it.next().unwrap(), "chunk_02.txt");
/// ```
pub struct FilenameIterator<'a> {
- additional_suffix: &'a str,
prefix: &'a str,
+ additional_suffix: &'a str,
number: Number,
first_iteration: bool,
}
impl<'a> FilenameIterator<'a> {
- pub fn new(
- prefix: &'a str,
- additional_suffix: &'a str,
- suffix_length: usize,
- suffix_type: SuffixType,
- suffix_start: usize,
- ) -> UResult<FilenameIterator<'a>> {
- let radix = suffix_type.radix();
- let number = if suffix_length == 0 {
- Number::DynamicWidth(DynamicWidthNumber::new(radix, suffix_start))
+ pub fn new(prefix: &'a str, suffix: &'a Suffix) -> UResult<Self> {
+ let radix = suffix.stype.radix();
+ let number = if suffix.auto_widening {
+ Number::DynamicWidth(DynamicWidthNumber::new(radix, suffix.start))
} else {
Number::FixedWidth(
- FixedWidthNumber::new(radix, suffix_length, suffix_start).map_err(|_| {
+ FixedWidthNumber::new(radix, suffix.length, suffix.start).map_err(|_| {
USimpleError::new(
1,
"numerical suffix start value is too large for the suffix length",
@@ -135,6 +330,7 @@ impl<'a> FilenameIterator<'a> {
})?,
)
};
+ let additional_suffix = suffix.additional.as_str();
Ok(FilenameIterator {
prefix,
@@ -167,40 +363,62 @@ impl<'a> Iterator for FilenameIterator<'a> {
mod tests {
use crate::filenames::FilenameIterator;
+ use crate::filenames::Suffix;
use crate::filenames::SuffixType;
#[test]
fn test_filename_iterator_alphabetic_fixed_width() {
- let mut it = FilenameIterator::new("chunk_", ".txt", 2, SuffixType::Alphabetic, 0).unwrap();
+ let suffix = Suffix {
+ stype: SuffixType::Alphabetic,
+ length: 2,
+ start: 0,
+ auto_widening: false,
+ additional: ".txt".to_string(),
+ };
+ let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
assert_eq!(it.next().unwrap(), "chunk_aa.txt");
assert_eq!(it.next().unwrap(), "chunk_ab.txt");
assert_eq!(it.next().unwrap(), "chunk_ac.txt");
- let mut it = FilenameIterator::new("chunk_", ".txt", 2, SuffixType::Alphabetic, 0).unwrap();
+ let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
assert_eq!(it.nth(26 * 26 - 1).unwrap(), "chunk_zz.txt");
assert_eq!(it.next(), None);
}
#[test]
fn test_filename_iterator_numeric_fixed_width() {
- let mut it = FilenameIterator::new("chunk_", ".txt", 2, SuffixType::Decimal, 0).unwrap();
+ let suffix = Suffix {
+ stype: SuffixType::Decimal,
+ length: 2,
+ start: 0,
+ auto_widening: false,
+ additional: ".txt".to_string(),
+ };
+ let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
assert_eq!(it.next().unwrap(), "chunk_00.txt");
assert_eq!(it.next().unwrap(), "chunk_01.txt");
assert_eq!(it.next().unwrap(), "chunk_02.txt");
- let mut it = FilenameIterator::new("chunk_", ".txt", 2, SuffixType::Decimal, 0).unwrap();
+ let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
assert_eq!(it.nth(10 * 10 - 1).unwrap(), "chunk_99.txt");
assert_eq!(it.next(), None);
}
#[test]
fn test_filename_iterator_alphabetic_dynamic_width() {
- let mut it = FilenameIterator::new("chunk_", ".txt", 0, SuffixType::Alphabetic, 0).unwrap();
+ let suffix = Suffix {
+ stype: SuffixType::Alphabetic,
+ length: 2,
+ start: 0,
+ auto_widening: true,
+ additional: ".txt".to_string(),
+ };
+ let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
assert_eq!(it.next().unwrap(), "chunk_aa.txt");
assert_eq!(it.next().unwrap(), "chunk_ab.txt");
assert_eq!(it.next().unwrap(), "chunk_ac.txt");
- let mut it = FilenameIterator::new("chunk_", ".txt", 0, SuffixType::Alphabetic, 0).unwrap();
+ let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
assert_eq!(it.nth(26 * 25 - 1).unwrap(), "chunk_yz.txt");
assert_eq!(it.next().unwrap(), "chunk_zaaa.txt");
assert_eq!(it.next().unwrap(), "chunk_zaab.txt");
@@ -208,49 +426,96 @@ mod tests {
#[test]
fn test_filename_iterator_numeric_dynamic_width() {
- let mut it = FilenameIterator::new("chunk_", ".txt", 0, SuffixType::Decimal, 0).unwrap();
+ let suffix = Suffix {
+ stype: SuffixType::Decimal,
+ length: 2,
+ start: 0,
+ auto_widening: true,
+ additional: ".txt".to_string(),
+ };
+ let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
assert_eq!(it.next().unwrap(), "chunk_00.txt");
assert_eq!(it.next().unwrap(), "chunk_01.txt");
assert_eq!(it.next().unwrap(), "chunk_02.txt");
- let mut it = FilenameIterator::new("chunk_", ".txt", 0, SuffixType::Decimal, 0).unwrap();
+ let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
assert_eq!(it.nth(10 * 9 - 1).unwrap(), "chunk_89.txt");
assert_eq!(it.next().unwrap(), "chunk_9000.txt");
assert_eq!(it.next().unwrap(), "chunk_9001.txt");
}
#[test]
- fn test_filename_iterator_numeric_suffix_decimal() {
- let mut it = FilenameIterator::new("chunk_", ".txt", 0, SuffixType::Decimal, 5).unwrap();
+ fn test_filename_iterator_numeric_decimal() {
+ let suffix = Suffix {
+ stype: SuffixType::Decimal,
+ length: 2,
+ start: 5,
+ auto_widening: true,
+ additional: ".txt".to_string(),
+ };
+ let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
assert_eq!(it.next().unwrap(), "chunk_05.txt");
assert_eq!(it.next().unwrap(), "chunk_06.txt");
assert_eq!(it.next().unwrap(), "chunk_07.txt");
}
#[test]
- fn test_filename_iterator_numeric_suffix_hex() {
- let mut it =
- FilenameIterator::new("chunk_", ".txt", 0, SuffixType::Hexadecimal, 9).unwrap();
+ fn test_filename_iterator_numeric_hex() {
+ let suffix = Suffix {
+ stype: SuffixType::Hexadecimal,
+ length: 2,
+ start: 9,
+ auto_widening: true,
+ additional: ".txt".to_string(),
+ };
+ let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
assert_eq!(it.next().unwrap(), "chunk_09.txt");
assert_eq!(it.next().unwrap(), "chunk_0a.txt");
assert_eq!(it.next().unwrap(), "chunk_0b.txt");
}
#[test]
- fn test_filename_iterator_numeric_suffix_err() {
- let mut it = FilenameIterator::new("chunk_", ".txt", 3, SuffixType::Decimal, 999).unwrap();
+ fn test_filename_iterator_numeric_err() {
+ let suffix = Suffix {
+ stype: SuffixType::Decimal,
+ length: 3,
+ start: 999,
+ auto_widening: false,
+ additional: ".txt".to_string(),
+ };
+ let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
assert_eq!(it.next().unwrap(), "chunk_999.txt");
assert!(it.next().is_none());
- let it = FilenameIterator::new("chunk_", ".txt", 3, SuffixType::Decimal, 1000);
+ let suffix = Suffix {
+ stype: SuffixType::Decimal,
+ length: 3,
+ start: 1000,
+ auto_widening: false,
+ additional: ".txt".to_string(),
+ };
+ let it = FilenameIterator::new("chunk_", &suffix);
assert!(it.is_err());
- let mut it =
- FilenameIterator::new("chunk_", ".txt", 3, SuffixType::Hexadecimal, 0xfff).unwrap();
+ let suffix = Suffix {
+ stype: SuffixType::Hexadecimal,
+ length: 3,
+ start: 0xfff,
+ auto_widening: false,
+ additional: ".txt".to_string(),
+ };
+ let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
assert_eq!(it.next().unwrap(), "chunk_fff.txt");
assert!(it.next().is_none());
- let it = FilenameIterator::new("chunk_", ".txt", 3, SuffixType::Hexadecimal, 0x1000);
+ let suffix = Suffix {
+ stype: SuffixType::Hexadecimal,
+ length: 3,
+ start: 0x1000,
+ auto_widening: false,
+ additional: ".txt".to_string(),
+ };
+ let it = FilenameIterator::new("chunk_", &suffix);
assert!(it.is_err());
}
}
diff --git a/src/uu/split/src/number.rs b/src/uu/split/src/number.rs
index 00a536af519018f998a7066290e809025150fb77..6312d0a3fa64c26776226525fc6fb2490e608731 100644
--- a/src/uu/split/src/number.rs
+++ b/src/uu/split/src/number.rs
@@ -1,8 +1,8 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
-// spell-checker:ignore zaaa zaab
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore zaaa zaab feff
//! A number in arbitrary radix expressed in a positional notation.
//!
//! Use the [`Number`] enum to represent an arbitrary number in an
@@ -200,10 +200,10 @@ impl FixedWidthNumber {
break;
}
}
- if suffix_start != 0 {
- Err(Overflow)
- } else {
+ if suffix_start == 0 {
Ok(Self { radix, digits })
+ } else {
+ Err(Overflow)
}
}
@@ -245,7 +245,7 @@ impl Display for FixedWidthNumber {
.iter()
.map(|d| map_digit(self.radix, *d))
.collect();
- write!(f, "{}", digits)
+ write!(f, "{digits}")
}
}
@@ -398,6 +398,7 @@ mod tests {
}
#[test]
+ #[allow(clippy::cognitive_complexity)]
fn test_dynamic_width_number_display_alphabetic() {
fn num(n: usize) -> Number {
let mut number = Number::DynamicWidth(DynamicWidthNumber::new(26, 0));
@@ -443,6 +444,7 @@ mod tests {
}
#[test]
+ #[allow(clippy::cognitive_complexity)]
fn test_dynamic_width_number_display_numeric_hexadecimal() {
fn num(n: usize) -> Number {
let mut number = Number::DynamicWidth(DynamicWidthNumber::new(16, 0));
@@ -467,6 +469,7 @@ mod tests {
}
#[test]
+ #[allow(clippy::cognitive_complexity)]
fn test_fixed_width_number_increment() {
let mut n = Number::FixedWidth(FixedWidthNumber::new(3, 2, 0).unwrap());
assert_eq!(n.digits(), vec![0, 0]);
@@ -490,6 +493,7 @@ mod tests {
}
#[test]
+ #[allow(clippy::cognitive_complexity)]
fn test_fixed_width_number_display_alphabetic() {
fn num(n: usize) -> Result<Number, Overflow> {
let mut number = Number::FixedWidth(FixedWidthNumber::new(26, 2, 0).unwrap());
diff --git a/src/uu/split/src/platform/mod.rs b/src/uu/split/src/platform/mod.rs
index cf5d8d3842c2a66164a85376b0b716e6dcc7190f..5afc43eeb7f714c60a7c0ee9bd44557dd1f82c71 100644
--- a/src/uu/split/src/platform/mod.rs
+++ b/src/uu/split/src/platform/mod.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
#[cfg(unix)]
pub use self::unix::instantiate_current_writer;
#[cfg(unix)]
diff --git a/src/uu/split/src/platform/unix.rs b/src/uu/split/src/platform/unix.rs
index 46f89eff5511ce99e9fc7cc06b320be442ff8c83..1fd990e0a91696acc0462e908bfbdd8d0a16a7e2 100644
--- a/src/uu/split/src/platform/unix.rs
+++ b/src/uu/split/src/platform/unix.rs
@@ -1,11 +1,16 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::env;
use std::io::Write;
use std::io::{BufWriter, Error, ErrorKind, Result};
use std::path::Path;
use std::process::{Child, Command, Stdio};
-use uucore::crash;
+use uucore::error::USimpleError;
use uucore::fs;
use uucore::fs::FileInformation;
+use uucore::show;
/// A writer that writes to a shell_process' stdin
///
@@ -97,10 +102,13 @@ impl Drop for FilterWriter {
.expect("Couldn't wait for child process");
if let Some(return_code) = exit_status.code() {
if return_code != 0 {
- crash!(1, "Shell process returned {}", return_code);
+ show!(USimpleError::new(
+ 1,
+ format!("Shell process returned {}", return_code)
+ ));
}
} else {
- crash!(1, "Shell process terminated by signal")
+ show!(USimpleError::new(1, "Shell process terminated by signal"));
}
}
}
@@ -109,22 +117,37 @@ impl Drop for FilterWriter {
pub fn instantiate_current_writer(
filter: &Option<String>,
filename: &str,
+ is_new: bool,
) -> Result<BufWriter<Box<dyn Write>>> {
match filter {
- None => Ok(BufWriter::new(Box::new(
- // write to the next file
- std::fs::OpenOptions::new()
- .write(true)
- .create(true)
- .truncate(true)
- .open(std::path::Path::new(&filename))
- .map_err(|_| {
- Error::new(
- ErrorKind::Other,
- format!("unable to open '{}'; aborting", filename),
- )
- })?,
- ) as Box<dyn Write>)),
+ None => {
+ let file = if is_new {
+ // create new file
+ std::fs::OpenOptions::new()
+ .write(true)
+ .create(true)
+ .truncate(true)
+ .open(std::path::Path::new(&filename))
+ .map_err(|_| {
+ Error::new(
+ ErrorKind::Other,
+ format!("unable to open '{filename}'; aborting"),
+ )
+ })?
+ } else {
+ // re-open file that we previously created to append to it
+ std::fs::OpenOptions::new()
+ .append(true)
+ .open(std::path::Path::new(&filename))
+ .map_err(|_| {
+ Error::new(
+ ErrorKind::Other,
+ format!("unable to re-open '{filename}'; aborting"),
+ )
+ })?
+ };
+ Ok(BufWriter::new(Box::new(file) as Box<dyn Write>))
+ }
Some(ref filter_command) => Ok(BufWriter::new(Box::new(
// spawn a shell command and write to it
FilterWriter::new(filter_command, filename)?,
diff --git a/src/uu/split/src/platform/windows.rs b/src/uu/split/src/platform/windows.rs
index 4b0dfbdfc000273a248a075e324480d6e188ee8b..a531d6abc1f3f0173de5c185c78cd47af25a61b4 100644
--- a/src/uu/split/src/platform/windows.rs
+++ b/src/uu/split/src/platform/windows.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::io::Write;
use std::io::{BufWriter, Error, ErrorKind, Result};
use std::path::Path;
@@ -10,9 +14,10 @@ use uucore::fs;
pub fn instantiate_current_writer(
_filter: &Option<String>,
filename: &str,
+ is_new: bool,
) -> Result<BufWriter<Box<dyn Write>>> {
- Ok(BufWriter::new(Box::new(
- // write to the next file
+ let file = if is_new {
+ // create new file
std::fs::OpenOptions::new()
.write(true)
.create(true)
@@ -21,10 +26,22 @@ pub fn instantiate_current_writer(
.map_err(|_| {
Error::new(
ErrorKind::Other,
- format!("'{}' would overwrite input; aborting", filename),
+ format!("unable to open '{filename}'; aborting"),
)
- })?,
- ) as Box<dyn Write>))
+ })?
+ } else {
+ // re-open file that we previously created to append to it
+ std::fs::OpenOptions::new()
+ .append(true)
+ .open(std::path::Path::new(&filename))
+ .map_err(|_| {
+ Error::new(
+ ErrorKind::Other,
+ format!("unable to re-open '{filename}'; aborting"),
+ )
+ })?
+ };
+ Ok(BufWriter::new(Box::new(file) as Box<dyn Write>))
}
pub fn paths_refer_to_same_file(p1: &str, p2: &str) -> bool {
diff --git a/src/uu/split/src/split.rs b/src/uu/split/src/split.rs
index 36200b2bd21492f7ed1bed84caf89bb1f7e838db..691721fc42d01a8d1d21cb3c93928abd59664d7d 100644
--- a/src/uu/split/src/split.rs
+++ b/src/uu/split/src/split.rs
@@ -1,31 +1,31 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Akira Hayakawa <ruby.wktk@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-// spell-checker:ignore (ToDO) PREFIXaa PREFIXab nbbbb ncccc
+// spell-checker:ignore nbbbb ncccc hexdigit getmaxstdio
mod filenames;
mod number;
mod platform;
+mod strategy;
-use crate::filenames::FilenameIterator;
-use crate::filenames::SuffixType;
-use clap::ArgAction;
-use clap::{crate_version, parser::ValueSource, Arg, ArgMatches, Command};
+use crate::filenames::{FilenameIterator, Suffix, SuffixError};
+use crate::strategy::{NumberType, Strategy, StrategyError};
+use clap::{crate_version, parser::ValueSource, Arg, ArgAction, ArgMatches, Command, ValueHint};
use std::env;
+use std::ffi::OsString;
use std::fmt;
use std::fs::{metadata, File};
use std::io;
-use std::io::{stdin, BufRead, BufReader, BufWriter, ErrorKind, Read, Write};
+use std::io::{stdin, BufRead, BufReader, BufWriter, ErrorKind, Read, Seek, SeekFrom, Write};
use std::path::Path;
use uucore::display::Quotable;
use uucore::error::{FromIo, UIoError, UResult, USimpleError, UUsageError};
-use uucore::format_usage;
-use uucore::parse_size::{parse_size, ParseSizeError};
+use uucore::parse_size::parse_size_u64;
+
use uucore::uio_error;
+use uucore::{format_usage, help_about, help_section, help_usage};
static OPT_BYTES: &str = "bytes";
static OPT_LINE_BYTES: &str = "line-bytes";
@@ -34,39 +34,202 @@ static OPT_ADDITIONAL_SUFFIX: &str = "additional-suffix";
static OPT_FILTER: &str = "filter";
static OPT_NUMBER: &str = "number";
static OPT_NUMERIC_SUFFIXES: &str = "numeric-suffixes";
+static OPT_NUMERIC_SUFFIXES_SHORT: &str = "-d";
static OPT_HEX_SUFFIXES: &str = "hex-suffixes";
+static OPT_HEX_SUFFIXES_SHORT: &str = "-x";
static OPT_SUFFIX_LENGTH: &str = "suffix-length";
-static OPT_DEFAULT_SUFFIX_LENGTH: &str = "0";
static OPT_VERBOSE: &str = "verbose";
-//The ---io and ---io-blksize parameters are consumed and ignored.
-//The parameter is included to make GNU coreutils tests pass.
-static OPT_IO: &str = "-io";
-static OPT_IO_BLKSIZE: &str = "-io-blksize";
+static OPT_SEPARATOR: &str = "separator";
static OPT_ELIDE_EMPTY_FILES: &str = "elide-empty-files";
+static OPT_IO_BLKSIZE: &str = "-io-blksize";
static ARG_INPUT: &str = "input";
static ARG_PREFIX: &str = "prefix";
-const USAGE: &str = "{} [OPTION]... [INPUT [PREFIX]]";
-const AFTER_HELP: &str = "\
- Output fixed-size pieces of INPUT to PREFIXaa, PREFIXab, ...; default \
- size is 1000, and default PREFIX is 'x'. With no INPUT, or when INPUT is \
- -, read standard input.";
+const ABOUT: &str = help_about!("split.md");
+const USAGE: &str = help_usage!("split.md");
+const AFTER_HELP: &str = help_section!("after help", "split.md");
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+ let (args, obs_lines) = handle_obsolete(args);
let matches = uu_app().try_get_matches_from(args)?;
- match Settings::from(&matches) {
+
+ match Settings::from(&matches, &obs_lines) {
Ok(settings) => split(&settings),
- Err(e) if e.requires_usage() => Err(UUsageError::new(1, format!("{}", e))),
- Err(e) => Err(USimpleError::new(1, format!("{}", e))),
+ Err(e) if e.requires_usage() => Err(UUsageError::new(1, format!("{e}"))),
+ Err(e) => Err(USimpleError::new(1, format!("{e}"))),
+ }
+}
+
+/// Extract obsolete shorthand (if any) for specifying lines in following scenarios (and similar)
+/// `split -22 file` would mean `split -l 22 file`
+/// `split -2de file` would mean `split -l 2 -d -e file`
+/// `split -x300e file` would mean `split -x -l 300 -e file`
+/// `split -x300e -22 file` would mean `split -x -e -l 22 file` (last obsolete lines option wins)
+/// following GNU `split` behavior
+fn handle_obsolete(args: impl uucore::Args) -> (Vec<OsString>, Option<String>) {
+ let mut obs_lines = None;
+ let mut preceding_long_opt_req_value = false;
+ let mut preceding_short_opt_req_value = false;
+
+ let filtered_args = args
+ .filter_map(|os_slice| {
+ filter_args(
+ os_slice,
+ &mut obs_lines,
+ &mut preceding_long_opt_req_value,
+ &mut preceding_short_opt_req_value,
+ )
+ })
+ .collect();
+
+ (filtered_args, obs_lines)
+}
+
+/// Helper function to [`handle_obsolete`]
+/// Filters out obsolete lines option from args
+fn filter_args(
+ os_slice: OsString,
+ obs_lines: &mut Option<String>,
+ preceding_long_opt_req_value: &mut bool,
+ preceding_short_opt_req_value: &mut bool,
+) -> Option<OsString> {
+ let filter: Option<OsString>;
+ if let Some(slice) = os_slice.to_str() {
+ if should_extract_obs_lines(
+ slice,
+ preceding_long_opt_req_value,
+ preceding_short_opt_req_value,
+ ) {
+ // start of the short option string
+ // that can have obsolete lines option value in it
+ filter = handle_extract_obs_lines(slice, obs_lines);
+ } else {
+ // either not a short option
+ // or a short option that cannot have obsolete lines value in it
+ filter = Some(OsString::from(slice));
+ }
+ handle_preceding_options(
+ slice,
+ preceding_long_opt_req_value,
+ preceding_short_opt_req_value,
+ );
+ } else {
+ // Cannot cleanly convert os_slice to UTF-8
+ // Do not process and return as-is
+ // This will cause failure later on, but we should not handle it here
+ // and let clap panic on invalid UTF-8 argument
+ filter = Some(os_slice);
+ }
+ filter
+}
+
+/// Helper function to [`filter_args`]
+/// Checks if the slice is a true short option (and not hyphen prefixed value of an option)
+/// and if so, a short option that can contain obsolete lines value
+fn should_extract_obs_lines(
+ slice: &str,
+ preceding_long_opt_req_value: &bool,
+ preceding_short_opt_req_value: &bool,
+) -> bool {
+ slice.starts_with('-')
+ && !slice.starts_with("--")
+ && !preceding_long_opt_req_value
+ && !preceding_short_opt_req_value
+ && !slice.starts_with("-a")
+ && !slice.starts_with("-b")
+ && !slice.starts_with("-C")
+ && !slice.starts_with("-l")
+ && !slice.starts_with("-n")
+ && !slice.starts_with("-t")
+}
+
+/// Helper function to [`filter_args`]
+/// Extracts obsolete lines numeric part from argument slice
+/// and filters it out
+fn handle_extract_obs_lines(slice: &str, obs_lines: &mut Option<String>) -> Option<OsString> {
+ let mut obs_lines_extracted: Vec<char> = vec![];
+ let mut obs_lines_end_reached = false;
+ let filtered_slice: Vec<char> = slice
+ .chars()
+ .filter(|c| {
+ // To correctly process scenario like '-x200a4'
+ // we need to stop extracting digits once alphabetic character is encountered
+ // after we already have something in obs_lines_extracted
+ if c.is_ascii_digit() && !obs_lines_end_reached {
+ obs_lines_extracted.push(*c);
+ false
+ } else {
+ if !obs_lines_extracted.is_empty() {
+ obs_lines_end_reached = true;
+ }
+ true
+ }
+ })
+ .collect();
+
+ if obs_lines_extracted.is_empty() {
+ // no obsolete lines value found/extracted
+ Some(OsString::from(slice))
+ } else {
+ // obsolete lines value was extracted
+ let extracted: String = obs_lines_extracted.iter().collect();
+ *obs_lines = Some(extracted);
+ if filtered_slice.get(1).is_some() {
+ // there were some short options in front of or after obsolete lines value
+ // i.e. '-xd100' or '-100de' or similar, which after extraction of obsolete lines value
+ // would look like '-xd' or '-de' or similar
+ let filtered_slice: String = filtered_slice.iter().collect();
+ Some(OsString::from(filtered_slice))
+ } else {
+ None
+ }
+ }
+}
+
+/// Helper function to [`handle_extract_obs_lines`]
+/// Captures if current slice is a preceding option
+/// that requires value
+fn handle_preceding_options(
+ slice: &str,
+ preceding_long_opt_req_value: &mut bool,
+ preceding_short_opt_req_value: &mut bool,
+) {
+ // capture if current slice is a preceding long option that requires value and does not use '=' to assign that value
+ // following slice should be treaded as value for this option
+ // even if it starts with '-' (which would be treated as hyphen prefixed value)
+ if slice.starts_with("--") {
+ *preceding_long_opt_req_value = &slice[2..] == OPT_BYTES
+ || &slice[2..] == OPT_LINE_BYTES
+ || &slice[2..] == OPT_LINES
+ || &slice[2..] == OPT_ADDITIONAL_SUFFIX
+ || &slice[2..] == OPT_FILTER
+ || &slice[2..] == OPT_NUMBER
+ || &slice[2..] == OPT_SUFFIX_LENGTH
+ || &slice[2..] == OPT_SEPARATOR;
+ }
+ // capture if current slice is a preceding short option that requires value and does not have value in the same slice (value separated by whitespace)
+ // following slice should be treaded as value for this option
+ // even if it starts with '-' (which would be treated as hyphen prefixed value)
+ *preceding_short_opt_req_value = slice == "-b"
+ || slice == "-C"
+ || slice == "-l"
+ || slice == "-n"
+ || slice == "-a"
+ || slice == "-t";
+ // slice is a value
+ // reset preceding option flags
+ if !slice.starts_with('-') {
+ *preceding_short_opt_req_value = false;
+ *preceding_long_opt_req_value = false;
}
}
pub fn uu_app() -> Command {
Command::new(uucore::util_name())
.version(crate_version!())
- .about("Create output files containing consecutive or interleaved sections of input")
+ .about(ABOUT)
.after_help(AFTER_HELP)
.override_usage(format_usage(USAGE))
.infer_long_args(true)
@@ -75,6 +238,7 @@ pub fn uu_app() -> Command {
Arg::new(OPT_BYTES)
.short('b')
.long(OPT_BYTES)
+ .allow_hyphen_values(true)
.value_name("SIZE")
.help("put SIZE bytes per output file"),
)
@@ -82,14 +246,15 @@ pub fn uu_app() -> Command {
Arg::new(OPT_LINE_BYTES)
.short('C')
.long(OPT_LINE_BYTES)
+ .allow_hyphen_values(true)
.value_name("SIZE")
- .default_value("2")
.help("put at most SIZE bytes of lines per output file"),
)
.arg(
Arg::new(OPT_LINES)
.short('l')
.long(OPT_LINES)
+ .allow_hyphen_values(true)
.value_name("NUMBER")
.default_value("1000")
.help("put NUMBER lines/records per output file"),
@@ -98,6 +263,7 @@ pub fn uu_app() -> Command {
Arg::new(OPT_NUMBER)
.short('n')
.long(OPT_NUMBER)
+ .allow_hyphen_values(true)
.value_name("CHUNKS")
.help("generate CHUNKS output files; see explanation below"),
)
@@ -105,6 +271,7 @@ pub fn uu_app() -> Command {
.arg(
Arg::new(OPT_ADDITIONAL_SUFFIX)
.long(OPT_ADDITIONAL_SUFFIX)
+ .allow_hyphen_values(true)
.value_name("SUFFIX")
.default_value("")
.help("additional SUFFIX to append to output file names"),
@@ -112,8 +279,9 @@ pub fn uu_app() -> Command {
.arg(
Arg::new(OPT_FILTER)
.long(OPT_FILTER)
+ .allow_hyphen_values(true)
.value_name("COMMAND")
- .value_hint(clap::ValueHint::CommandName)
+ .value_hint(ValueHint::CommandName)
.help(
"write to shell COMMAND; file name is $FILE (Currently not implemented for Windows)",
),
@@ -126,28 +294,64 @@ pub fn uu_app() -> Command {
.action(ArgAction::SetTrue),
)
.arg(
- Arg::new(OPT_NUMERIC_SUFFIXES)
+ Arg::new(OPT_NUMERIC_SUFFIXES_SHORT)
.short('d')
+ .action(ArgAction::SetTrue)
+ .overrides_with_all([
+ OPT_NUMERIC_SUFFIXES,
+ OPT_NUMERIC_SUFFIXES_SHORT,
+ OPT_HEX_SUFFIXES,
+ OPT_HEX_SUFFIXES_SHORT
+ ])
+ .help("use numeric suffixes starting at 0, not alphabetic"),
+ )
+ .arg(
+ Arg::new(OPT_NUMERIC_SUFFIXES)
.long(OPT_NUMERIC_SUFFIXES)
- .default_missing_value("0")
+ .require_equals(true)
.num_args(0..=1)
- .help("use numeric suffixes instead of alphabetic"),
+ .overrides_with_all([
+ OPT_NUMERIC_SUFFIXES,
+ OPT_NUMERIC_SUFFIXES_SHORT,
+ OPT_HEX_SUFFIXES,
+ OPT_HEX_SUFFIXES_SHORT
+ ])
+ .value_name("FROM")
+ .help("same as -d, but allow setting the start value"),
)
.arg(
- Arg::new(OPT_SUFFIX_LENGTH)
- .short('a')
- .long(OPT_SUFFIX_LENGTH)
- .value_name("N")
- .default_value(OPT_DEFAULT_SUFFIX_LENGTH)
- .help("use suffixes of fixed length N. 0 implies dynamic length."),
+ Arg::new(OPT_HEX_SUFFIXES_SHORT)
+ .short('x')
+ .action(ArgAction::SetTrue)
+ .overrides_with_all([
+ OPT_NUMERIC_SUFFIXES,
+ OPT_NUMERIC_SUFFIXES_SHORT,
+ OPT_HEX_SUFFIXES,
+ OPT_HEX_SUFFIXES_SHORT
+ ])
+ .help("use hex suffixes starting at 0, not alphabetic"),
)
.arg(
Arg::new(OPT_HEX_SUFFIXES)
- .short('x')
.long(OPT_HEX_SUFFIXES)
- .default_missing_value("0")
+ .require_equals(true)
.num_args(0..=1)
- .help("use hex suffixes instead of alphabetic"),
+ .overrides_with_all([
+ OPT_NUMERIC_SUFFIXES,
+ OPT_NUMERIC_SUFFIXES_SHORT,
+ OPT_HEX_SUFFIXES,
+ OPT_HEX_SUFFIXES_SHORT
+ ])
+ .value_name("FROM")
+ .help("same as -x, but allow setting the start value"),
+ )
+ .arg(
+ Arg::new(OPT_SUFFIX_LENGTH)
+ .short('a')
+ .long(OPT_SUFFIX_LENGTH)
+ .allow_hyphen_values(true)
+ .value_name("N")
+ .help("generate suffixes of length N (default 2)"),
)
.arg(
Arg::new(OPT_VERBOSE)
@@ -156,10 +360,13 @@ pub fn uu_app() -> Command {
.action(ArgAction::SetTrue),
)
.arg(
- Arg::new(OPT_IO)
- .long("io")
- .alias(OPT_IO)
- .hide(true),
+ Arg::new(OPT_SEPARATOR)
+ .short('t')
+ .long(OPT_SEPARATOR)
+ .allow_hyphen_values(true)
+ .value_name("SEP")
+ .action(ArgAction::Append)
+ .help("use SEP instead of newline as the record separator; '\\0' (zero) specifies the NUL character"),
)
.arg(
Arg::new(OPT_IO_BLKSIZE)
@@ -170,7 +377,7 @@ pub fn uu_app() -> Command {
.arg(
Arg::new(ARG_INPUT)
.default_value("-")
- .value_hint(clap::ValueHint::FilePath),
+ .value_hint(ValueHint::FilePath),
)
.arg(
Arg::new(ARG_PREFIX)
@@ -178,260 +385,19 @@ pub fn uu_app() -> Command {
)
}
-/// Sub-strategy to use when splitting a file into a specific number of chunks.
-#[derive(Debug, PartialEq)]
-enum NumberType {
- /// Split into a specific number of chunks by byte.
- Bytes(u64),
-
- /// Split into a specific number of chunks by line (approximately).
- Lines(u64),
-
- /// Split into a specific number of chunks by line
- /// (approximately), but output only the *k*th chunk.
- KthLines(u64, u64),
-
- /// Assign lines via round-robin to the specified number of output chunks.
- RoundRobin(u64),
-
- /// Assign lines via round-robin to the specified number of output
- /// chunks, but output only the *k*th chunk.
- KthRoundRobin(u64, u64),
-}
-
-impl NumberType {
- /// The number of chunks for this number type.
- fn num_chunks(&self) -> u64 {
- match self {
- Self::Bytes(n) => *n,
- Self::Lines(n) => *n,
- Self::KthLines(_, n) => *n,
- Self::RoundRobin(n) => *n,
- Self::KthRoundRobin(_, n) => *n,
- }
- }
-}
-
-/// An error due to an invalid parameter to the `-n` command-line option.
-#[derive(Debug, PartialEq)]
-enum NumberTypeError {
- /// The number of chunks was invalid.
- ///
- /// This can happen if the value of `N` in any of the following
- /// command-line options is not a positive integer:
- ///
- /// ```ignore
- /// -n N
- /// -n l/N
- /// -n l/K/N
- /// -n r/N
- /// -n r/K/N
- /// ```
- NumberOfChunks(String),
-
- /// The chunk number was invalid.
- ///
- /// This can happen if the value of `K` in any of the following
- /// command-line options is not a positive integer:
- ///
- /// ```ignore
- /// -n l/K/N
- /// -n r/K/N
- /// ```
- ChunkNumber(String),
-}
-
-impl NumberType {
- /// Parse a `NumberType` from a string.
- ///
- /// The following strings are valid arguments:
- ///
- /// ```ignore
- /// "N"
- /// "l/N"
- /// "l/K/N"
- /// "r/N"
- /// "r/K/N"
- /// ```
- ///
- /// The `N` represents the number of chunks and the `K` represents
- /// a chunk number.
- ///
- /// # Errors
- ///
- /// If the string is not one of the valid number types, if `K` is
- /// not a nonnegative integer, or if `N` is not a positive
- /// integer, then this function returns [`NumberTypeError`].
- fn from(s: &str) -> Result<Self, NumberTypeError> {
- let parts: Vec<&str> = s.split('/').collect();
- match &parts[..] {
- [n_str] => {
- let num_chunks = n_str
- .parse()
- .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
- Ok(Self::Bytes(num_chunks))
- }
- ["l", n_str] => {
- let num_chunks = n_str
- .parse()
- .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
- Ok(Self::Lines(num_chunks))
- }
- ["l", k_str, n_str] => {
- let num_chunks = n_str
- .parse()
- .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
- let chunk_number = k_str
- .parse()
- .map_err(|_| NumberTypeError::ChunkNumber(k_str.to_string()))?;
- Ok(Self::KthLines(chunk_number, num_chunks))
- }
- ["r", n_str] => {
- let num_chunks = n_str
- .parse()
- .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
- Ok(Self::RoundRobin(num_chunks))
- }
- ["r", k_str, n_str] => {
- let num_chunks = n_str
- .parse()
- .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
- let chunk_number = k_str
- .parse()
- .map_err(|_| NumberTypeError::ChunkNumber(k_str.to_string()))?;
- Ok(Self::KthRoundRobin(chunk_number, num_chunks))
- }
- _ => Err(NumberTypeError::NumberOfChunks(s.to_string())),
- }
- }
-}
-
-/// The strategy for breaking up the input file into chunks.
-enum Strategy {
- /// Each chunk has the specified number of lines.
- Lines(u64),
-
- /// Each chunk has the specified number of bytes.
- Bytes(u64),
-
- /// Each chunk has as many lines as possible without exceeding the
- /// specified number of bytes.
- LineBytes(u64),
-
- /// Split the file into this many chunks.
- ///
- /// There are several sub-strategies available, as defined by
- /// [`NumberType`].
- Number(NumberType),
-}
-
-/// An error when parsing a chunking strategy from command-line arguments.
-enum StrategyError {
- /// Invalid number of lines.
- Lines(ParseSizeError),
-
- /// Invalid number of bytes.
- Bytes(ParseSizeError),
-
- /// Invalid number type.
- NumberType(NumberTypeError),
-
- /// Multiple chunking strategies were specified (but only one should be).
- MultipleWays,
-}
-
-impl fmt::Display for StrategyError {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- match self {
- Self::Lines(e) => write!(f, "invalid number of lines: {}", e),
- Self::Bytes(e) => write!(f, "invalid number of bytes: {}", e),
- Self::NumberType(NumberTypeError::NumberOfChunks(s)) => {
- write!(f, "invalid number of chunks: {}", s)
- }
- Self::NumberType(NumberTypeError::ChunkNumber(s)) => {
- write!(f, "invalid chunk number: {}", s)
- }
- Self::MultipleWays => write!(f, "cannot split in more than one way"),
- }
- }
-}
-
-impl Strategy {
- /// Parse a strategy from the command-line arguments.
- fn from(matches: &ArgMatches) -> Result<Self, StrategyError> {
- // Check that the user is not specifying more than one strategy.
- //
- // Note: right now, this exact behavior cannot be handled by
- // `ArgGroup` since `ArgGroup` considers a default value `Arg`
- // as "defined".
- match (
- matches.value_source(OPT_LINES) == Some(ValueSource::CommandLine),
- matches.value_source(OPT_BYTES) == Some(ValueSource::CommandLine),
- matches.value_source(OPT_LINE_BYTES) == Some(ValueSource::CommandLine),
- matches.value_source(OPT_NUMBER) == Some(ValueSource::CommandLine),
- ) {
- (false, false, false, false) => Ok(Self::Lines(1000)),
- (true, false, false, false) => {
- let s = matches.get_one::<String>(OPT_LINES).unwrap();
- let n = parse_size(s).map_err(StrategyError::Lines)?;
- Ok(Self::Lines(n))
- }
- (false, true, false, false) => {
- let s = matches.get_one::<String>(OPT_BYTES).unwrap();
- let n = parse_size(s).map_err(StrategyError::Bytes)?;
- Ok(Self::Bytes(n))
- }
- (false, false, true, false) => {
- let s = matches.get_one::<String>(OPT_LINE_BYTES).unwrap();
- let n = parse_size(s).map_err(StrategyError::Bytes)?;
- Ok(Self::LineBytes(n))
- }
- (false, false, false, true) => {
- let s = matches.get_one::<String>(OPT_NUMBER).unwrap();
- let number_type = NumberType::from(s).map_err(StrategyError::NumberType)?;
- Ok(Self::Number(number_type))
- }
- _ => Err(StrategyError::MultipleWays),
- }
- }
-}
-
-/// Parse the suffix type from the command-line arguments.
-fn suffix_type_from(matches: &ArgMatches) -> Result<(SuffixType, usize), SettingsError> {
- if matches.value_source(OPT_NUMERIC_SUFFIXES) == Some(ValueSource::CommandLine) {
- let suffix_start = matches.get_one::<String>(OPT_NUMERIC_SUFFIXES);
- let suffix_start = suffix_start.ok_or(SettingsError::SuffixNotParsable(String::new()))?;
- let suffix_start = suffix_start
- .parse()
- .map_err(|_| SettingsError::SuffixNotParsable(suffix_start.to_string()))?;
- Ok((SuffixType::Decimal, suffix_start))
- } else if matches.value_source(OPT_HEX_SUFFIXES) == Some(ValueSource::CommandLine) {
- let suffix_start = matches.get_one::<String>(OPT_HEX_SUFFIXES);
- let suffix_start = suffix_start.ok_or(SettingsError::SuffixNotParsable(String::new()))?;
- let suffix_start = usize::from_str_radix(suffix_start, 16)
- .map_err(|_| SettingsError::SuffixNotParsable(suffix_start.to_string()))?;
- Ok((SuffixType::Hexadecimal, suffix_start))
- } else {
- // no numeric/hex suffix
- Ok((SuffixType::Alphabetic, 0))
- }
-}
-
/// Parameters that control how a file gets split.
///
/// You can convert an [`ArgMatches`] instance into a [`Settings`]
/// instance by calling [`Settings::from`].
struct Settings {
prefix: String,
- suffix_type: SuffixType,
- suffix_length: usize,
- suffix_start: usize,
- additional_suffix: String,
+ suffix: Suffix,
input: String,
/// When supplied, a shell command to output to instead of xaa, xab …
filter: Option<String>,
strategy: Strategy,
verbose: bool,
+ separator: u8,
/// Whether to *not* produce empty files when using `-n`.
///
@@ -442,6 +408,7 @@ struct Settings {
/// chunks. If this is `false`, then empty files will not be
/// created.
elide_empty_files: bool,
+ io_blksize: Option<u64>,
}
/// An error when parsing settings from command-line arguments.
@@ -450,13 +417,22 @@ enum SettingsError {
Strategy(StrategyError),
/// Invalid suffix length parameter.
- SuffixNotParsable(String),
+ Suffix(SuffixError),
- /// Suffix contains a directory separator, which is not allowed.
- SuffixContainsSeparator(String),
+ /// Multi-character (Invalid) separator
+ MultiCharacterSeparator(String),
- /// Suffix is not large enough to split into specified chunks
- SuffixTooSmall(usize),
+ /// Multiple different separator characters
+ MultipleSeparatorCharacters,
+
+ /// Using `--filter` with `--number` option sub-strategies that print Kth chunk out of N chunks to stdout
+ /// K/N
+ /// l/K/N
+ /// r/K/N
+ FilterWithKthChunkNumber,
+
+ /// Invalid IO block size
+ InvalidIOBlockSize(String),
/// The `--filter` option is not supported on Windows.
#[cfg(windows)]
@@ -468,7 +444,8 @@ impl SettingsError {
fn requires_usage(&self) -> bool {
matches!(
self,
- Self::Strategy(StrategyError::MultipleWays) | Self::SuffixContainsSeparator(_)
+ Self::Strategy(StrategyError::MultipleWays)
+ | Self::Suffix(SuffixError::ContainsSeparator(_))
)
}
}
@@ -477,18 +454,21 @@ impl fmt::Display for SettingsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
Self::Strategy(e) => e.fmt(f),
- Self::SuffixNotParsable(s) => write!(f, "invalid suffix length: {}", s.quote()),
- Self::SuffixTooSmall(i) => write!(f, "the suffix length needs to be at least {}", i),
- Self::SuffixContainsSeparator(s) => write!(
- f,
- "invalid suffix {}, contains directory separator",
- s.quote()
- ),
+ Self::Suffix(e) => e.fmt(f),
+ Self::MultiCharacterSeparator(s) => {
+ write!(f, "multi-character separator {}", s.quote())
+ }
+ Self::MultipleSeparatorCharacters => {
+ write!(f, "multiple separator characters specified")
+ }
+ Self::FilterWithKthChunkNumber => {
+ write!(f, "--filter does not process a chunk extracted to stdout")
+ }
+ Self::InvalidIOBlockSize(s) => write!(f, "invalid IO block size: {}", s.quote()),
#[cfg(windows)]
Self::NotSupported => write!(
f,
- "{} is currently not supported in this platform",
- OPT_FILTER
+ "{OPT_FILTER} is currently not supported in this platform"
),
}
}
@@ -496,62 +476,218 @@ impl fmt::Display for SettingsError {
impl Settings {
/// Parse a strategy from the command-line arguments.
- fn from(matches: &ArgMatches) -> Result<Self, SettingsError> {
- let additional_suffix = matches
- .get_one::<String>(OPT_ADDITIONAL_SUFFIX)
- .unwrap()
- .to_string();
- if additional_suffix.contains('/') {
- return Err(SettingsError::SuffixContainsSeparator(additional_suffix));
- }
- let strategy = Strategy::from(matches).map_err(SettingsError::Strategy)?;
- let (suffix_type, suffix_start) = suffix_type_from(matches)?;
- let suffix_length_str = matches.get_one::<String>(OPT_SUFFIX_LENGTH).unwrap();
- let suffix_length: usize = suffix_length_str
- .parse()
- .map_err(|_| SettingsError::SuffixNotParsable(suffix_length_str.to_string()))?;
- if let Strategy::Number(ref number_type) = strategy {
- let chunks = number_type.num_chunks();
- if suffix_length != 0 {
- let required_suffix_length =
- (chunks as f64).log(suffix_type.radix() as f64).ceil() as usize;
- if suffix_length < required_suffix_length {
- return Err(SettingsError::SuffixTooSmall(required_suffix_length));
+ fn from(matches: &ArgMatches, obs_lines: &Option<String>) -> Result<Self, SettingsError> {
+ let strategy = Strategy::from(matches, obs_lines).map_err(SettingsError::Strategy)?;
+ let suffix = Suffix::from(matches, &strategy).map_err(SettingsError::Suffix)?;
+
+ // Make sure that separator is only one UTF8 character (if specified)
+ // defaults to '\n' - newline character
+ // If the same separator (the same value) was used multiple times - `split` should NOT fail
+ // If the separator was used multiple times but with different values (not all values are the same) - `split` should fail
+ let separator = match matches.get_many::<String>(OPT_SEPARATOR) {
+ Some(mut sep_values) => {
+ let first = sep_values.next().unwrap(); // it is safe to just unwrap here since Clap should not return empty ValuesRef<'_,String> in the option from get_many() call
+ if !sep_values.all(|s| s == first) {
+ return Err(SettingsError::MultipleSeparatorCharacters);
+ }
+ match first.as_str() {
+ "\\0" => b'\0',
+ s if s.as_bytes().len() == 1 => s.as_bytes()[0],
+ s => return Err(SettingsError::MultiCharacterSeparator(s.to_string())),
}
}
- }
+ None => b'\n',
+ };
+
+ let io_blksize: Option<u64> = if let Some(s) = matches.get_one::<String>(OPT_IO_BLKSIZE) {
+ match parse_size_u64(s) {
+ Ok(0) => return Err(SettingsError::InvalidIOBlockSize(s.to_string())),
+ Ok(n) if n <= uucore::fs::sane_blksize::MAX => Some(n),
+ _ => return Err(SettingsError::InvalidIOBlockSize(s.to_string())),
+ }
+ } else {
+ None
+ };
+
let result = Self {
- suffix_length: suffix_length_str
- .parse()
- .map_err(|_| SettingsError::SuffixNotParsable(suffix_length_str.to_string()))?,
- suffix_type,
- suffix_start,
- additional_suffix,
- verbose: matches.value_source("verbose") == Some(ValueSource::CommandLine),
+ prefix: matches.get_one::<String>(ARG_PREFIX).unwrap().clone(),
+ suffix,
+ input: matches.get_one::<String>(ARG_INPUT).unwrap().clone(),
+ filter: matches.get_one::<String>(OPT_FILTER).cloned(),
strategy,
- input: matches.get_one::<String>(ARG_INPUT).unwrap().to_owned(),
- prefix: matches.get_one::<String>(ARG_PREFIX).unwrap().to_owned(),
- filter: matches.get_one::<String>(OPT_FILTER).map(|s| s.to_owned()),
+ verbose: matches.value_source(OPT_VERBOSE) == Some(ValueSource::CommandLine),
+ separator,
elide_empty_files: matches.get_flag(OPT_ELIDE_EMPTY_FILES),
+ io_blksize,
};
+
#[cfg(windows)]
if result.filter.is_some() {
// see https://github.com/rust-lang/rust/issues/29494
return Err(SettingsError::NotSupported);
}
+ // Return an error if `--filter` option is used with any of the
+ // Kth chunk sub-strategies of `--number` option
+ // As those are writing to stdout of `split` and cannot write to filter command child process
+ let kth_chunk = matches!(
+ result.strategy,
+ Strategy::Number(NumberType::KthBytes(_, _))
+ | Strategy::Number(NumberType::KthLines(_, _))
+ | Strategy::Number(NumberType::KthRoundRobin(_, _))
+ );
+ if kth_chunk && result.filter.is_some() {
+ return Err(SettingsError::FilterWithKthChunkNumber);
+ }
+
Ok(result)
}
- fn instantiate_current_writer(&self, filename: &str) -> io::Result<BufWriter<Box<dyn Write>>> {
+ fn instantiate_current_writer(
+ &self,
+ filename: &str,
+ is_new: bool,
+ ) -> io::Result<BufWriter<Box<dyn Write>>> {
if platform::paths_refer_to_same_file(&self.input, filename) {
return Err(io::Error::new(
ErrorKind::Other,
- format!("'{}' would overwrite input; aborting", filename),
+ format!("'{filename}' would overwrite input; aborting"),
));
}
- platform::instantiate_current_writer(&self.filter, filename)
+ platform::instantiate_current_writer(&self.filter, filename, is_new)
+ }
+}
+
+/// When using `--filter` option, writing to child command process stdin
+/// could fail with BrokenPipe error
+/// It can be safely ignored
+fn ignorable_io_error(error: &std::io::Error, settings: &Settings) -> bool {
+ error.kind() == ErrorKind::BrokenPipe && settings.filter.is_some()
+}
+
+/// Custom wrapper for `write()` method
+/// Follows similar approach to GNU implementation
+/// If ignorable io error occurs, return number of bytes as if all bytes written
+/// Should not be used for Kth chunk number sub-strategies
+/// as those do not work with `--filter` option
+fn custom_write<T: Write>(
+ bytes: &[u8],
+ writer: &mut T,
+ settings: &Settings,
+) -> std::io::Result<usize> {
+ match writer.write(bytes) {
+ Ok(n) => Ok(n),
+ Err(e) if ignorable_io_error(&e, settings) => Ok(bytes.len()),
+ Err(e) => Err(e),
+ }
+}
+
+/// Custom wrapper for `write_all()` method
+/// Similar to [`custom_write`], but returns true or false
+/// depending on if `--filter` stdin is still open (no BrokenPipe error)
+/// Should not be used for Kth chunk number sub-strategies
+/// as those do not work with `--filter` option
+fn custom_write_all<T: Write>(
+ bytes: &[u8],
+ writer: &mut T,
+ settings: &Settings,
+) -> std::io::Result<bool> {
+ match writer.write_all(bytes) {
+ Ok(()) => Ok(true),
+ Err(e) if ignorable_io_error(&e, settings) => Ok(false),
+ Err(e) => Err(e),
+ }
+}
+
+/// Get the size of the input file in bytes
+/// Used only for subset of `--number=CHUNKS` strategy, as there is a need
+/// to determine input file size upfront in order to estimate the chunk size
+/// to be written into each of N files/chunks:
+/// * N split into N files based on size of input
+/// * K/N output Kth of N to stdout
+/// * l/N split into N files without splitting lines/records
+/// * l/K/N output Kth of N to stdout without splitting lines/records
+///
+/// For most files the size will be determined by either reading entire file content into a buffer
+/// or by `len()` function of [`std::fs::metadata`].
+///
+/// However, for some files which report filesystem metadata size that does not match
+/// their actual content size, we will need to attempt to find the end of file
+/// with direct `seek()` on [`std::fs::File`].
+///
+/// For STDIN stream - read into a buffer up to a limit
+/// If input stream does not EOF before that - return an error
+/// (i.e. "infinite" input as in `cat /dev/zero | split ...`, `yes | split ...` etc.).
+///
+/// Note: The `buf` might end up with either partial or entire input content.
+fn get_input_size<R>(
+ input: &String,
+ reader: &mut R,
+ buf: &mut Vec<u8>,
+ io_blksize: &Option<u64>,
+) -> std::io::Result<u64>
+where
+ R: BufRead,
+{
+ // Set read limit to io_blksize if specified
+ let read_limit: u64 = if let Some(custom_blksize) = io_blksize {
+ *custom_blksize
+ } else {
+ // otherwise try to get it from filesystem, or use default
+ uucore::fs::sane_blksize::sane_blksize_from_path(Path::new(input))
+ };
+
+ // Try to read into buffer up to a limit
+ let num_bytes = reader
+ .by_ref()
+ .take(read_limit)
+ .read_to_end(buf)
+ .map(|n| n as u64)?;
+
+ if num_bytes < read_limit {
+ // Finite file or STDIN stream that fits entirely
+ // into a buffer within the limit
+ // Note: files like /dev/null or similar,
+ // empty STDIN stream,
+ // and files with true file size 0
+ // will also fit here
+ Ok(num_bytes)
+ } else if input == "-" {
+ // STDIN stream that did not fit all content into a buffer
+ // Most likely continuous/infinite input stream
+ return Err(io::Error::new(
+ ErrorKind::Other,
+ format!("{}: cannot determine input size", input),
+ ));
+ } else {
+ // Could be that file size is larger than set read limit
+ // Get the file size from filesystem metadata
+ let metadata = metadata(input)?;
+ let metadata_size = metadata.len();
+ if num_bytes <= metadata_size {
+ Ok(metadata_size)
+ } else {
+ // Could be a file from locations like /dev, /sys, /proc or similar
+ // which report filesystem metadata size that does not match
+ // their actual content size
+ // Attempt direct `seek()` for the end of a file
+ let mut tmp_fd = File::open(Path::new(input))?;
+ let end = tmp_fd.seek(SeekFrom::End(0))?;
+ if end > 0 {
+ Ok(end)
+ } else {
+ // Edge case of either "infinite" file (i.e. /dev/zero)
+ // or some other "special" non-standard file type
+ // Give up and return an error
+ // TODO It might be possible to do more here
+ // to address all possible file types and edge cases
+ return Err(io::Error::new(
+ ErrorKind::Other,
+ format!("{}: cannot determine file size", input),
+ ));
+ }
+ }
}
}
@@ -592,21 +728,15 @@ struct ByteChunkWriter<'a> {
}
impl<'a> ByteChunkWriter<'a> {
- fn new(chunk_size: u64, settings: &'a Settings) -> UResult<ByteChunkWriter<'a>> {
- let mut filename_iterator = FilenameIterator::new(
- &settings.prefix,
- &settings.additional_suffix,
- settings.suffix_length,
- settings.suffix_type,
- settings.suffix_start,
- )?;
+ fn new(chunk_size: u64, settings: &'a Settings) -> UResult<Self> {
+ let mut filename_iterator = FilenameIterator::new(&settings.prefix, &settings.suffix)?;
let filename = filename_iterator
.next()
.ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?;
if settings.verbose {
println!("creating file {}", filename.quote());
}
- let inner = settings.instantiate_current_writer(&filename)?;
+ let inner = settings.instantiate_current_writer(&filename, true)?;
Ok(ByteChunkWriter {
settings,
chunk_size,
@@ -619,6 +749,7 @@ impl<'a> ByteChunkWriter<'a> {
}
impl<'a> Write for ByteChunkWriter<'a> {
+ /// Implements `--bytes=SIZE`
fn write(&mut self, mut buf: &[u8]) -> std::io::Result<usize> {
// If the length of `buf` exceeds the number of bytes remaining
// in the current chunk, we will need to write to multiple
@@ -643,16 +774,16 @@ impl<'a> Write for ByteChunkWriter<'a> {
if self.settings.verbose {
println!("creating file {}", filename.quote());
}
- self.inner = self.settings.instantiate_current_writer(&filename)?;
+ self.inner = self.settings.instantiate_current_writer(&filename, true)?;
}
// If the capacity of this chunk is greater than the number of
// bytes in `buf`, then write all the bytes in `buf`. Otherwise,
// write enough bytes to fill the current chunk, then increment
// the chunk number and repeat.
- let n = buf.len();
- if (n as u64) < self.num_bytes_remaining_in_current_chunk {
- let num_bytes_written = self.inner.write(buf)?;
+ let buf_len = buf.len();
+ if (buf_len as u64) < self.num_bytes_remaining_in_current_chunk {
+ let num_bytes_written = custom_write(buf, &mut self.inner, self.settings)?;
self.num_bytes_remaining_in_current_chunk -= num_bytes_written as u64;
return Ok(carryover_bytes_written + num_bytes_written);
} else {
@@ -662,7 +793,7 @@ impl<'a> Write for ByteChunkWriter<'a> {
// self.num_bytes_remaining_in_current_chunk is lower than
// n, which is already usize.
let i = self.num_bytes_remaining_in_current_chunk as usize;
- let num_bytes_written = self.inner.write(&buf[..i])?;
+ let num_bytes_written = custom_write(&buf[..i], &mut self.inner, self.settings)?;
self.num_bytes_remaining_in_current_chunk -= num_bytes_written as u64;
// It's possible that the underlying writer did not
@@ -721,21 +852,15 @@ struct LineChunkWriter<'a> {
}
impl<'a> LineChunkWriter<'a> {
- fn new(chunk_size: u64, settings: &'a Settings) -> UResult<LineChunkWriter<'a>> {
- let mut filename_iterator = FilenameIterator::new(
- &settings.prefix,
- &settings.additional_suffix,
- settings.suffix_length,
- settings.suffix_type,
- settings.suffix_start,
- )?;
+ fn new(chunk_size: u64, settings: &'a Settings) -> UResult<Self> {
+ let mut filename_iterator = FilenameIterator::new(&settings.prefix, &settings.suffix)?;
let filename = filename_iterator
.next()
.ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?;
if settings.verbose {
println!("creating file {}", filename.quote());
}
- let inner = settings.instantiate_current_writer(&filename)?;
+ let inner = settings.instantiate_current_writer(&filename, true)?;
Ok(LineChunkWriter {
settings,
chunk_size,
@@ -748,6 +873,7 @@ impl<'a> LineChunkWriter<'a> {
}
impl<'a> Write for LineChunkWriter<'a> {
+ /// Implements `--lines=NUMBER`
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
// If the number of lines in `buf` exceeds the number of lines
// remaining in the current chunk, we will need to write to
@@ -756,7 +882,8 @@ impl<'a> Write for LineChunkWriter<'a> {
// corresponds to the current chunk number.
let mut prev = 0;
let mut total_bytes_written = 0;
- for i in memchr::memchr_iter(b'\n', buf) {
+ let sep = self.settings.separator;
+ for i in memchr::memchr_iter(sep, buf) {
// If we have exceeded the number of lines to write in the
// current chunk, then start a new chunk and its
// corresponding writer.
@@ -768,21 +895,22 @@ impl<'a> Write for LineChunkWriter<'a> {
if self.settings.verbose {
println!("creating file {}", filename.quote());
}
- self.inner = self.settings.instantiate_current_writer(&filename)?;
+ self.inner = self.settings.instantiate_current_writer(&filename, true)?;
self.num_lines_remaining_in_current_chunk = self.chunk_size;
}
// Write the line, starting from *after* the previous
- // newline character and ending *after* the current
- // newline character.
- let n = self.inner.write(&buf[prev..i + 1])?;
- total_bytes_written += n;
+ // separator character and ending *after* the current
+ // separator character.
+ let num_bytes_written = custom_write(&buf[prev..=i], &mut self.inner, self.settings)?;
+ total_bytes_written += num_bytes_written;
prev = i + 1;
self.num_lines_remaining_in_current_chunk -= 1;
}
- let n = self.inner.write(&buf[prev..buf.len()])?;
- total_bytes_written += n;
+ let num_bytes_written =
+ custom_write(&buf[prev..buf.len()], &mut self.inner, self.settings)?;
+ total_bytes_written += num_bytes_written;
Ok(total_bytes_written)
}
@@ -830,21 +958,15 @@ struct LineBytesChunkWriter<'a> {
}
impl<'a> LineBytesChunkWriter<'a> {
- fn new(chunk_size: u64, settings: &'a Settings) -> UResult<LineBytesChunkWriter<'a>> {
- let mut filename_iterator = FilenameIterator::new(
- &settings.prefix,
- &settings.additional_suffix,
- settings.suffix_length,
- settings.suffix_type,
- settings.suffix_start,
- )?;
+ fn new(chunk_size: u64, settings: &'a Settings) -> UResult<Self> {
+ let mut filename_iterator = FilenameIterator::new(&settings.prefix, &settings.suffix)?;
let filename = filename_iterator
.next()
.ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?;
if settings.verbose {
println!("creating file {}", filename.quote());
}
- let inner = settings.instantiate_current_writer(&filename)?;
+ let inner = settings.instantiate_current_writer(&filename, true)?;
Ok(LineBytesChunkWriter {
settings,
chunk_size,
@@ -879,6 +1001,8 @@ impl<'a> Write for LineBytesChunkWriter<'a> {
/// |------| |-------| |--------| |---|
/// aaaaaaaa a\nbbbb\n cccc\ndd\n ee\n
/// ```
+ ///
+ /// Implements `--line-bytes=SIZE`
fn write(&mut self, mut buf: &[u8]) -> std::io::Result<usize> {
// The total number of bytes written during the loop below.
//
@@ -908,49 +1032,55 @@ impl<'a> Write for LineBytesChunkWriter<'a> {
if self.settings.verbose {
println!("creating file {}", filename.quote());
}
- self.inner = self.settings.instantiate_current_writer(&filename)?;
+ self.inner = self.settings.instantiate_current_writer(&filename, true)?;
self.num_bytes_remaining_in_current_chunk = self.chunk_size.try_into().unwrap();
}
- // Find the first newline character in the buffer.
- match memchr::memchr(b'\n', buf) {
- // If there is no newline character and the buffer is
+ // Find the first separator (default - newline character) in the buffer.
+ let sep = self.settings.separator;
+ match memchr::memchr(sep, buf) {
+ // If there is no separator character and the buffer is
// not empty, then write as many bytes as we can and
// then move on to the next chunk if necessary.
None => {
let end = self.num_bytes_remaining_in_current_chunk;
// This is ugly but here to match GNU behavior. If the input
- // doesn't end with a \n, pretend that it does for handling
+ // doesn't end with a separator, pretend that it does for handling
// the second to last segment chunk. See `line-bytes.sh`.
if end == buf.len()
&& self.num_bytes_remaining_in_current_chunk
< self.chunk_size.try_into().unwrap()
- && buf[buf.len() - 1] != b'\n'
+ && buf[buf.len() - 1] != sep
{
self.num_bytes_remaining_in_current_chunk = 0;
} else {
- let num_bytes_written = self.inner.write(&buf[..end.min(buf.len())])?;
+ let num_bytes_written = custom_write(
+ &buf[..end.min(buf.len())],
+ &mut self.inner,
+ self.settings,
+ )?;
self.num_bytes_remaining_in_current_chunk -= num_bytes_written;
total_bytes_written += num_bytes_written;
buf = &buf[num_bytes_written..];
}
}
- // If there is a newline character and the line
- // (including the newline character) will fit in the
+ // If there is a separator character and the line
+ // (including the separator character) will fit in the
// current chunk, then write the entire line and
// continue to the next iteration. (See chunk 1 in the
// example comment above.)
Some(i) if i < self.num_bytes_remaining_in_current_chunk => {
- let num_bytes_written = self.inner.write(&buf[..i + 1])?;
+ let num_bytes_written =
+ custom_write(&buf[..=i], &mut self.inner, self.settings)?;
self.num_bytes_remaining_in_current_chunk -= num_bytes_written;
total_bytes_written += num_bytes_written;
buf = &buf[num_bytes_written..];
}
- // If there is a newline character, the line
- // (including the newline character) will not fit in
+ // If there is a separator character, the line
+ // (including the separator character) will not fit in
// the current chunk, *and* no other lines have been
// written to the current chunk, then write as many
// bytes as we can and continue to the next
@@ -961,14 +1091,15 @@ impl<'a> Write for LineBytesChunkWriter<'a> {
== self.chunk_size.try_into().unwrap() =>
{
let end = self.num_bytes_remaining_in_current_chunk;
- let num_bytes_written = self.inner.write(&buf[..end])?;
+ let num_bytes_written =
+ custom_write(&buf[..end], &mut self.inner, self.settings)?;
self.num_bytes_remaining_in_current_chunk -= num_bytes_written;
total_bytes_written += num_bytes_written;
buf = &buf[num_bytes_written..];
}
- // If there is a newline character, the line
- // (including the newline character) will not fit in
+ // If there is a separator character, the line
+ // (including the separator character) will not fit in
// the current chunk, and at least one other line has
// been written to the current chunk, then signal to
// the next iteration that a new chunk needs to be
@@ -986,47 +1117,212 @@ impl<'a> Write for LineBytesChunkWriter<'a> {
}
}
-/// Split a file into a specific number of chunks by byte.
+/// Output file parameters
+struct OutFile {
+ filename: String,
+ maybe_writer: Option<BufWriter<Box<dyn Write>>>,
+ is_new: bool,
+}
+
+/// A set of output files
+/// Used in [`n_chunks_by_byte`], [`n_chunks_by_line`]
+/// and [`n_chunks_by_line_round_robin`] functions.
+type OutFiles = Vec<OutFile>;
+trait ManageOutFiles {
+ fn instantiate_writer(
+ &mut self,
+ idx: usize,
+ settings: &Settings,
+ ) -> UResult<&mut BufWriter<Box<dyn Write>>>;
+ /// Initialize a new set of output files
+ /// Each OutFile is generated with filename, while the writer for it could be
+ /// optional, to be instantiated later by the calling function as needed.
+ /// Optional writers could happen in the following situations:
+ /// * in [`n_chunks_by_line`] and [`n_chunks_by_line_round_robin`] if `elide_empty_files` parameter is set to `true`
+ /// * if the number of files is greater than system limit for open files
+ fn init(num_files: u64, settings: &Settings, is_writer_optional: bool) -> UResult<Self>
+ where
+ Self: Sized;
+ /// Get the writer for the output file by index.
+ /// If system limit of open files has been reached
+ /// it will try to close one of previously instantiated writers
+ /// to free up resources and re-try instantiating current writer,
+ /// except for `--filter` mode.
+ /// The writers that get closed to free up resources for the current writer
+ /// are flagged as `is_new=false`, so they can be re-opened for appending
+ /// instead of created anew if we need to keep writing into them later,
+ /// i.e. in case of round robin distribution as in [`n_chunks_by_line_round_robin`]
+ fn get_writer(
+ &mut self,
+ idx: usize,
+ settings: &Settings,
+ ) -> UResult<&mut BufWriter<Box<dyn Write>>>;
+}
+
+impl ManageOutFiles for OutFiles {
+ fn init(num_files: u64, settings: &Settings, is_writer_optional: bool) -> UResult<Self> {
+ // This object is responsible for creating the filename for each chunk
+ let mut filename_iterator: FilenameIterator<'_> =
+ FilenameIterator::new(&settings.prefix, &settings.suffix)
+ .map_err(|e| io::Error::new(ErrorKind::Other, format!("{e}")))?;
+ let mut out_files: Self = Self::new();
+ for _ in 0..num_files {
+ let filename = filename_iterator
+ .next()
+ .ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?;
+ let maybe_writer = if is_writer_optional {
+ None
+ } else {
+ let instantiated = settings.instantiate_current_writer(filename.as_str(), true);
+ // If there was an error instantiating the writer for a file,
+ // it could be due to hitting the system limit of open files,
+ // so record it as None and let [`get_writer`] function handle closing/re-opening
+ // of writers as needed within system limits.
+ // However, for `--filter` child process writers - propagate the error,
+ // as working around system limits of open files for child shell processes
+ // is currently not supported (same as in GNU)
+ match instantiated {
+ Ok(writer) => Some(writer),
+ Err(e) if settings.filter.is_some() => {
+ return Err(e.into());
+ }
+ Err(_) => None,
+ }
+ };
+ out_files.push(OutFile {
+ filename,
+ maybe_writer,
+ is_new: true,
+ });
+ }
+ Ok(out_files)
+ }
+
+ fn instantiate_writer(
+ &mut self,
+ idx: usize,
+ settings: &Settings,
+ ) -> UResult<&mut BufWriter<Box<dyn Write>>> {
+ let mut count = 0;
+ // Use-case for doing multiple tries of closing fds:
+ // E.g. split running in parallel to other processes (e.g. another split) doing similar stuff,
+ // sharing the same limits. In this scenario, after closing one fd, the other process
+ // might "steel" the freed fd and open a file on its side. Then it would be beneficial
+ // if split would be able to close another fd before cancellation.
+ 'loop1: loop {
+ let filename_to_open = self[idx].filename.as_str();
+ let file_to_open_is_new = self[idx].is_new;
+ let maybe_writer =
+ settings.instantiate_current_writer(filename_to_open, file_to_open_is_new);
+ if let Ok(writer) = maybe_writer {
+ self[idx].maybe_writer = Some(writer);
+ return Ok(self[idx].maybe_writer.as_mut().unwrap());
+ }
+
+ if settings.filter.is_some() {
+ // Propagate error if in `--filter` mode
+ return Err(maybe_writer.err().unwrap().into());
+ }
+
+ // Could have hit system limit for open files.
+ // Try to close one previously instantiated writer first
+ for (i, out_file) in self.iter_mut().enumerate() {
+ if i != idx && out_file.maybe_writer.is_some() {
+ out_file.maybe_writer.as_mut().unwrap().flush()?;
+ out_file.maybe_writer = None;
+ out_file.is_new = false;
+ count += 1;
+
+ // And then try to instantiate the writer again
+ continue 'loop1;
+ }
+ }
+
+ // If this fails - give up and propagate the error
+ uucore::show_error!("at file descriptor limit, but no file descriptor left to close. Closed {count} writers before.");
+ return Err(maybe_writer.err().unwrap().into());
+ }
+ }
+
+ fn get_writer(
+ &mut self,
+ idx: usize,
+ settings: &Settings,
+ ) -> UResult<&mut BufWriter<Box<dyn Write>>> {
+ if self[idx].maybe_writer.is_some() {
+ Ok(self[idx].maybe_writer.as_mut().unwrap())
+ } else {
+ // Writer was not instantiated upfront or was temporarily closed due to system resources constraints.
+ // Instantiate it and record for future use.
+ self.instantiate_writer(idx, settings)
+ }
+ }
+}
+
+/// Split a file or STDIN into a specific number of chunks by byte.
+///
+/// When file size cannot be evenly divided into the number of chunks of the same size,
+/// the first X chunks are 1 byte longer than the rest,
+/// where X is a modulus reminder of (file size % number of chunks)
+///
+/// In Kth chunk of N mode - writes to STDOUT the contents of the chunk identified by `kth_chunk`
///
-/// This function always creates one output file for each chunk, even
+/// In N chunks mode - this function always creates one output file for each chunk, even
/// if there is an error reading or writing one of the chunks or if
-/// the input file is truncated. However, if the `filter` option is
-/// being used, then no files are created.
+/// the input file is truncated. However, if the `--filter` option is
+/// being used, then files will only be created if `$FILE` variable was used
+/// in filter command,
+/// i.e. `split -n 10 --filter='head -c1 > $FILE' in`
///
/// # Errors
///
/// This function returns an error if there is a problem reading from
-/// `reader` or writing to one of the output files.
-fn split_into_n_chunks_by_byte<R>(
+/// `reader` or writing to one of the output files or stdout.
+///
+/// # See also
+///
+/// * [`n_chunks_by_line`], which splits its input into a specific number of chunks by line.
+///
+/// Implements `--number=CHUNKS`
+/// Where CHUNKS
+/// * N
+/// * K/N
+fn n_chunks_by_byte<R>(
settings: &Settings,
reader: &mut R,
num_chunks: u64,
+ kth_chunk: Option<u64>,
) -> UResult<()>
where
- R: Read,
+ R: BufRead,
{
- // Get the size of the input file in bytes and compute the number
- // of bytes per chunk.
- //
+ // Get the size of the input in bytes
+ let initial_buf = &mut Vec::new();
+ let mut num_bytes = get_input_size(&settings.input, reader, initial_buf, &settings.io_blksize)?;
+ let mut reader = initial_buf.chain(reader);
+
+ // If input file is empty and we would not have determined the Kth chunk
+ // in the Kth chunk of N chunk mode, then terminate immediately.
+ // This happens on `split -n 3/10 /dev/null`, for example.
+ if kth_chunk.is_some() && num_bytes == 0 {
+ return Ok(());
+ }
+
// If the requested number of chunks exceeds the number of bytes
- // in the file *and* the `elide_empty_files` parameter is enabled,
- // then behave as if the number of chunks was set to the number of
- // bytes in the file. This ensures that we don't write empty
- // files. Otherwise, just write the `num_chunks - num_bytes` empty
- // files.
- let metadata = metadata(&settings.input).map_err(|_| {
- USimpleError::new(1, format!("{}: cannot determine file size", settings.input))
- })?;
-
- let num_bytes = metadata.len();
- let will_have_empty_files = settings.elide_empty_files && num_chunks > num_bytes;
- let (num_chunks, chunk_size) = if will_have_empty_files {
- let num_chunks = num_bytes;
- let chunk_size = 1;
- (num_chunks, chunk_size)
+ // in the input:
+ // * in Kth chunk of N mode - just write empty byte string to stdout
+ // NOTE: the `elide_empty_files` parameter is ignored here
+ // as we do not generate any files
+ // and instead writing to stdout
+ // * In N chunks mode - if the `elide_empty_files` parameter is enabled,
+ // then behave as if the number of chunks was set to the number of
+ // bytes in the file. This ensures that we don't write empty
+ // files. Otherwise, just write the `num_chunks - num_bytes` empty files.
+ let num_chunks = if kth_chunk.is_none() && settings.elide_empty_files && num_chunks > num_bytes
+ {
+ num_bytes
} else {
- let chunk_size = (num_bytes / (num_chunks)).max(1);
- (num_chunks, chunk_size)
+ num_chunks
};
// If we would have written zero chunks of output, then terminate
@@ -1036,63 +1332,92 @@ where
return Ok(());
}
- let num_chunks: usize = num_chunks
- .try_into()
- .map_err(|_| USimpleError::new(1, "Number of chunks too big"))?;
-
- // This object is responsible for creating the filename for each chunk.
- let mut filename_iterator = FilenameIterator::new(
- &settings.prefix,
- &settings.additional_suffix,
- settings.suffix_length,
- settings.suffix_type,
- settings.suffix_start,
- )?;
-
- // Create one writer for each chunk. This will create each
- // of the underlying files (if not in `--filter` mode).
- let mut writers = vec![];
- for _ in 0..num_chunks {
- let filename = filename_iterator
- .next()
- .ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?;
- let writer = settings.instantiate_current_writer(filename.as_str())?;
- writers.push(writer);
+ // In Kth chunk of N mode - we will write to stdout instead of to a file.
+ let mut stdout_writer = std::io::stdout().lock();
+ // In N chunks mode - we will write to `num_chunks` files
+ let mut out_files: OutFiles = OutFiles::new();
+
+ // Calculate chunk size base and modulo reminder
+ // to be used in calculating chunk_size later on
+ let chunk_size_base = num_bytes / num_chunks;
+ let chunk_size_reminder = num_bytes % num_chunks;
+
+ // If in N chunks mode
+ // Create one writer for each chunk.
+ // This will create each of the underlying files
+ // or stdin pipes to child shell/command processes if in `--filter` mode
+ if kth_chunk.is_none() {
+ out_files = OutFiles::init(num_chunks, settings, false)?;
}
- // Capture the result of the `std::io::copy()` calls to check for
- // `BrokenPipe`.
- let result: std::io::Result<()> = {
- // Write `chunk_size` bytes from the reader into each writer
- // except the last.
- //
- // The last writer gets all remaining bytes so that if the number
- // of bytes in the input file was not evenly divisible by
- // `num_chunks`, we don't leave any bytes behind.
- for writer in writers.iter_mut().take(num_chunks - 1) {
- io::copy(&mut reader.by_ref().take(chunk_size), writer)?;
- }
+ for i in 1_u64..=num_chunks {
+ let chunk_size = chunk_size_base + (chunk_size_reminder > i - 1) as u64;
+ let buf = &mut Vec::new();
+ if num_bytes > 0 {
+ // Read `chunk_size` bytes from the reader into `buf`
+ // except the last.
+ //
+ // The last chunk gets all remaining bytes so that if the number
+ // of bytes in the input file was not evenly divisible by
+ // `num_chunks`, we don't leave any bytes behind.
+ let limit = {
+ if i == num_chunks {
+ num_bytes
+ } else {
+ chunk_size
+ }
+ };
- // Write all the remaining bytes to the last chunk.
- let i = num_chunks - 1;
- let last_chunk_size = num_bytes - (chunk_size * (num_chunks as u64 - 1));
- io::copy(&mut reader.by_ref().take(last_chunk_size), &mut writers[i])?;
+ let n_bytes_read = reader.by_ref().take(limit).read_to_end(buf);
- Ok(())
- };
- match result {
- Ok(_) => Ok(()),
- Err(e) if e.kind() == ErrorKind::BrokenPipe => Ok(()),
- Err(e) => Err(uio_error!(e, "input/output error")),
+ match n_bytes_read {
+ Ok(n_bytes) => {
+ num_bytes -= n_bytes as u64;
+ }
+ Err(error) => {
+ return Err(USimpleError::new(
+ 1,
+ format!("{}: cannot read from input : {}", settings.input, error),
+ ));
+ }
+ }
+
+ match kth_chunk {
+ Some(chunk_number) => {
+ if i == chunk_number {
+ stdout_writer.write_all(buf)?;
+ break;
+ }
+ }
+ None => {
+ let idx = (i - 1) as usize;
+ let writer = out_files.get_writer(idx, settings)?;
+ writer.write_all(buf)?;
+ }
+ }
+ } else {
+ break;
+ }
}
+ Ok(())
}
-/// Split a file into a specific number of chunks by line.
+/// Split a file or STDIN into a specific number of chunks by line.
+///
+/// It is most likely that input cannot be evenly divided into the number of chunks
+/// of the same size in bytes or number of lines, since we cannot break lines.
+/// It is also likely that there could be empty files (having `elide_empty_files` is disabled)
+/// when a long line overlaps one or more chunks.
///
-/// This function always creates one output file for each chunk, even
+/// In Kth chunk of N mode - writes to STDOUT the contents of the chunk identified by `kth_chunk`
+/// Note: the `elide_empty_files` flag is ignored in this mode
+///
+/// In N chunks mode - this function always creates one output file for each chunk, even
/// if there is an error reading or writing one of the chunks or if
-/// the input file is truncated. However, if the `filter` option is
-/// being used, then no files are created.
+/// the input file is truncated. However, if the `--filter` option is
+/// being used, then files will only be created if `$FILE` variable was used
+/// in filter command,
+/// i.e. `split -n l/10 --filter='head -c1 > $FILE' in`
///
/// # Errors
///
@@ -1101,70 +1426,135 @@ where
///
/// # See also
///
-/// * [`kth_chunk_by_line`], which splits its input in the same way,
-/// but writes only one specified chunk to stdout.
-fn split_into_n_chunks_by_line<R>(
+/// * [`n_chunks_by_byte`], which splits its input into a specific number of chunks by byte.
+///
+/// Implements `--number=CHUNKS`
+/// Where CHUNKS
+/// * l/N
+/// * l/K/N
+fn n_chunks_by_line<R>(
settings: &Settings,
reader: &mut R,
num_chunks: u64,
+ kth_chunk: Option<u64>,
) -> UResult<()>
where
R: BufRead,
{
- // Get the size of the input file in bytes and compute the number
+ // Get the size of the input in bytes and compute the number
// of bytes per chunk.
- let metadata = metadata(&settings.input).unwrap();
- let num_bytes = metadata.len();
- let chunk_size = (num_bytes / num_chunks) as usize;
-
- // This object is responsible for creating the filename for each chunk.
- let mut filename_iterator = FilenameIterator::new(
- &settings.prefix,
- &settings.additional_suffix,
- settings.suffix_length,
- settings.suffix_type,
- settings.suffix_start,
- )?;
-
- // Create one writer for each chunk. This will create each
- // of the underlying files (if not in `--filter` mode).
- let mut writers = vec![];
- for _ in 0..num_chunks {
- let filename = filename_iterator
- .next()
- .ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?;
- let writer = settings.instantiate_current_writer(filename.as_str())?;
- writers.push(writer);
+ let initial_buf = &mut Vec::new();
+ let num_bytes = get_input_size(&settings.input, reader, initial_buf, &settings.io_blksize)?;
+ let reader = initial_buf.chain(reader);
+
+ // If input file is empty and we would not have determined the Kth chunk
+ // in the Kth chunk of N chunk mode, then terminate immediately.
+ // This happens on `split -n l/3/10 /dev/null`, for example.
+ // Similarly, if input file is empty and `elide_empty_files` parameter is enabled,
+ // then we would have written zero chunks of output,
+ // so terminate immediately as well.
+ // This happens on `split -e -n l/3 /dev/null`, for example.
+ if num_bytes == 0 && (kth_chunk.is_some() || settings.elide_empty_files) {
+ return Ok(());
}
- let mut num_bytes_remaining_in_current_chunk = chunk_size;
- let mut i = 0;
- for line_result in reader.lines() {
- let line = line_result.unwrap();
- let maybe_writer = writers.get_mut(i);
- let writer = maybe_writer.unwrap();
- let bytes = line.as_bytes();
- writer.write_all(bytes)?;
- writer.write_all(b"\n")?;
-
- // Add one byte for the newline character.
- let num_bytes = bytes.len() + 1;
- if num_bytes > num_bytes_remaining_in_current_chunk {
- num_bytes_remaining_in_current_chunk = chunk_size;
- i += 1;
- } else {
- num_bytes_remaining_in_current_chunk -= num_bytes;
- }
+ // In Kth chunk of N mode - we will write to stdout instead of to a file.
+ let mut stdout_writer = std::io::stdout().lock();
+ // In N chunks mode - we will write to `num_chunks` files
+ let mut out_files: OutFiles = OutFiles::new();
+
+ // Calculate chunk size base and modulo reminder
+ // to be used in calculating `num_bytes_should_be_written` later on
+ let chunk_size_base = num_bytes / num_chunks;
+ let chunk_size_reminder = num_bytes % num_chunks;
+
+ // If in N chunks mode
+ // Generate filenames for each file and
+ // if `elide_empty_files` parameter is NOT enabled - instantiate the writer
+ // which will create each of the underlying files or stdin pipes
+ // to child shell/command processes if in `--filter` mode.
+ // Otherwise keep writer optional, to be instantiated later if there is data
+ // to write for the associated chunk.
+ if kth_chunk.is_none() {
+ out_files = OutFiles::init(num_chunks, settings, settings.elide_empty_files)?;
}
+ let mut chunk_number = 1;
+ let sep = settings.separator;
+ let mut num_bytes_should_be_written = chunk_size_base + (chunk_size_reminder > 0) as u64;
+ let mut num_bytes_written = 0;
+
+ for line_result in reader.split(sep) {
+ let mut line = line_result?;
+ // add separator back in at the end of the line,
+ // since `reader.split(sep)` removes it,
+ // except if the last line did not end with separator character
+ if (num_bytes_written + line.len() as u64) < num_bytes {
+ line.push(sep);
+ }
+ let bytes = line.as_slice();
+
+ match kth_chunk {
+ Some(kth) => {
+ if chunk_number == kth {
+ stdout_writer.write_all(bytes)?;
+ }
+ }
+ None => {
+ // Should write into a file
+ let idx = (chunk_number - 1) as usize;
+ let writer = out_files.get_writer(idx, settings)?;
+ custom_write_all(bytes, writer, settings)?;
+ }
+ }
+
+ // Advance to the next chunk if the current one is filled.
+ // There could be a situation when a long line, which started in current chunk,
+ // would overlap the next chunk (or even several next chunks),
+ // and since we cannot break lines for this split strategy, we could end up with
+ // empty files in place(s) of skipped chunk(s)
+ let num_line_bytes = bytes.len() as u64;
+ num_bytes_written += num_line_bytes;
+ let mut skipped = -1;
+ while num_bytes_should_be_written <= num_bytes_written {
+ num_bytes_should_be_written +=
+ chunk_size_base + (chunk_size_reminder > chunk_number) as u64;
+ chunk_number += 1;
+ skipped += 1;
+ }
+
+ // If a chunk was skipped and `elide_empty_files` flag is set,
+ // roll chunk_number back to preserve sequential continuity
+ // of file names for files written to,
+ // except for Kth chunk of N mode
+ if settings.elide_empty_files && skipped > 0 && kth_chunk.is_none() {
+ chunk_number -= skipped as u64;
+ }
+
+ if let Some(kth) = kth_chunk {
+ if chunk_number > kth {
+ break;
+ }
+ }
+ }
Ok(())
}
-/// Print the k-th chunk of a file, splitting by line.
+/// Split a file or STDIN into a specific number of chunks by line, but
+/// assign lines via round-robin.
+/// Note: There is no need to know the size of the input upfront for this method,
+/// since the lines are assigned to chunks randomly and the size of each chunk
+/// does not need to be estimated. As a result, "infinite" inputs are supported
+/// for this method, i.e. `yes | split -n r/10` or `yes | split -n r/3/11`
///
-/// This function is like [`split_into_n_chunks_by_line`], but instead
-/// of writing each chunk to its own file, it only writes to stdout
-/// the contents of the chunk identified by `chunk_number`.
+/// In Kth chunk of N mode - writes to stdout the contents of the chunk identified by `kth_chunk`
+///
+/// In N chunks mode - this function always creates one output file for each chunk, even
+/// if there is an error reading or writing one of the chunks or if
+/// the input file is truncated. However, if the `--filter` option is
+/// being used, then files will only be created if `$FILE` variable was used
+/// in filter command,
+/// i.e. `split -n r/10 --filter='head -c1 > $FILE' in`
///
/// # Errors
///
@@ -1173,125 +1563,108 @@ where
///
/// # See also
///
-/// * [`split_into_n_chunks_by_line`], which splits its input in the
-/// same way, but writes each chunk to its own file.
-fn kth_chunk_by_line<R>(
+/// * [`n_chunks_by_line`], which splits its input into a specific number of chunks by line.
+///
+/// Implements `--number=CHUNKS`
+/// Where CHUNKS
+/// * r/N
+/// * r/K/N
+fn n_chunks_by_line_round_robin<R>(
settings: &Settings,
reader: &mut R,
- chunk_number: u64,
num_chunks: u64,
+ kth_chunk: Option<u64>,
) -> UResult<()>
where
R: BufRead,
{
- // Get the size of the input file in bytes and compute the number
- // of bytes per chunk.
- let metadata = metadata(&settings.input).unwrap();
- let num_bytes = metadata.len();
- let chunk_size = (num_bytes / num_chunks) as usize;
+ // In Kth chunk of N mode - we will write to stdout instead of to a file.
+ let mut stdout_writer = std::io::stdout().lock();
+ // In N chunks mode - we will write to `num_chunks` files
+ let mut out_files: OutFiles = OutFiles::new();
+
+ // If in N chunks mode
+ // Create one writer for each chunk.
+ // This will create each of the underlying files
+ // or stdin pipes to child shell/command processes if in `--filter` mode
+ if kth_chunk.is_none() {
+ out_files = OutFiles::init(num_chunks, settings, settings.elide_empty_files)?;
+ }
- // Write to stdout instead of to a file.
- let stdout = std::io::stdout();
- let mut writer = stdout.lock();
+ let num_chunks: usize = num_chunks.try_into().unwrap();
+ let sep = settings.separator;
+ let mut closed_writers = 0;
- let mut num_bytes_remaining_in_current_chunk = chunk_size;
let mut i = 0;
- for line_result in reader.lines() {
- let line = line_result?;
- let bytes = line.as_bytes();
- if i == chunk_number {
- writer.write_all(bytes)?;
- writer.write_all(b"\n")?;
- }
+ loop {
+ let line = &mut Vec::new();
+ let num_bytes_read = reader.by_ref().read_until(sep, line)?;
- // Add one byte for the newline character.
- let num_bytes = bytes.len() + 1;
- if num_bytes >= num_bytes_remaining_in_current_chunk {
- num_bytes_remaining_in_current_chunk = chunk_size;
- i += 1;
- } else {
- num_bytes_remaining_in_current_chunk -= num_bytes;
- }
+ // if there is nothing else to read - exit the loop
+ if num_bytes_read == 0 {
+ break;
+ };
- if i > chunk_number {
+ let bytes = line.as_slice();
+ match kth_chunk {
+ Some(chunk_number) => {
+ if (i % num_chunks) == (chunk_number - 1) as usize {
+ stdout_writer.write_all(bytes)?;
+ }
+ }
+ None => {
+ let writer = out_files.get_writer(i % num_chunks, settings)?;
+ let writer_stdin_open = custom_write_all(bytes, writer, settings)?;
+ if !writer_stdin_open {
+ closed_writers += 1;
+ }
+ }
+ }
+ i += 1;
+ if closed_writers == num_chunks {
+ // all writers are closed - stop reading
break;
}
}
-
- Ok(())
-}
-
-fn split_into_n_chunks_by_line_round_robin<R>(
- settings: &Settings,
- reader: &mut R,
- num_chunks: u64,
-) -> UResult<()>
-where
- R: BufRead,
-{
- // This object is responsible for creating the filename for each chunk.
- let mut filename_iterator = FilenameIterator::new(
- &settings.prefix,
- &settings.additional_suffix,
- settings.suffix_length,
- settings.suffix_type,
- settings.suffix_start,
- )?;
-
- // Create one writer for each chunk. This will create each
- // of the underlying files (if not in `--filter` mode).
- let mut writers = vec![];
- for _ in 0..num_chunks {
- let filename = filename_iterator
- .next()
- .ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?;
- let writer = settings.instantiate_current_writer(filename.as_str())?;
- writers.push(writer);
- }
-
- let num_chunks: usize = num_chunks.try_into().unwrap();
- for (i, line_result) in reader.lines().enumerate() {
- let line = line_result.unwrap();
- let maybe_writer = writers.get_mut(i % num_chunks);
- let writer = maybe_writer.unwrap();
- let bytes = line.as_bytes();
- writer.write_all(bytes)?;
- writer.write_all(b"\n")?;
- }
-
Ok(())
}
+#[allow(clippy::cognitive_complexity)]
fn split(settings: &Settings) -> UResult<()> {
- let mut reader = BufReader::new(if settings.input == "-" {
+ let r_box = if settings.input == "-" {
Box::new(stdin()) as Box<dyn Read>
} else {
- let r = File::open(Path::new(&settings.input)).map_err_context(|| {
- format!(
- "cannot open {} for reading: No such file or directory",
- settings.input.quote()
- )
- })?;
+ let r = File::open(Path::new(&settings.input))
+ .map_err_context(|| format!("cannot open {} for reading", settings.input.quote()))?;
Box::new(r) as Box<dyn Read>
- });
+ };
+ let mut reader = if let Some(c) = settings.io_blksize {
+ BufReader::with_capacity(c.try_into().unwrap(), r_box)
+ } else {
+ BufReader::new(r_box)
+ };
match settings.strategy {
Strategy::Number(NumberType::Bytes(num_chunks)) => {
- split_into_n_chunks_by_byte(settings, &mut reader, num_chunks)
+ // split_into_n_chunks_by_byte(settings, &mut reader, num_chunks)
+ n_chunks_by_byte(settings, &mut reader, num_chunks, None)
+ }
+ Strategy::Number(NumberType::KthBytes(chunk_number, num_chunks)) => {
+ // kth_chunks_by_byte(settings, &mut reader, chunk_number, num_chunks)
+ n_chunks_by_byte(settings, &mut reader, num_chunks, Some(chunk_number))
}
Strategy::Number(NumberType::Lines(num_chunks)) => {
- split_into_n_chunks_by_line(settings, &mut reader, num_chunks)
+ n_chunks_by_line(settings, &mut reader, num_chunks, None)
}
Strategy::Number(NumberType::KthLines(chunk_number, num_chunks)) => {
- // The chunk number is given as a 1-indexed number, but it
- // is a little easier to deal with a 0-indexed number.
- let chunk_number = chunk_number - 1;
- kth_chunk_by_line(settings, &mut reader, chunk_number, num_chunks)
+ n_chunks_by_line(settings, &mut reader, num_chunks, Some(chunk_number))
}
Strategy::Number(NumberType::RoundRobin(num_chunks)) => {
- split_into_n_chunks_by_line_round_robin(settings, &mut reader, num_chunks)
+ n_chunks_by_line_round_robin(settings, &mut reader, num_chunks, None)
+ }
+ Strategy::Number(NumberType::KthRoundRobin(chunk_number, num_chunks)) => {
+ n_chunks_by_line_round_robin(settings, &mut reader, num_chunks, Some(chunk_number))
}
- Strategy::Number(_) => Err(USimpleError::new(1, "-n mode not yet fully implemented")),
Strategy::Lines(chunk_size) => {
let mut writer = LineChunkWriter::new(chunk_size, settings)?;
match std::io::copy(&mut reader, &mut writer) {
@@ -1305,8 +1678,7 @@ fn split(settings: &Settings) -> UResult<()> {
// allowable filenames, we use `ErrorKind::Other` to
// indicate that. A special error message needs to be
// printed in that case.
- ErrorKind::Other => Err(USimpleError::new(1, format!("{}", e))),
- ErrorKind::BrokenPipe => Ok(()),
+ ErrorKind::Other => Err(USimpleError::new(1, format!("{e}"))),
_ => Err(uio_error!(e, "input/output error")),
},
}
@@ -1324,8 +1696,7 @@ fn split(settings: &Settings) -> UResult<()> {
// allowable filenames, we use `ErrorKind::Other` to
// indicate that. A special error message needs to be
// printed in that case.
- ErrorKind::Other => Err(USimpleError::new(1, format!("{}", e))),
- ErrorKind::BrokenPipe => Ok(()),
+ ErrorKind::Other => Err(USimpleError::new(1, format!("{e}"))),
_ => Err(uio_error!(e, "input/output error")),
},
}
@@ -1343,95 +1714,10 @@ fn split(settings: &Settings) -> UResult<()> {
// allowable filenames, we use `ErrorKind::Other` to
// indicate that. A special error message needs to be
// printed in that case.
- ErrorKind::Other => Err(USimpleError::new(1, format!("{}", e))),
- ErrorKind::BrokenPipe => Ok(()),
+ ErrorKind::Other => Err(USimpleError::new(1, format!("{e}"))),
_ => Err(uio_error!(e, "input/output error")),
},
}
}
}
}
-
-#[cfg(test)]
-mod tests {
-
- use crate::NumberType;
- use crate::NumberTypeError;
-
- #[test]
- fn test_number_type_from() {
- assert_eq!(NumberType::from("123").unwrap(), NumberType::Bytes(123));
- assert_eq!(NumberType::from("l/123").unwrap(), NumberType::Lines(123));
- assert_eq!(
- NumberType::from("l/123/456").unwrap(),
- NumberType::KthLines(123, 456)
- );
- assert_eq!(
- NumberType::from("r/123").unwrap(),
- NumberType::RoundRobin(123)
- );
- assert_eq!(
- NumberType::from("r/123/456").unwrap(),
- NumberType::KthRoundRobin(123, 456)
- );
- }
-
- #[test]
- fn test_number_type_from_error() {
- assert_eq!(
- NumberType::from("xyz").unwrap_err(),
- NumberTypeError::NumberOfChunks("xyz".to_string())
- );
- assert_eq!(
- NumberType::from("l/xyz").unwrap_err(),
- NumberTypeError::NumberOfChunks("xyz".to_string())
- );
- assert_eq!(
- NumberType::from("l/123/xyz").unwrap_err(),
- NumberTypeError::NumberOfChunks("xyz".to_string())
- );
- assert_eq!(
- NumberType::from("l/abc/456").unwrap_err(),
- NumberTypeError::ChunkNumber("abc".to_string())
- );
- // In GNU split, the number of chunks get precedence:
- //
- // $ split -n l/abc/xyz
- // split: invalid number of chunks: ‘xyz’
- //
- assert_eq!(
- NumberType::from("l/abc/xyz").unwrap_err(),
- NumberTypeError::NumberOfChunks("xyz".to_string())
- );
- assert_eq!(
- NumberType::from("r/xyz").unwrap_err(),
- NumberTypeError::NumberOfChunks("xyz".to_string())
- );
- assert_eq!(
- NumberType::from("r/123/xyz").unwrap_err(),
- NumberTypeError::NumberOfChunks("xyz".to_string())
- );
- assert_eq!(
- NumberType::from("r/abc/456").unwrap_err(),
- NumberTypeError::ChunkNumber("abc".to_string())
- );
- // In GNU split, the number of chunks get precedence:
- //
- // $ split -n r/abc/xyz
- // split: invalid number of chunks: ‘xyz’
- //
- assert_eq!(
- NumberType::from("r/abc/xyz").unwrap_err(),
- NumberTypeError::NumberOfChunks("xyz".to_string())
- );
- }
-
- #[test]
- fn test_number_type_num_chunks() {
- assert_eq!(NumberType::from("123").unwrap().num_chunks(), 123);
- assert_eq!(NumberType::from("l/123").unwrap().num_chunks(), 123);
- assert_eq!(NumberType::from("l/123/456").unwrap().num_chunks(), 456);
- assert_eq!(NumberType::from("r/123").unwrap().num_chunks(), 123);
- assert_eq!(NumberType::from("r/123/456").unwrap().num_chunks(), 456);
- }
-}
diff --git a/src/uu/split/src/strategy.rs b/src/uu/split/src/strategy.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7b934f72047e1b70e056acf00ff9fdf6e6968c79
--- /dev/null
+++ b/src/uu/split/src/strategy.rs
@@ -0,0 +1,382 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+//! Determine the strategy for breaking up the input (file or stdin) into chunks
+//! based on the command line options
+
+use crate::{OPT_BYTES, OPT_LINES, OPT_LINE_BYTES, OPT_NUMBER};
+use clap::{parser::ValueSource, ArgMatches};
+use std::fmt;
+use uucore::{
+ display::Quotable,
+ parse_size::{parse_size_u64, parse_size_u64_max, ParseSizeError},
+};
+
+/// Sub-strategy of the [`Strategy::Number`]
+/// Splitting a file into a specific number of chunks.
+#[derive(Debug, PartialEq)]
+pub enum NumberType {
+ /// Split into a specific number of chunks by byte.
+ Bytes(u64),
+
+ /// Split into a specific number of chunks by byte
+ /// but output only the *k*th chunk.
+ KthBytes(u64, u64),
+
+ /// Split into a specific number of chunks by line (approximately).
+ Lines(u64),
+
+ /// Split into a specific number of chunks by line
+ /// (approximately), but output only the *k*th chunk.
+ KthLines(u64, u64),
+
+ /// Assign lines via round-robin to the specified number of output chunks.
+ RoundRobin(u64),
+
+ /// Assign lines via round-robin to the specified number of output
+ /// chunks, but output only the *k*th chunk.
+ KthRoundRobin(u64, u64),
+}
+
+impl NumberType {
+ /// The number of chunks for this number type.
+ pub fn num_chunks(&self) -> u64 {
+ match self {
+ Self::Bytes(n) => *n,
+ Self::KthBytes(_, n) => *n,
+ Self::Lines(n) => *n,
+ Self::KthLines(_, n) => *n,
+ Self::RoundRobin(n) => *n,
+ Self::KthRoundRobin(_, n) => *n,
+ }
+ }
+}
+
+/// An error due to an invalid parameter to the `-n` command-line option.
+#[derive(Debug, PartialEq)]
+pub enum NumberTypeError {
+ /// The number of chunks was invalid.
+ ///
+ /// This can happen if the value of `N` in any of the following
+ /// command-line options is not a positive integer:
+ ///
+ /// ```ignore
+ /// -n N
+ /// -n K/N
+ /// -n l/N
+ /// -n l/K/N
+ /// -n r/N
+ /// -n r/K/N
+ /// ```
+ NumberOfChunks(String),
+
+ /// The chunk number was invalid.
+ ///
+ /// This can happen if the value of `K` in any of the following
+ /// command-line options is not a positive integer
+ /// or if `K` is 0
+ /// or if `K` is greater than `N`:
+ ///
+ /// ```ignore
+ /// -n K/N
+ /// -n l/K/N
+ /// -n r/K/N
+ /// ```
+ ChunkNumber(String),
+}
+
+impl NumberType {
+ /// Parse a `NumberType` from a string.
+ ///
+ /// The following strings are valid arguments:
+ ///
+ /// ```ignore
+ /// "N"
+ /// "K/N"
+ /// "l/N"
+ /// "l/K/N"
+ /// "r/N"
+ /// "r/K/N"
+ /// ```
+ ///
+ /// The `N` represents the number of chunks and the `K` represents
+ /// a chunk number.
+ ///
+ /// # Errors
+ ///
+ /// If the string is not one of the valid number types,
+ /// if `K` is not a nonnegative integer,
+ /// or if `K` is 0,
+ /// or if `N` is not a positive integer,
+ /// or if `K` is greater than `N`
+ /// then this function returns [`NumberTypeError`].
+ fn from(s: &str) -> Result<Self, NumberTypeError> {
+ fn is_invalid_chunk(chunk_number: u64, num_chunks: u64) -> bool {
+ chunk_number > num_chunks || chunk_number == 0
+ }
+ let parts: Vec<&str> = s.split('/').collect();
+ match &parts[..] {
+ [n_str] => {
+ let num_chunks = parse_size_u64(n_str)
+ .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
+ if num_chunks > 0 {
+ Ok(Self::Bytes(num_chunks))
+ } else {
+ Err(NumberTypeError::NumberOfChunks(s.to_string()))
+ }
+ }
+ [k_str, n_str] if !k_str.starts_with('l') && !k_str.starts_with('r') => {
+ let num_chunks = parse_size_u64(n_str)
+ .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
+ let chunk_number = parse_size_u64(k_str)
+ .map_err(|_| NumberTypeError::ChunkNumber(k_str.to_string()))?;
+ if is_invalid_chunk(chunk_number, num_chunks) {
+ return Err(NumberTypeError::ChunkNumber(k_str.to_string()));
+ }
+ Ok(Self::KthBytes(chunk_number, num_chunks))
+ }
+ ["l", n_str] => {
+ let num_chunks = parse_size_u64(n_str)
+ .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
+ Ok(Self::Lines(num_chunks))
+ }
+ ["l", k_str, n_str] => {
+ let num_chunks = parse_size_u64(n_str)
+ .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
+ let chunk_number = parse_size_u64(k_str)
+ .map_err(|_| NumberTypeError::ChunkNumber(k_str.to_string()))?;
+ if is_invalid_chunk(chunk_number, num_chunks) {
+ return Err(NumberTypeError::ChunkNumber(k_str.to_string()));
+ }
+ Ok(Self::KthLines(chunk_number, num_chunks))
+ }
+ ["r", n_str] => {
+ let num_chunks = parse_size_u64(n_str)
+ .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
+ Ok(Self::RoundRobin(num_chunks))
+ }
+ ["r", k_str, n_str] => {
+ let num_chunks = parse_size_u64(n_str)
+ .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
+ let chunk_number = parse_size_u64(k_str)
+ .map_err(|_| NumberTypeError::ChunkNumber(k_str.to_string()))?;
+ if is_invalid_chunk(chunk_number, num_chunks) {
+ return Err(NumberTypeError::ChunkNumber(k_str.to_string()));
+ }
+ Ok(Self::KthRoundRobin(chunk_number, num_chunks))
+ }
+ _ => Err(NumberTypeError::NumberOfChunks(s.to_string())),
+ }
+ }
+}
+
+/// The strategy for breaking up the input file into chunks.
+pub enum Strategy {
+ /// Each chunk has the specified number of lines.
+ Lines(u64),
+
+ /// Each chunk has the specified number of bytes.
+ Bytes(u64),
+
+ /// Each chunk has as many lines as possible without exceeding the
+ /// specified number of bytes.
+ LineBytes(u64),
+
+ /// Split the file into this many chunks.
+ ///
+ /// There are several sub-strategies available, as defined by
+ /// [`NumberType`].
+ Number(NumberType),
+}
+
+/// An error when parsing a chunking strategy from command-line arguments.
+pub enum StrategyError {
+ /// Invalid number of lines.
+ Lines(ParseSizeError),
+
+ /// Invalid number of bytes.
+ Bytes(ParseSizeError),
+
+ /// Invalid number type.
+ NumberType(NumberTypeError),
+
+ /// Multiple chunking strategies were specified (but only one should be).
+ MultipleWays,
+}
+
+impl fmt::Display for StrategyError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match self {
+ Self::Lines(e) => write!(f, "invalid number of lines: {e}"),
+ Self::Bytes(e) => write!(f, "invalid number of bytes: {e}"),
+ Self::NumberType(NumberTypeError::NumberOfChunks(s)) => {
+ write!(f, "invalid number of chunks: {}", s.quote())
+ }
+ Self::NumberType(NumberTypeError::ChunkNumber(s)) => {
+ write!(f, "invalid chunk number: {}", s.quote())
+ }
+ Self::MultipleWays => write!(f, "cannot split in more than one way"),
+ }
+ }
+}
+
+impl Strategy {
+ /// Parse a strategy from the command-line arguments.
+ pub fn from(matches: &ArgMatches, obs_lines: &Option<String>) -> Result<Self, StrategyError> {
+ fn get_and_parse(
+ matches: &ArgMatches,
+ option: &str,
+ strategy: fn(u64) -> Strategy,
+ error: fn(ParseSizeError) -> StrategyError,
+ ) -> Result<Strategy, StrategyError> {
+ let s = matches.get_one::<String>(option).unwrap();
+ let n = parse_size_u64_max(s).map_err(error)?;
+ if n > 0 {
+ Ok(strategy(n))
+ } else {
+ Err(error(ParseSizeError::ParseFailure(s.to_string())))
+ }
+ }
+ // Check that the user is not specifying more than one strategy.
+ //
+ // Note: right now, this exact behavior cannot be handled by
+ // overrides_with_all() due to obsolete lines value option
+ match (
+ obs_lines,
+ matches.value_source(OPT_LINES) == Some(ValueSource::CommandLine),
+ matches.value_source(OPT_BYTES) == Some(ValueSource::CommandLine),
+ matches.value_source(OPT_LINE_BYTES) == Some(ValueSource::CommandLine),
+ matches.value_source(OPT_NUMBER) == Some(ValueSource::CommandLine),
+ ) {
+ (Some(v), false, false, false, false) => {
+ let v = parse_size_u64_max(v).map_err(|_| {
+ StrategyError::Lines(ParseSizeError::ParseFailure(v.to_string()))
+ })?;
+ if v > 0 {
+ Ok(Self::Lines(v))
+ } else {
+ Err(StrategyError::Lines(ParseSizeError::ParseFailure(
+ v.to_string(),
+ )))
+ }
+ }
+ (None, false, false, false, false) => Ok(Self::Lines(1000)),
+ (None, true, false, false, false) => {
+ get_and_parse(matches, OPT_LINES, Self::Lines, StrategyError::Lines)
+ }
+ (None, false, true, false, false) => {
+ get_and_parse(matches, OPT_BYTES, Self::Bytes, StrategyError::Bytes)
+ }
+ (None, false, false, true, false) => get_and_parse(
+ matches,
+ OPT_LINE_BYTES,
+ Self::LineBytes,
+ StrategyError::Bytes,
+ ),
+ (None, false, false, false, true) => {
+ let s = matches.get_one::<String>(OPT_NUMBER).unwrap();
+ let number_type = NumberType::from(s).map_err(StrategyError::NumberType)?;
+ Ok(Self::Number(number_type))
+ }
+ _ => Err(StrategyError::MultipleWays),
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+
+ use crate::{strategy::NumberType, strategy::NumberTypeError};
+
+ #[test]
+ fn test_number_type_from() {
+ assert_eq!(NumberType::from("123").unwrap(), NumberType::Bytes(123));
+ assert_eq!(NumberType::from("l/123").unwrap(), NumberType::Lines(123));
+ assert_eq!(
+ NumberType::from("l/123/456").unwrap(),
+ NumberType::KthLines(123, 456)
+ );
+ assert_eq!(
+ NumberType::from("r/123").unwrap(),
+ NumberType::RoundRobin(123)
+ );
+ assert_eq!(
+ NumberType::from("r/123/456").unwrap(),
+ NumberType::KthRoundRobin(123, 456)
+ );
+ }
+
+ #[test]
+ #[allow(clippy::cognitive_complexity)]
+ fn test_number_type_from_error() {
+ assert_eq!(
+ NumberType::from("xyz").unwrap_err(),
+ NumberTypeError::NumberOfChunks("xyz".to_string())
+ );
+ assert_eq!(
+ NumberType::from("l/xyz").unwrap_err(),
+ NumberTypeError::NumberOfChunks("xyz".to_string())
+ );
+ assert_eq!(
+ NumberType::from("l/123/xyz").unwrap_err(),
+ NumberTypeError::NumberOfChunks("xyz".to_string())
+ );
+ assert_eq!(
+ NumberType::from("l/abc/456").unwrap_err(),
+ NumberTypeError::ChunkNumber("abc".to_string())
+ );
+ assert_eq!(
+ NumberType::from("l/456/123").unwrap_err(),
+ NumberTypeError::ChunkNumber("456".to_string())
+ );
+ assert_eq!(
+ NumberType::from("r/456/123").unwrap_err(),
+ NumberTypeError::ChunkNumber("456".to_string())
+ );
+ assert_eq!(
+ NumberType::from("456/123").unwrap_err(),
+ NumberTypeError::ChunkNumber("456".to_string())
+ );
+ // In GNU split, the number of chunks get precedence:
+ //
+ // $ split -n l/abc/xyz
+ // split: invalid number of chunks: ‘xyz’
+ //
+ assert_eq!(
+ NumberType::from("l/abc/xyz").unwrap_err(),
+ NumberTypeError::NumberOfChunks("xyz".to_string())
+ );
+ assert_eq!(
+ NumberType::from("r/xyz").unwrap_err(),
+ NumberTypeError::NumberOfChunks("xyz".to_string())
+ );
+ assert_eq!(
+ NumberType::from("r/123/xyz").unwrap_err(),
+ NumberTypeError::NumberOfChunks("xyz".to_string())
+ );
+ assert_eq!(
+ NumberType::from("r/abc/456").unwrap_err(),
+ NumberTypeError::ChunkNumber("abc".to_string())
+ );
+ // In GNU split, the number of chunks get precedence:
+ //
+ // $ split -n r/abc/xyz
+ // split: invalid number of chunks: ‘xyz’
+ //
+ assert_eq!(
+ NumberType::from("r/abc/xyz").unwrap_err(),
+ NumberTypeError::NumberOfChunks("xyz".to_string())
+ );
+ }
+
+ #[test]
+ fn test_number_type_num_chunks() {
+ assert_eq!(NumberType::from("123").unwrap().num_chunks(), 123);
+ assert_eq!(NumberType::from("123/456").unwrap().num_chunks(), 456);
+ assert_eq!(NumberType::from("l/123").unwrap().num_chunks(), 123);
+ assert_eq!(NumberType::from("l/123/456").unwrap().num_chunks(), 456);
+ assert_eq!(NumberType::from("r/123").unwrap().num_chunks(), 123);
+ assert_eq!(NumberType::from("r/123/456").unwrap().num_chunks(), 456);
+ }
+}
diff --git a/src/uu/stat/Cargo.toml b/src/uu/stat/Cargo.toml
index 2f32abc512325d029f5f051141f391046010bebe..1de2b59fc67108b6e295bebdf9e2f9554bb83ee7 100644
--- a/src/uu/stat/Cargo.toml
+++ b/src/uu/stat/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_stat"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "stat ~ (uutils) display FILE status"
@@ -15,8 +15,9 @@ edition = "2021"
path = "src/stat.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["entries", "libc", "fs", "fsext"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["entries", "libc", "fs", "fsext"] }
+chrono = { workspace = true }
[[bin]]
name = "stat"
diff --git a/src/uu/stat/src/stat.rs b/src/uu/stat/src/stat.rs
index 8fd9fecfaaefa7841b95d1d4df814bc1e0c8aac2..fe007397d18c1dd20918142cf9992eeff2cc3e4c 100644
--- a/src/uu/stat/src/stat.rs
+++ b/src/uu/stat/src/stat.rs
@@ -1,31 +1,31 @@
// This file is part of the uutils coreutils package.
//
-// (c) Jian Zeng <anonymousknight96@gmail.com>
-//
-// For the full copyright and license information, please view the LICENSE file
-// that was distributed with this source code.
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore datetime
use clap::builder::ValueParser;
use uucore::display::Quotable;
use uucore::error::{FromIo, UResult, USimpleError};
use uucore::fs::display_permissions;
-use uucore::fsext::{
- pretty_filetype, pretty_fstype, pretty_time, read_fs_list, statfs, BirthTime, FsMeta,
-};
+use uucore::fsext::{pretty_filetype, pretty_fstype, read_fs_list, statfs, BirthTime, FsMeta};
use uucore::libc::mode_t;
-use uucore::{entries, format_usage, show_error, show_warning};
+use uucore::{
+ entries, format_usage, help_about, help_section, help_usage, show_error, show_warning,
+};
+use chrono::{DateTime, Local};
use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
use std::borrow::Cow;
-use std::convert::AsRef;
use std::ffi::{OsStr, OsString};
use std::fs;
use std::os::unix::fs::{FileTypeExt, MetadataExt};
use std::os::unix::prelude::OsStrExt;
use std::path::Path;
-const ABOUT: &str = "Display file or file system status.";
-const USAGE: &str = "{} [OPTION]... FILE...";
+const ABOUT: &str = help_about!("stat.md");
+const USAGE: &str = help_usage!("stat.md");
+const LONG_USAGE: &str = help_section!("long usage", "stat.md");
mod options {
pub const DEREFERENCE: &str = "dereference";
@@ -202,7 +202,16 @@ struct Stater {
default_dev_tokens: Vec<Token>,
}
-#[allow(clippy::cognitive_complexity)]
+/// Prints a formatted output based on the provided output type, flags, width, and precision.
+///
+/// # Arguments
+///
+/// * `output` - A reference to the OutputType enum containing the value to be printed.
+/// * `flags` - A Flags struct containing formatting flags.
+/// * `width` - The width of the field for the printed output.
+/// * `precision` - An Option containing the precision value.
+///
+/// This function delegates the printing process to more specialized functions depending on the output type.
fn print_it(output: &OutputType, flags: Flags, width: usize, precision: Option<usize>) {
// If the precision is given as just '.', the precision is taken to be zero.
// A negative precision is taken as if the precision were omitted.
@@ -233,72 +242,279 @@ fn print_it(output: &OutputType, flags: Flags, width: usize, precision: Option<u
// A sign (+ or -) should always be placed before a number produced by a signed conversion.
// By default, a sign is used only for negative numbers.
// A + overrides a space if both are used.
+ let padding_char = determine_padding_char(&flags, &precision);
+
+ match output {
+ OutputType::Str(s) => print_str(s, &flags, width, precision),
+ OutputType::Integer(num) => print_integer(*num, &flags, width, precision, padding_char),
+ OutputType::Unsigned(num) => print_unsigned(*num, &flags, width, precision, padding_char),
+ OutputType::UnsignedOct(num) => {
+ print_unsigned_oct(*num, &flags, width, precision, padding_char);
+ }
+ OutputType::UnsignedHex(num) => {
+ print_unsigned_hex(*num, &flags, width, precision, padding_char);
+ }
+ OutputType::Unknown => print!("?"),
+ }
+}
- let padding_char = if flags.zero && !flags.left && precision.is_none() {
+/// Determines the padding character based on the provided flags and precision.
+///
+/// # Arguments
+///
+/// * `flags` - A reference to the Flags struct containing formatting flags.
+/// * `precision` - An Option containing the precision value.
+///
+/// # Returns
+///
+/// * Padding - An instance of the Padding enum representing the padding character.
+fn determine_padding_char(flags: &Flags, precision: &Option<usize>) -> Padding {
+ if flags.zero && !flags.left && precision.is_none() {
Padding::Zero
} else {
Padding::Space
+ }
+}
+
+/// Prints a string value based on the provided flags, width, and precision.
+///
+/// # Arguments
+///
+/// * `s` - The string to be printed.
+/// * `flags` - A reference to the Flags struct containing formatting flags.
+/// * `width` - The width of the field for the printed string.
+/// * `precision` - An Option containing the precision value.
+fn print_str(s: &str, flags: &Flags, width: usize, precision: Option<usize>) {
+ let s = match precision {
+ Some(p) if p < s.len() => &s[..p],
+ _ => s,
};
+ pad_and_print(s, flags.left, width, Padding::Space);
+}
- match output {
- OutputType::Str(s) => {
- let s = match precision {
- Some(p) if p < s.len() => &s[..p],
- _ => s,
- };
- pad_and_print(s, flags.left, width, Padding::Space);
+/// Prints an integer value based on the provided flags, width, and precision.
+///
+/// # Arguments
+///
+/// * `num` - The integer value to be printed.
+/// * `flags` - A reference to the Flags struct containing formatting flags.
+/// * `width` - The width of the field for the printed integer.
+/// * `precision` - An Option containing the precision value.
+/// * `padding_char` - The padding character as determined by `determine_padding_char`.
+fn print_integer(
+ num: i64,
+ flags: &Flags,
+ width: usize,
+ precision: Option<usize>,
+ padding_char: Padding,
+) {
+ let num = num.to_string();
+ let arg = if flags.group {
+ group_num(&num)
+ } else {
+ Cow::Borrowed(num.as_str())
+ };
+ let prefix = if flags.sign {
+ "+"
+ } else if flags.space {
+ " "
+ } else {
+ ""
+ };
+ let extended = format!(
+ "{prefix}{arg:0>precision$}",
+ precision = precision.unwrap_or(0)
+ );
+ pad_and_print(&extended, flags.left, width, padding_char);
+}
+
+/// Prints an unsigned integer value based on the provided flags, width, and precision.
+///
+/// # Arguments
+///
+/// * `num` - The unsigned integer value to be printed.
+/// * `flags` - A reference to the Flags struct containing formatting flags.
+/// * `width` - The width of the field for the printed unsigned integer.
+/// * `precision` - An Option containing the precision value.
+/// * `padding_char` - The padding character as determined by `determine_padding_char`.
+fn print_unsigned(
+ num: u64,
+ flags: &Flags,
+ width: usize,
+ precision: Option<usize>,
+ padding_char: Padding,
+) {
+ let num = num.to_string();
+ let s = if flags.group {
+ group_num(&num)
+ } else {
+ Cow::Borrowed(num.as_str())
+ };
+ let s = format!("{s:0>precision$}", precision = precision.unwrap_or(0));
+ pad_and_print(&s, flags.left, width, padding_char);
+}
+
+/// Prints an unsigned octal integer value based on the provided flags, width, and precision.
+///
+/// # Arguments
+///
+/// * `num` - The unsigned octal integer value to be printed.
+/// * `flags` - A reference to the Flags struct containing formatting flags.
+/// * `width` - The width of the field for the printed unsigned octal integer.
+/// * `precision` - An Option containing the precision value.
+/// * `padding_char` - The padding character as determined by `determine_padding_char`.
+fn print_unsigned_oct(
+ num: u32,
+ flags: &Flags,
+ width: usize,
+ precision: Option<usize>,
+ padding_char: Padding,
+) {
+ let prefix = if flags.alter { "0" } else { "" };
+ let s = format!(
+ "{prefix}{num:0>precision$o}",
+ precision = precision.unwrap_or(0)
+ );
+ pad_and_print(&s, flags.left, width, padding_char);
+}
+
+/// Prints an unsigned hexadecimal integer value based on the provided flags, width, and precision.
+///
+/// # Arguments
+///
+/// * `num` - The unsigned hexadecimal integer value to be printed.
+/// * `flags` - A reference to the Flags struct containing formatting flags.
+/// * `width` - The width of the field for the printed unsigned hexadecimal integer.
+/// * `precision` - An Option containing the precision value.
+/// * `padding_char` - The padding character as determined by `determine_padding_char`.
+fn print_unsigned_hex(
+ num: u64,
+ flags: &Flags,
+ width: usize,
+ precision: Option<usize>,
+ padding_char: Padding,
+) {
+ let prefix = if flags.alter { "0x" } else { "" };
+ let s = format!(
+ "{prefix}{num:0>precision$x}",
+ precision = precision.unwrap_or(0)
+ );
+ pad_and_print(&s, flags.left, width, padding_char);
+}
+
+impl Stater {
+ fn handle_percent_case(
+ chars: &[char],
+ i: &mut usize,
+ bound: usize,
+ format_str: &str,
+ ) -> UResult<Token> {
+ let old = *i;
+
+ *i += 1;
+ if *i >= bound {
+ return Ok(Token::Char('%'));
}
- OutputType::Integer(num) => {
- let num = num.to_string();
- let arg = if flags.group {
- group_num(&num)
- } else {
- Cow::Borrowed(num.as_str())
- };
- let prefix = if flags.sign {
- "+"
- } else if flags.space {
- " "
- } else {
- ""
- };
- let extended = format!(
- "{prefix}{arg:0>precision$}",
- precision = precision.unwrap_or(0)
- );
- pad_and_print(&extended, flags.left, width, padding_char);
+ if chars[*i] == '%' {
+ *i += 1;
+ return Ok(Token::Char('%'));
}
- OutputType::Unsigned(num) => {
- let num = num.to_string();
- let s = if flags.group {
- group_num(&num)
- } else {
- Cow::Borrowed(num.as_str())
- };
- let s = format!("{s:0>precision$}", precision = precision.unwrap_or(0));
- pad_and_print(&s, flags.left, width, padding_char);
+
+ let mut flag = Flags::default();
+
+ while *i < bound {
+ match chars[*i] {
+ '#' => flag.alter = true,
+ '0' => flag.zero = true,
+ '-' => flag.left = true,
+ ' ' => flag.space = true,
+ '+' => flag.sign = true,
+ '\'' => flag.group = true,
+ 'I' => unimplemented!(),
+ _ => break,
+ }
+ *i += 1;
}
- OutputType::UnsignedOct(num) => {
- let prefix = if flags.alter { "0" } else { "" };
- let s = format!(
- "{prefix}{num:0>precision$o}",
- precision = precision.unwrap_or(0)
- );
- pad_and_print(&s, flags.left, width, padding_char);
+ check_bound(format_str, bound, old, *i)?;
+
+ let mut width = 0;
+ let mut precision = None;
+ let mut j = *i;
+
+ if let Some((field_width, offset)) = format_str[j..].scan_num::<usize>() {
+ width = field_width;
+ j += offset;
}
- OutputType::UnsignedHex(num) => {
- let prefix = if flags.alter { "0x" } else { "" };
- let s = format!(
- "{prefix}{num:0>precision$x}",
- precision = precision.unwrap_or(0)
- );
- pad_and_print(&s, flags.left, width, padding_char);
+ check_bound(format_str, bound, old, j)?;
+
+ if chars[j] == '.' {
+ j += 1;
+ check_bound(format_str, bound, old, j)?;
+
+ match format_str[j..].scan_num::<i32>() {
+ Some((value, offset)) => {
+ if value >= 0 {
+ precision = Some(value as usize);
+ }
+ j += offset;
+ }
+ None => precision = Some(0),
+ }
+ check_bound(format_str, bound, old, j)?;
+ }
+
+ *i = j;
+ Ok(Token::Directive {
+ width,
+ flag,
+ precision,
+ format: chars[*i],
+ })
+ }
+
+ fn handle_escape_sequences(
+ chars: &[char],
+ i: &mut usize,
+ bound: usize,
+ format_str: &str,
+ ) -> Token {
+ *i += 1;
+ if *i >= bound {
+ show_warning!("backslash at end of format");
+ return Token::Char('\\');
+ }
+ match chars[*i] {
+ 'x' if *i + 1 < bound => {
+ if let Some((c, offset)) = format_str[*i + 1..].scan_char(16) {
+ *i += offset;
+ Token::Char(c)
+ } else {
+ show_warning!("unrecognized escape '\\x'");
+ Token::Char('x')
+ }
+ }
+ '0'..='7' => {
+ let (c, offset) = format_str[*i..].scan_char(8).unwrap();
+ *i += offset - 1;
+ Token::Char(c)
+ }
+ '"' => Token::Char('"'),
+ '\\' => Token::Char('\\'),
+ 'a' => Token::Char('\x07'),
+ 'b' => Token::Char('\x08'),
+ 'e' => Token::Char('\x1B'),
+ 'f' => Token::Char('\x0C'),
+ 'n' => Token::Char('\n'),
+ 'r' => Token::Char('\r'),
+ 't' => Token::Char('\t'),
+ 'v' => Token::Char('\x0B'),
+ c => {
+ show_warning!("unrecognized escape '\\{}'", c);
+ Token::Char(c)
+ }
}
- OutputType::Unknown => print!("?"),
}
-}
-impl Stater {
fn generate_tokens(format_str: &str, use_printf: bool) -> UResult<Vec<Token>> {
let mut tokens = Vec::new();
let bound = format_str.len();
@@ -306,114 +522,18 @@ impl Stater {
let mut i = 0;
while i < bound {
match chars[i] {
- '%' => {
- let old = i;
-
- i += 1;
- if i >= bound {
- tokens.push(Token::Char('%'));
- continue;
- }
- if chars[i] == '%' {
- tokens.push(Token::Char('%'));
- i += 1;
- continue;
- }
-
- let mut flag = Flags::default();
-
- while i < bound {
- match chars[i] {
- '#' => flag.alter = true,
- '0' => flag.zero = true,
- '-' => flag.left = true,
- ' ' => flag.space = true,
- '+' => flag.sign = true,
- '\'' => flag.group = true,
- 'I' => unimplemented!(),
- _ => break,
- }
- i += 1;
- }
- check_bound(format_str, bound, old, i)?;
-
- let mut width = 0;
- let mut precision = None;
- let mut j = i;
-
- if let Some((field_width, offset)) = format_str[j..].scan_num::<usize>() {
- width = field_width;
- j += offset;
- }
- check_bound(format_str, bound, old, j)?;
-
- if chars[j] == '.' {
- j += 1;
- check_bound(format_str, bound, old, j)?;
-
- match format_str[j..].scan_num::<i32>() {
- Some((value, offset)) => {
- if value >= 0 {
- precision = Some(value as usize);
- }
- j += offset;
- }
- None => precision = Some(0),
- }
- check_bound(format_str, bound, old, j)?;
- }
-
- i = j;
- tokens.push(Token::Directive {
- width,
- flag,
- precision,
- format: chars[i],
- });
- }
+ '%' => tokens.push(Self::handle_percent_case(
+ &chars, &mut i, bound, format_str,
+ )?),
'\\' => {
- if !use_printf {
- tokens.push(Token::Char('\\'));
+ if use_printf {
+ tokens.push(Self::handle_escape_sequences(
+ &chars, &mut i, bound, format_str,
+ ));
} else {
- i += 1;
- if i >= bound {
- show_warning!("backslash at end of format");
- tokens.push(Token::Char('\\'));
- continue;
- }
- match chars[i] {
- 'x' if i + 1 < bound => {
- if let Some((c, offset)) = format_str[i + 1..].scan_char(16) {
- tokens.push(Token::Char(c));
- i += offset;
- } else {
- show_warning!("unrecognized escape '\\x'");
- tokens.push(Token::Char('x'));
- }
- }
- '0'..='7' => {
- let (c, offset) = format_str[i..].scan_char(8).unwrap();
- tokens.push(Token::Char(c));
- i += offset - 1;
- }
- '"' => tokens.push(Token::Char('"')),
- '\\' => tokens.push(Token::Char('\\')),
- 'a' => tokens.push(Token::Char('\x07')),
- 'b' => tokens.push(Token::Char('\x08')),
- 'e' => tokens.push(Token::Char('\x1B')),
- 'f' => tokens.push(Token::Char('\x0C')),
- 'n' => tokens.push(Token::Char('\n')),
- 'r' => tokens.push(Token::Char('\r')),
- 't' => tokens.push(Token::Char('\t')),
- 'v' => tokens.push(Token::Char('\x0B')),
- c => {
- show_warning!("unrecognized escape '\\{}'", c);
- tokens.push(Token::Char(c));
- }
- }
+ tokens.push(Token::Char('\\'));
}
}
-
c => tokens.push(Token::Char(c)),
}
i += 1;
@@ -425,10 +545,16 @@ impl Stater {
}
fn new(matches: &ArgMatches) -> UResult<Self> {
- let files = matches
+ let files: Vec<OsString> = matches
.get_many::<OsString>(options::FILES)
.map(|v| v.map(OsString::from).collect())
.unwrap_or_default();
+ if files.is_empty() {
+ return Err(Box::new(USimpleError {
+ code: 1,
+ message: "missing operand\nTry 'stat --help' for more information.".to_string(),
+ }));
+ }
let format_str = if matches.contains_id(options::PRINTF) {
matches
.get_one::<String>(options::PRINTF)
@@ -504,9 +630,14 @@ impl Stater {
ret
}
+ #[allow(clippy::cognitive_complexity)]
fn do_stat(&self, file: &OsStr, stdin_is_fifo: bool) -> i32 {
let display_name = file.to_string_lossy();
let file = if cfg!(unix) && display_name == "-" {
+ if self.show_fs {
+ show_error!("using '-' to denote standard input does not work in file system mode");
+ return 1;
+ }
if let Ok(p) = Path::new("/dev/stdin").canonicalize() {
p.into_os_string()
} else {
@@ -515,8 +646,67 @@ impl Stater {
} else {
OsString::from(file)
};
+ if self.show_fs {
+ #[cfg(unix)]
+ let p = file.as_bytes();
+ #[cfg(not(unix))]
+ let p = file.into_string().unwrap();
+ match statfs(p) {
+ Ok(meta) => {
+ let tokens = &self.default_tokens;
+
+ for t in tokens {
+ match *t {
+ Token::Char(c) => print!("{c}"),
+ Token::Directive {
+ flag,
+ width,
+ precision,
+ format,
+ } => {
+ let output = match format {
+ // free blocks available to non-superuser
+ 'a' => OutputType::Unsigned(meta.avail_blocks()),
+ // total data blocks in file system
+ 'b' => OutputType::Unsigned(meta.total_blocks()),
+ // total file nodes in file system
+ 'c' => OutputType::Unsigned(meta.total_file_nodes()),
+ // free file nodes in file system
+ 'd' => OutputType::Unsigned(meta.free_file_nodes()),
+ // free blocks in file system
+ 'f' => OutputType::Unsigned(meta.free_blocks()),
+ // file system ID in hex
+ 'i' => OutputType::UnsignedHex(meta.fsid()),
+ // maximum length of filenames
+ 'l' => OutputType::Unsigned(meta.namelen()),
+ // file name
+ 'n' => OutputType::Str(display_name.to_string()),
+ // block size (for faster transfers)
+ 's' => OutputType::Unsigned(meta.io_size()),
+ // fundamental block size (for block counts)
+ 'S' => OutputType::Integer(meta.block_size()),
+ // file system type in hex
+ 't' => OutputType::UnsignedHex(meta.fs_type() as u64),
+ // file system type in human readable form
+ 'T' => OutputType::Str(pretty_fstype(meta.fs_type()).into()),
+ _ => OutputType::Unknown,
+ };
- if !self.show_fs {
+ print_it(&output, flag, width, precision);
+ }
+ }
+ }
+ }
+ Err(e) => {
+ show_error!(
+ "cannot read file system information for {}: {}",
+ display_name.quote(),
+ e
+ );
+ return 1;
+ }
+ }
+ } else {
let result = if self.follow || stdin_is_fifo && display_name == "-" {
fs::metadata(&file)
} else {
@@ -533,9 +723,9 @@ impl Stater {
&self.default_dev_tokens
};
- for t in tokens.iter() {
+ for t in tokens {
match *t {
- Token::Char(c) => print!("{}", c),
+ Token::Char(c) => print!("{c}"),
Token::Directive {
flag,
width,
@@ -588,7 +778,7 @@ impl Stater {
let dst = match fs::read_link(&file) {
Ok(path) => path,
Err(e) => {
- println!("{}", e);
+ println!("{e}");
return 1;
}
};
@@ -618,10 +808,14 @@ impl Stater {
}
// time of file birth, human-readable; - if unknown
- 'w' => OutputType::Str(meta.pretty_birth()),
+ 'w' => OutputType::Str(
+ meta.birth()
+ .map(|(sec, nsec)| pretty_time(sec as i64, nsec as i64))
+ .unwrap_or(String::from("-")),
+ ),
// time of file birth, seconds since Epoch; 0 if unknown
- 'W' => OutputType::Unsigned(meta.birth()),
+ 'W' => OutputType::Unsigned(meta.birth().unwrap_or_default().0),
// time of last access, human-readable
'x' => OutputType::Str(pretty_time(
@@ -657,66 +851,6 @@ impl Stater {
return 1;
}
}
- } else {
- #[cfg(unix)]
- let p = file.as_bytes();
- #[cfg(not(unix))]
- let p = file.into_string().unwrap();
- match statfs(p) {
- Ok(meta) => {
- let tokens = &self.default_tokens;
-
- for t in tokens.iter() {
- match *t {
- Token::Char(c) => print!("{}", c),
- Token::Directive {
- flag,
- width,
- precision,
- format,
- } => {
- let output = match format {
- // free blocks available to non-superuser
- 'a' => OutputType::Unsigned(meta.avail_blocks()),
- // total data blocks in file system
- 'b' => OutputType::Unsigned(meta.total_blocks()),
- // total file nodes in file system
- 'c' => OutputType::Unsigned(meta.total_file_nodes()),
- // free file nodes in file system
- 'd' => OutputType::Unsigned(meta.free_file_nodes()),
- // free blocks in file system
- 'f' => OutputType::Unsigned(meta.free_blocks()),
- // file system ID in hex
- 'i' => OutputType::UnsignedHex(meta.fsid()),
- // maximum length of filenames
- 'l' => OutputType::Unsigned(meta.namelen()),
- // file name
- 'n' => OutputType::Str(display_name.to_string()),
- // block size (for faster transfers)
- 's' => OutputType::Unsigned(meta.io_size()),
- // fundamental block size (for block counts)
- 'S' => OutputType::Integer(meta.block_size()),
- // file system type in hex
- 't' => OutputType::UnsignedHex(meta.fs_type() as u64),
- // file system type in human readable form
- 'T' => OutputType::Str(pretty_fstype(meta.fs_type()).into()),
- _ => OutputType::Unknown,
- };
-
- print_it(&output, flag, width, precision);
- }
- }
- }
- }
- Err(e) => {
- show_error!(
- "cannot read file system information for {}: {}",
- display_name.quote(),
- e
- );
- return 1;
- }
- }
}
0
}
@@ -751,67 +885,9 @@ impl Stater {
}
}
-fn get_long_usage() -> &'static str {
- "
-The valid format sequences for files (without --file-system):
-
- %a access rights in octal (note '#' and '0' printf flags)
- %A access rights in human readable form
- %b number of blocks allocated (see %B)
- %B the size in bytes of each block reported by %b
- %C SELinux security context string
- %d device number in decimal
- %D device number in hex
- %f raw mode in hex
- %F file type
- %g group ID of owner
- %G group name of owner
- %h number of hard links
- %i inode number
- %m mount point
- %n file name
- %N quoted file name with dereference if symbolic link
- %o optimal I/O transfer size hint
- %s total size, in bytes
- %t major device type in hex, for character/block device special files
- %T minor device type in hex, for character/block device special files
- %u user ID of owner
- %U user name of owner
- %w time of file birth, human-readable; - if unknown
- %W time of file birth, seconds since Epoch; 0 if unknown
- %x time of last access, human-readable
- %X time of last access, seconds since Epoch
- %y time of last data modification, human-readable
- %Y time of last data modification, seconds since Epoch
- %z time of last status change, human-readable
- %Z time of last status change, seconds since Epoch
-
-Valid format sequences for file systems:
-
- %a free blocks available to non-superuser
- %b total data blocks in file system
- %c total file nodes in file system
- %d free file nodes in file system
- %f free blocks in file system
- %i file system ID in hex
- %l maximum length of filenames
- %n file name
- %s block size (for faster transfers)
- %S fundamental block size (for block counts)
- %t file system type in hex
- %T file system type in human readable form
-
-NOTE: your shell may have its own version of stat, which usually supersedes
-the version described here. Please refer to your shell's documentation
-for details about the options it supports.
-"
-}
-
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let matches = uu_app()
- .after_help(get_long_usage())
- .try_get_matches_from(args)?;
+ let matches = uu_app().after_help(LONG_USAGE).try_get_matches_from(args)?;
let stater = Stater::new(&matches)?;
let exit_status = stater.exec();
@@ -877,6 +953,16 @@ pub fn uu_app() -> Command {
)
}
+const PRETTY_DATETIME_FORMAT: &str = "%Y-%m-%d %H:%M:%S.%f %z";
+
+fn pretty_time(sec: i64, nsec: i64) -> String {
+ // Return the date in UTC
+ let tm = chrono::DateTime::from_timestamp(sec, nsec as u32).unwrap_or_default();
+ let tm: DateTime<Local> = tm.into();
+
+ tm.format(PRETTY_DATETIME_FORMAT).to_string()
+}
+
#[cfg(test)]
mod tests {
use super::{group_num, Flags, ScanUtil, Stater, Token};
@@ -895,6 +981,7 @@ mod tests {
}
#[test]
+ #[allow(clippy::cognitive_complexity)]
fn test_group_num() {
assert_eq!("12,379,821,234", group_num("12379821234"));
assert_eq!("21,234", group_num("21234"));
diff --git a/src/uu/stat/stat.md b/src/uu/stat/stat.md
new file mode 100644
index 0000000000000000000000000000000000000000..ac63edd18d24a6012e58de36cc709fee5d1b46ed
--- /dev/null
+++ b/src/uu/stat/stat.md
@@ -0,0 +1,61 @@
+# stat
+
+```
+stat [OPTION]... FILE...
+```
+
+Display file or file system status.
+
+## Long Usage
+
+Valid format sequences for files (without `--file-system`):
+
+- `%a`: access rights in octal (note '#' and '0' printf flags)
+- `%A`: access rights in human readable form
+- `%b`: number of blocks allocated (see %B)
+- `%B`: the size in bytes of each block reported by %b
+- `%C`: SELinux security context string
+- `%d`: device number in decimal
+- `%D`: device number in hex
+- `%f`: raw mode in hex
+- `%F`: file type
+- `%g`: group ID of owner
+- `%G`: group name of owner
+- `%h`: number of hard links
+- `%i`: inode number
+- `%m`: mount point
+- `%n`: file name
+- `%N`: quoted file name with dereference (follow) if symbolic link
+- `%o`: optimal I/O transfer size hint
+- `%s`: total size, in bytes
+- `%t`: major device type in hex, for character/block device special files
+- `%T`: minor device type in hex, for character/block device special files
+- `%u`: user ID of owner
+- `%U`: user name of owner
+- `%w`: time of file birth, human-readable; - if unknown
+- `%W`: time of file birth, seconds since Epoch; 0 if unknown
+- `%x`: time of last access, human-readable
+- `%X`: time of last access, seconds since Epoch
+- `%y`: time of last data modification, human-readable
+- `%Y`: time of last data modification, seconds since Epoch
+- `%z`: time of last status change, human-readable
+- `%Z`: time of last status change, seconds since Epoch
+
+Valid format sequences for file systems:
+
+- `%a`: free blocks available to non-superuser
+- `%b`: total data blocks in file system
+- `%c`: total file nodes in file system
+- `%d`: free file nodes in file system
+- `%f`: free blocks in file system
+- `%i`: file system ID in hex
+- `%l`: maximum length of filenames
+- `%n`: file name
+- `%s`: block size (for faster transfers)
+- `%S`: fundamental block size (for block counts)
+- `%t`: file system type in hex
+- `%T`: file system type in human readable form
+
+NOTE: your shell may have its own version of stat, which usually supersedes
+the version described here. Please refer to your shell's documentation
+for details about the options it supports.
diff --git a/src/uu/stdbuf/Cargo.toml b/src/uu/stdbuf/Cargo.toml
index aad0d29e104ce077c16870ff954ddc68fa621e82..af4c1b80b0e9da4715c2f42bd1a5d262850efd38 100644
--- a/src/uu/stdbuf/Cargo.toml
+++ b/src/uu/stdbuf/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_stdbuf"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "stdbuf ~ (uutils) run COMMAND with modified standard stream buffering"
@@ -15,12 +15,12 @@ edition = "2021"
path = "src/stdbuf.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-tempfile = "3"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+tempfile = { workspace = true }
+uucore = { workspace = true }
[build-dependencies]
-libstdbuf = { version="0.0.17", package="uu_stdbuf_libstdbuf", path="src/libstdbuf" }
+libstdbuf = { version = "0.0.27", package = "uu_stdbuf_libstdbuf", path = "src/libstdbuf" }
[[bin]]
name = "stdbuf"
diff --git a/src/uu/stdbuf/build.rs b/src/uu/stdbuf/build.rs
index 9d36f20f4f16275e70b64de9fca4da7363fb1113..7483aeacfefe5088cfc9770f2cb55c287afe0883 100644
--- a/src/uu/stdbuf/build.rs
+++ b/src/uu/stdbuf/build.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) dylib libstdbuf deps liblibstdbuf
use std::env;
@@ -9,7 +13,7 @@ mod platform {
pub const DYLIB_EXT: &str = ".so";
}
-#[cfg(any(target_vendor = "apple"))]
+#[cfg(target_vendor = "apple")]
mod platform {
pub const DYLIB_EXT: &str = ".dylib";
}
@@ -23,19 +27,34 @@ fn main() {
let out_dir = env::var("OUT_DIR").unwrap();
let mut target_dir = Path::new(&out_dir);
- // Depending on how this is util is built, the directory structure. This seems to work for now.
- // Here are three cases to test when changing this:
+ // Depending on how this is util is built, the directory structure changes.
+ // This seems to work for now. Here are three cases to test when changing
+ // this:
+ //
// - cargo run
// - cross run
// - cargo install --git
// - cargo publish --dry-run
+ //
+ // The goal is to find the directory in which we are installing, but that
+ // depends on the build method, which is annoying. Additionally the env
+ // var for the profile can only be "debug" or "release", not a custom
+ // profile name, so we have to use the name of the directory within target
+ // as the profile name.
+ //
+ // Adapted from https://stackoverflow.com/questions/73595435/how-to-get-profile-from-cargo-toml-in-build-rs-or-at-runtime
+ let profile_name = out_dir
+ .split(std::path::MAIN_SEPARATOR)
+ .nth_back(3)
+ .unwrap();
+
let mut name = target_dir.file_name().unwrap().to_string_lossy();
while name != "target" && !name.starts_with("cargo-install") {
target_dir = target_dir.parent().unwrap();
name = target_dir.file_name().unwrap().to_string_lossy();
}
let mut dir = target_dir.to_path_buf();
- dir.push(env::var("PROFILE").unwrap());
+ dir.push(profile_name);
dir.push("deps");
let mut path = None;
diff --git a/src/uu/stdbuf/src/libstdbuf/Cargo.toml b/src/uu/stdbuf/src/libstdbuf/Cargo.toml
index c40f3aa86ba2714e035a71ff65bfe0aa86461ae2..28c3f60c82d6e43421a90b8b93bdef2d2f69b211 100644
--- a/src/uu/stdbuf/src/libstdbuf/Cargo.toml
+++ b/src/uu/stdbuf/src/libstdbuf/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_stdbuf_libstdbuf"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "stdbuf/libstdbuf ~ (uutils); dynamic library required for stdbuf"
@@ -14,12 +14,14 @@ edition = "2021"
[lib]
name = "libstdbuf"
path = "src/libstdbuf.rs"
-crate-type = ["cdylib", "rlib"] # XXX: note: the rlib is just to prevent Cargo from spitting out a warning
+crate-type = [
+ "cdylib",
+ "rlib",
+] # XXX: note: the rlib is just to prevent Cargo from spitting out a warning
[dependencies]
-cpp = "0.5"
-libc = "0.2"
-uucore = { version=">=0.0.17", package="uucore", path="../../../../uucore" }
+cpp = "0.5.9"
+libc = { workspace = true }
[build-dependencies]
-cpp_build = "0.5"
+cpp_build = "0.5.9"
diff --git a/src/uu/stdbuf/src/libstdbuf/build.rs b/src/uu/stdbuf/src/libstdbuf/build.rs
index fc8ddeac89797e551bf813f628b43d11cd381bdb..6dcd6a86912d6ff2df8991ba78283db3ccd453c9 100644
--- a/src/uu/stdbuf/src/libstdbuf/build.rs
+++ b/src/uu/stdbuf/src/libstdbuf/build.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) libstdbuf
use cpp_build::Config;
diff --git a/src/uu/stdbuf/src/libstdbuf/src/libstdbuf.rs b/src/uu/stdbuf/src/libstdbuf/src/libstdbuf.rs
index ec99c386458fd431d7cb277ef6fdce54d7aa5fe9..d744ca4c5456a0ab1a99c7a5566902b7b6c4e9bd 100644
--- a/src/uu/stdbuf/src/libstdbuf/src/libstdbuf.rs
+++ b/src/uu/stdbuf/src/libstdbuf/src/libstdbuf.rs
@@ -1,10 +1,13 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) IOFBF IOLBF IONBF cstdio setvbuf
use cpp::cpp;
-use libc::{c_char, c_int, size_t, FILE, _IOFBF, _IOLBF, _IONBF};
+use libc::{c_char, c_int, fileno, size_t, FILE, _IOFBF, _IOLBF, _IONBF};
use std::env;
use std::ptr;
-use uucore::crash;
cpp! {{
#include <cstdio>
@@ -36,7 +39,10 @@ fn set_buffer(stream: *mut FILE, value: &str) {
input => {
let buff_size: usize = match input.parse() {
Ok(num) => num,
- Err(e) => crash!(1, "incorrect size of buffer!: {}", e),
+ Err(_) => {
+ eprintln!("failed to allocate a {} byte stdio buffer", value);
+ std::process::exit(1);
+ }
};
(_IOFBF, buff_size as size_t)
}
@@ -48,7 +54,11 @@ fn set_buffer(stream: *mut FILE, value: &str) {
res = libc::setvbuf(stream, buffer, mode, size);
}
if res != 0 {
- crash!(res, "error while calling setvbuf!");
+ eprintln!(
+ "could not set buffering of {} to mode {}",
+ unsafe { fileno(stream) },
+ mode
+ );
}
}
diff --git a/src/uu/stdbuf/src/stdbuf.rs b/src/uu/stdbuf/src/stdbuf.rs
index 97e06ad1990ff2035eb3bf28d70d5795faf2c61c..d2375b2f60858a8a6b986557b531fbbcc23402cf 100644
--- a/src/uu/stdbuf/src/stdbuf.rs
+++ b/src/uu/stdbuf/src/stdbuf.rs
@@ -1,39 +1,25 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Dorota Kapturkiewicz <dokaptur@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-// spell-checker:ignore (ToDO) tempdir dyld dylib dragonflybsd optgrps libstdbuf
+// spell-checker:ignore (ToDO) tempdir dyld dylib optgrps libstdbuf
use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
use std::fs::File;
-use std::io::{self, Write};
+use std::io::Write;
use std::os::unix::process::ExitStatusExt;
use std::path::PathBuf;
use std::process;
use tempfile::tempdir;
use tempfile::TempDir;
use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
-use uucore::parse_size::parse_size;
-use uucore::{crash, format_usage};
-
-static ABOUT: &str =
- "Run COMMAND, with modified buffering operations for its standard streams.\n\n\
- Mandatory arguments to long options are mandatory for short options too.";
-const USAGE: &str = "{} OPTION... COMMAND";
-static LONG_HELP: &str = "If MODE is 'L' the corresponding stream will be line buffered.\n\
- This option is invalid with standard input.\n\n\
- If MODE is '0' the corresponding stream will be unbuffered.\n\n\
- Otherwise MODE is a number which may be followed by one of the following:\n\n\
- KB 1000, K 1024, MB 1000*1000, M 1024*1024, and so on for G, T, P, E, Z, Y.\n\
- In this case the corresponding stream will be fully buffered with the buffer size set to \
- MODE bytes.\n\n\
- NOTE: If COMMAND adjusts the buffering of its standard streams ('tee' does for e.g.) then \
- that will override corresponding settings changed by 'stdbuf'.\n\
- Also some filters (like 'dd' and 'cat' etc.) don't use streams for I/O, \
- and are thus unaffected by 'stdbuf' settings.\n";
+use uucore::parse_size::parse_size_u64;
+use uucore::{format_usage, help_about, help_section, help_usage};
+
+const ABOUT: &str = help_about!("stdbuf.md");
+const USAGE: &str = help_usage!("stdbuf.md");
+const LONG_HELP: &str = help_section!("after help", "stdbuf.md");
mod options {
pub const INPUT: &str = "input";
@@ -78,15 +64,15 @@ struct ProgramOptionsError(String);
target_os = "android",
target_os = "freebsd",
target_os = "netbsd",
- target_os = "dragonflybsd"
+ target_os = "dragonfly"
))]
-fn preload_strings() -> (&'static str, &'static str) {
- ("LD_PRELOAD", "so")
+fn preload_strings() -> UResult<(&'static str, &'static str)> {
+ Ok(("LD_PRELOAD", "so"))
}
#[cfg(target_vendor = "apple")]
-fn preload_strings() -> (&'static str, &'static str) {
- ("DYLD_LIBRARY_PATH", "dylib")
+fn preload_strings() -> UResult<(&'static str, &'static str)> {
+ Ok(("DYLD_LIBRARY_PATH", "dylib"))
}
#[cfg(not(any(
@@ -94,13 +80,14 @@ fn preload_strings() -> (&'static str, &'static str) {
target_os = "android",
target_os = "freebsd",
target_os = "netbsd",
- target_os = "dragonflybsd",
+ target_os = "dragonfly",
target_vendor = "apple"
)))]
-fn preload_strings() -> (&'static str, &'static str) {
- use uucore::crash;
-
- crash!(1, "Command not supported for this operating system!")
+fn preload_strings() -> UResult<(&'static str, &'static str)> {
+ Err(USimpleError::new(
+ 1,
+ "Command not supported for this operating system!",
+ ))
}
fn check_option(matches: &ArgMatches, name: &str) -> Result<BufferType, ProgramOptionsError> {
@@ -115,13 +102,12 @@ fn check_option(matches: &ArgMatches, name: &str) -> Result<BufferType, ProgramO
Ok(BufferType::Line)
}
}
- x => parse_size(x).map_or_else(
- |e| crash!(125, "invalid mode {}", e),
+ x => parse_size_u64(x).map_or_else(
+ |e| Err(ProgramOptionsError(format!("invalid mode {e}"))),
|m| {
Ok(BufferType::Size(m.try_into().map_err(|_| {
ProgramOptionsError(format!(
- "invalid mode '{}': Value too large for defined data type",
- x
+ "invalid mode '{x}': Value too large for defined data type"
))
})?))
},
@@ -143,8 +129,8 @@ fn set_command_env(command: &mut process::Command, buffer_name: &str, buffer_typ
}
}
-fn get_preload_env(tmp_dir: &mut TempDir) -> io::Result<(String, PathBuf)> {
- let (preload, extension) = preload_strings();
+fn get_preload_env(tmp_dir: &TempDir) -> UResult<(String, PathBuf)> {
+ let (preload, extension) = preload_strings()?;
let inject_path = tmp_dir.path().join("libstdbuf").with_extension(extension);
let mut file = File::create(&inject_path)?;
@@ -155,8 +141,6 @@ fn get_preload_env(tmp_dir: &mut TempDir) -> io::Result<(String, PathBuf)> {
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_ignore();
-
let matches = uu_app().try_get_matches_from(args)?;
let options = ProgramOptions::try_from(&matches).map_err(|e| UUsageError::new(125, e.0))?;
@@ -165,8 +149,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let mut command = process::Command::new(command_values.next().unwrap());
let command_params: Vec<&str> = command_values.map(|s| s.as_ref()).collect();
- let mut tmp_dir = tempdir().unwrap();
- let (preload_env, libstdbuf) = get_preload_env(&mut tmp_dir).map_err_context(String::new)?;
+ let tmp_dir = tempdir().unwrap();
+ let (preload_env, libstdbuf) = get_preload_env(&tmp_dir)?;
command.env(preload_env, libstdbuf);
set_command_env(&mut command, "_STDBUF_I", &options.stdin);
set_command_env(&mut command, "_STDBUF_O", &options.stdout);
diff --git a/src/uu/stdbuf/stdbuf.md b/src/uu/stdbuf/stdbuf.md
new file mode 100644
index 0000000000000000000000000000000000000000..e0062e6271a0bb8804ed0b2cacd9d29a659bf1d6
--- /dev/null
+++ b/src/uu/stdbuf/stdbuf.md
@@ -0,0 +1,24 @@
+# stdbuf
+
+```
+stdbuf [OPTION]... COMMAND
+```
+
+Run `COMMAND`, with modified buffering operations for its standard streams.
+
+Mandatory arguments to long options are mandatory for short options too.
+
+## After Help
+
+If `MODE` is 'L' the corresponding stream will be line buffered.
+This option is invalid with standard input.
+
+If `MODE` is '0' the corresponding stream will be unbuffered.
+
+Otherwise, `MODE` is a number which may be followed by one of the following:
+
+KB 1000, K 1024, MB 1000*1000, M 1024*1024, and so on for G, T, P, E, Z, Y.
+In this case the corresponding stream will be fully buffered with the buffer size set to `MODE` bytes.
+
+NOTE: If `COMMAND` adjusts the buffering of its standard streams (`tee` does for e.g.) then that will override corresponding settings changed by `stdbuf`.
+Also some filters (like `dd` and `cat` etc.) don't use streams for I/O, and are thus unaffected by `stdbuf` settings.
diff --git a/src/uu/stty/Cargo.toml b/src/uu/stty/Cargo.toml
index 06e926e68deec985d289b174410b0fd41767b157..9fe80ea61ae3c18ce825085b3b4f2bf0e330e435 100644
--- a/src/uu/stty/Cargo.toml
+++ b/src/uu/stty/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_stty"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "stty ~ (uutils) print or change terminal characteristics"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/stty.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
-nix = { version="0.25", features = ["term"] }
+clap = { workspace = true }
+uucore = { workspace = true }
+nix = { workspace = true, features = ["term", "ioctl"] }
[[bin]]
name = "stty"
diff --git a/src/uu/stty/src/flags.rs b/src/uu/stty/src/flags.rs
index 2c3f00eecceb8c26cde04152db30b30426c5dd91..eac57151be9adc1a2646e348b9fa97be685ab762 100644
--- a/src/uu/stty/src/flags.rs
+++ b/src/uu/stty/src/flags.rs
@@ -1,12 +1,14 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore parenb parodd cmspar hupcl cstopb cread clocal crtscts CSIZE
// spell-checker:ignore ignbrk brkint ignpar parmrk inpck istrip inlcr igncr icrnl ixoff ixon iuclc ixany imaxbel iutf
-// spell-checker:ignore opost olcuc ocrnl onlcr onocr onlret ofill ofdel nldly crdly tabdly bsdly vtdly ffdly
+// spell-checker:ignore opost olcuc ocrnl onlcr onocr onlret ofdel nldly crdly tabdly bsdly vtdly ffdly
// spell-checker:ignore isig icanon iexten echoe crterase echok echonl noflsh xcase tostop echoprt prterase echoctl ctlecho echoke crtkill flusho extproc
+// spell-checker:ignore lnext rprnt susp swtch vdiscard veof veol verase vintr vkill vlnext vquit vreprint vstart vstop vsusp vswtc vwerase werase
+// spell-checker:ignore sigquit sigtstp
use crate::Flag;
@@ -19,7 +21,10 @@ use crate::Flag;
target_os = "openbsd"
)))]
use nix::sys::termios::BaudRate;
-use nix::sys::termios::{ControlFlags as C, InputFlags as I, LocalFlags as L, OutputFlags as O};
+use nix::sys::termios::{
+ ControlFlags as C, InputFlags as I, LocalFlags as L, OutputFlags as O,
+ SpecialCharacterIndices as S,
+};
pub const CONTROL_FLAGS: &[Flag<C>] = &[
Flag::new("parenb", C::PARENB),
@@ -81,14 +86,6 @@ pub const OUTPUT_FLAGS: &[Flag<O>] = &[
target_os = "linux",
target_os = "macos"
))]
- Flag::new("ofill", O::OFILL),
- #[cfg(any(
- target_os = "android",
- target_os = "haiku",
- target_os = "ios",
- target_os = "linux",
- target_os = "macos"
- ))]
Flag::new("ofdel", O::OFDEL),
#[cfg(any(
target_os = "android",
@@ -313,3 +310,40 @@ pub const BAUD_RATES: &[(&str, BaudRate)] = &[
))]
("4000000", BaudRate::B4000000),
];
+/// Control characters for the stty command.
+///
+/// This constant provides a mapping between the names of control characters
+/// and their corresponding values in the `S` enum.
+pub const CONTROL_CHARS: &[(&str, S)] = &[
+ // Sends an interrupt signal (SIGINT).
+ ("intr", S::VINTR),
+ // Sends a quit signal (SIGQUIT).
+ ("quit", S::VQUIT),
+ // Deletes the last typed character.
+ ("erase", S::VERASE),
+ // Deletes the current line.
+ ("kill", S::VKILL),
+ // Signals the end of input.
+ ("eof", S::VEOF),
+ // Signals the end of line.
+ ("eol", S::VEOL),
+ // Alternate end-of-line character.
+ ("eol2", S::VEOL2),
+ // Switch character (only on Linux).
+ #[cfg(target_os = "linux")]
+ ("swtch", S::VSWTC),
+ // Starts output after it has been stopped.
+ ("start", S::VSTART),
+ // Stops output.
+ ("stop", S::VSTOP),
+ // Sends a suspend signal (SIGTSTP).
+ ("susp", S::VSUSP),
+ // Reprints the current line.
+ ("rprnt", S::VREPRINT),
+ // Deletes the last word typed.
+ ("werase", S::VWERASE),
+ // Enters literal mode (next character is taken literally).
+ ("lnext", S::VLNEXT),
+ // Discards the current line.
+ ("discard", S::VDISCARD),
+];
diff --git a/src/uu/stty/src/stty.rs b/src/uu/stty/src/stty.rs
index 3c3fcaf638ddfa9c125909c5abda924fac33e1a1..5a5c31f5e6064ace6488427b7efa663b0184c658 100644
--- a/src/uu/stty/src/stty.rs
+++ b/src/uu/stty/src/stty.rs
@@ -1,23 +1,27 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-// spell-checker:ignore tcgetattr tcsetattr tcsanow tiocgwinsz tiocswinsz cfgetospeed ushort
+// spell-checker:ignore clocal erange tcgetattr tcsetattr tcsanow tiocgwinsz tiocswinsz cfgetospeed cfsetospeed ushort vmin vtime
mod flags;
use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
-use nix::libc::{c_ushort, TIOCGWINSZ, TIOCSWINSZ};
+use nix::libc::{c_ushort, O_NONBLOCK, TIOCGWINSZ, TIOCSWINSZ};
use nix::sys::termios::{
- cfgetospeed, tcgetattr, tcsetattr, ControlFlags, InputFlags, LocalFlags, OutputFlags, Termios,
+ cfgetospeed, cfsetospeed, tcgetattr, tcsetattr, ControlFlags, InputFlags, LocalFlags,
+ OutputFlags, SpecialCharacterIndices, Termios,
};
use nix::{ioctl_read_bad, ioctl_write_ptr_bad};
-use std::io::{self, stdout};
+use std::fs::File;
+use std::io::{self, stdout, Stdout};
use std::ops::ControlFlow;
+use std::os::fd::{AsFd, BorrowedFd};
+use std::os::unix::fs::OpenOptionsExt;
use std::os::unix::io::{AsRawFd, RawFd};
use uucore::error::{UResult, USimpleError};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
#[cfg(not(any(
target_os = "freebsd",
@@ -28,13 +32,10 @@ use uucore::format_usage;
target_os = "openbsd"
)))]
use flags::BAUD_RATES;
-use flags::{CONTROL_FLAGS, INPUT_FLAGS, LOCAL_FLAGS, OUTPUT_FLAGS};
+use flags::{CONTROL_CHARS, CONTROL_FLAGS, INPUT_FLAGS, LOCAL_FLAGS, OUTPUT_FLAGS};
-const USAGE: &str = "\
- {} [-F DEVICE | --file=DEVICE] [SETTING]...
- {} [-F DEVICE | --file=DEVICE] [-a|--all]
- {} [-F DEVICE | --file=DEVICE] [-g|--save]";
-const SUMMARY: &str = "Print or change terminal characteristics.";
+const USAGE: &str = help_usage!("stty.md");
+const SUMMARY: &str = help_about!("stty.md");
#[derive(Clone, Copy, Debug)]
pub struct Flag<T> {
@@ -92,18 +93,55 @@ mod options {
struct Options<'a> {
all: bool,
save: bool,
- file: RawFd,
+ file: Device,
settings: Option<Vec<&'a str>>,
}
+enum Device {
+ File(File),
+ Stdout(Stdout),
+}
+
+impl AsFd for Device {
+ fn as_fd(&self) -> BorrowedFd<'_> {
+ match self {
+ Self::File(f) => f.as_fd(),
+ Self::Stdout(stdout) => stdout.as_fd(),
+ }
+ }
+}
+
+impl AsRawFd for Device {
+ fn as_raw_fd(&self) -> RawFd {
+ match self {
+ Self::File(f) => f.as_raw_fd(),
+ Self::Stdout(stdout) => stdout.as_raw_fd(),
+ }
+ }
+}
+
impl<'a> Options<'a> {
fn from(matches: &'a ArgMatches) -> io::Result<Self> {
Ok(Self {
all: matches.get_flag(options::ALL),
save: matches.get_flag(options::SAVE),
file: match matches.get_one::<String>(options::FILE) {
- Some(_f) => todo!(),
- None => stdout().as_raw_fd(),
+ // Two notes here:
+ // 1. O_NONBLOCK is needed because according to GNU docs, a
+ // POSIX tty can block waiting for carrier-detect if the
+ // "clocal" flag is not set. If your TTY is not connected
+ // to a modem, it is probably not relevant though.
+ // 2. We never close the FD that we open here, but the OS
+ // will clean up the FD for us on exit, so it doesn't
+ // matter. The alternative would be to have an enum of
+ // BorrowedFd/OwnedFd to handle both cases.
+ Some(f) => Device::File(
+ std::fs::OpenOptions::new()
+ .read(true)
+ .custom_flags(O_NONBLOCK)
+ .open(f)?,
+ ),
+ None => Device::Stdout(stdout()),
},
settings: matches
.get_many::<String>(options::SETTINGS)
@@ -138,8 +176,6 @@ ioctl_write_ptr_bad!(
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_lossy();
-
let matches = uu_app().try_get_matches_from(args)?;
let opts = Options::from(&matches)?;
@@ -163,20 +199,24 @@ fn stty(opts: &Options) -> UResult<()> {
}
// TODO: Figure out the right error message for when tcgetattr fails
- let mut termios = tcgetattr(opts.file).expect("Could not get terminal attributes");
+ let mut termios = tcgetattr(opts.file.as_fd()).expect("Could not get terminal attributes");
if let Some(settings) = &opts.settings {
for setting in settings {
if let ControlFlow::Break(false) = apply_setting(&mut termios, setting) {
return Err(USimpleError::new(
1,
- format!("invalid argument '{}'", setting),
+ format!("invalid argument '{setting}'"),
));
}
}
- tcsetattr(opts.file, nix::sys::termios::SetArg::TCSANOW, &termios)
- .expect("Could not write terminal attributes");
+ tcsetattr(
+ opts.file.as_fd(),
+ nix::sys::termios::SetArg::TCSANOW,
+ &termios,
+ )
+ .expect("Could not write terminal attributes");
} else {
print_settings(&termios, opts).expect("TODO: make proper error here from nix error");
}
@@ -195,7 +235,7 @@ fn print_terminal_size(termios: &Termios, opts: &Options) -> nix::Result<()> {
target_os = "netbsd",
target_os = "openbsd"
))]
- print!("speed {} baud; ", speed);
+ print!("speed {speed} baud; ");
// Other platforms need to use the baud rate enum, so printing the right value
// becomes slightly more complicated.
@@ -209,14 +249,14 @@ fn print_terminal_size(termios: &Termios, opts: &Options) -> nix::Result<()> {
)))]
for (text, baud_rate) in BAUD_RATES {
if *baud_rate == speed {
- print!("speed {} baud; ", text);
+ print!("speed {text} baud; ");
break;
}
}
if opts.all {
let mut size = TermSize::default();
- unsafe { tiocgwinsz(opts.file, &mut size as *mut _)? };
+ unsafe { tiocgwinsz(opts.file.as_raw_fd(), &mut size as *mut _)? };
print!("rows {}; columns {}; ", size.rows, size.columns);
}
@@ -226,19 +266,84 @@ fn print_terminal_size(termios: &Termios, opts: &Options) -> nix::Result<()> {
// so we get the underlying libc::termios struct to get that information.
let libc_termios: nix::libc::termios = termios.clone().into();
let line = libc_termios.c_line;
- print!("line = {};", line);
+ print!("line = {line};");
}
println!();
Ok(())
}
+fn control_char_to_string(cc: nix::libc::cc_t) -> nix::Result<String> {
+ if cc == 0 {
+ return Ok("<undef>".to_string());
+ }
+
+ let (meta_prefix, code) = if cc >= 0x80 {
+ ("M-", cc - 0x80)
+ } else {
+ ("", cc)
+ };
+
+ // Determine the '^'-prefix if applicable and character based on the code
+ let (ctrl_prefix, character) = match code {
+ // Control characters in ASCII range
+ 0..=0x1f => Ok(("^", (b'@' + code) as char)),
+ // Printable ASCII characters
+ 0x20..=0x7e => Ok(("", code as char)),
+ // DEL character
+ 0x7f => Ok(("^", '?')),
+ // Out of range (above 8 bits)
+ _ => Err(nix::errno::Errno::ERANGE),
+ }?;
+
+ Ok(format!("{meta_prefix}{ctrl_prefix}{character}"))
+}
+
+fn print_control_chars(termios: &Termios, opts: &Options) -> nix::Result<()> {
+ if !opts.all {
+ // TODO: this branch should print values that differ from defaults
+ return Ok(());
+ }
+
+ for (text, cc_index) in CONTROL_CHARS {
+ print!(
+ "{text} = {}; ",
+ control_char_to_string(termios.control_chars[*cc_index as usize])?
+ );
+ }
+ println!(
+ "min = {}; time = {};",
+ termios.control_chars[SpecialCharacterIndices::VMIN as usize],
+ termios.control_chars[SpecialCharacterIndices::VTIME as usize]
+ );
+ Ok(())
+}
+
+fn print_in_save_format(termios: &Termios) {
+ print!(
+ "{:x}:{:x}:{:x}:{:x}",
+ termios.input_flags.bits(),
+ termios.output_flags.bits(),
+ termios.control_flags.bits(),
+ termios.local_flags.bits()
+ );
+ for cc in termios.control_chars {
+ print!(":{cc:x}");
+ }
+ println!();
+}
+
fn print_settings(termios: &Termios, opts: &Options) -> nix::Result<()> {
- print_terminal_size(termios, opts)?;
- print_flags(termios, opts, CONTROL_FLAGS);
- print_flags(termios, opts, INPUT_FLAGS);
- print_flags(termios, opts, OUTPUT_FLAGS);
- print_flags(termios, opts, LOCAL_FLAGS);
+ if opts.save {
+ print_in_save_format(termios);
+ } else {
+ print_terminal_size(termios, opts)?;
+ print_control_chars(termios, opts)?;
+ print_flags(termios, opts, CONTROL_FLAGS);
+ print_flags(termios, opts, INPUT_FLAGS);
+ print_flags(termios, opts, OUTPUT_FLAGS);
+ print_flags(termios, opts, LOCAL_FLAGS);
+ }
Ok(())
}
@@ -258,14 +363,14 @@ fn print_flags<T: TermiosFlag>(termios: &Termios, opts: &Options, flags: &[Flag<
let val = flag.is_in(termios, group);
if group.is_some() {
if val && (!sane || opts.all) {
- print!("{} ", name);
+ print!("{name} ");
printed = true;
}
} else if opts.all || val != sane {
if !val {
print!("-");
}
- print!("{} ", name);
+ print!("{name} ");
printed = true;
}
}
@@ -279,6 +384,8 @@ fn print_flags<T: TermiosFlag>(termios: &Termios, opts: &Options, flags: &[Flag<
/// The value inside the `Break` variant of the `ControlFlow` indicates whether
/// the setting has been applied.
fn apply_setting(termios: &mut Termios, s: &str) -> ControlFlow<bool> {
+ apply_baud_rate_flag(termios, s)?;
+
let (remove, name) = match s.strip_prefix('-') {
Some(s) => (true, s),
None => (false, s),
@@ -321,6 +428,39 @@ fn apply_flag<T: TermiosFlag>(
ControlFlow::Continue(())
}
+fn apply_baud_rate_flag(termios: &mut Termios, input: &str) -> ControlFlow<bool> {
+ // BSDs use a u32 for the baud rate, so any decimal number applies.
+ #[cfg(any(
+ target_os = "freebsd",
+ target_os = "dragonfly",
+ target_os = "ios",
+ target_os = "macos",
+ target_os = "netbsd",
+ target_os = "openbsd"
+ ))]
+ if let Ok(n) = input.parse::<u32>() {
+ cfsetospeed(termios, n).expect("Failed to set baud rate");
+ return ControlFlow::Break(true);
+ }
+
+ // Other platforms use an enum.
+ #[cfg(not(any(
+ target_os = "freebsd",
+ target_os = "dragonfly",
+ target_os = "ios",
+ target_os = "macos",
+ target_os = "netbsd",
+ target_os = "openbsd"
+ )))]
+ for (text, baud_rate) in BAUD_RATES {
+ if *text == input {
+ cfsetospeed(termios, *baud_rate).expect("Failed to set baud rate");
+ return ControlFlow::Break(true);
+ }
+ }
+ ControlFlow::Continue(())
+}
+
pub fn uu_app() -> Command {
Command::new(uucore::util_name())
.version(crate_version!())
diff --git a/src/uu/stty/stty.md b/src/uu/stty/stty.md
new file mode 100644
index 0000000000000000000000000000000000000000..6aa1decf5e7a8668b7f51d600480ae9b3a3f4fd4
--- /dev/null
+++ b/src/uu/stty/stty.md
@@ -0,0 +1,9 @@
+# stty
+
+```
+stty [-F DEVICE | --file=DEVICE] [SETTING]...
+stty [-F DEVICE | --file=DEVICE] [-a|--all]
+stty [-F DEVICE | --file=DEVICE] [-g|--save]
+```
+
+Print or change terminal characteristics.
diff --git a/src/uu/sum/BENCHMARKING.md b/src/uu/sum/BENCHMARKING.md
index d93e4220f747e523f533738bf6c81ddc0830a757..30cda74710b16824df69b134e3c179e0e369445c 100644
--- a/src/uu/sum/BENCHMARKING.md
+++ b/src/uu/sum/BENCHMARKING.md
@@ -1,4 +1,4 @@
-## Benchmarking `sum`
+# Benchmarking `sum`
<!-- spell-checker:ignore wikidatawiki -->
@@ -7,17 +7,17 @@ Large sample files can for example be found in the [Wikipedia database dumps](ht
After you have obtained and uncompressed such a file, you need to build `sum` in release mode
```shell
-$ cargo build --release --package uu_sum
+cargo build --release --package uu_sum
```
and then you can time how it long it takes to checksum the file by running
```shell
-$ time ./target/release/sum wikidatawiki-20211001-pages-logging.xml
+time ./target/release/sum wikidatawiki-20211001-pages-logging.xml
```
For more systematic measurements that include warm-ups, repetitions and comparisons, [Hyperfine](https://github.com/sharkdp/hyperfine) can be helpful. For example, to compare this implementation to the one provided by your distribution run
```shell
-$ hyperfine "./target/release/sum wikidatawiki-20211001-pages-logging.xml" "sum wikidatawiki-20211001-pages-logging.xml"
+hyperfine "./target/release/sum wikidatawiki-20211001-pages-logging.xml" "sum wikidatawiki-20211001-pages-logging.xml"
```
diff --git a/src/uu/sum/Cargo.toml b/src/uu/sum/Cargo.toml
index bcc53d11c68bcd9c1fe322f1e3b6df35079e76ac..028039ed60af34d2df10e7d9b30a21188a3396c4 100644
--- a/src/uu/sum/Cargo.toml
+++ b/src/uu/sum/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_sum"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "sum ~ (uutils) display checksum and block counts for input"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/sum.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "sum"
diff --git a/src/uu/sum/src/sum.rs b/src/uu/sum/src/sum.rs
index 54c254faa8c8e20cc2193c990c7764676b3ea1db..d1f383351aa3e06d2ed8b18cce02d2bfd860befd 100644
--- a/src/uu/sum/src/sum.rs
+++ b/src/uu/sum/src/sum.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) T. Jameson Little <t.jameson.little@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) sysv
@@ -13,11 +11,10 @@ use std::io::{stdin, Read};
use std::path::Path;
use uucore::display::Quotable;
use uucore::error::{FromIo, UResult, USimpleError};
-use uucore::{format_usage, show};
+use uucore::{format_usage, help_about, help_usage, show};
-static USAGE: &str = "{} [OPTION]... [FILE]...";
-static ABOUT: &str = "Checksum and count the blocks in a file.\n\n\
- With no FILE, or when FILE is -, read standard input.";
+const USAGE: &str = help_usage!("sum.md");
+const ABOUT: &str = help_about!("sum.md");
// This can be replaced with usize::div_ceil once it is stabilized.
// This implementation approach is optimized for when `b` is a constant,
@@ -34,8 +31,8 @@ fn bsd_sum(mut reader: Box<dyn Read>) -> (usize, u16) {
match reader.read(&mut buf) {
Ok(n) if n != 0 => {
bytes_read += n;
- for &byte in buf[..n].iter() {
- checksum = (checksum >> 1) + ((checksum & 1) << 15);
+ for &byte in &buf[..n] {
+ checksum = checksum.rotate_right(1);
checksum = checksum.wrapping_add(u16::from(byte));
}
}
@@ -57,7 +54,7 @@ fn sysv_sum(mut reader: Box<dyn Read>) -> (usize, u16) {
match reader.read(&mut buf) {
Ok(n) if n != 0 => {
bytes_read += n;
- for &byte in buf[..n].iter() {
+ for &byte in &buf[..n] {
ret = ret.wrapping_add(u32::from(byte));
}
}
@@ -105,12 +102,10 @@ mod options {
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_lossy();
-
let matches = uu_app().try_get_matches_from(args)?;
let files: Vec<String> = match matches.get_many::<String>(options::FILE) {
- Some(v) => v.clone().map(|v| v.to_owned()).collect(),
+ Some(v) => v.cloned().collect(),
None => vec!["-".to_owned()],
};
@@ -134,9 +129,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
};
if print_names {
- println!("{:0width$} {:width$} {}", sum, blocks, file);
+ println!("{sum:0width$} {blocks:width$} {file}");
} else {
- println!("{:0width$} {:width$}", sum, blocks);
+ println!("{sum:0width$} {blocks:width$}");
}
}
Ok(())
diff --git a/src/uu/sum/sum.md b/src/uu/sum/sum.md
new file mode 100644
index 0000000000000000000000000000000000000000..93dbdbf62d04b4fbbbf8c0af5ecbcffcd48d6b43
--- /dev/null
+++ b/src/uu/sum/sum.md
@@ -0,0 +1,9 @@
+# sum
+
+```
+sum [OPTION]... [FILE]...
+```
+
+Checksum and count the blocks in a file.
+
+With no FILE, or when FILE is -, read standard input.
diff --git a/src/uu/sync/Cargo.toml b/src/uu/sync/Cargo.toml
index f357cdc62e48acd8328e382e30152f99de6a707f..1871c896dac8be3b759e603ee28a8407c2e848b7 100644
--- a/src/uu/sync/Cargo.toml
+++ b/src/uu/sync/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_sync"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "sync ~ (uutils) synchronize cache writes to storage"
@@ -15,15 +15,19 @@ edition = "2021"
path = "src/sync.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-libc = "0.2.137"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["wide"] }
+clap = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true, features = ["wide"] }
[target.'cfg(any(target_os = "linux", target_os = "android"))'.dependencies]
-nix = "0.25"
+nix = { workspace = true }
[target.'cfg(target_os = "windows")'.dependencies]
-windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_Storage_FileSystem", "Win32_System_WindowsProgramming", "Win32_Foundation"] }
+windows-sys = { workspace = true, features = [
+ "Win32_Storage_FileSystem",
+ "Win32_System_WindowsProgramming",
+ "Win32_Foundation",
+] }
[[bin]]
name = "sync"
diff --git a/src/uu/sync/src/sync.rs b/src/uu/sync/src/sync.rs
index d4bc1604d9a4a4becd49d9d201809a30f6f7f647..c0b8f3d00b5b5e3244d94706c46792b56a4d1153 100644
--- a/src/uu/sync/src/sync.rs
+++ b/src/uu/sync/src/sync.rs
@@ -1,14 +1,10 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Alexander Fomin <xander.fomin@ya.ru>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
/* Last synced with: sync (GNU coreutils) 8.13 */
-extern crate libc;
-
use clap::{crate_version, Arg, ArgAction, Command};
#[cfg(any(target_os = "linux", target_os = "android"))]
use nix::errno::Errno;
@@ -21,10 +17,11 @@ use uucore::display::Quotable;
#[cfg(any(target_os = "linux", target_os = "android"))]
use uucore::error::FromIo;
use uucore::error::{UResult, USimpleError};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
+
+const ABOUT: &str = help_about!("sync.md");
+const USAGE: &str = help_usage!("sync.md");
-static ABOUT: &str = "Synchronize cached writes to persistent storage";
-const USAGE: &str = "{} [OPTION]... FILE...";
pub mod options {
pub static FILE_SYSTEM: &str = "file-system";
pub static DATA: &str = "data";
@@ -34,7 +31,6 @@ static ARG_FILES: &str = "files";
#[cfg(unix)]
mod platform {
- use super::libc;
#[cfg(any(target_os = "linux", target_os = "android"))]
use std::fs::File;
#[cfg(any(target_os = "linux", target_os = "android"))]
@@ -175,7 +171,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let path = Path::new(&f);
if let Err(e) = open(path, OFlag::O_NONBLOCK, Mode::empty()) {
if e != Errno::EACCES || (e == Errno::EACCES && path.is_dir()) {
- return e.map_err_context(|| format!("cannot stat {}", f.quote()))?;
+ e.map_err_context(|| format!("error opening {}", f.quote()))?;
}
}
}
@@ -185,7 +181,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
if !Path::new(&f).exists() {
return Err(USimpleError::new(
1,
- format!("cannot stat {}: No such file or directory", f.quote()),
+ format!("error opening {}: No such file or directory", f.quote()),
));
}
}
diff --git a/src/uu/sync/sync.md b/src/uu/sync/sync.md
new file mode 100644
index 0000000000000000000000000000000000000000..2fdd363399ff54290bdb216909db1ddb77c4df65
--- /dev/null
+++ b/src/uu/sync/sync.md
@@ -0,0 +1,7 @@
+# sync
+
+```
+sync [OPTION]... FILE...
+```
+
+Synchronize cached writes to persistent storage
diff --git a/src/uu/tac/BENCHMARKING.md b/src/uu/tac/BENCHMARKING.md
index 4e6d13ea29e8f48c9f1f58a129a4fdcf16377c54..c972d14539d5e87b57518480ca8aea1219a751b8 100644
--- a/src/uu/tac/BENCHMARKING.md
+++ b/src/uu/tac/BENCHMARKING.md
@@ -1,25 +1,36 @@
-## Benchmarking `tac`
+# Benchmarking `tac`
<!-- spell-checker:ignore wikidatawiki -->
-`tac` is often used to process log files in reverse chronological order, i.e. from newer towards older entries. In this case, the performance target to yield results as fast as possible, i.e. without reading in the whole file that is to be reversed line-by-line. Therefore, a sensible benchmark is to read a large log file containing N lines and measure how long it takes to produce the last K lines from that file.
+`tac` is often used to process log files in reverse chronological order, i.e.
+from newer towards older entries. In this case, the performance target to yield
+results as fast as possible, i.e. without reading in the whole file that is to
+be reversed line-by-line. Therefore, a sensible benchmark is to read a large log
+file containing N lines and measure how long it takes to produce the last K
+lines from that file.
-Large text files can for example be found in the [Wikipedia database dumps](https://dumps.wikimedia.org/wikidatawiki/latest/), usually sized at multiple gigabytes and comprising more than 100M lines.
+Large text files can for example be found in the
+[Wikipedia database dumps](https://dumps.wikimedia.org/wikidatawiki/latest/),
+usually sized at multiple gigabytes and comprising more than 100M lines.
-After you have obtained and uncompressed such a file, you need to build `tac` in release mode
+After you have obtained and uncompressed such a file, you need to build `tac`
+in release mode
```shell
-$ cargo build --release --package uu_tac
+cargo build --release --package uu_tac
```
-and then you can time how it long it takes to extract the last 10M lines by running
+and then you can time how it long it takes to extract the last 10M lines by
+running
```shell
-$ /usr/bin/time ./target/release/tac wikidatawiki-20211001-pages-logging.xml | head -n10000000 >/dev/null
+/usr/bin/time ./target/release/tac wikidatawiki-20211001-pages-logging.xml | head -n10000000 >/dev/null
```
-For more systematic measurements that include warm-ups, repetitions and comparisons, [Hyperfine](https://github.com/sharkdp/hyperfine) can be helpful. For example, to compare this implementation to the one provided by your distribution run
+For more systematic measurements that include warm-ups, repetitions and comparisons,
+[Hyperfine](https://github.com/sharkdp/hyperfine) can be helpful.
+For example, to compare this implementation to the one provided by your distribution run
```shell
-$ hyperfine "./target/release/tac wikidatawiki-20211001-pages-logging.xml | head -n10000000 >/dev/null" "/usr/bin/tac wikidatawiki-20211001-pages-logging.xml | head -n10000000 >/dev/null"
+hyperfine "./target/release/tac wikidatawiki-20211001-pages-logging.xml | head -n10000000 >/dev/null" "/usr/bin/tac wikidatawiki-20211001-pages-logging.xml | head -n10000000 >/dev/null"
```
diff --git a/src/uu/tac/Cargo.toml b/src/uu/tac/Cargo.toml
index 31a177e4a77ff6ac4eb991c70b0b99f910d04351..f1687ae600f5553ae40c78f779ff1161a158e626 100644
--- a/src/uu/tac/Cargo.toml
+++ b/src/uu/tac/Cargo.toml
@@ -2,7 +2,7 @@
[package]
name = "uu_tac"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "tac ~ (uutils) concatenate and display input lines in reverse order"
@@ -17,11 +17,11 @@ edition = "2021"
path = "src/tac.rs"
[dependencies]
-memchr = "2"
-memmap2 = "0.5"
-regex = "1"
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+memchr = { workspace = true }
+memmap2 = { workspace = true }
+regex = { workspace = true }
+clap = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "tac"
diff --git a/src/uu/tac/src/error.rs b/src/uu/tac/src/error.rs
index 52c66851624207eb1b02e3f0b3b520623e8a85e3..7a737ad9b97e260040080d6ad940e8cb110fdaa3 100644
--- a/src/uu/tac/src/error.rs
+++ b/src/uu/tac/src/error.rs
@@ -1,7 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//! Errors returned by tac during processing of a file.
use std::error::Error;
use std::fmt::Display;
@@ -44,7 +44,7 @@ impl Error for TacError {}
impl Display for TacError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
- Self::InvalidRegex(e) => write!(f, "invalid regular expression: {}", e),
+ Self::InvalidRegex(e) => write!(f, "invalid regular expression: {e}"),
Self::InvalidArgument(s) => {
write!(f, "{}: read error: Invalid argument", s.maybe_quote())
}
@@ -53,8 +53,8 @@ impl Display for TacError {
"failed to open {} for reading: No such file or directory",
s.quote()
),
- Self::ReadError(s, e) => write!(f, "failed to read from {}: {}", s, e),
- Self::WriteError(e) => write!(f, "failed to write to stdout: {}", e),
+ Self::ReadError(s, e) => write!(f, "failed to read from {s}: {e}"),
+ Self::WriteError(e) => write!(f, "failed to write to stdout: {e}"),
}
}
}
diff --git a/src/uu/tac/src/tac.rs b/src/uu/tac/src/tac.rs
index b0d79e6da735939a99459b0f2e7291cb7768324c..3865c61ae4843e6ddfe372ca0f552a1199c53a11 100644
--- a/src/uu/tac/src/tac.rs
+++ b/src/uu/tac/src/tac.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Alex Lyon <arcterus@mail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) sbytes slen dlen memmem memmap Mmap mmap SIGBUS
mod error;
@@ -19,12 +17,12 @@ use std::{
use uucore::display::Quotable;
use uucore::error::UError;
use uucore::error::UResult;
-use uucore::{format_usage, show};
+use uucore::{format_usage, help_about, help_usage, show};
use crate::error::TacError;
-static USAGE: &str = "{} [OPTION]... [FILE]...";
-static ABOUT: &str = "Write each file to standard output, last line first.";
+static USAGE: &str = help_usage!("tac.md");
+static ABOUT: &str = help_about!("tac.md");
mod options {
pub static BEFORE: &str = "before";
@@ -35,8 +33,6 @@ mod options {
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_lossy();
-
let matches = uu_app().try_get_matches_from(args)?;
let before = matches.get_flag(options::BEFORE);
@@ -222,6 +218,7 @@ fn buffer_tac(data: &[u8], before: bool, separator: &str) -> std::io::Result<()>
Ok(())
}
+#[allow(clippy::cognitive_complexity)]
fn tac(filenames: &[&str], before: bool, regex: bool, separator: &str) -> UResult<()> {
// Compile the regular expression pattern if it is provided.
let maybe_pattern = if regex {
diff --git a/src/uu/tac/tac.md b/src/uu/tac/tac.md
new file mode 100644
index 0000000000000000000000000000000000000000..6787b3f49ebf7e5539b946a1b342cd93e63cbd11
--- /dev/null
+++ b/src/uu/tac/tac.md
@@ -0,0 +1,7 @@
+# tac
+
+```
+tac [OPTION]... [FILE]...
+```
+
+Write each file to standard output, last line first.
diff --git a/src/uu/tail/Cargo.toml b/src/uu/tail/Cargo.toml
index 9ad6d8609463b38294f430551d6d07f33f5121d3..44ea8532714abb06aa40a5411c1dd71242c54838 100644
--- a/src/uu/tail/Cargo.toml
+++ b/src/uu/tail/Cargo.toml
@@ -1,7 +1,7 @@
-# spell-checker:ignore (libs) kqueue
+# spell-checker:ignore (libs) kqueue fundu
[package]
name = "uu_tail"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "tail ~ (uutils) display the last lines of input"
@@ -16,20 +16,23 @@ edition = "2021"
path = "src/tail.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-libc = "0.2.137"
-memchr = "2.5.0"
-notify = { version = "=5.0.0", features=["macos_kqueue"]}
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["ringbuffer", "lines"] }
-same-file = "1.0.6"
-atty = "0.2"
+clap = { workspace = true }
+libc = { workspace = true }
+memchr = { workspace = true }
+notify = { workspace = true }
+uucore = { workspace = true }
+same-file = { workspace = true }
+fundu = { workspace = true }
[target.'cfg(windows)'.dependencies]
-windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_System_Threading", "Win32_Foundation"] }
-winapi-util = { version="0.1.5" }
+windows-sys = { workspace = true, features = [
+ "Win32_System_Threading",
+ "Win32_Foundation",
+] }
+winapi-util = { workspace = true }
-[target.'cfg(unix)'.dependencies]
-nix = { version = "0.25", features = ["fs"] }
+[dev-dependencies]
+rstest = { workspace = true }
[[bin]]
name = "tail"
diff --git a/src/uu/tail/README.md b/src/uu/tail/README.md
index f59e9e147b71cb4fcd747d327cd7028cd65021d2..ef7cfbd6c4d88c9f888c85d70b657fa925a1e3a0 100644
--- a/src/uu/tail/README.md
+++ b/src/uu/tail/README.md
@@ -7,40 +7,59 @@
* `--max-unchanged-stats`
Note:
-There's a stub for `--max-unchanged-stats` so GNU test-suite checks using it can run, however this flag has no functionality yet.
+There's a stub for `--max-unchanged-stats` so GNU test-suite checks using it
+can run, however this flag has no functionality yet.
### Platform support for `--follow` and `--retry`
-The `--follow=descriptor`, `--follow=name` and `--retry` flags have very good support on Linux (inotify backend).
-They work good enough on macOS/BSD (kqueue backend) with some tests failing due to differences of how kqueue works compared to inotify.
-Windows support is there in theory due to ReadDirectoryChanges support by the notify-crate, however these flags are completely untested on Windows.
+
+The `--follow=descriptor`, `--follow=name` and `--retry` flags have very good
+support on Linux (inotify backend).
+They work good enough on macOS/BSD (kqueue backend) with some tests failing due
+to differences of how kqueue works compared to inotify.
+Windows support is there in theory due to ReadDirectoryChanges support by the
+notify-crate, however these flags are completely untested on Windows.
Note:
-The undocumented `---disable-inotify` flag is used to disable the inotify backend to test polling.
-However inotify is a Linux only backend and polling is now supported also for the other backends.
-Because of this, `disable-inotify` is now an alias to the new and more versatile flag name: `--use-polling`.
+The undocumented `---disable-inotify` flag is used to disable the inotify
+backend to test polling.
+However inotify is a Linux only backend and polling is now supported also
+for the other backends.
+Because of this, `disable-inotify` is now an alias to the new and more versatile
+flag name: `--use-polling`.
## Possible optimizations
-* Don't read the whole file if not using `-f` and input is regular file. Read in chunks from the end going backwards, reading each individual chunk forward.
+* Don't read the whole file if not using `-f` and input is regular file.
+ Read in chunks from the end going backwards, reading each individual chunk
+ forward.
* Reduce number of system calls to e.g. `fstat`
-* Improve resource management by adding more system calls to `inotify_rm_watch` when appropriate.
+* Improve resource management by adding more system calls to `inotify_rm_watch`
+ when appropriate.
# GNU test-suite results (9.1.8-e08752)
The functionality for the test "gnu/tests/tail-2/follow-stdin.sh" is implemented.
-It fails because it is provoking closing a file descriptor with `tail -f <&-` and as part of a workaround, Rust's stdlib reopens closed FDs as `/dev/null` which means uu_tail cannot detect this.
-See also, e.g. the discussion at: https://github.com/uutils/coreutils/issues/2873
+It fails because it is provoking closing a file descriptor with `tail -f <&-`
+and as part of a workaround, Rust's stdlib reopens closed FDs as `/dev/null`
+which means uu_tail cannot detect this.
+See also, e.g. the discussion at:
+<https://github.com/uutils/coreutils/issues/2873>
-The functionality for the test "gnu/tests/tail-2/inotify-rotate-resources.sh" is implemented.
-It fails with an error because it is using `strace` to look for calls to `inotify_add_watch` and `inotify_rm_watch`,
+The functionality for the test "gnu/tests/tail-2/inotify-rotate-resources.sh"
+is implemented.
+It fails with an error because it is using `strace` to look for calls to
+`inotify_add_watch` and `inotify_rm_watch`,
however in uu_tail these system calls are invoked from a separate thread.
-If the GNU test would follow threads, i.e. use `strace -f`, this issue could be resolved.
+If the GNU test would follow threads, i.e. use `strace -f`, this issue could be
+resolved.
-There are 5 tests which are fixed but do not (always) pass the test suite if it's run inside the CI.
+There are 5 tests which are fixed but do not (always) pass the test suite
+if it's run inside the CI.
The reason for this is probably related to load/scheduling on the CI test VM.
The tests in question are:
-- [x] `tail-2/F-vs-rename.sh`
-- [x] `tail-2/follow-name.sh`
-- [x] `tail-2/inotify-rotate.sh`
-- [x] `tail-2/overlay-headers.sh`
-- [x] `tail-2/retry.sh`
+
+* [x] `tail-2/F-vs-rename.sh`
+* [x] `tail-2/follow-name.sh`
+* [x] `tail-2/inotify-rotate.sh`
+* [x] `tail-2/overlay-headers.sh`
+* [x] `tail-2/retry.sh`
diff --git a/src/uu/tail/src/args.rs b/src/uu/tail/src/args.rs
index 6e972d25f2ac157f3444a7d28e988299670c4cab..5cadac608698d62fb97901e175f88dfaa695a39f 100644
--- a/src/uu/tail/src/args.rs
+++ b/src/uu/tail/src/args.rs
@@ -1,50 +1,45 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-// spell-checker:ignore (ToDO) kqueue Signum
+// spell-checker:ignore (ToDO) kqueue Signum fundu
use crate::paths::Input;
use crate::{parse, platform, Quotable};
-use atty::Stream;
-use clap::crate_version;
-use clap::{parser::ValueSource, Arg, ArgAction, ArgMatches, Command};
+use clap::{crate_version, value_parser};
+use clap::{Arg, ArgAction, ArgMatches, Command};
+use fundu::{DurationParser, SaturatingInto};
use same_file::Handle;
-use std::collections::VecDeque;
use std::ffi::OsString;
+use std::io::IsTerminal;
use std::time::Duration;
use uucore::error::{UResult, USimpleError, UUsageError};
-use uucore::parse_size::{parse_size, ParseSizeError};
-use uucore::{format_usage, show_warning};
-
-const ABOUT: &str = "\
- Print the last 10 lines of each FILE to standard output.\n\
- With more than one FILE, precede each with a header giving the file name.\n\
- With no FILE, or when FILE is -, read standard input.\n\
- \n\
- Mandatory arguments to long flags are mandatory for short flags too.\
- ";
-const USAGE: &str = "{} [FLAG]... [FILE]...";
+use uucore::parse_size::{parse_size_u64, ParseSizeError};
+use uucore::shortcut_value_parser::ShortcutValueParser;
+use uucore::{format_usage, help_about, help_usage, show_warning};
+
+const ABOUT: &str = help_about!("tail.md");
+const USAGE: &str = help_usage!("tail.md");
pub mod options {
pub mod verbosity {
- pub static QUIET: &str = "quiet";
- pub static VERBOSE: &str = "verbose";
+ pub const QUIET: &str = "quiet";
+ pub const VERBOSE: &str = "verbose";
}
- pub static BYTES: &str = "bytes";
- pub static FOLLOW: &str = "follow";
- pub static LINES: &str = "lines";
- pub static PID: &str = "pid";
- pub static SLEEP_INT: &str = "sleep-interval";
- pub static ZERO_TERM: &str = "zero-terminated";
- pub static DISABLE_INOTIFY_TERM: &str = "-disable-inotify"; // NOTE: three hyphens is correct
- pub static USE_POLLING: &str = "use-polling";
- pub static RETRY: &str = "retry";
- pub static FOLLOW_RETRY: &str = "F";
- pub static MAX_UNCHANGED_STATS: &str = "max-unchanged-stats";
- pub static ARG_FILES: &str = "files";
- pub static PRESUME_INPUT_PIPE: &str = "-presume-input-pipe"; // NOTE: three hyphens is correct
+ pub const BYTES: &str = "bytes";
+ pub const FOLLOW: &str = "follow";
+ pub const LINES: &str = "lines";
+ pub const PID: &str = "pid";
+ pub const SLEEP_INT: &str = "sleep-interval";
+ pub const ZERO_TERM: &str = "zero-terminated";
+ pub const DISABLE_INOTIFY_TERM: &str = "-disable-inotify"; // NOTE: three hyphens is correct
+ pub const USE_POLLING: &str = "use-polling";
+ pub const RETRY: &str = "retry";
+ pub const FOLLOW_RETRY: &str = "F";
+ pub const MAX_UNCHANGED_STATS: &str = "max-unchanged-stats";
+ pub const ARG_FILES: &str = "files";
+ pub const PRESUME_INPUT_PIPE: &str = "-presume-input-pipe"; // NOTE: three hyphens is correct
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -64,15 +59,28 @@ pub enum FilterMode {
}
impl FilterMode {
+ fn from_obsolete_args(args: &parse::ObsoleteArgs) -> Self {
+ let signum = if args.plus {
+ Signum::Positive(args.num)
+ } else {
+ Signum::Negative(args.num)
+ };
+ if args.lines {
+ Self::Lines(signum, b'\n')
+ } else {
+ Self::Bytes(signum)
+ }
+ }
+
fn from(matches: &ArgMatches) -> UResult<Self> {
let zero_term = matches.get_flag(options::ZERO_TERM);
let mode = if let Some(arg) = matches.get_one::<String>(options::BYTES) {
match parse_num(arg) {
Ok(signum) => Self::Bytes(signum),
Err(e) => {
- return Err(UUsageError::new(
+ return Err(USimpleError::new(
1,
- format!("invalid number of bytes: {}", e),
+ format!("invalid number of bytes: '{e}'"),
))
}
}
@@ -83,9 +91,9 @@ impl FilterMode {
Self::Lines(signum, delimiter)
}
Err(e) => {
- return Err(UUsageError::new(
+ return Err(USimpleError::new(
1,
- format!("invalid number of lines: {}", e),
+ format!("invalid number of lines: {e}"),
))
}
}
@@ -122,7 +130,7 @@ pub enum VerificationResult {
NoOutput,
}
-#[derive(Debug, Default)]
+#[derive(Debug)]
pub struct Settings {
pub follow: Option<FollowMode>,
pub max_unchanged_stats: u32,
@@ -133,45 +141,112 @@ pub struct Settings {
pub use_polling: bool,
pub verbose: bool,
pub presume_input_pipe: bool,
- pub inputs: VecDeque<Input>,
+ /// `FILE(s)` positional arguments
+ pub inputs: Vec<Input>,
}
-impl Settings {
- pub fn from(matches: &clap::ArgMatches) -> UResult<Self> {
- let mut settings: Self = Self {
- sleep_sec: Duration::from_secs_f32(1.0),
+impl Default for Settings {
+ fn default() -> Self {
+ Self {
max_unchanged_stats: 5,
- ..Default::default()
- };
+ sleep_sec: Duration::from_secs_f32(1.0),
+ follow: Option::default(),
+ mode: FilterMode::default(),
+ pid: Default::default(),
+ retry: Default::default(),
+ use_polling: Default::default(),
+ verbose: Default::default(),
+ presume_input_pipe: Default::default(),
+ inputs: Vec::default(),
+ }
+ }
+}
- settings.follow = if matches.get_flag(options::FOLLOW_RETRY) {
- Some(FollowMode::Name)
- } else if matches.value_source(options::FOLLOW) != Some(ValueSource::CommandLine) {
- None
- } else if matches.get_one::<String>(options::FOLLOW) == Some(String::from("name")).as_ref()
- {
- Some(FollowMode::Name)
+impl Settings {
+ pub fn from_obsolete_args(args: &parse::ObsoleteArgs, name: Option<&OsString>) -> Self {
+ let mut settings = Self::default();
+ if args.follow {
+ settings.follow = if name.is_some() {
+ Some(FollowMode::Name)
+ } else {
+ Some(FollowMode::Descriptor)
+ };
+ }
+ settings.mode = FilterMode::from_obsolete_args(args);
+ let input = if let Some(name) = name {
+ Input::from(name)
} else {
- Some(FollowMode::Descriptor)
+ Input::default()
+ };
+ settings.inputs.push(input);
+ settings
+ }
+
+ pub fn from(matches: &clap::ArgMatches) -> UResult<Self> {
+ // We're parsing --follow, -F and --retry under the following conditions:
+ // * -F sets --retry and --follow=name
+ // * plain --follow or short -f is the same like specifying --follow=descriptor
+ // * All these options and flags can occur multiple times as command line arguments
+ let follow_retry = matches.get_flag(options::FOLLOW_RETRY);
+ // We don't need to check for occurrences of --retry if -F was specified which already sets
+ // retry
+ let retry = follow_retry || matches.get_flag(options::RETRY);
+ let follow = match (
+ follow_retry,
+ matches
+ .get_one::<String>(options::FOLLOW)
+ .map(|s| s.as_str()),
+ ) {
+ // -F and --follow if -F is specified after --follow. We don't need to care about the
+ // value of --follow.
+ (true, Some(_))
+ // It's ok to use `index_of` instead of `indices_of` since -F and --follow
+ // overwrite themselves (not only the value but also the index).
+ if matches.index_of(options::FOLLOW_RETRY) > matches.index_of(options::FOLLOW) =>
+ {
+ Some(FollowMode::Name)
+ }
+ // * -F and --follow=name if --follow=name is specified after -F
+ // * No occurrences of -F but --follow=name
+ // * -F and no occurrences of --follow
+ (_, Some("name")) | (true, None) => Some(FollowMode::Name),
+ // * -F and --follow=descriptor (or plain --follow, -f) if --follow=descriptor is
+ // specified after -F
+ // * No occurrences of -F but --follow=descriptor, --follow, -f
+ (_, Some(_)) => Some(FollowMode::Descriptor),
+ // The default for no occurrences of -F or --follow
+ (false, None) => None,
};
- settings.retry =
- matches.get_flag(options::RETRY) || matches.get_flag(options::FOLLOW_RETRY);
+ let mut settings: Self = Self {
+ follow,
+ retry,
+ use_polling: matches.get_flag(options::USE_POLLING),
+ mode: FilterMode::from(matches)?,
+ verbose: matches.get_flag(options::verbosity::VERBOSE),
+ presume_input_pipe: matches.get_flag(options::PRESUME_INPUT_PIPE),
+ ..Default::default()
+ };
- if let Some(s) = matches.get_one::<String>(options::SLEEP_INT) {
- settings.sleep_sec = match s.parse::<f32>() {
- Ok(s) => Duration::from_secs_f32(s),
+ if let Some(source) = matches.get_one::<String>(options::SLEEP_INT) {
+ // Advantage of `fundu` over `Duration::(try_)from_secs_f64(source.parse().unwrap())`:
+ // * doesn't panic on errors like `Duration::from_secs_f64` would.
+ // * no precision loss, rounding errors or other floating point problems.
+ // * evaluates to `Duration::MAX` if the parsed number would have exceeded
+ // `DURATION::MAX` or `infinity` was given
+ // * not applied here but it supports customizable time units and provides better error
+ // messages
+ settings.sleep_sec = match DurationParser::without_time_units().parse(source) {
+ Ok(duration) => SaturatingInto::<std::time::Duration>::saturating_into(duration),
Err(_) => {
return Err(UUsageError::new(
1,
- format!("invalid number of seconds: {}", s.quote()),
+ format!("invalid number of seconds: '{source}'"),
))
}
}
}
- settings.use_polling = matches.get_flag(options::USE_POLLING);
-
if let Some(s) = matches.get_one::<String>(options::MAX_UNCHANGED_STATS) {
settings.max_unchanged_stats = match s.parse::<u32>() {
Ok(s) => s,
@@ -211,24 +286,13 @@ impl Settings {
}
}
- settings.mode = FilterMode::from(matches)?;
-
- let mut inputs: VecDeque<Input> = matches
- .get_many::<String>(options::ARG_FILES)
- .map(|v| v.map(|string| Input::from(string.clone())).collect())
- .unwrap_or_default();
-
- // apply default and add '-' to inputs if none is present
- if inputs.is_empty() {
- inputs.push_front(Input::default());
- }
+ settings.inputs = matches
+ .get_many::<OsString>(options::ARG_FILES)
+ .map(|v| v.map(Input::from).collect())
+ .unwrap_or_else(|| vec![Input::default()]);
- settings.verbose = (matches.get_flag(options::verbosity::VERBOSE) || inputs.len() > 1)
- && !matches.get_flag(options::verbosity::QUIET);
-
- settings.inputs = inputs;
-
- settings.presume_input_pipe = matches.get_flag(options::PRESUME_INPUT_PIPE);
+ settings.verbose =
+ settings.inputs.len() > 1 && !matches.get_flag(options::verbosity::QUIET);
Ok(settings)
}
@@ -279,7 +343,7 @@ impl Settings {
.map_or(false, |meta| !meta.is_file())
});
- if !blocking_stdin && atty::is(Stream::Stdin) {
+ if !blocking_stdin && std::io::stdin().is_terminal() {
show_warning!("following standard input indefinitely is ineffective");
}
}
@@ -309,32 +373,31 @@ impl Settings {
}
}
-pub fn arg_iterate<'a>(
- mut args: impl uucore::Args + 'a,
-) -> UResult<Box<dyn Iterator<Item = OsString> + 'a>> {
- // argv[0] is always present
- let first = args.next().unwrap();
- if let Some(second) = args.next() {
- if let Some(s) = second.to_str() {
- match parse::parse_obsolete(s) {
- Some(Ok(iter)) => Ok(Box::new(vec![first].into_iter().chain(iter).chain(args))),
- Some(Err(e)) => Err(UUsageError::new(
- 1,
- match e {
- parse::ParseError::Syntax => format!("bad argument format: {}", s.quote()),
- parse::ParseError::Overflow => format!(
- "invalid argument: {} Value too large for defined datatype",
- s.quote()
- ),
- },
- )),
- None => Ok(Box::new(vec![first, second].into_iter().chain(args))),
- }
- } else {
- Err(UUsageError::new(1, "bad argument encoding".to_owned()))
+pub fn parse_obsolete(arg: &OsString, input: Option<&OsString>) -> UResult<Option<Settings>> {
+ match parse::parse_obsolete(arg) {
+ Some(Ok(args)) => Ok(Some(Settings::from_obsolete_args(&args, input))),
+ None => Ok(None),
+ Some(Err(e)) => {
+ let arg_str = arg.to_string_lossy();
+ Err(USimpleError::new(
+ 1,
+ match e {
+ parse::ParseError::OutOfRange => format!(
+ "invalid number: {}: Numerical result out of range",
+ arg_str.quote()
+ ),
+ parse::ParseError::Overflow => format!("invalid number: {}", arg_str.quote()),
+ // this ensures compatibility to GNU's error message (as tested in misc/tail)
+ parse::ParseError::Context => format!(
+ "option used in invalid context -- {}",
+ arg_str.chars().nth(1).unwrap_or_default()
+ ),
+ parse::ParseError::InvalidEncoding => {
+ format!("bad argument encoding: '{arg_str}'")
+ }
+ },
+ ))
}
- } else {
- Ok(Box::new(vec![first].into_iter()))
}
}
@@ -350,31 +413,67 @@ fn parse_num(src: &str) -> Result<Signum, ParseSizeError> {
starting_with = true;
}
}
- } else {
- return Err(ParseSizeError::ParseFailure(src.to_string()));
}
- parse_size(size_string).map(|n| match (n, starting_with) {
- (0, true) => Signum::PlusZero,
- (0, false) => Signum::MinusZero,
- (n, true) => Signum::Positive(n),
- (n, false) => Signum::Negative(n),
- })
+ match parse_size_u64(size_string) {
+ Ok(n) => match (n, starting_with) {
+ (0, true) => Ok(Signum::PlusZero),
+ (0, false) => Ok(Signum::MinusZero),
+ (n, true) => Ok(Signum::Positive(n)),
+ (n, false) => Ok(Signum::Negative(n)),
+ },
+ Err(_) => Err(ParseSizeError::ParseFailure(size_string.to_string())),
+ }
}
pub fn parse_args(args: impl uucore::Args) -> UResult<Settings> {
- let matches = uu_app().try_get_matches_from(arg_iterate(args)?)?;
- Settings::from(&matches)
+ let args_vec: Vec<OsString> = args.collect();
+ let clap_args = uu_app().try_get_matches_from(args_vec.clone());
+ let clap_result = match clap_args {
+ Ok(matches) => Ok(Settings::from(&matches)?),
+ Err(err) => Err(err.into()),
+ };
+
+ // clap isn't able to handle obsolete syntax.
+ // therefore, we want to check further for obsolete arguments.
+ // argv[0] is always present, argv[1] might be obsolete arguments
+ // argv[2] might contain an input file, argv[3] isn't allowed in obsolete mode
+ if args_vec.len() != 2 && args_vec.len() != 3 {
+ return clap_result;
+ }
+
+ // At this point, there are a few possible cases:
+ //
+ // 1. clap has succeeded and the arguments would be invalid for the obsolete syntax.
+ // 2. The case of `tail -c 5` is ambiguous. clap parses this as `tail -c5`,
+ // but it could also be interpreted as valid obsolete syntax (tail -c on file '5').
+ // GNU chooses to interpret this as `tail -c5`, like clap.
+ // 3. `tail -f foo` is also ambiguous, but has the same effect in both cases. We can safely
+ // use the clap result here.
+ // 4. clap succeeded for obsolete arguments starting with '+', but misinterprets them as
+ // input files (e.g. 'tail +f').
+ // 5. clap failed because of unknown flags, but possibly valid obsolete arguments
+ // (e.g. tail -l; tail -10c).
+ //
+ // In cases 4 & 5, we want to try parsing the obsolete arguments, which corresponds to
+ // checking whether clap succeeded or the first argument starts with '+'.
+ let possible_obsolete_args = &args_vec[1];
+ if clap_result.is_ok() && !possible_obsolete_args.to_string_lossy().starts_with('+') {
+ return clap_result;
+ }
+ match parse_obsolete(possible_obsolete_args, args_vec.get(2))? {
+ Some(settings) => Ok(settings),
+ None => clap_result,
+ }
}
pub fn uu_app() -> Command {
#[cfg(target_os = "linux")]
- pub static POLLING_HELP: &str = "Disable 'inotify' support and use polling instead";
+ const POLLING_HELP: &str = "Disable 'inotify' support and use polling instead";
#[cfg(all(unix, not(target_os = "linux")))]
- pub static POLLING_HELP: &str = "Disable 'kqueue' support and use polling instead";
+ const POLLING_HELP: &str = "Disable 'kqueue' support and use polling instead";
#[cfg(target_os = "windows")]
- pub static POLLING_HELP: &str =
- "Disable 'ReadDirectoryChanges' support and use polling instead";
+ const POLLING_HELP: &str = "Disable 'ReadDirectoryChanges' support and use polling instead";
Command::new(uucore::util_name())
.version(crate_version!())
@@ -393,10 +492,11 @@ pub fn uu_app() -> Command {
Arg::new(options::FOLLOW)
.short('f')
.long(options::FOLLOW)
- .default_value("descriptor")
+ .default_missing_value("descriptor")
.num_args(0..=1)
.require_equals(true)
- .value_parser(["descriptor", "name"])
+ .value_parser(ShortcutValueParser::new(["descriptor", "name"]))
+ .overrides_with(options::FOLLOW)
.help("Print the file as it grows"),
)
.arg(
@@ -411,7 +511,8 @@ pub fn uu_app() -> Command {
Arg::new(options::PID)
.long(options::PID)
.value_name("PID")
- .help("With -f, terminate after process ID, PID dies"),
+ .help("With -f, terminate after process ID, PID dies")
+ .overrides_with(options::PID),
)
.arg(
Arg::new(options::verbosity::QUIET)
@@ -467,13 +568,14 @@ pub fn uu_app() -> Command {
Arg::new(options::RETRY)
.long(options::RETRY)
.help("Keep trying to open a file if it is inaccessible")
+ .overrides_with(options::RETRY)
.action(ArgAction::SetTrue),
)
.arg(
Arg::new(options::FOLLOW_RETRY)
.short('F')
.help("Same as --follow=name --retry")
- .overrides_with_all([options::RETRY, options::FOLLOW])
+ .overrides_with(options::FOLLOW_RETRY)
.action(ArgAction::SetTrue),
)
.arg(
@@ -487,12 +589,17 @@ pub fn uu_app() -> Command {
Arg::new(options::ARG_FILES)
.action(ArgAction::Append)
.num_args(1..)
+ .value_parser(value_parser!(OsString))
.value_hint(clap::ValueHint::FilePath),
)
}
#[cfg(test)]
mod tests {
+ use rstest::rstest;
+
+ use crate::parse::ObsoleteArgs;
+
use super::*;
#[test]
@@ -524,4 +631,52 @@ mod tests {
assert!(result.is_ok());
assert_eq!(result.unwrap(), Signum::Negative(1));
}
+
+ #[test]
+ fn test_parse_obsolete_settings_f() {
+ let args = ObsoleteArgs {
+ follow: true,
+ ..Default::default()
+ };
+ let result = Settings::from_obsolete_args(&args, None);
+ assert_eq!(result.follow, Some(FollowMode::Descriptor));
+
+ let result = Settings::from_obsolete_args(&args, Some(&"file".into()));
+ assert_eq!(result.follow, Some(FollowMode::Name));
+ }
+
+ #[rstest]
+ #[case::default(vec![], None, false)]
+ #[case::retry(vec!["--retry"], None, true)]
+ #[case::multiple_retry(vec!["--retry", "--retry"], None, true)]
+ #[case::follow_long(vec!["--follow"], Some(FollowMode::Descriptor), false)]
+ #[case::follow_short(vec!["-f"], Some(FollowMode::Descriptor), false)]
+ #[case::follow_long_with_retry(vec!["--follow", "--retry"], Some(FollowMode::Descriptor), true)]
+ #[case::follow_short_with_retry(vec!["-f", "--retry"], Some(FollowMode::Descriptor), true)]
+ #[case::follow_overwrites_previous_selection_1(vec!["--follow=name", "--follow=descriptor"], Some(FollowMode::Descriptor), false)]
+ #[case::follow_overwrites_previous_selection_2(vec!["--follow=descriptor", "--follow=name"], Some(FollowMode::Name), false)]
+ #[case::big_f(vec!["-F"], Some(FollowMode::Name), true)]
+ #[case::multiple_big_f(vec!["-F", "-F"], Some(FollowMode::Name), true)]
+ #[case::big_f_with_retry_then_does_not_change(vec!["-F", "--retry"], Some(FollowMode::Name), true)]
+ #[case::big_f_with_follow_descriptor_then_change(vec!["-F", "--follow=descriptor"], Some(FollowMode::Descriptor), true)]
+ #[case::multiple_big_f_with_follow_descriptor_then_no_change(vec!["-F", "--follow=descriptor", "-F"], Some(FollowMode::Name), true)]
+ #[case::big_f_with_follow_short_then_change(vec!["-F", "-f"], Some(FollowMode::Descriptor), true)]
+ #[case::follow_descriptor_with_big_f_then_change(vec!["--follow=descriptor", "-F"], Some(FollowMode::Name), true)]
+ #[case::follow_short_with_big_f_then_change(vec!["-f", "-F"], Some(FollowMode::Name), true)]
+ #[case::big_f_with_follow_name_then_not_change(vec!["-F", "--follow=name"], Some(FollowMode::Name), true)]
+ #[case::follow_name_with_big_f_then_not_change(vec!["--follow=name", "-F"], Some(FollowMode::Name), true)]
+ #[case::big_f_with_multiple_long_follow(vec!["--follow=name", "-F", "--follow=descriptor"], Some(FollowMode::Descriptor), true)]
+ #[case::big_f_with_multiple_long_follow_name(vec!["--follow=name", "-F", "--follow=name"], Some(FollowMode::Name), true)]
+ #[case::big_f_with_multiple_short_follow(vec!["-f", "-F", "-f"], Some(FollowMode::Descriptor), true)]
+ #[case::multiple_big_f_with_multiple_short_follow(vec!["-f", "-F", "-f", "-F"], Some(FollowMode::Name), true)]
+ fn test_parse_settings_follow_mode_and_retry(
+ #[case] args: Vec<&str>,
+ #[case] expected_follow_mode: Option<FollowMode>,
+ #[case] expected_retry: bool,
+ ) {
+ let settings =
+ Settings::from(&uu_app().no_binary_name(true).get_matches_from(args)).unwrap();
+ assert_eq!(settings.follow, expected_follow_mode);
+ assert_eq!(settings.retry, expected_retry);
+ }
}
diff --git a/src/uu/tail/src/chunks.rs b/src/uu/tail/src/chunks.rs
index 7ad2e153b2abdf504aeda3283461b394374d81b6..636de7a90ef16d4ef97725aadff5032248c421ff 100644
--- a/src/uu/tail/src/chunks.rs
+++ b/src/uu/tail/src/chunks.rs
@@ -1,7 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//! Iterating over a file by chunks, either starting at the end of the file with [`ReverseChunks`]
//! or at the end of piped stdin with [`LinesChunk`] or [`BytesChunk`].
@@ -46,9 +46,9 @@ pub struct ReverseChunks<'a> {
}
impl<'a> ReverseChunks<'a> {
- pub fn new(file: &'a mut File) -> ReverseChunks<'a> {
+ pub fn new(file: &'a mut File) -> Self {
let current = if cfg!(unix) {
- file.seek(SeekFrom::Current(0)).unwrap()
+ file.stream_position().unwrap()
} else {
0
};
@@ -495,7 +495,7 @@ impl LinesChunk {
fn calculate_bytes_offset_from(&self, offset: usize) -> usize {
let mut lines_offset = offset;
let mut bytes_offset = 0;
- for byte in self.get_buffer().iter() {
+ for byte in self.get_buffer() {
if lines_offset == 0 {
break;
}
@@ -579,16 +579,16 @@ impl LinesChunkBuffer {
}
}
- if !&self.chunks.is_empty() {
+ if self.chunks.is_empty() {
+ // chunks is empty when a file is empty so quitting early here
+ return Ok(());
+ } else {
let length = &self.chunks.len();
let last = &mut self.chunks[length - 1];
if !last.get_buffer().ends_with(&[self.delimiter]) {
last.lines += 1;
self.lines += 1;
}
- } else {
- // chunks is empty when a file is empty so quitting early here
- return Ok(());
}
// skip unnecessary chunks and save the first chunk which may hold some lines we have to
diff --git a/src/uu/tail/src/follow/files.rs b/src/uu/tail/src/follow/files.rs
index 8686e73f418710fe19188b11f88b14b074f7f528..d1aa0aed6fc94aa8687b1d92323cce912db220aa 100644
--- a/src/uu/tail/src/follow/files.rs
+++ b/src/uu/tail/src/follow/files.rs
@@ -1,7 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore tailable seekable stdlib (stdlib)
@@ -40,7 +40,7 @@ impl FileHandling {
pub fn insert(&mut self, k: &Path, v: PathData, update_last: bool) {
let k = Self::canonicalize_path(k);
if update_last {
- self.last = Some(k.to_owned());
+ self.last = Some(k.clone());
}
let _ = self.map.insert(k, v);
}
diff --git a/src/uu/tail/src/follow/mod.rs b/src/uu/tail/src/follow/mod.rs
index e31eb54d1cf4fe5df0a527a6669797eb89c1c6fe..52eef318f96e473cc82a43f2c7dfbfc54cd964f2 100644
--- a/src/uu/tail/src/follow/mod.rs
+++ b/src/uu/tail/src/follow/mod.rs
@@ -1,7 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
mod files;
mod watch;
diff --git a/src/uu/tail/src/follow/watch.rs b/src/uu/tail/src/follow/watch.rs
index 31a6d70cbbdd7c58d8c419232e2ce1dd718de493..b74e5c108d9c752ee78f64fc397feca4c439b57c 100644
--- a/src/uu/tail/src/follow/watch.rs
+++ b/src/uu/tail/src/follow/watch.rs
@@ -1,7 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) tailable untailable stdlib kqueue Uncategorized unwatch
@@ -10,7 +10,6 @@ use crate::follow::files::{FileHandling, PathData};
use crate::paths::{Input, InputKind, MetadataExtTail, PathExtTail};
use crate::{platform, text};
use notify::{RecommendedWatcher, RecursiveMode, Watcher, WatcherKind};
-use std::collections::VecDeque;
use std::io::BufRead;
use std::path::{Path, PathBuf};
use std::sync::mpsc::{self, channel, Receiver};
@@ -46,6 +45,9 @@ impl WatcherRx {
Tested for notify::InotifyWatcher and for notify::PollWatcher.
*/
if let Some(parent) = path.parent() {
+ // clippy::assigning_clones added with Rust 1.78
+ // Rust version = 1.76 on OpenBSD stable/7.5
+ #[cfg_attr(not(target_os = "openbsd"), allow(clippy::assigning_clones))]
if parent.is_dir() {
path = parent.to_owned();
} else {
@@ -270,7 +272,7 @@ impl Observer {
self.follow_name() && self.retry
}
- fn init_files(&mut self, inputs: &VecDeque<Input>) -> UResult<()> {
+ fn init_files(&mut self, inputs: &Vec<Input>) -> UResult<()> {
if let Some(watcher_rx) = &mut self.watcher_rx {
for input in inputs {
match input.kind() {
@@ -280,7 +282,7 @@ impl Observer {
if !path.is_file() {
continue;
}
- let mut path = path.to_owned();
+ let mut path = path.clone();
if path.is_relative() {
path = std::env::current_dir()?.join(path);
}
@@ -303,6 +305,7 @@ impl Observer {
Ok(())
}
+ #[allow(clippy::cognitive_complexity)]
fn handle_event(
&mut self,
event: ¬ify::Event,
@@ -345,7 +348,7 @@ impl Observer {
show_error!("{}: file truncated", display_name);
self.files.update_reader(event_path)?;
}
- paths.push(event_path.to_owned());
+ paths.push(event_path.clone());
} else if !is_tailable && old_md.is_tailable() {
if pd.reader.is_some() {
self.files.reset_reader(event_path);
@@ -359,7 +362,7 @@ impl Observer {
} else if is_tailable {
show_error!( "{} has appeared; following new file", display_name.quote());
self.files.update_reader(event_path)?;
- paths.push(event_path.to_owned());
+ paths.push(event_path.clone());
} else if settings.retry {
if self.follow_descriptor() {
show_error!(
@@ -403,7 +406,7 @@ impl Observer {
"{} cannot be used, reverting to polling",
text::BACKEND
);
- self.orphans.push(event_path.to_owned());
+ self.orphans.push(event_path.clone());
let _ = self.watcher_rx.as_mut().unwrap().unwatch(event_path);
}
} else {
@@ -451,7 +454,7 @@ impl Observer {
if self.follow_descriptor() {
let new_path = event.paths.last().unwrap();
- paths.push(new_path.to_owned());
+ paths.push(new_path.clone());
let new_data = PathData::from_other_with_path(self.files.remove(event_path), new_path);
self.files.insert(
@@ -471,6 +474,7 @@ impl Observer {
}
}
+#[allow(clippy::cognitive_complexity)]
pub fn follow(mut observer: Observer, settings: &Settings) -> UResult<()> {
if observer.files.no_files_remaining(settings) && !observer.files.only_stdin_remaining() {
return Err(USimpleError::new(1, text::NO_FILES_REMAINING.to_string()));
@@ -478,8 +482,7 @@ pub fn follow(mut observer: Observer, settings: &Settings) -> UResult<()> {
let mut process = platform::ProcessChecker::new(observer.pid);
- let mut _event_counter = 0;
- let mut _timeout_counter = 0;
+ let mut timeout_counter = 0;
// main follow loop
loop {
@@ -528,8 +531,7 @@ pub fn follow(mut observer: Observer, settings: &Settings) -> UResult<()> {
.receiver
.recv_timeout(settings.sleep_sec);
if rx_result.is_ok() {
- _event_counter += 1;
- _timeout_counter = 0;
+ timeout_counter = 0;
}
let mut paths = vec![]; // Paths worth checking for new content to print
@@ -566,11 +568,11 @@ pub fn follow(mut observer: Observer, settings: &Settings) -> UResult<()> {
format!("{} resources exhausted", text::BACKEND),
))
}
- Ok(Err(e)) => return Err(USimpleError::new(1, format!("NotifyError: {}", e))),
+ Ok(Err(e)) => return Err(USimpleError::new(1, format!("NotifyError: {e}"))),
Err(mpsc::RecvTimeoutError::Timeout) => {
- _timeout_counter += 1;
+ timeout_counter += 1;
}
- Err(e) => return Err(USimpleError::new(1, format!("RecvTimeoutError: {}", e))),
+ Err(e) => return Err(USimpleError::new(1, format!("RecvTimeoutError: {e}"))),
}
if observer.use_polling && settings.follow.is_some() {
@@ -585,7 +587,7 @@ pub fn follow(mut observer: Observer, settings: &Settings) -> UResult<()> {
_read_some = observer.files.tail_file(path, settings.verbose)?;
}
- if _timeout_counter == settings.max_unchanged_stats {
+ if timeout_counter == settings.max_unchanged_stats {
/*
TODO: [2021-10; jhscheer] implement timeout_counter for each file.
‘--max-unchanged-stats=n’
diff --git a/src/uu/tail/src/parse.rs b/src/uu/tail/src/parse.rs
index 7511f2405e49e9d65f020b8f4e625293421a702f..6d6826077f89b2ab222adff1a395bb91e821c344 100644
--- a/src/uu/tail/src/parse.rs
+++ b/src/uu/tail/src/parse.rs
@@ -1,161 +1,189 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::ffi::OsString;
+#[derive(PartialEq, Eq, Debug, Copy, Clone)]
+pub struct ObsoleteArgs {
+ pub num: u64,
+ pub plus: bool,
+ pub lines: bool,
+ pub follow: bool,
+}
+
+impl Default for ObsoleteArgs {
+ fn default() -> Self {
+ Self {
+ num: 10,
+ plus: false,
+ lines: true,
+ follow: false,
+ }
+ }
+}
+
#[derive(PartialEq, Eq, Debug)]
pub enum ParseError {
- Syntax,
+ OutOfRange,
Overflow,
+ Context,
+ InvalidEncoding,
}
/// Parses obsolete syntax
-/// tail -NUM\[kmzv\] // spell-checker:disable-line
-pub fn parse_obsolete(src: &str) -> Option<Result<impl Iterator<Item = OsString>, ParseError>> {
- let mut chars = src.char_indices();
- if let Some((_, '-')) = chars.next() {
- let mut num_end = 0usize;
- let mut has_num = false;
- let mut last_char = 0 as char;
- for (n, c) in &mut chars {
- if c.is_ascii_digit() {
- has_num = true;
- num_end = n;
- } else {
- last_char = c;
- break;
- }
- }
- if has_num {
- match src[1..=num_end].parse::<usize>() {
- Ok(num) => {
- let mut quiet = false;
- let mut verbose = false;
- let mut zero_terminated = false;
- let mut multiplier = None;
- let mut c = last_char;
- loop {
- // not that here, we only match lower case 'k', 'c', and 'm'
- match c {
- // we want to preserve order
- // this also saves us 1 heap allocation
- 'q' => {
- quiet = true;
- verbose = false;
- }
- 'v' => {
- verbose = true;
- quiet = false;
- }
- 'z' => zero_terminated = true,
- 'c' => multiplier = Some(1),
- 'b' => multiplier = Some(512),
- 'k' => multiplier = Some(1024),
- 'm' => multiplier = Some(1024 * 1024),
- '\0' => {}
- _ => return Some(Err(ParseError::Syntax)),
- }
- if let Some((_, next)) = chars.next() {
- c = next;
- } else {
- break;
- }
- }
- let mut options = Vec::new();
- if quiet {
- options.push(OsString::from("-q"));
- }
- if verbose {
- options.push(OsString::from("-v"));
- }
- if zero_terminated {
- options.push(OsString::from("-z"));
- }
- if let Some(n) = multiplier {
- options.push(OsString::from("-c"));
- let num = match num.checked_mul(n) {
- Some(n) => n,
- None => return Some(Err(ParseError::Overflow)),
- };
- options.push(OsString::from(format!("{}", num)));
- } else {
- options.push(OsString::from("-n"));
- options.push(OsString::from(format!("{}", num)));
- }
- Some(Ok(options.into_iter()))
- }
- Err(_) => Some(Err(ParseError::Overflow)),
- }
+/// tail -\[NUM\]\[bcl\]\[f\] and tail +\[NUM\]\[bcl\]\[f\]
+pub fn parse_obsolete(src: &OsString) -> Option<Result<ObsoleteArgs, ParseError>> {
+ let mut rest = match src.to_str() {
+ Some(src) => src,
+ None => return Some(Err(ParseError::InvalidEncoding)),
+ };
+ let sign = if let Some(r) = rest.strip_prefix('-') {
+ rest = r;
+ '-'
+ } else if let Some(r) = rest.strip_prefix('+') {
+ rest = r;
+ '+'
+ } else {
+ return None;
+ };
+
+ let end_num = rest
+ .find(|c: char| !c.is_ascii_digit())
+ .unwrap_or(rest.len());
+ let has_num = !rest[..end_num].is_empty();
+ let num: u64 = if has_num {
+ if let Ok(num) = rest[..end_num].parse() {
+ num
} else {
- None
+ return Some(Err(ParseError::OutOfRange));
}
} else {
- None
+ 10
+ };
+ rest = &rest[end_num..];
+
+ let mode = if let Some(r) = rest.strip_prefix('l') {
+ rest = r;
+ 'l'
+ } else if let Some(r) = rest.strip_prefix('c') {
+ rest = r;
+ 'c'
+ } else if let Some(r) = rest.strip_prefix('b') {
+ rest = r;
+ 'b'
+ } else {
+ 'l'
+ };
+
+ let follow = rest.contains('f');
+ if !rest.chars().all(|f| f == 'f') {
+ // GNU allows an arbitrary amount of following fs, but nothing else
+ if sign == '-' && has_num {
+ return Some(Err(ParseError::Context));
+ }
+ return None;
}
+
+ let multiplier = if mode == 'b' { 512 } else { 1 };
+ let num = match num.checked_mul(multiplier) {
+ Some(n) => n,
+ None => return Some(Err(ParseError::Overflow)),
+ };
+
+ Some(Ok(ObsoleteArgs {
+ num,
+ plus: sign == '+',
+ lines: mode == 'l',
+ follow,
+ }))
}
#[cfg(test)]
mod tests {
use super::*;
- fn obsolete(src: &str) -> Option<Result<Vec<String>, ParseError>> {
- let r = parse_obsolete(src);
- match r {
- Some(s) => match s {
- Ok(v) => Some(Ok(v.map(|s| s.to_str().unwrap().to_owned()).collect())),
- Err(e) => Some(Err(e)),
- },
- None => None,
- }
- }
- fn obsolete_result(src: &[&str]) -> Option<Result<Vec<String>, ParseError>> {
- Some(Ok(src.iter().map(|s| s.to_string()).collect()))
- }
#[test]
fn test_parse_numbers_obsolete() {
- assert_eq!(obsolete("-5"), obsolete_result(&["-n", "5"]));
- assert_eq!(obsolete("-100"), obsolete_result(&["-n", "100"]));
- assert_eq!(obsolete("-5m"), obsolete_result(&["-c", "5242880"]));
- assert_eq!(obsolete("-1k"), obsolete_result(&["-c", "1024"]));
- assert_eq!(obsolete("-2b"), obsolete_result(&["-c", "1024"]));
- assert_eq!(obsolete("-1mmk"), obsolete_result(&["-c", "1024"]));
- assert_eq!(obsolete("-1vz"), obsolete_result(&["-v", "-z", "-n", "1"]));
assert_eq!(
- obsolete("-1vzqvq"), // spell-checker:disable-line
- obsolete_result(&["-q", "-z", "-n", "1"])
+ parse_obsolete(&OsString::from("+2c")),
+ Some(Ok(ObsoleteArgs {
+ num: 2,
+ plus: true,
+ lines: false,
+ follow: false,
+ }))
+ );
+ assert_eq!(
+ parse_obsolete(&OsString::from("-5")),
+ Some(Ok(ObsoleteArgs {
+ num: 5,
+ plus: false,
+ lines: true,
+ follow: false,
+ }))
+ );
+ assert_eq!(
+ parse_obsolete(&OsString::from("+100f")),
+ Some(Ok(ObsoleteArgs {
+ num: 100,
+ plus: true,
+ lines: true,
+ follow: true,
+ }))
);
- assert_eq!(obsolete("-1vzc"), obsolete_result(&["-v", "-z", "-c", "1"]));
assert_eq!(
- obsolete("-105kzm"),
- obsolete_result(&["-z", "-c", "110100480"])
+ parse_obsolete(&OsString::from("-2b")),
+ Some(Ok(ObsoleteArgs {
+ num: 1024,
+ plus: false,
+ lines: false,
+ follow: false,
+ }))
);
}
#[test]
fn test_parse_errors_obsolete() {
- assert_eq!(obsolete("-5n"), Some(Err(ParseError::Syntax)));
- assert_eq!(obsolete("-5c5"), Some(Err(ParseError::Syntax)));
- }
- #[test]
- fn test_parse_obsolete_no_match() {
- assert_eq!(obsolete("-k"), None);
- assert_eq!(obsolete("asd"), None);
- }
- #[test]
- #[cfg(target_pointer_width = "64")]
- fn test_parse_obsolete_overflow_x64() {
assert_eq!(
- obsolete("-1000000000000000m"),
- Some(Err(ParseError::Overflow))
+ parse_obsolete(&OsString::from("-5n")),
+ Some(Err(ParseError::Context))
);
assert_eq!(
- obsolete("-10000000000000000000000"),
- Some(Err(ParseError::Overflow))
+ parse_obsolete(&OsString::from("-5c5")),
+ Some(Err(ParseError::Context))
+ );
+ assert_eq!(
+ parse_obsolete(&OsString::from("-1vzc")),
+ Some(Err(ParseError::Context))
+ );
+ assert_eq!(
+ parse_obsolete(&OsString::from("-5m")),
+ Some(Err(ParseError::Context))
+ );
+ assert_eq!(
+ parse_obsolete(&OsString::from("-1k")),
+ Some(Err(ParseError::Context))
+ );
+ assert_eq!(
+ parse_obsolete(&OsString::from("-1mmk")),
+ Some(Err(ParseError::Context))
+ );
+ assert_eq!(
+ parse_obsolete(&OsString::from("-105kzm")),
+ Some(Err(ParseError::Context))
+ );
+ assert_eq!(
+ parse_obsolete(&OsString::from("-1vz")),
+ Some(Err(ParseError::Context))
+ );
+ assert_eq!(
+ parse_obsolete(&OsString::from("-1vzqvq")), // spell-checker:disable-line
+ Some(Err(ParseError::Context))
);
}
#[test]
- #[cfg(target_pointer_width = "32")]
- fn test_parse_obsolete_overflow_x32() {
- assert_eq!(obsolete("-42949672960"), Some(Err(ParseError::Overflow)));
- assert_eq!(obsolete("-42949672k"), Some(Err(ParseError::Overflow)));
+ fn test_parse_obsolete_no_match() {
+ assert_eq!(parse_obsolete(&OsString::from("-k")), None);
+ assert_eq!(parse_obsolete(&OsString::from("asd")), None);
+ assert_eq!(parse_obsolete(&OsString::from("-cc")), None);
}
}
diff --git a/src/uu/tail/src/paths.rs b/src/uu/tail/src/paths.rs
index 03656d036b20bb7d5372c3e08db8e22d48993953..117cab8b0a074bc90f8f6b80cf80052c7cd3a4ed 100644
--- a/src/uu/tail/src/paths.rs
+++ b/src/uu/tail/src/paths.rs
@@ -1,11 +1,12 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore tailable seekable stdlib (stdlib)
use crate::text;
+use std::ffi::OsStr;
use std::fs::{File, Metadata};
use std::io::{Seek, SeekFrom};
#[cfg(unix)]
@@ -19,6 +20,28 @@ pub enum InputKind {
Stdin,
}
+#[cfg(unix)]
+impl From<&OsStr> for InputKind {
+ fn from(value: &OsStr) -> Self {
+ if value == OsStr::new("-") {
+ Self::Stdin
+ } else {
+ Self::File(PathBuf::from(value))
+ }
+ }
+}
+
+#[cfg(not(unix))]
+impl From<&OsStr> for InputKind {
+ fn from(value: &OsStr) -> Self {
+ if value == OsStr::new(text::DASH) {
+ Self::Stdin
+ } else {
+ Self::File(PathBuf::from(value))
+ }
+ }
+}
+
#[derive(Debug, Clone)]
pub struct Input {
kind: InputKind,
@@ -26,23 +49,13 @@ pub struct Input {
}
impl Input {
- // TODO: from &str may be the better choice
- pub fn from(string: String) -> Self {
- let kind = if string == text::DASH {
- InputKind::Stdin
- } else {
- InputKind::File(PathBuf::from(&string))
- };
+ pub fn from<T: AsRef<OsStr>>(string: T) -> Self {
+ let string = string.as_ref();
+ let kind = string.into();
let display_name = match kind {
- InputKind::File(_) => string,
- InputKind::Stdin => {
- if cfg!(unix) {
- text::STDIN_HEADER.to_string()
- } else {
- string
- }
- }
+ InputKind::File(_) => string.to_string_lossy().to_string(),
+ InputKind::Stdin => text::STDIN_HEADER.to_string(),
};
Self { kind, display_name }
@@ -132,7 +145,7 @@ impl FileExtTail for File {
/// Test if File is seekable.
/// Set the current position offset to `current_offset`.
fn is_seekable(&mut self, current_offset: u64) -> bool {
- self.seek(SeekFrom::Current(0)).is_ok()
+ self.stream_position().is_ok()
&& self.seek(SeekFrom::End(0)).is_ok()
&& self.seek(SeekFrom::Start(current_offset)).is_ok()
}
diff --git a/src/uu/tail/src/platform/mod.rs b/src/uu/tail/src/platform/mod.rs
index e5ae8b8d86172ce2e44251ca92f9aacacf83668e..cd2953ffd315958aaddfa727d5bf285d09ea9692 100644
--- a/src/uu/tail/src/platform/mod.rs
+++ b/src/uu/tail/src/platform/mod.rs
@@ -1,12 +1,7 @@
-/*
- * This file is part of the uutils coreutils package.
- *
- * (c) Alexander Batischev <eual.jp@gmail.com>
- * (c) Thomas Queiroz <thomasqueirozb@gmail.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
#[cfg(unix)]
pub use self::unix::{
diff --git a/src/uu/tail/src/platform/unix.rs b/src/uu/tail/src/platform/unix.rs
index ed34b2cf9bcfeda47797a37e066b59ad11449470..a04582a2c221f952d62687acbec024dbf8520302 100644
--- a/src/uu/tail/src/platform/unix.rs
+++ b/src/uu/tail/src/platform/unix.rs
@@ -1,12 +1,7 @@
-/*
- * This file is part of the uutils coreutils package.
- *
- * (c) Alexander Batischev <eual.jp@gmail.com>
- * (c) Thomas Queiroz <thomasqueirozb@gmail.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) stdlib, ISCHR, GETFD
// spell-checker:ignore (options) EPERM, ENOSYS
diff --git a/src/uu/tail/src/platform/windows.rs b/src/uu/tail/src/platform/windows.rs
index 3e4cc7edc1ed926add2e7bb2e4e67f6a3e5e998e..5925161621bbe8075d9002a724d970b914c9f066 100644
--- a/src/uu/tail/src/platform/windows.rs
+++ b/src/uu/tail/src/platform/windows.rs
@@ -1,11 +1,8 @@
-/*
- * This file is part of the uutils coreutils package.
- *
- * (c) Alexander Batischev <eual.jp@gmail.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
use windows_sys::Win32::Foundation::{CloseHandle, BOOL, HANDLE, WAIT_FAILED, WAIT_OBJECT_0};
use windows_sys::Win32::System::Threading::{
OpenProcess, WaitForSingleObject, PROCESS_SYNCHRONIZE,
diff --git a/src/uu/tail/src/tail.rs b/src/uu/tail/src/tail.rs
index 2a5a94352022a9a4be04dfd985d9bb9b30301a41..edac4b151cb68307b4bd3f9eaaddca8f733a2a18 100644
--- a/src/uu/tail/src/tail.rs
+++ b/src/uu/tail/src/tail.rs
@@ -1,11 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Morten Olsen Lysgaard <morten@lysgaard.no>
-// * (c) Alexander Batischev <eual.jp@gmail.com>
-// * (c) Thomas Queiroz <thomasqueirozb@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) seekable seek'd tail'ing ringbuffer ringbuf unwatch Uncategorized filehandle Signum
// spell-checker:ignore (libs) kqueue
@@ -35,7 +31,7 @@ use std::fs::File;
use std::io::{self, stdin, stdout, BufRead, BufReader, BufWriter, Read, Seek, SeekFrom, Write};
use std::path::{Path, PathBuf};
use uucore::display::Quotable;
-use uucore::error::{get_exit_code, set_exit_code, FromIo, UError, UResult, USimpleError};
+use uucore::error::{get_exit_code, set_exit_code, FromIo, UResult, USimpleError};
use uucore::{show, show_error};
#[uucore::main]
@@ -125,10 +121,10 @@ fn tail_file(
show_error!("error reading '{}': {}", input.display_name, err_msg);
if settings.follow.is_some() {
- let msg = if !settings.retry {
- "; giving up on this name"
- } else {
+ let msg = if settings.retry {
""
+ } else {
+ "; giving up on this name"
};
show_error!(
"{}: cannot follow end of this type of file{}",
@@ -198,7 +194,7 @@ fn tail_stdin(
// Save the current seek position/offset of a stdin redirected file.
// This is needed to pass "gnu/tests/tail-2/start-middle.sh"
if let Ok(mut stdin_handle) = Handle::stdin() {
- if let Ok(offset) = stdin_handle.as_file_mut().seek(SeekFrom::Current(0)) {
+ if let Ok(offset) = stdin_handle.as_file_mut().stream_position() {
stdin_offset = offset;
}
}
@@ -215,11 +211,7 @@ fn tail_stdin(
// pipe
None => {
header_printer.print_input(input);
- if !paths::stdin_is_bad_fd() {
- let mut reader = BufReader::new(stdin());
- unbounded_tail(&mut reader, settings)?;
- observer.add_stdin(input.display_name.as_str(), Some(Box::new(reader)), true)?;
- } else {
+ if paths::stdin_is_bad_fd() {
set_exit_code(1);
show_error!(
"cannot fstat {}: {}",
@@ -233,6 +225,10 @@ fn tail_stdin(
text::BAD_FD
);
}
+ } else {
+ let mut reader = BufReader::new(stdin());
+ unbounded_tail(&mut reader, settings)?;
+ observer.add_stdin(input.display_name.as_str(), Some(Box::new(reader)), true)?;
}
}
};
diff --git a/src/uu/tail/src/text.rs b/src/uu/tail/src/text.rs
index 0e4a26f39aaeccda9b7321f625e2f5bf6ddd7986..e7aa6c2536fdfdeaca2a86a715888406112f1b15 100644
--- a/src/uu/tail/src/text.rs
+++ b/src/uu/tail/src/text.rs
@@ -1,24 +1,24 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) kqueue
-pub static DASH: &str = "-";
-pub static DEV_STDIN: &str = "/dev/stdin";
-pub static STDIN_HEADER: &str = "standard input";
-pub static NO_FILES_REMAINING: &str = "no files remaining";
-pub static NO_SUCH_FILE: &str = "No such file or directory";
-pub static BECOME_INACCESSIBLE: &str = "has become inaccessible";
-pub static BAD_FD: &str = "Bad file descriptor";
+pub const DASH: &str = "-";
+pub const DEV_STDIN: &str = "/dev/stdin";
+pub const STDIN_HEADER: &str = "standard input";
+pub const NO_FILES_REMAINING: &str = "no files remaining";
+pub const NO_SUCH_FILE: &str = "No such file or directory";
+pub const BECOME_INACCESSIBLE: &str = "has become inaccessible";
+pub const BAD_FD: &str = "Bad file descriptor";
#[cfg(target_os = "linux")]
-pub static BACKEND: &str = "inotify";
+pub const BACKEND: &str = "inotify";
#[cfg(all(unix, not(target_os = "linux")))]
-pub static BACKEND: &str = "kqueue";
+pub const BACKEND: &str = "kqueue";
#[cfg(target_os = "windows")]
-pub static BACKEND: &str = "ReadDirectoryChanges";
-pub static FD0: &str = "/dev/fd/0";
-pub static IS_A_DIRECTORY: &str = "Is a directory";
-pub static DEV_TTY: &str = "/dev/tty";
-pub static DEV_PTMX: &str = "/dev/ptmx";
+pub const BACKEND: &str = "ReadDirectoryChanges";
+pub const FD0: &str = "/dev/fd/0";
+pub const IS_A_DIRECTORY: &str = "Is a directory";
+pub const DEV_TTY: &str = "/dev/tty";
+pub const DEV_PTMX: &str = "/dev/ptmx";
diff --git a/src/uu/tail/tail.md b/src/uu/tail/tail.md
new file mode 100644
index 0000000000000000000000000000000000000000..fefe7f6ee68d212e2e645183633f1c716b06bf16
--- /dev/null
+++ b/src/uu/tail/tail.md
@@ -0,0 +1,11 @@
+# tail
+
+```
+tail [FLAG]... [FILE]...
+```
+
+Print the last 10 lines of each FILE to standard output.
+With more than one FILE, precede each with a header giving the file name.
+With no FILE, or when FILE is -, read standard input.
+
+Mandatory arguments to long flags are mandatory for short flags too.
diff --git a/src/uu/tee/Cargo.toml b/src/uu/tee/Cargo.toml
index 139e3df3c7c3f6890f09a2ac29f638f489b4c0a2..9ff8769f83a61b885afcff28c847bbbc96fbc0d7 100644
--- a/src/uu/tee/Cargo.toml
+++ b/src/uu/tee/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_tee"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "tee ~ (uutils) display input and copy to FILE"
@@ -15,10 +15,9 @@ edition = "2021"
path = "src/tee.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-libc = "0.2.137"
-retain_mut = "=0.1.7" # ToDO: [2021-01-01; rivy; maint/MinSRV] ~ v0.1.5 uses const generics which aren't stabilized until rust v1.51.0
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["libc"] }
+clap = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true, features = ["libc", "signals"] }
[[bin]]
name = "tee"
diff --git a/src/uu/tee/src/tee.rs b/src/uu/tee/src/tee.rs
index 67b16f84365b1fe9cd11b48a93c24ac08f4357f1..f072e3df41e7109925cf181cbd71a5b17e691bdd 100644
--- a/src/uu/tee/src/tee.rs
+++ b/src/uu/tee/src/tee.rs
@@ -1,26 +1,25 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Aleksander Bielawski <pabzdzdzwiagief@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use clap::{builder::PossibleValue, crate_version, Arg, ArgAction, Command};
-use retain_mut::RetainMut;
use std::fs::OpenOptions;
-use std::io::{copy, sink, stdin, stdout, Error, ErrorKind, Read, Result, Write};
+use std::io::{copy, stdin, stdout, Error, ErrorKind, Read, Result, Write};
use std::path::PathBuf;
use uucore::display::Quotable;
use uucore::error::UResult;
-use uucore::{format_usage, show_error};
+use uucore::shortcut_value_parser::ShortcutValueParser;
+use uucore::{format_usage, help_about, help_section, help_usage, show_error};
// spell-checker:ignore nopipe
#[cfg(unix)]
-use uucore::libc;
+use uucore::signals::{enable_pipe_errors, ignore_interrupts};
-static ABOUT: &str = "Copy standard input to each FILE, and also to standard output.";
-const USAGE: &str = "{} [OPTION]... [FILE]...";
+const ABOUT: &str = help_about!("tee.md");
+const USAGE: &str = help_usage!("tee.md");
+const AFTER_HELP: &str = help_section!("after help", "tee.md");
mod options {
pub const APPEND: &str = "append";
@@ -89,8 +88,18 @@ pub fn uu_app() -> Command {
.version(crate_version!())
.about(ABOUT)
.override_usage(format_usage(USAGE))
- .after_help("If a FILE is -, it refers to a file named - .")
+ .after_help(AFTER_HELP)
.infer_long_args(true)
+ // Since we use value-specific help texts for "--output-error", clap's "short help" and "long help" differ.
+ // However, this is something that the GNU tests explicitly test for, so we *always* show the long help instead.
+ .disable_help_flag(true)
+ .arg(
+ Arg::new("--help")
+ .short('h')
+ .long("help")
+ .help("Print help")
+ .action(ArgAction::HelpLong)
+ )
.arg(
Arg::new(options::APPEND)
.long(options::APPEND)
@@ -121,7 +130,7 @@ pub fn uu_app() -> Command {
.long(options::OUTPUT_ERROR)
.require_equals(true)
.num_args(0..=1)
- .value_parser([
+ .value_parser(ShortcutValueParser::new([
PossibleValue::new("warn")
.help("produce warnings for errors writing to any output"),
PossibleValue::new("warn-nopipe")
@@ -129,61 +138,31 @@ pub fn uu_app() -> Command {
PossibleValue::new("exit").help("exit on write errors to any output"),
PossibleValue::new("exit-nopipe")
.help("exit on write errors to any output that are not pipe errors (equivalent to exit on non-unix platforms)"),
- ])
+ ]))
.help("set write error behavior")
.conflicts_with(options::IGNORE_PIPE_ERRORS),
)
}
-#[cfg(unix)]
-fn ignore_interrupts() -> Result<()> {
- let ret = unsafe { libc::signal(libc::SIGINT, libc::SIG_IGN) };
- if ret == libc::SIG_ERR {
- return Err(Error::new(ErrorKind::Other, ""));
- }
- Ok(())
-}
-
-#[cfg(not(unix))]
-fn ignore_interrupts() -> Result<()> {
- // Do nothing.
- Ok(())
-}
-
-#[cfg(unix)]
-fn enable_pipe_errors() -> Result<()> {
- let ret = unsafe { libc::signal(libc::SIGPIPE, libc::SIG_DFL) };
- if ret == libc::SIG_ERR {
- return Err(Error::new(ErrorKind::Other, ""));
- }
- Ok(())
-}
-
-#[cfg(not(unix))]
-fn enable_pipe_errors() -> Result<()> {
- // Do nothing.
- Ok(())
-}
-
fn tee(options: &Options) -> Result<()> {
- if options.ignore_interrupts {
- ignore_interrupts()?;
- }
- if options.output_error.is_none() {
- enable_pipe_errors()?;
- }
+ #[cfg(unix)]
+ {
+ // ErrorKind::Other is raised by MultiWriter when all writers have exited.
+ // This is therefore just a clever way to stop all writers
+ if options.ignore_interrupts {
+ ignore_interrupts().map_err(|_| Error::from(ErrorKind::Other))?;
+ }
+ if options.output_error.is_none() {
+ enable_pipe_errors().map_err(|_| Error::from(ErrorKind::Other))?;
+ }
+ }
let mut writers: Vec<NamedWriter> = options
.files
- .clone()
- .into_iter()
- .map(|file| {
- Ok(NamedWriter {
- name: file.clone(),
- inner: open(file, options.append, options.output_error.as_ref())?,
- })
- })
+ .iter()
+ .filter_map(|file| open(file, options.append, options.output_error.as_ref()))
.collect::<Result<Vec<NamedWriter>>>()?;
+ let had_open_errors = writers.len() != options.files.len();
writers.insert(
0,
@@ -208,38 +187,41 @@ fn tee(options: &Options) -> Result<()> {
_ => Ok(()),
};
- if res.is_err() || output.flush().is_err() || output.error_occurred() {
+ if had_open_errors || res.is_err() || output.flush().is_err() || output.error_occurred() {
Err(Error::from(ErrorKind::Other))
} else {
Ok(())
}
}
+/// Tries to open the indicated file and return it. Reports an error if that's not possible.
+/// If that error should lead to program termination, this function returns Some(Err()),
+/// otherwise it returns None.
fn open(
- name: String,
+ name: &str,
append: bool,
output_error: Option<&OutputErrorMode>,
-) -> Result<Box<dyn Write>> {
- let path = PathBuf::from(name.clone());
- let inner: Box<dyn Write> = {
- let mut options = OpenOptions::new();
- let mode = if append {
- options.append(true)
- } else {
- options.truncate(true)
- };
- match mode.write(true).create(true).open(path.as_path()) {
- Ok(file) => Box::new(file),
- Err(f) => {
- show_error!("{}: {}", name.maybe_quote(), f);
- match output_error {
- Some(OutputErrorMode::Exit | OutputErrorMode::ExitNoPipe) => return Err(f),
- _ => Box::new(sink()),
- }
+) -> Option<Result<NamedWriter>> {
+ let path = PathBuf::from(name);
+ let mut options = OpenOptions::new();
+ let mode = if append {
+ options.append(true)
+ } else {
+ options.truncate(true)
+ };
+ match mode.write(true).create(true).open(path.as_path()) {
+ Ok(file) => Some(Ok(NamedWriter {
+ inner: Box::new(file),
+ name: name.to_owned(),
+ })),
+ Err(f) => {
+ show_error!("{}: {}", name.maybe_quote(), f);
+ match output_error {
+ Some(OutputErrorMode::Exit | OutputErrorMode::ExitNoPipe) => Some(Err(f)),
+ _ => None,
}
}
- };
- Ok(Box::new(NamedWriter { inner, name }) as Box<dyn Write>)
+ }
}
struct MultiWriter {
@@ -286,11 +268,11 @@ fn process_error(
Err(f)
}
Some(OutputErrorMode::ExitNoPipe) => {
- if f.kind() != ErrorKind::BrokenPipe {
+ if f.kind() == ErrorKind::BrokenPipe {
+ Ok(())
+ } else {
show_error!("{}: {}", writer.name.maybe_quote(), f);
Err(f)
- } else {
- Ok(())
}
}
}
@@ -301,7 +283,7 @@ impl Write for MultiWriter {
let mut aborted = None;
let mode = self.output_error_mode.clone();
let mut errors = 0;
- RetainMut::retain_mut(&mut self.writers, |writer| {
+ self.writers.retain_mut(|writer| {
let result = writer.write_all(buf);
match result {
Err(f) => {
@@ -332,7 +314,7 @@ impl Write for MultiWriter {
let mut aborted = None;
let mode = self.output_error_mode.clone();
let mut errors = 0;
- RetainMut::retain_mut(&mut self.writers, |writer| {
+ self.writers.retain_mut(|writer| {
let result = writer.flush();
match result {
Err(f) => {
diff --git a/src/uu/tee/tee.md b/src/uu/tee/tee.md
new file mode 100644
index 0000000000000000000000000000000000000000..8bf097cecd5b661c642bdfad591ea3cff2be3c69
--- /dev/null
+++ b/src/uu/tee/tee.md
@@ -0,0 +1,11 @@
+# tee
+
+```
+tee [OPTION]... [FILE]...
+```
+
+Copy standard input to each FILE, and also to standard output.
+
+## After Help
+
+If a FILE is -, it refers to a file named - .
diff --git a/src/uu/test/Cargo.toml b/src/uu/test/Cargo.toml
index 396373f4952b9062783c26e3ba792186a880c25d..978a393a44eac55f0e84481182c74916d60336c2 100644
--- a/src/uu/test/Cargo.toml
+++ b/src/uu/test/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_test"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "test ~ (uutils) evaluate comparison and file type expressions"
@@ -15,12 +15,12 @@ edition = "2021"
path = "src/test.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-libc = "0.2.137"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true, features = ["process"] }
[target.'cfg(target_os = "redox")'.dependencies]
-redox_syscall = "0.2"
+redox_syscall = { workspace = true }
[[bin]]
name = "test"
diff --git a/src/uu/test/src/error.rs b/src/uu/test/src/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..48238fa1356875c2df5ada5fff9a76fdd75d20f7
--- /dev/null
+++ b/src/uu/test/src/error.rs
@@ -0,0 +1,41 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+/// Represents an error encountered while parsing a test expression
+#[derive(Debug)]
+pub enum ParseError {
+ ExpectedValue,
+ Expected(String),
+ ExtraArgument(String),
+ MissingArgument(String),
+ UnknownOperator(String),
+ InvalidInteger(String),
+}
+
+/// A Result type for parsing test expressions
+pub type ParseResult<T> = Result<T, ParseError>;
+
+/// Implement Display trait for ParseError to make it easier to print useful errors.
+impl std::fmt::Display for ParseError {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ Self::Expected(s) => write!(f, "expected {s}"),
+ Self::ExpectedValue => write!(f, "expected value"),
+ Self::MissingArgument(s) => write!(f, "missing argument after {s}"),
+ Self::ExtraArgument(s) => write!(f, "extra argument {s}"),
+ Self::UnknownOperator(s) => write!(f, "unknown operator {s}"),
+ Self::InvalidInteger(s) => write!(f, "invalid integer {s}"),
+ }
+ }
+}
+
+/// Implement UError trait for ParseError to make it easier to return useful error codes from main().
+impl uucore::error::UError for ParseError {
+ fn code(&self) -> i32 {
+ 2
+ }
+}
+
+/// Implement standard Error trait for UError
+impl std::error::Error for ParseError {}
diff --git a/src/uu/test/src/parser.rs b/src/uu/test/src/parser.rs
index 1177f49eac31e286fba4262ef281ecfa8384538a..23a2d7cf66ebaf56808c3668a93263f6741e6717 100644
--- a/src/uu/test/src/parser.rs
+++ b/src/uu/test/src/parser.rs
@@ -1,17 +1,16 @@
// This file is part of the uutils coreutils package.
//
-// (c) Daniel Rocco <drocco@gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
// spell-checker:ignore (grammar) BOOLOP STRLEN FILETEST FILEOP INTOP STRINGOP ; (vars) LParen StrlenOp
-use std::ffi::OsString;
+use std::ffi::{OsStr, OsString};
use std::iter::Peekable;
+use super::error::{ParseError, ParseResult};
+
use uucore::display::Quotable;
-use uucore::show_error;
/// Represents one of the binary comparison operators for strings, integers, or files
#[derive(Debug, PartialEq, Eq)]
@@ -90,6 +89,27 @@ impl Symbol {
}
}
+/// Implement Display trait for Symbol to make it easier to print useful errors.
+/// We will try to match the format in which the symbol appears in the input.
+impl std::fmt::Display for Symbol {
+ /// Format a Symbol for printing
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ let s = match &self {
+ Self::LParen => OsStr::new("("),
+ Self::Bang => OsStr::new("!"),
+ Self::BoolOp(s)
+ | Self::Literal(s)
+ | Self::Op(Operator::String(s))
+ | Self::Op(Operator::Int(s))
+ | Self::Op(Operator::File(s))
+ | Self::UnaryOp(UnaryOperator::StrlenOp(s))
+ | Self::UnaryOp(UnaryOperator::FiletestOp(s)) => OsStr::new(s),
+ Self::None => OsStr::new("None"),
+ };
+ write!(f, "{}", s.quote())
+ }
+}
+
/// Recursive descent parser for test, which converts a list of OsStrings
/// (typically command line arguments) into a stack of Symbols in postfix
/// order.
@@ -133,16 +153,10 @@ impl Parser {
}
/// Consume the next token & verify that it matches the provided value.
- ///
- /// # Panics
- ///
- /// Panics if the next token does not match the provided value.
- ///
- /// TODO: remove panics and convert Parser to return error messages.
- fn expect(&mut self, value: &str) {
+ fn expect(&mut self, value: &str) -> ParseResult<()> {
match self.next_token() {
- Symbol::Literal(s) if s == value => (),
- _ => panic!("expected ‘{}’", value),
+ Symbol::Literal(s) if s == value => Ok(()),
+ _ => Err(ParseError::Expected(value.quote().to_string())),
}
}
@@ -150,7 +164,7 @@ impl Parser {
/// The stream is unchanged and will return the same Symbol on subsequent
/// calls to `next()` or `peek()`.
fn peek(&mut self) -> Symbol {
- Symbol::new(self.tokens.peek().map(|s| s.to_os_string()))
+ Symbol::new(self.tokens.peek().cloned())
}
/// Test if the next token in the stream is a BOOLOP (-a or -o), without
@@ -162,25 +176,27 @@ impl Parser {
/// Parse an expression.
///
/// EXPR → TERM | EXPR BOOLOP EXPR
- fn expr(&mut self) {
+ fn expr(&mut self) -> ParseResult<()> {
if !self.peek_is_boolop() {
- self.term();
+ self.term()?;
}
- self.maybe_boolop();
+ self.maybe_boolop()?;
+ Ok(())
}
/// Parse a term token and possible subsequent symbols: "(", "!", UOP,
/// literal, or None.
- fn term(&mut self) {
+ fn term(&mut self) -> ParseResult<()> {
let symbol = self.next_token();
match symbol {
- Symbol::LParen => self.lparen(),
- Symbol::Bang => self.bang(),
+ Symbol::LParen => self.lparen()?,
+ Symbol::Bang => self.bang()?,
Symbol::UnaryOp(_) => self.uop(symbol),
Symbol::None => self.stack.push(symbol),
- literal => self.literal(literal),
+ literal => self.literal(literal)?,
}
+ Ok(())
}
/// Parse a (possibly) parenthesized expression.
@@ -192,7 +208,7 @@ impl Parser {
/// * when followed by a binary operator that is not _itself_ interpreted
/// as a literal
///
- fn lparen(&mut self) {
+ fn lparen(&mut self) -> ParseResult<()> {
// Look ahead up to 3 tokens to determine if the lparen is being used
// as a grouping operator or should be treated as a literal string
let peek3: Vec<Symbol> = self
@@ -204,13 +220,13 @@ impl Parser {
match peek3.as_slice() {
// case 1: lparen is a literal when followed by nothing
- [] => self.literal(Symbol::LParen.into_literal()),
+ [] => {
+ self.literal(Symbol::LParen.into_literal())?;
+ Ok(())
+ }
// case 2: error if end of stream is `( <any_token>`
- [symbol] => {
- show_error!("missing argument after ‘{:?}’", symbol);
- std::process::exit(2);
- }
+ [symbol] => Err(ParseError::MissingArgument(format!("{symbol}"))),
// case 3: `( uop <any_token> )` → parenthesized unary operation;
// this case ensures we don’t get confused by `( -f ) )`
@@ -218,43 +234,49 @@ impl Parser {
[Symbol::UnaryOp(_), _, Symbol::Literal(s)] if s == ")" => {
let symbol = self.next_token();
self.uop(symbol);
- self.expect(")");
+ self.expect(")")?;
+ Ok(())
}
// case 4: binary comparison of literal lparen, e.g. `( != )`
[Symbol::Op(_), Symbol::Literal(s)] | [Symbol::Op(_), Symbol::Literal(s), _]
if s == ")" =>
{
- self.literal(Symbol::LParen.into_literal());
+ self.literal(Symbol::LParen.into_literal())?;
+ Ok(())
}
// case 5: after handling the prior cases, any single token inside
// parentheses is a literal, e.g. `( -f )`
[_, Symbol::Literal(s)] | [_, Symbol::Literal(s), _] if s == ")" => {
let symbol = self.next_token();
- self.literal(symbol);
- self.expect(")");
+ self.literal(symbol)?;
+ self.expect(")")?;
+ Ok(())
}
// case 6: two binary ops in a row, treat the first op as a literal
[Symbol::Op(_), Symbol::Op(_), _] => {
let symbol = self.next_token();
- self.literal(symbol);
- self.expect(")");
+ self.literal(symbol)?;
+ self.expect(")")?;
+ Ok(())
}
// case 7: if earlier cases didn’t match, `( op <any_token>…`
// indicates binary comparison of literal lparen with
// anything _except_ ")" (case 4)
[Symbol::Op(_), _] | [Symbol::Op(_), _, _] => {
- self.literal(Symbol::LParen.into_literal());
+ self.literal(Symbol::LParen.into_literal())?;
+ Ok(())
}
// Otherwise, lparen indicates the start of a parenthesized
// expression
_ => {
- self.expr();
- self.expect(")");
+ self.expr()?;
+ self.expect(")")?;
+ Ok(())
}
}
}
@@ -276,7 +298,7 @@ impl Parser {
/// * `! str BOOLOP str`: negate the entire Boolean expression
/// * `! str BOOLOP EXPR BOOLOP EXPR`: negate the value of the first `str` term
///
- fn bang(&mut self) {
+ fn bang(&mut self) -> ParseResult<()> {
match self.peek() {
Symbol::Op(_) | Symbol::BoolOp(_) => {
// we need to peek ahead one more token to disambiguate the first
@@ -289,14 +311,14 @@ impl Parser {
Symbol::Op(_) | Symbol::None => {
// op is literal
let op = self.next_token().into_literal();
- self.literal(op);
+ self.literal(op)?;
self.stack.push(Symbol::Bang);
}
// case 2: `<! as literal> OP str [BOOLOP EXPR]`.
_ => {
// bang is literal; parsing continues with op
- self.literal(Symbol::Bang.into_literal());
- self.maybe_boolop();
+ self.literal(Symbol::Bang.into_literal())?;
+ self.maybe_boolop()?;
}
}
}
@@ -317,32 +339,34 @@ impl Parser {
match peek4.as_slice() {
// we peeked ahead 4 but there were only 3 tokens left
[Symbol::Literal(_), Symbol::BoolOp(_), Symbol::Literal(_)] => {
- self.expr();
+ self.expr()?;
self.stack.push(Symbol::Bang);
}
_ => {
- self.term();
+ self.term()?;
self.stack.push(Symbol::Bang);
}
}
}
}
+ Ok(())
}
/// Peek at the next token and parse it as a BOOLOP or string literal,
/// as appropriate.
- fn maybe_boolop(&mut self) {
+ fn maybe_boolop(&mut self) -> ParseResult<()> {
if self.peek_is_boolop() {
let symbol = self.next_token();
// BoolOp by itself interpreted as Literal
if let Symbol::None = self.peek() {
- self.literal(symbol.into_literal());
+ self.literal(symbol.into_literal())?;
} else {
- self.boolop(symbol);
- self.maybe_boolop();
+ self.boolop(symbol)?;
+ self.maybe_boolop()?;
}
}
+ Ok(())
}
/// Parse a Boolean expression.
@@ -350,13 +374,14 @@ impl Parser {
/// Logical and (-a) has higher precedence than or (-o), so in an
/// expression like `foo -o '' -a ''`, the and subexpression is evaluated
/// first.
- fn boolop(&mut self, op: Symbol) {
+ fn boolop(&mut self, op: Symbol) -> ParseResult<()> {
if op == Symbol::BoolOp(OsString::from("-a")) {
- self.term();
+ self.term()?;
} else {
- self.expr();
+ self.expr()?;
}
self.stack.push(op);
+ Ok(())
}
/// Parse a (possible) unary argument test (string length or file
@@ -375,7 +400,7 @@ impl Parser {
/// Parse a string literal, optionally followed by a comparison operator
/// and a second string literal.
- fn literal(&mut self, token: Symbol) {
+ fn literal(&mut self, token: Symbol) -> ParseResult<()> {
self.stack.push(token.into_literal());
// EXPR → str OP str
@@ -383,21 +408,24 @@ impl Parser {
let op = self.next_token();
match self.next_token() {
- Symbol::None => panic!("missing argument after {:?}", op),
+ Symbol::None => {
+ return Err(ParseError::MissingArgument(format!("{op}")));
+ }
token => self.stack.push(token.into_literal()),
}
self.stack.push(op);
}
+ Ok(())
}
/// Parser entry point: parse the token stream `self.tokens`, storing the
/// resulting `Symbol` stack in `self.stack`.
- fn parse(&mut self) -> Result<(), String> {
- self.expr();
+ fn parse(&mut self) -> ParseResult<()> {
+ self.expr()?;
match self.tokens.next() {
- Some(token) => Err(format!("extra argument {}", token.quote())),
+ Some(token) => Err(ParseError::ExtraArgument(token.quote().to_string())),
None => Ok(()),
}
}
@@ -405,7 +433,7 @@ impl Parser {
/// Parse the token stream `args`, returning a `Symbol` stack representing the
/// operations to perform in postfix order.
-pub fn parse(args: Vec<OsString>) -> Result<Vec<Symbol>, String> {
+pub fn parse(args: Vec<OsString>) -> ParseResult<Vec<Symbol>> {
let mut p = Parser::new(args);
p.parse()?;
Ok(p.stack)
diff --git a/src/uu/test/src/test.rs b/src/uu/test/src/test.rs
index bc274bc8b4d8eee033950cbe1c36eaab7861cf7c..9d3c2b290312c37c592be495edf8d0c7d66d648f 100644
--- a/src/uu/test/src/test.rs
+++ b/src/uu/test/src/test.rs
@@ -1,16 +1,15 @@
// This file is part of the uutils coreutils package.
//
-// (c) mahkoh (ju.orth [at] gmail [dot] com)
-// (c) Daniel Rocco <drocco@gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
// spell-checker:ignore (vars) egid euid FiletestOp StrlenOp
+pub(crate) mod error;
mod parser;
use clap::{crate_version, Command};
+use error::{ParseError, ParseResult};
use parser::{parse, Operator, Symbol, UnaryOperator};
use std::ffi::{OsStr, OsString};
use std::fs;
@@ -18,82 +17,30 @@ use std::fs;
use std::os::unix::fs::MetadataExt;
use uucore::display::Quotable;
use uucore::error::{UResult, USimpleError};
-use uucore::format_usage;
+#[cfg(not(windows))]
+use uucore::process::{getegid, geteuid};
+use uucore::{format_usage, help_about, help_section};
+const ABOUT: &str = help_about!("test.md");
+
+// The help_usage method replaces util name (the first word) with {}.
+// And, The format_usage method replaces {} with execution_phrase ( e.g. test or [ ).
+// However, This test command has two util names.
+// So, we use test or [ instead of {} so that the usage string is correct.
const USAGE: &str = "\
- {} EXPRESSION
- {}
- [ EXPRESSION ]
- [ ]
- [ OPTION";
+test EXPRESSION
+[
+[ EXPRESSION ]
+[ ]
+[ OPTION
+]";
// We use after_help so that this comes after the usage string (it would come before if we used about)
-const AFTER_HELP: &str = "
-Exit with the status determined by EXPRESSION.
-
-An omitted EXPRESSION defaults to false. Otherwise,
-EXPRESSION is true or false and sets exit status. It is one of:
-
- ( EXPRESSION ) EXPRESSION is true
- ! EXPRESSION EXPRESSION is false
- EXPRESSION1 -a EXPRESSION2 both EXPRESSION1 and EXPRESSION2 are true
- EXPRESSION1 -o EXPRESSION2 either EXPRESSION1 or EXPRESSION2 is true
-
- -n STRING the length of STRING is nonzero
- STRING equivalent to -n STRING
- -z STRING the length of STRING is zero
- STRING1 = STRING2 the strings are equal
- STRING1 != STRING2 the strings are not equal
-
- INTEGER1 -eq INTEGER2 INTEGER1 is equal to INTEGER2
- INTEGER1 -ge INTEGER2 INTEGER1 is greater than or equal to INTEGER2
- INTEGER1 -gt INTEGER2 INTEGER1 is greater than INTEGER2
- INTEGER1 -le INTEGER2 INTEGER1 is less than or equal to INTEGER2
- INTEGER1 -lt INTEGER2 INTEGER1 is less than INTEGER2
- INTEGER1 -ne INTEGER2 INTEGER1 is not equal to INTEGER2
-
- FILE1 -ef FILE2 FILE1 and FILE2 have the same device and inode numbers
- FILE1 -nt FILE2 FILE1 is newer (modification date) than FILE2
- FILE1 -ot FILE2 FILE1 is older than FILE2
-
- -b FILE FILE exists and is block special
- -c FILE FILE exists and is character special
- -d FILE FILE exists and is a directory
- -e FILE FILE exists
- -f FILE FILE exists and is a regular file
- -g FILE FILE exists and is set-group-ID
- -G FILE FILE exists and is owned by the effective group ID
- -h FILE FILE exists and is a symbolic link (same as -L)
- -k FILE FILE exists and has its sticky bit set
- -L FILE FILE exists and is a symbolic link (same as -h)
- -N FILE FILE exists and has been modified since it was last read
- -O FILE FILE exists and is owned by the effective user ID
- -p FILE FILE exists and is a named pipe
- -r FILE FILE exists and read permission is granted
- -s FILE FILE exists and has a size greater than zero
- -S FILE FILE exists and is a socket
- -t FD file descriptor FD is opened on a terminal
- -u FILE FILE exists and its set-user-ID bit is set
- -w FILE FILE exists and write permission is granted
- -x FILE FILE exists and execute (or search) permission is granted
-
-Except for -h and -L, all FILE-related tests dereference symbolic links.
-Beware that parentheses need to be escaped (e.g., by backslashes) for shells.
-INTEGER may also be -l STRING, which evaluates to the length of STRING.
-
-NOTE: Binary -a and -o are inherently ambiguous. Use 'test EXPR1 && test
-EXPR2' or 'test EXPR1 || test EXPR2' instead.
-
-NOTE: [ honors the --help and --version options, but test does not.
-test treats each of those as it treats any other nonempty STRING.
-
-NOTE: your shell may have its own version of test and/or [, which usually supersedes
-the version described here. Please refer to your shell's documentation
-for details about the options it supports.";
-
-const ABOUT: &str = "Check file types and compare values.";
+const AFTER_HELP: &str = help_section!("after help", "test.md");
pub fn uu_app() -> Command {
+ // Disable printing of -h and -v as valid alternatives for --help and --version,
+ // since we don't recognize -h and -v as help/version flags.
Command::new(uucore::util_name())
.version(crate_version!())
.about(ABOUT)
@@ -110,15 +57,7 @@ pub fn uumain(mut args: impl uucore::Args) -> UResult<()> {
if binary_name.ends_with('[') {
// If invoked as [ we should recognize --help and --version (but not -h or -v)
if args.len() == 1 && (args[0] == "--help" || args[0] == "--version") {
- // Let clap pretty-print help and version
- Command::new(binary_name)
- .version(crate_version!())
- .about(ABOUT)
- .override_usage(format_usage(USAGE))
- .after_help(AFTER_HELP)
- // Disable printing of -h and -v as valid alternatives for --help and --version,
- // since we don't recognize -h and -v as help/version flags.
- .get_matches_from(std::iter::once(program).chain(args.into_iter()));
+ uu_app().get_matches_from(std::iter::once(program).chain(args.into_iter()));
return Ok(());
}
// If invoked via name '[', matching ']' must be in the last arg
@@ -128,23 +67,18 @@ pub fn uumain(mut args: impl uucore::Args) -> UResult<()> {
}
}
- let result = parse(args).and_then(|mut stack| eval(&mut stack));
+ let result = parse(args).map(|mut stack| eval(&mut stack))??;
- match result {
- Ok(result) => {
- if result {
- Ok(())
- } else {
- Err(1.into())
- }
- }
- Err(e) => Err(USimpleError::new(2, e)),
+ if result {
+ Ok(())
+ } else {
+ Err(1.into())
}
}
/// Evaluate a stack of Symbols, returning the result of the evaluation or
/// an error message if evaluation failed.
-fn eval(stack: &mut Vec<Symbol>) -> Result<bool, String> {
+fn eval(stack: &mut Vec<Symbol>) -> ParseResult<bool> {
macro_rules! pop_literal {
() => {
match stack.pop() {
@@ -186,7 +120,7 @@ fn eval(stack: &mut Vec<Symbol>) -> Result<bool, String> {
return Ok(true);
}
_ => {
- return Err(format!("missing argument after '{:?}'", op));
+ return Err(ParseError::MissingArgument(op.quote().to_string()));
}
};
@@ -233,7 +167,7 @@ fn eval(stack: &mut Vec<Symbol>) -> Result<bool, String> {
Ok(if op == "-a" { a && b } else { a || b })
}
- _ => Err("expected value".to_string()),
+ _ => Err(ParseError::ExpectedValue),
}
}
@@ -241,19 +175,17 @@ fn eval(stack: &mut Vec<Symbol>) -> Result<bool, String> {
/// `a` is the left hand side
/// `b` is the left hand side
/// `op` the operation (ex: -eq, -lt, etc)
-fn integers(a: &OsStr, b: &OsStr, op: &OsStr) -> Result<bool, String> {
- let format_err = |value: &OsStr| format!("invalid integer {}", value.quote());
-
+fn integers(a: &OsStr, b: &OsStr, op: &OsStr) -> ParseResult<bool> {
// Parse the two inputs
let a: i128 = a
.to_str()
.and_then(|s| s.parse().ok())
- .ok_or_else(|| format_err(a))?;
+ .ok_or_else(|| ParseError::InvalidInteger(a.quote().to_string()))?;
let b: i128 = b
.to_str()
.and_then(|s| s.parse().ok())
- .ok_or_else(|| format_err(b))?;
+ .ok_or_else(|| ParseError::InvalidInteger(b.quote().to_string()))?;
// Do the maths
Ok(match op.to_str() {
@@ -263,7 +195,7 @@ fn integers(a: &OsStr, b: &OsStr, op: &OsStr) -> Result<bool, String> {
Some("-ge") => a >= b,
Some("-lt") => a < b,
Some("-le") => a <= b,
- _ => return Err(format!("unknown operator {}", op.quote())),
+ _ => return Err(ParseError::UnknownOperator(op.quote().to_string())),
})
}
@@ -271,7 +203,7 @@ fn integers(a: &OsStr, b: &OsStr, op: &OsStr) -> Result<bool, String> {
/// `a` is the left hand side
/// `b` is the left hand side
/// `op` the operation (ex: -ef, -nt, etc)
-fn files(a: &OsStr, b: &OsStr, op: &OsStr) -> Result<bool, String> {
+fn files(a: &OsStr, b: &OsStr, op: &OsStr) -> ParseResult<bool> {
// Don't manage the error. GNU doesn't show error when doing
// test foo -nt bar
let f_a = match fs::metadata(a) {
@@ -289,15 +221,15 @@ fn files(a: &OsStr, b: &OsStr, op: &OsStr) -> Result<bool, String> {
#[cfg(not(unix))]
Some("-ef") => unimplemented!(),
Some("-nt") => f_a.modified().unwrap() > f_b.modified().unwrap(),
- Some("-ot") => f_a.created().unwrap() > f_b.created().unwrap(),
- _ => return Err(format!("unknown operator {}", op.quote())),
+ Some("-ot") => f_a.modified().unwrap() < f_b.modified().unwrap(),
+ _ => return Err(ParseError::UnknownOperator(op.quote().to_string())),
})
}
-fn isatty(fd: &OsStr) -> Result<bool, String> {
+fn isatty(fd: &OsStr) -> ParseResult<bool> {
fd.to_str()
.and_then(|s| s.parse().ok())
- .ok_or_else(|| format!("invalid integer {}", fd.quote()))
+ .ok_or_else(|| ParseError::InvalidInteger(fd.quote().to_string()))
.map(|i| {
#[cfg(not(target_os = "redox"))]
unsafe {
@@ -347,7 +279,7 @@ fn path(path: &OsStr, condition: &PathCondition) -> bool {
let geteuid = || {
#[cfg(not(target_os = "redox"))]
- let euid = unsafe { libc::geteuid() };
+ let euid = geteuid();
#[cfg(target_os = "redox")]
let euid = syscall::geteuid().unwrap() as u32;
@@ -356,7 +288,7 @@ fn path(path: &OsStr, condition: &PathCondition) -> bool {
let getegid = || {
#[cfg(not(target_os = "redox"))]
- let egid = unsafe { libc::getegid() };
+ let egid = getegid();
#[cfg(target_os = "redox")]
let egid = syscall::getegid().unwrap() as u32;
diff --git a/src/uu/test/test.md b/src/uu/test/test.md
new file mode 100644
index 0000000000000000000000000000000000000000..b198c220b24468a1b5e951161cbd1ff2e6e66c18
--- /dev/null
+++ b/src/uu/test/test.md
@@ -0,0 +1,80 @@
+# test
+
+```
+test EXPRESSION
+[
+[ EXPRESSION ]
+[ ]
+[ OPTION
+]
+```
+
+Check file types and compare values.
+
+## After Help
+
+Exit with the status determined by `EXPRESSION`.
+
+An omitted `EXPRESSION` defaults to false.
+Otherwise, `EXPRESSION` is true or false and sets exit status.
+
+It is one of:
+
+* ( EXPRESSION ) `EXPRESSION` is true
+* ! EXPRESSION `EXPRESSION` is false
+* EXPRESSION1 -a EXPRESSION2 both `EXPRESSION1` and `EXPRESSION2` are true
+* EXPRESSION1 -o EXPRESSION2 either `EXPRESSION1` or `EXPRESSION2` is true
+
+String operations:
+* -n STRING the length of `STRING` is nonzero
+* STRING equivalent to -n `STRING`
+* -z STRING the length of `STRING` is zero
+* STRING1 = STRING2 the strings are equal
+* STRING1 != STRING2 the strings are not equal
+
+Integer comparisons:
+* INTEGER1 -eq INTEGER2 `INTEGER1` is equal to `INTEGER2`
+* INTEGER1 -ge INTEGER2 `INTEGER1` is greater than or equal to `INTEGER2`
+* INTEGER1 -gt INTEGER2 `INTEGER1` is greater than `INTEGER2`
+* INTEGER1 -le INTEGER2 `INTEGER1` is less than or equal to `INTEGER2`
+* INTEGER1 -lt INTEGER2 `INTEGER1` is less than `INTEGER2`
+* INTEGER1 -ne INTEGER2 `INTEGER1` is not equal to `INTEGER2`
+
+File operations:
+* FILE1 -ef FILE2 `FILE1` and `FILE2` have the same device and inode numbers
+* FILE1 -nt FILE2 `FILE1` is newer (modification date) than `FILE2`
+* FILE1 -ot FILE2 `FILE1` is older than `FILE2`
+
+* -b FILE `FILE` exists and is block special
+* -c FILE `FILE` exists and is character special
+* -d FILE `FILE` exists and is a directory
+* -e FILE `FILE` exists
+* -f FILE `FILE` exists and is a regular file
+* -g FILE `FILE` exists and is set-group-ID
+* -G FILE `FILE` exists and is owned by the effective group ID
+* -h FILE `FILE` exists and is a symbolic link (same as -L)
+* -k FILE `FILE` exists and has its sticky bit set
+* -L FILE `FILE` exists and is a symbolic link (same as -h)
+* -N FILE `FILE` exists and has been modified since it was last read
+* -O FILE `FILE` exists and is owned by the effective user ID
+* -p FILE `FILE` exists and is a named pipe
+* -r FILE `FILE` exists and read permission is granted
+* -s FILE `FILE` exists and has a size greater than zero
+* -S FILE `FILE` exists and is a socket
+* -t FD `file` descriptor `FD` is opened on a terminal
+* -u FILE `FILE` exists and its set-user-ID bit is set
+* -w FILE `FILE` exists and write permission is granted
+* -x FILE `FILE` exists and execute (or search) permission is granted
+
+Except for `-h` and `-L`, all FILE-related tests dereference (follow) symbolic links.
+Beware that parentheses need to be escaped (e.g., by backslashes) for shells.
+`INTEGER` may also be -l `STRING`, which evaluates to the length of `STRING`.
+
+NOTE: Binary `-a` and `-o` are inherently ambiguous.
+Use `test EXPR1 && test EXPR2` or `test EXPR1 || test EXPR2` instead.
+
+NOTE: `[` honors the `--help` and `--version` options, but test does not.
+test treats each of those as it treats any other nonempty `STRING`.
+
+NOTE: your shell may have its own version of `test` and/or `[`, which usually supersedes the version described here.
+Please refer to your shell's documentation for details about the options it supports.
diff --git a/src/uu/timeout/Cargo.toml b/src/uu/timeout/Cargo.toml
index ab71bad9a4fac5eb10ed526a69b49bb8398ff3b8..7f5af04574463b78f720e3c36bda7d8f8f7af422 100644
--- a/src/uu/timeout/Cargo.toml
+++ b/src/uu/timeout/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_timeout"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "timeout ~ (uutils) run COMMAND with a DURATION time limit"
@@ -15,10 +15,10 @@ edition = "2021"
path = "src/timeout.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-libc = "0.2.137"
-nix = { version = "0.25", default-features = false, features = ["signal"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["process", "signals"] }
+clap = { workspace = true }
+libc = { workspace = true }
+nix = { workspace = true, features = ["signal"] }
+uucore = { workspace = true, features = ["process", "signals"] }
[[bin]]
name = "timeout"
diff --git a/src/uu/timeout/src/status.rs b/src/uu/timeout/src/status.rs
index 9a85589546bb2f71fe313c7fc0b05a7f2fe9f9b5..7a94c7f9441630bc9760a64b7c8b0ad21522576d 100644
--- a/src/uu/timeout/src/status.rs
+++ b/src/uu/timeout/src/status.rs
@@ -1,9 +1,8 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//! Exit status codes produced by `timeout`.
-use std::convert::From;
use uucore::error::UError;
/// Enumerates the exit statuses produced by `timeout`.
diff --git a/src/uu/timeout/src/timeout.rs b/src/uu/timeout/src/timeout.rs
index 246537a307caab2ba3fbb57736c0265375ef7066..19016900ac2efda7cf837c57f575224c25491da2 100644
--- a/src/uu/timeout/src/timeout.rs
+++ b/src/uu/timeout/src/timeout.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Alex Lyon <arcterus@mail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) tstr sigstr cmdname setpgid sigchld getpid
mod status;
@@ -17,11 +15,17 @@ use std::time::Duration;
use uucore::display::Quotable;
use uucore::error::{UClapError, UResult, USimpleError, UUsageError};
use uucore::process::ChildExt;
-use uucore::signals::{signal_by_name_or_value, signal_name_by_value};
-use uucore::{format_usage, show_error};
-static ABOUT: &str = "Start COMMAND, and kill it if still running after DURATION.";
-const USAGE: &str = "{} [OPTION] DURATION COMMAND...";
+#[cfg(unix)]
+use uucore::signals::enable_pipe_errors;
+
+use uucore::{
+ format_usage, help_about, help_usage, show_error,
+ signals::{signal_by_name_or_value, signal_name_by_value},
+};
+
+const ABOUT: &str = help_about!("timeout.md");
+const USAGE: &str = help_usage!("timeout.md");
pub mod options {
pub static FOREGROUND: &str = "foreground";
@@ -103,8 +107,6 @@ impl Config {
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_lossy();
-
let matches = uu_app().try_get_matches_from(args).with_exit_code(125)?;
let config = Config::from(&matches)?;
@@ -196,6 +198,22 @@ fn report_if_verbose(signal: usize, cmd: &str, verbose: bool) {
}
}
+fn send_signal(process: &mut Child, signal: usize, foreground: bool) {
+ // NOTE: GNU timeout doesn't check for errors of signal.
+ // The subprocess might have exited just after the timeout.
+ // Sending a signal now would return "No such process", but we should still try to kill the children.
+ if foreground {
+ let _ = process.send_signal(signal);
+ } else {
+ let _ = process.send_signal_group(signal);
+ let kill_signal = signal_by_name_or_value("KILL").unwrap();
+ let continued_signal = signal_by_name_or_value("CONT").unwrap();
+ if signal != kill_signal && signal != continued_signal {
+ _ = process.send_signal_group(continued_signal);
+ }
+ }
+}
+
/// Wait for a child process and send a kill signal if it does not terminate.
///
/// This function waits for the child `process` for the time period
@@ -217,10 +235,11 @@ fn report_if_verbose(signal: usize, cmd: &str, verbose: bool) {
/// If there is a problem sending the `SIGKILL` signal or waiting for
/// the process after that signal is sent.
fn wait_or_kill_process(
- mut process: Child,
+ process: &mut Child,
cmd: &str,
duration: Duration,
preserve_status: bool,
+ foreground: bool,
verbose: bool,
) -> std::io::Result<i32> {
match process.wait_or_timeout(duration) {
@@ -234,7 +253,7 @@ fn wait_or_kill_process(
Ok(None) => {
let signal = signal_by_name_or_value("KILL").unwrap();
report_if_verbose(signal, cmd, verbose);
- process.send_signal(signal)?;
+ send_signal(process, signal, foreground);
process.wait()?;
Ok(ExitStatus::SignalSent(signal).into())
}
@@ -268,21 +287,6 @@ fn preserve_signal_info(signal: libc::c_int) -> libc::c_int {
signal
}
-#[cfg(unix)]
-fn enable_pipe_errors() -> std::io::Result<()> {
- let ret = unsafe { libc::signal(libc::SIGPIPE, libc::SIG_DFL) };
- if ret == libc::SIG_ERR {
- return Err(std::io::Error::new(std::io::ErrorKind::Other, ""));
- }
- Ok(())
-}
-
-#[cfg(not(unix))]
-fn enable_pipe_errors() -> std::io::Result<()> {
- // Do nothing.
- Ok(())
-}
-
/// TODO: Improve exit codes, and make them consistent with the GNU Coreutils exit codes.
fn timeout(
@@ -297,10 +301,10 @@ fn timeout(
if !foreground {
unsafe { libc::setpgid(0, 0) };
}
-
+ #[cfg(unix)]
enable_pipe_errors()?;
- let mut process = process::Command::new(&cmd[0])
+ let process = &mut process::Command::new(&cmd[0])
.args(&cmd[1..])
.stdin(Stdio::inherit())
.stdout(Stdio::inherit())
@@ -314,7 +318,7 @@ fn timeout(
// FIXME: this may not be 100% correct...
126
};
- USimpleError::new(status_code, format!("failed to execute process: {}", err))
+ USimpleError::new(status_code, format!("failed to execute process: {err}"))
})?;
unblock_sigchld();
// Wait for the child process for the specified time period.
@@ -335,11 +339,18 @@ fn timeout(
.into()),
Ok(None) => {
report_if_verbose(signal, &cmd[0], verbose);
- process.send_signal(signal)?;
+ send_signal(process, signal, foreground);
match kill_after {
None => {
+ let status = process.wait()?;
if preserve_status {
- Err(ExitStatus::SignalSent(signal).into())
+ if let Some(ec) = status.code() {
+ Err(ec.into())
+ } else if let Some(sc) = status.signal() {
+ Err(ExitStatus::SignalSent(sc.try_into().unwrap()).into())
+ } else {
+ Err(ExitStatus::CommandTimedOut.into())
+ }
} else {
Err(ExitStatus::CommandTimedOut.into())
}
@@ -350,12 +361,13 @@ fn timeout(
&cmd[0],
kill_after,
preserve_status,
+ foreground,
verbose,
) {
Ok(status) => Err(status.into()),
Err(e) => Err(USimpleError::new(
ExitStatus::TimeoutFailed.into(),
- format!("{}", e),
+ format!("{e}"),
)),
}
}
@@ -363,11 +375,8 @@ fn timeout(
}
Err(_) => {
// We're going to return ERR_EXIT_STATUS regardless of
- // whether `send_signal()` succeeds or fails, so just
- // ignore the return value.
- process.send_signal(signal).map_err(|e| {
- USimpleError::new(ExitStatus::TimeoutFailed.into(), format!("{}", e))
- })?;
+ // whether `send_signal()` succeeds or fails
+ send_signal(process, signal, foreground);
Err(ExitStatus::TimeoutFailed.into())
}
}
diff --git a/src/uu/timeout/timeout.md b/src/uu/timeout/timeout.md
new file mode 100644
index 0000000000000000000000000000000000000000..f992ab32772e1726dd409f53305c8e527d8be8e9
--- /dev/null
+++ b/src/uu/timeout/timeout.md
@@ -0,0 +1,7 @@
+# timeout
+
+```
+timeout [OPTION] DURATION COMMAND...
+```
+
+Start `COMMAND`, and kill it if still running after `DURATION`.
diff --git a/src/uu/touch/Cargo.toml b/src/uu/touch/Cargo.toml
index 40ee899af4c37fd62b86fee7ecf2dc39f2801e28..e0d0dd8903e8f3a439ed82e675f92084e3133bba 100644
--- a/src/uu/touch/Cargo.toml
+++ b/src/uu/touch/Cargo.toml
@@ -1,6 +1,7 @@
+# spell-checker:ignore datetime
[package]
name = "uu_touch"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "touch ~ (uutils) change FILE timestamps"
@@ -15,13 +16,17 @@ edition = "2021"
path = "src/touch.rs"
[dependencies]
-filetime = "0.2.18"
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-time = { version = "0.3", features = ["parsing", "formatting", "local-offset", "macros"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["libc"] }
+filetime = { workspace = true }
+clap = { workspace = true }
+chrono = { workspace = true }
+parse_datetime = { workspace = true }
+uucore = { workspace = true, features = ["libc"] }
[target.'cfg(target_os = "windows")'.dependencies]
-windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_Storage_FileSystem", "Win32_Foundation"] }
+windows-sys = { workspace = true, features = [
+ "Win32_Storage_FileSystem",
+ "Win32_Foundation",
+] }
[[bin]]
name = "touch"
diff --git a/src/uu/touch/src/touch.rs b/src/uu/touch/src/touch.rs
index a50a0030306d82e7b1c478a52795db14b6cc76a7..4192a7a838058b8667cc40422ef532e49e23a52e 100644
--- a/src/uu/touch/src/touch.rs
+++ b/src/uu/touch/src/touch.rs
@@ -1,35 +1,36 @@
// This file is part of the uutils coreutils package.
//
-// (c) Nick Platt <platt.nicholas@gmail.com>
-// (c) Jian Zeng <anonymousknight96 AT gmail.com>
-//
-// For the full copyright and license information, please view the LICENSE file
-// that was distributed with this source code.
-
-// spell-checker:ignore (ToDO) filetime strptime utcoff strs datetime MMDDhhmm clapv PWSTR lpszfilepath hresult mktime YYYYMMDDHHMM YYMMDDHHMM DATETIME YYYYMMDDHHMMS subsecond
-pub extern crate filetime;
-
-use clap::builder::ValueParser;
-use clap::{crate_version, Arg, ArgAction, ArgGroup, Command};
-use filetime::*;
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore (ToDO) filetime datetime lpszfilepath mktime DATETIME datelike timelike
+// spell-checker:ignore (FORMATS) MMDDhhmm YYYYMMDDHHMM YYMMDDHHMM YYYYMMDDHHMMS
+
+use chrono::{
+ DateTime, Datelike, Duration, Local, LocalResult, NaiveDate, NaiveDateTime, NaiveTime,
+ TimeZone, Timelike,
+};
+use clap::builder::{PossibleValue, ValueParser};
+use clap::{crate_version, Arg, ArgAction, ArgGroup, ArgMatches, Command};
+use filetime::{set_file_times, set_symlink_file_times, FileTime};
use std::ffi::OsString;
use std::fs::{self, File};
use std::path::{Path, PathBuf};
-use time::macros::{format_description, offset, time};
-use time::Duration;
use uucore::display::Quotable;
-use uucore::error::{FromIo, UError, UResult, USimpleError};
-use uucore::{format_usage, show};
+use uucore::error::{FromIo, UResult, USimpleError};
+use uucore::shortcut_value_parser::ShortcutValueParser;
+use uucore::{format_usage, help_about, help_usage, show};
+
+const ABOUT: &str = help_about!("touch.md");
+const USAGE: &str = help_usage!("touch.md");
-static ABOUT: &str = "Update the access and modification times of each FILE to the current time.";
-const USAGE: &str = "{} [OPTION]... [USER]";
pub mod options {
// Both SOURCES and sources are needed as we need to be able to refer to the ArgGroup.
pub static SOURCES: &str = "sources";
pub mod sources {
pub static DATE: &str = "date";
pub static REFERENCE: &str = "reference";
- pub static CURRENT: &str = "current";
+ pub static TIMESTAMP: &str = "timestamp";
}
pub static HELP: &str = "help";
pub static ACCESS: &str = "access";
@@ -41,27 +42,35 @@ pub mod options {
static ARG_FILES: &str = "files";
-// Convert a date/time to a date with a TZ offset
-fn to_local(tm: time::PrimitiveDateTime) -> time::OffsetDateTime {
- let offset = match time::OffsetDateTime::now_local() {
- Ok(lo) => lo.offset(),
- Err(e) => {
- panic!("error: {}", e);
- }
- };
- tm.assume_offset(offset)
+mod format {
+ pub(crate) const POSIX_LOCALE: &str = "%a %b %e %H:%M:%S %Y";
+ pub(crate) const ISO_8601: &str = "%Y-%m-%d";
+ // "%Y%m%d%H%M.%S" 15 chars
+ pub(crate) const YYYYMMDDHHMM_DOT_SS: &str = "%Y%m%d%H%M.%S";
+ // "%Y-%m-%d %H:%M:%S.%SS" 12 chars
+ pub(crate) const YYYYMMDDHHMMSS: &str = "%Y-%m-%d %H:%M:%S.%f";
+ // "%Y-%m-%d %H:%M:%S" 12 chars
+ pub(crate) const YYYYMMDDHHMMS: &str = "%Y-%m-%d %H:%M:%S";
+ // "%Y-%m-%d %H:%M" 12 chars
+ // Used for example in tests/touch/no-rights.sh
+ pub(crate) const YYYY_MM_DD_HH_MM: &str = "%Y-%m-%d %H:%M";
+ // "%Y%m%d%H%M" 12 chars
+ pub(crate) const YYYYMMDDHHMM: &str = "%Y%m%d%H%M";
+ // "%Y-%m-%d %H:%M +offset"
+ // Used for example in tests/touch/relative.sh
+ pub(crate) const YYYYMMDDHHMM_OFFSET: &str = "%Y-%m-%d %H:%M %z";
}
-// Convert a date/time with a TZ offset into a FileTime
-fn local_dt_to_filetime(dt: time::OffsetDateTime) -> FileTime {
- FileTime::from_unix_time(dt.unix_timestamp(), dt.nanosecond())
+/// Convert a DateTime with a TZ offset into a FileTime
+///
+/// The DateTime is converted into a unix timestamp from which the FileTime is
+/// constructed.
+fn datetime_to_filetime<T: TimeZone>(dt: &DateTime<T>) -> FileTime {
+ FileTime::from_unix_time(dt.timestamp(), dt.timestamp_subsec_nanos())
}
-// Convert a date/time, considering that the input is in UTC time
-// Used for touch -d 1970-01-01 18:43:33.023456789 for example
-fn dt_to_filename(tm: time::PrimitiveDateTime) -> FileTime {
- let dt = tm.assume_offset(offset!(UTC));
- local_dt_to_filetime(dt)
+fn filetime_to_datetime(ft: &FileTime) -> Option<DateTime<Local>> {
+ Some(DateTime::from_timestamp(ft.unix_seconds(), ft.nanoseconds())?.into())
}
#[uucore::main]
@@ -77,19 +86,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
),
)
})?;
- let (mut atime, mut mtime) =
- if let Some(reference) = matches.get_one::<OsString>(options::sources::REFERENCE) {
- stat(Path::new(reference), !matches.get_flag(options::NO_DEREF))?
- } else {
- let timestamp = if let Some(date) = matches.get_one::<String>(options::sources::DATE) {
- parse_date(date)?
- } else if let Some(current) = matches.get_one::<String>(options::sources::CURRENT) {
- parse_timestamp(current)?
- } else {
- local_dt_to_filetime(time::OffsetDateTime::now_local().unwrap())
- };
- (timestamp, timestamp)
- };
+
+ let (atime, mtime) = determine_times(&matches)?;
for filename in files {
// FIXME: find a way to avoid having to clone the path
@@ -101,7 +99,13 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let path = pathbuf.as_path();
- if let Err(e) = path.metadata() {
+ let metadata_result = if matches.get_flag(options::NO_DEREF) {
+ path.symlink_metadata()
+ } else {
+ path.metadata()
+ };
+
+ if let Err(e) = metadata_result {
if e.kind() != std::io::ErrorKind::NotFound {
return Err(e.map_err_context(|| format!("setting times of {}", filename.quote())));
}
@@ -132,42 +136,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
}
}
- // If changing "only" atime or mtime, grab the existing value of the other.
- // Note that "-a" and "-m" may be passed together; this is not an xor.
- if matches.get_flag(options::ACCESS)
- || matches.get_flag(options::MODIFICATION)
- || matches.contains_id(options::TIME)
- {
- let st = stat(path, !matches.get_flag(options::NO_DEREF))?;
- let time = matches
- .get_one::<String>(options::TIME)
- .map(|s| s.as_str())
- .unwrap_or("");
-
- if !(matches.get_flag(options::ACCESS)
- || time.contains(&"access".to_owned())
- || time.contains(&"atime".to_owned())
- || time.contains(&"use".to_owned()))
- {
- atime = st.0;
- }
-
- if !(matches.get_flag(options::MODIFICATION)
- || time.contains(&"modify".to_owned())
- || time.contains(&"mtime".to_owned()))
- {
- mtime = st.1;
- }
- }
-
- if matches.get_flag(options::NO_DEREF) {
- set_symlink_file_times(path, atime, mtime)
- } else {
- filetime::set_file_times(path, atime, mtime)
- }
- .map_err_context(|| format!("setting times of {}", path.quote()))?;
+ update_times(&matches, path, atime, mtime, filename)?;
}
-
Ok(())
}
@@ -191,7 +161,7 @@ pub fn uu_app() -> Command {
.action(ArgAction::SetTrue),
)
.arg(
- Arg::new(options::sources::CURRENT)
+ Arg::new(options::sources::TIMESTAMP)
.short('t')
.help("use [[CC]YY]MMDDhhmm[.ss] instead of the current time")
.value_name("STAMP"),
@@ -202,7 +172,8 @@ pub fn uu_app() -> Command {
.long(options::sources::DATE)
.allow_hyphen_values(true)
.help("parse argument and use it instead of current time")
- .value_name("STRING"),
+ .value_name("STRING")
+ .conflicts_with(options::sources::TIMESTAMP),
)
.arg(
Arg::new(options::MODIFICATION)
@@ -234,7 +205,8 @@ pub fn uu_app() -> Command {
.help("use this file's times instead of the current time")
.value_name("FILE")
.value_parser(ValueParser::os_string())
- .value_hint(clap::ValueHint::AnyPath),
+ .value_hint(clap::ValueHint::AnyPath)
+ .conflicts_with(options::sources::TIMESTAMP),
)
.arg(
Arg::new(options::TIME)
@@ -245,7 +217,10 @@ pub fn uu_app() -> Command {
equivalent to -m",
)
.value_name("WORD")
- .value_parser(["access", "atime", "use"]),
+ .value_parser(ShortcutValueParser::new([
+ PossibleValue::new("atime").alias("access").alias("use"),
+ PossibleValue::new("mtime").alias("modify"),
+ ])),
)
.arg(
Arg::new(ARG_FILES)
@@ -254,18 +229,111 @@ pub fn uu_app() -> Command {
.value_parser(ValueParser::os_string())
.value_hint(clap::ValueHint::AnyPath),
)
- .group(ArgGroup::new(options::SOURCES).args([
- options::sources::CURRENT,
- options::sources::DATE,
- options::sources::REFERENCE,
- ]))
+ .group(
+ ArgGroup::new(options::SOURCES)
+ .args([
+ options::sources::TIMESTAMP,
+ options::sources::DATE,
+ options::sources::REFERENCE,
+ ])
+ .multiple(true),
+ )
+}
+
+// Determine the access and modification time
+fn determine_times(matches: &ArgMatches) -> UResult<(FileTime, FileTime)> {
+ match (
+ matches.get_one::<OsString>(options::sources::REFERENCE),
+ matches.get_one::<String>(options::sources::DATE),
+ ) {
+ (Some(reference), Some(date)) => {
+ let (atime, mtime) = stat(Path::new(&reference), !matches.get_flag(options::NO_DEREF))?;
+ let atime = filetime_to_datetime(&atime).ok_or_else(|| {
+ USimpleError::new(1, "Could not process the reference access time")
+ })?;
+ let mtime = filetime_to_datetime(&mtime).ok_or_else(|| {
+ USimpleError::new(1, "Could not process the reference modification time")
+ })?;
+ Ok((parse_date(atime, date)?, parse_date(mtime, date)?))
+ }
+ (Some(reference), None) => {
+ stat(Path::new(&reference), !matches.get_flag(options::NO_DEREF))
+ }
+ (None, Some(date)) => {
+ let timestamp = parse_date(Local::now(), date)?;
+ Ok((timestamp, timestamp))
+ }
+ (None, None) => {
+ let timestamp = if let Some(ts) = matches.get_one::<String>(options::sources::TIMESTAMP)
+ {
+ parse_timestamp(ts)?
+ } else {
+ datetime_to_filetime(&Local::now())
+ };
+ Ok((timestamp, timestamp))
+ }
+ }
}
+// Updating file access and modification times based on user-specified options
+fn update_times(
+ matches: &ArgMatches,
+ path: &Path,
+ mut atime: FileTime,
+ mut mtime: FileTime,
+ filename: &OsString,
+) -> UResult<()> {
+ // If changing "only" atime or mtime, grab the existing value of the other.
+ // Note that "-a" and "-m" may be passed together; this is not an xor.
+ if matches.get_flag(options::ACCESS)
+ || matches.get_flag(options::MODIFICATION)
+ || matches.contains_id(options::TIME)
+ {
+ let st = stat(path, !matches.get_flag(options::NO_DEREF))?;
+ let time = matches
+ .get_one::<String>(options::TIME)
+ .map(|s| s.as_str())
+ .unwrap_or("");
+
+ if !(matches.get_flag(options::ACCESS)
+ || time.contains(&"access".to_owned())
+ || time.contains(&"atime".to_owned())
+ || time.contains(&"use".to_owned()))
+ {
+ atime = st.0;
+ }
+
+ if !(matches.get_flag(options::MODIFICATION)
+ || time.contains(&"modify".to_owned())
+ || time.contains(&"mtime".to_owned()))
+ {
+ mtime = st.1;
+ }
+ }
+
+ // sets the file access and modification times for a file or a symbolic link.
+ // The filename, access time (atime), and modification time (mtime) are provided as inputs.
+
+ // If the filename is not "-", indicating a special case for touch -h -,
+ // the code checks if the NO_DEREF flag is set, which means the user wants to
+ // set the times for a symbolic link itself, rather than the file it points to.
+ if filename == "-" {
+ filetime::set_file_times(path, atime, mtime)
+ } else if matches.get_flag(options::NO_DEREF) {
+ set_symlink_file_times(path, atime, mtime)
+ } else {
+ set_file_times(path, atime, mtime)
+ }
+ .map_err_context(|| format!("setting times of {}", path.quote()))
+}
+// Get metadata of the provided path
+// If `follow` is `true`, the function will try to follow symlinks
+// If `follow` is `false` or the symlink is broken, the function will return metadata of the symlink itself
fn stat(path: &Path, follow: bool) -> UResult<(FileTime, FileTime)> {
let metadata = if follow {
- fs::symlink_metadata(path)
+ fs::metadata(path).or_else(|_| fs::symlink_metadata(path))
} else {
- fs::metadata(path)
+ fs::symlink_metadata(path)
}
.map_err_context(|| format!("failed to get attributes of {}", path.quote()))?;
@@ -275,65 +343,7 @@ fn stat(path: &Path, follow: bool) -> UResult<(FileTime, FileTime)> {
))
}
-const POSIX_LOCALE_FORMAT: &[time::format_description::FormatItem] = format_description!(
- "[weekday repr:short] [month repr:short] [day padding:space] \
- [hour]:[minute]:[second] [year]"
-);
-
-const ISO_8601_FORMAT: &[time::format_description::FormatItem] =
- format_description!("[year]-[month]-[day]");
-
-// "%Y%m%d%H%M.%S" 15 chars
-const YYYYMMDDHHMM_DOT_SS_FORMAT: &[time::format_description::FormatItem] = format_description!(
- "[year repr:full][month repr:numerical padding:zero]\
- [day][hour][minute].[second]"
-);
-
-// "%Y-%m-%d %H:%M:%S.%SS" 12 chars
-const YYYYMMDDHHMMSS_FORMAT: &[time::format_description::FormatItem] = format_description!(
- "[year repr:full]-[month repr:numerical padding:zero]-\
- [day] [hour]:[minute]:[second].[subsecond]"
-);
-
-// "%Y-%m-%d %H:%M:%S" 12 chars
-const YYYYMMDDHHMMS_FORMAT: &[time::format_description::FormatItem] = format_description!(
- "[year repr:full]-[month repr:numerical padding:zero]-\
- [day] [hour]:[minute]:[second]"
-);
-
-// "%Y-%m-%d %H:%M" 12 chars
-// Used for example in tests/touch/no-rights.sh
-const YYYY_MM_DD_HH_MM_FORMAT: &[time::format_description::FormatItem] = format_description!(
- "[year repr:full]-[month repr:numerical padding:zero]-\
- [day] [hour]:[minute]"
-);
-
-// "%Y%m%d%H%M" 12 chars
-const YYYYMMDDHHMM_FORMAT: &[time::format_description::FormatItem] = format_description!(
- "[year repr:full][month repr:numerical padding:zero]\
- [day][hour][minute]"
-);
-
-// "%y%m%d%H%M.%S" 13 chars
-const YYMMDDHHMM_DOT_SS_FORMAT: &[time::format_description::FormatItem] = format_description!(
- "[year repr:last_two padding:none][month][day]\
- [hour][minute].[second]"
-);
-
-// "%y%m%d%H%M" 10 chars
-const YYMMDDHHMM_FORMAT: &[time::format_description::FormatItem] = format_description!(
- "[year repr:last_two padding:none][month padding:zero][day padding:zero]\
- [hour repr:24 padding:zero][minute padding:zero]"
-);
-
-// "%Y-%m-%d %H:%M +offset"
-// Used for example in tests/touch/relative.sh
-const YYYYMMDDHHMM_OFFSET_FORMAT: &[time::format_description::FormatItem] = format_description!(
- "[year]-[month]-[day] [hour repr:24]:[minute] \
- [offset_hour sign:mandatory][offset_minute]"
-);
-
-fn parse_date(s: &str) -> UResult<FileTime> {
+fn parse_date(ref_time: DateTime<Local>, s: &str) -> UResult<FileTime> {
// This isn't actually compatible with GNU touch, but there doesn't seem to
// be any simple specification for what format this parameter allows and I'm
// not about to implement GNU parse_datetime.
@@ -348,110 +358,60 @@ fn parse_date(s: &str) -> UResult<FileTime> {
// Tue Dec 3 ...
// ("%c", POSIX_LOCALE_FORMAT),
//
- if let Ok(parsed) = time::PrimitiveDateTime::parse(s, &POSIX_LOCALE_FORMAT) {
- return Ok(local_dt_to_filetime(to_local(parsed)));
+ if let Ok(parsed) = NaiveDateTime::parse_from_str(s, format::POSIX_LOCALE) {
+ return Ok(datetime_to_filetime(&parsed.and_utc()));
}
// Also support other formats found in the GNU tests like
// in tests/misc/stat-nanoseconds.sh
// or tests/touch/no-rights.sh
for fmt in [
- YYYYMMDDHHMMS_FORMAT,
- YYYYMMDDHHMMSS_FORMAT,
- YYYY_MM_DD_HH_MM_FORMAT,
- YYYYMMDDHHMM_OFFSET_FORMAT,
+ format::YYYYMMDDHHMMS,
+ format::YYYYMMDDHHMMSS,
+ format::YYYY_MM_DD_HH_MM,
+ format::YYYYMMDDHHMM_OFFSET,
] {
- if let Ok(parsed) = time::PrimitiveDateTime::parse(s, &fmt) {
- return Ok(dt_to_filename(parsed));
+ if let Ok(parsed) = NaiveDateTime::parse_from_str(s, fmt) {
+ return Ok(datetime_to_filetime(&parsed.and_utc()));
}
}
// "Equivalent to %Y-%m-%d (the ISO 8601 date format). (C99)"
// ("%F", ISO_8601_FORMAT),
- if let Ok(parsed) = time::Date::parse(s, &ISO_8601_FORMAT) {
- return Ok(local_dt_to_filetime(to_local(
- time::PrimitiveDateTime::new(parsed, time!(00:00)),
- )));
+ if let Ok(parsed_date) = NaiveDate::parse_from_str(s, format::ISO_8601) {
+ let parsed = Local
+ .from_local_datetime(&parsed_date.and_time(NaiveTime::MIN))
+ .unwrap();
+ return Ok(datetime_to_filetime(&parsed));
}
// "@%s" is "The number of seconds since the Epoch, 1970-01-01 00:00:00 +0000 (UTC). (TZ) (Calculated from mktime(tm).)"
if s.bytes().next() == Some(b'@') {
if let Ok(ts) = &s[1..].parse::<i64>() {
- // Don't convert to local time in this case - seconds since epoch are not time-zone dependent
- return Ok(local_dt_to_filetime(
- time::OffsetDateTime::from_unix_timestamp(*ts).unwrap(),
- ));
+ return Ok(FileTime::from_unix_time(*ts, 0));
}
}
- // Relative day, like "today", "tomorrow", or "yesterday".
- match s {
- "now" | "today" => {
- let now_local = time::OffsetDateTime::now_local().unwrap();
- return Ok(local_dt_to_filetime(now_local));
- }
- "tomorrow" => {
- let duration = time::Duration::days(1);
- let now_local = time::OffsetDateTime::now_local().unwrap();
- let diff = now_local.checked_add(duration).unwrap();
- return Ok(local_dt_to_filetime(diff));
- }
- "yesterday" => {
- let duration = time::Duration::days(1);
- let now_local = time::OffsetDateTime::now_local().unwrap();
- let diff = now_local.checked_sub(duration).unwrap();
- return Ok(local_dt_to_filetime(diff));
- }
- _ => {}
+ if let Ok(dt) = parse_datetime::parse_datetime_at_date(ref_time, s) {
+ return Ok(datetime_to_filetime(&dt));
}
- // Relative time, like "-1 hour" or "+3 days".
- //
- // TODO Add support for "year" and "month".
- // TODO Add support for times without spaces like "-1hour".
- let tokens: Vec<&str> = s.split_whitespace().collect();
- let maybe_duration = match &tokens[..] {
- [num_str, "fortnight" | "fortnights"] => num_str
- .parse::<i64>()
- .ok()
- .map(|n| time::Duration::weeks(2 * n)),
- ["fortnight" | "fortnights"] => Some(time::Duration::weeks(2)),
- [num_str, "week" | "weeks"] => num_str.parse::<i64>().ok().map(time::Duration::weeks),
- ["week" | "weeks"] => Some(time::Duration::weeks(1)),
- [num_str, "day" | "days"] => num_str.parse::<i64>().ok().map(time::Duration::days),
- ["day" | "days"] => Some(time::Duration::days(1)),
- [num_str, "hour" | "hours"] => num_str.parse::<i64>().ok().map(time::Duration::hours),
- ["hour" | "hours"] => Some(time::Duration::hours(1)),
- [num_str, "minute" | "minutes" | "min" | "mins"] => {
- num_str.parse::<i64>().ok().map(time::Duration::minutes)
- }
- ["minute" | "minutes" | "min" | "mins"] => Some(time::Duration::minutes(1)),
- [num_str, "second" | "seconds" | "sec" | "secs"] => {
- num_str.parse::<i64>().ok().map(time::Duration::seconds)
- }
- ["second" | "seconds" | "sec" | "secs"] => Some(time::Duration::seconds(1)),
- _ => None,
- };
- if let Some(duration) = maybe_duration {
- let now_local = time::OffsetDateTime::now_local().unwrap();
- let diff = now_local.checked_add(duration).unwrap();
- return Ok(local_dt_to_filetime(diff));
- }
-
- Err(USimpleError::new(1, format!("Unable to parse date: {}", s)))
+ Err(USimpleError::new(1, format!("Unable to parse date: {s}")))
}
fn parse_timestamp(s: &str) -> UResult<FileTime> {
- // TODO: handle error
- let now = time::OffsetDateTime::now_utc();
-
- let (mut format, mut ts) = match s.chars().count() {
- 15 => (YYYYMMDDHHMM_DOT_SS_FORMAT, s.to_owned()),
- 12 => (YYYYMMDDHHMM_FORMAT, s.to_owned()),
- 13 => (YYMMDDHHMM_DOT_SS_FORMAT, s.to_owned()),
- 10 => (YYMMDDHHMM_FORMAT, s.to_owned()),
- 11 => (YYYYMMDDHHMM_DOT_SS_FORMAT, format!("{}{}", now.year(), s)),
- 8 => (YYYYMMDDHHMM_FORMAT, format!("{}{}", now.year(), s)),
+ use format::*;
+
+ let current_year = || Local::now().year();
+
+ let (format, ts) = match s.chars().count() {
+ 15 => (YYYYMMDDHHMM_DOT_SS, s.to_owned()),
+ 12 => (YYYYMMDDHHMM, s.to_owned()),
+ // If we don't add "20", we have insufficient information to parse
+ 13 => (YYYYMMDDHHMM_DOT_SS, format!("20{}", s)),
+ 10 => (YYYYMMDDHHMM, format!("20{}", s)),
+ 11 => (YYYYMMDDHHMM_DOT_SS, format!("{}{}", current_year(), s)),
+ 8 => (YYYYMMDDHHMM, format!("{}{}", current_year(), s)),
_ => {
return Err(USimpleError::new(
1,
@@ -459,54 +419,41 @@ fn parse_timestamp(s: &str) -> UResult<FileTime> {
))
}
};
- // workaround time returning Err(TryFromParsed(InsufficientInformation)) for year w/
- // repr:last_two
- // https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=1ccfac7c07c5d1c7887a11decf0e1996
- if s.chars().count() == 10 {
- format = YYYYMMDDHHMM_FORMAT;
- ts = "20".to_owned() + &ts;
- } else if s.chars().count() == 13 {
- format = YYYYMMDDHHMM_DOT_SS_FORMAT;
- ts = "20".to_owned() + &ts;
- }
- let leap_sec = if (format == YYYYMMDDHHMM_DOT_SS_FORMAT || format == YYMMDDHHMM_DOT_SS_FORMAT)
- && ts.ends_with(".60")
- {
- // Work around to disable leap seconds
- // Used in gnu/tests/touch/60-seconds
- ts = ts.replace(".60", ".59");
- true
- } else {
- false
+ let local = NaiveDateTime::parse_from_str(&ts, format)
+ .map_err(|_| USimpleError::new(1, format!("invalid date ts format {}", ts.quote())))?;
+ let mut local = match chrono::Local.from_local_datetime(&local) {
+ LocalResult::Single(dt) => dt,
+ _ => {
+ return Err(USimpleError::new(
+ 1,
+ format!("invalid date ts format {}", ts.quote()),
+ ))
+ }
};
- let tm = time::PrimitiveDateTime::parse(&ts, &format)
- .map_err(|_| USimpleError::new(1, format!("invalid date ts format {}", ts.quote())))?;
- let mut local = to_local(tm);
- if leap_sec {
- // We are dealing with a leap second, add it
- local = local.saturating_add(Duration::SECOND);
+ // Chrono caps seconds at 59, but 60 is valid. It might be a leap second
+ // or wrap to the next minute. But that doesn't really matter, because we
+ // only care about the timestamp anyway.
+ // Tested in gnu/tests/touch/60-seconds
+ if local.second() == 59 && ts.ends_with(".60") {
+ local += Duration::try_seconds(1).unwrap();
}
- let ft = local_dt_to_filetime(local);
-
- // // We have to check that ft is valid time. Due to daylight saving
- // // time switch, local time can jump from 1:59 AM to 3:00 AM,
- // // in which case any time between 2:00 AM and 2:59 AM is not valid.
- // // Convert back to local time and see if we got the same value back.
- // let ts = time::Timespec {
- // sec: ft.unix_seconds(),
- // nsec: 0,
- // };
- // let tm2 = time::at(ts);
- // if tm.tm_hour != tm2.tm_hour {
- // return Err(USimpleError::new(
- // 1,
- // format!("invalid date format {}", s.quote()),
- // ));
- // }
-
- Ok(ft)
+
+ // Due to daylight saving time switch, local time can jump from 1:59 AM to
+ // 3:00 AM, in which case any time between 2:00 AM and 2:59 AM is not
+ // valid. If we are within this jump, chrono takes the offset from before
+ // the jump. If we then jump forward an hour, we get the new corrected
+ // offset. Jumping back will then now correctly take the jump into account.
+ let local2 = local + Duration::try_hours(1).unwrap() - Duration::try_hours(1).unwrap();
+ if local.hour() != local2.hour() {
+ return Err(USimpleError::new(
+ 1,
+ format!("invalid date format {}", s.quote()),
+ ));
+ }
+
+ Ok(datetime_to_filetime(&local))
}
// TODO: this may be a good candidate to put in fsext.rs
@@ -558,10 +505,10 @@ fn pathbuf_from_stdout() -> UResult<PathBuf> {
ERROR_PATH_NOT_FOUND | ERROR_NOT_ENOUGH_MEMORY | ERROR_INVALID_PARAMETER => {
return Err(USimpleError::new(
1,
- format!("GetFinalPathNameByHandleW failed with code {}", ret),
+ format!("GetFinalPathNameByHandleW failed with code {ret}"),
))
}
- e if e == 0 => {
+ 0 => {
return Err(USimpleError::new(
1,
format!(
@@ -589,8 +536,7 @@ mod tests {
// We can trigger an error by not setting stdout to anything (will
// fail with code 1)
assert!(super::pathbuf_from_stdout()
- .err()
- .expect("pathbuf_from_stdout should have failed")
+ .expect_err("pathbuf_from_stdout should have failed")
.to_string()
.contains("GetFinalPathNameByHandleW failed with code 1"));
}
diff --git a/src/uu/touch/touch.md b/src/uu/touch/touch.md
new file mode 100644
index 0000000000000000000000000000000000000000..8ce35b6868a5b628e36a76e142defdef1883390f
--- /dev/null
+++ b/src/uu/touch/touch.md
@@ -0,0 +1,7 @@
+# touch
+
+```
+touch [OPTION]... [USER]
+```
+
+Update the access and modification times of each `FILE` to the current time.
diff --git a/src/uu/tr/Cargo.toml b/src/uu/tr/Cargo.toml
index 99242399914c199f3d742ea81202637dbb2459d6..a0c3e0f41ab969881537169b83cb891353bdfba3 100644
--- a/src/uu/tr/Cargo.toml
+++ b/src/uu/tr/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_tr"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "tr ~ (uutils) translate characters within input and display"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/tr.rs"
[dependencies]
-nom = "7.1.1"
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+nom = { workspace = true }
+clap = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "tr"
diff --git a/src/uu/tr/src/convert.rs b/src/uu/tr/src/convert.rs
deleted file mode 100644
index 00656ca494336c0b183a6bfe6aefe28477c1b471..0000000000000000000000000000000000000000
--- a/src/uu/tr/src/convert.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
-
-// spell-checker:ignore (strings) anychar combinator
-
-use nom::{
- branch::alt,
- bytes::complete::tag,
- character::complete::{anychar, one_of},
- combinator::{map_opt, recognize},
- multi::{many0, many_m_n},
- sequence::preceded,
- IResult,
-};
-
-fn parse_octal(input: &str) -> IResult<&str, char> {
- map_opt(
- preceded(tag("\\"), recognize(many_m_n(1, 3, one_of("01234567")))),
- |out: &str| {
- u32::from_str_radix(out, 8)
- .map(std::char::from_u32)
- .ok()
- .flatten()
- },
- )(input)
-}
-
-pub fn reduce_octal_to_char(input: &str) -> String {
- many0(alt((parse_octal, anychar)))(input)
- .map(|(_, r)| r)
- .unwrap()
- .into_iter()
- .collect()
-}
diff --git a/src/uu/tr/src/operation.rs b/src/uu/tr/src/operation.rs
index 0bc8005fe29dd4e854b006f9735ad6d10026198d..026ac96a4457c07a40617c18bb73be27462b91e8 100644
--- a/src/uu/tr/src/operation.rs
+++ b/src/uu/tr/src/operation.rs
@@ -1,16 +1,16 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-// spell-checker:ignore (strings) anychar combinator Alnum Punct Xdigit alnum punct xdigit cntrl
+// spell-checker:ignore (strings) anychar combinator Alnum Punct Xdigit alnum punct xdigit cntrl boop
use nom::{
branch::alt,
- bytes::complete::tag,
- character::complete::{anychar, digit1},
- combinator::{map, peek, value},
- multi::many0,
+ bytes::complete::{tag, take},
+ character::complete::{digit1, one_of},
+ combinator::{map, map_opt, peek, recognize, value},
+ multi::{many0, many_m_n},
sequence::{delimited, preceded, separated_pair},
IResult,
};
@@ -19,6 +19,7 @@ use std::{
error::Error,
fmt::{Debug, Display},
io::{BufRead, Write},
+ ops::Not,
};
use uucore::error::UError;
@@ -32,26 +33,42 @@ pub enum BadSequence {
CharRepeatInSet1,
InvalidRepeatCount(String),
EmptySet2WhenNotTruncatingSet1,
+ ClassExceptLowerUpperInSet2,
+ ClassInSet2NotMatchedBySet1,
+ Set1LongerSet2EndsInClass,
+ ComplementMoreThanOneUniqueInSet2,
}
impl Display for BadSequence {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
- Self::MissingCharClassName => writeln!(f, "missing character class name '[::]'"),
+ Self::MissingCharClassName => write!(f, "missing character class name '[::]'"),
Self::MissingEquivalentClassChar => {
- writeln!(f, "missing equivalence class character '[==]'")
+ write!(f, "missing equivalence class character '[==]'")
}
Self::MultipleCharRepeatInSet2 => {
- writeln!(f, "only one [c*] repeat construct may appear in string2")
+ write!(f, "only one [c*] repeat construct may appear in string2")
}
Self::CharRepeatInSet1 => {
- writeln!(f, "the [c*] repeat construct may not appear in string1")
+ write!(f, "the [c*] repeat construct may not appear in string1")
}
Self::InvalidRepeatCount(count) => {
- writeln!(f, "invalid repeat count '{}' in [c*n] construct", count)
+ write!(f, "invalid repeat count '{count}' in [c*n] construct")
}
Self::EmptySet2WhenNotTruncatingSet1 => {
- writeln!(f, "when not truncating set1, string2 must be non-empty")
+ write!(f, "when not truncating set1, string2 must be non-empty")
+ }
+ Self::ClassExceptLowerUpperInSet2 => {
+ write!(f, "when translating, the only character classes that may appear in set2 are 'upper' and 'lower'")
+ }
+ Self::ClassInSet2NotMatchedBySet1 => {
+ write!(f, "when translating, every 'upper'/'lower' in set2 must be matched by a 'upper'/'lower' in the same position in set1")
+ }
+ Self::Set1LongerSet2EndsInClass => {
+ write!(f, "when translating with string1 longer than string2,\nthe latter string must not end with a character class")
+ }
+ Self::ComplementMoreThanOneUniqueInSet2 => {
+ write!(f, "when translating with complemented character classes,\nstring2 must map all characters in the domain to one")
}
}
}
@@ -61,11 +78,7 @@ impl Error for BadSequence {}
impl UError for BadSequence {}
#[derive(Debug, Clone, Copy)]
-pub enum Sequence {
- Char(char),
- CharRange(u32, u32),
- CharStar(char),
- CharRepeat(char, usize),
+pub enum Class {
Alnum,
Alpha,
Blank,
@@ -80,143 +93,213 @@ pub enum Sequence {
Xdigit,
}
+#[derive(Debug, Clone, Copy)]
+pub enum Sequence {
+ Char(u8),
+ CharRange(u8, u8),
+ CharStar(u8),
+ CharRepeat(u8, usize),
+ Class(Class),
+}
+
impl Sequence {
- pub fn flatten(&self) -> Box<dyn Iterator<Item = char>> {
+ pub fn flatten_non_lower_upper(&self) -> Box<dyn Iterator<Item = Self>> {
match self {
- Self::Char(c) => Box::new(std::iter::once(*c)),
- Self::CharRange(l, r) => Box::new((*l..=*r).flat_map(std::char::from_u32)),
- Self::CharStar(c) => Box::new(std::iter::repeat(*c)),
- Self::CharRepeat(c, n) => Box::new(std::iter::repeat(*c).take(*n)),
- Self::Alnum => Box::new(('0'..='9').chain('A'..='Z').chain('a'..='z')),
- Self::Alpha => Box::new(('A'..='Z').chain('a'..='z')),
- Self::Blank => Box::new(unicode_table::BLANK.iter().cloned()),
- Self::Control => Box::new(
- (0..=31)
- .chain(std::iter::once(127))
- .flat_map(std::char::from_u32),
- ),
- Self::Digit => Box::new('0'..='9'),
- Self::Graph => Box::new(
- (48..=57) // digit
- .chain(65..=90) // uppercase
- .chain(97..=122) // lowercase
- // punctuations
- .chain(33..=47)
- .chain(58..=64)
- .chain(91..=96)
- .chain(123..=126)
- .chain(std::iter::once(32)) // space
- .flat_map(std::char::from_u32),
- ),
- Self::Lower => Box::new('a'..='z'),
- Self::Print => Box::new(
- (48..=57) // digit
- .chain(65..=90) // uppercase
- .chain(97..=122) // lowercase
- // punctuations
- .chain(33..=47)
- .chain(58..=64)
- .chain(91..=96)
- .chain(123..=126)
- .flat_map(std::char::from_u32),
- ),
- Self::Punct => Box::new(
- (33..=47)
- .chain(58..=64)
- .chain(91..=96)
- .chain(123..=126)
- .flat_map(std::char::from_u32),
- ),
- Self::Space => Box::new(unicode_table::SPACES.iter().cloned()),
- Self::Upper => Box::new('A'..='Z'),
- Self::Xdigit => Box::new(('0'..='9').chain('A'..='F').chain('a'..='f')),
+ Self::Char(c) => Box::new(std::iter::once(*c).map(Self::Char)),
+ Self::CharRange(l, r) => Box::new((*l..=*r).map(Self::Char)),
+ Self::CharRepeat(c, n) => Box::new(std::iter::repeat(*c).take(*n).map(Self::Char)),
+ Self::Class(class) => match class {
+ Class::Alnum => Box::new(
+ (b'0'..=b'9')
+ .chain(b'A'..=b'Z')
+ .chain(b'a'..=b'z')
+ .map(Self::Char),
+ ),
+ Class::Alpha => Box::new((b'A'..=b'Z').chain(b'a'..=b'z').map(Self::Char)),
+ Class::Blank => Box::new(unicode_table::BLANK.iter().cloned().map(Self::Char)),
+ Class::Control => Box::new((0..=31).chain(std::iter::once(127)).map(Self::Char)),
+ Class::Digit => Box::new((b'0'..=b'9').map(Self::Char)),
+ Class::Graph => Box::new(
+ (48..=57) // digit
+ .chain(65..=90) // uppercase
+ .chain(97..=122) // lowercase
+ // punctuations
+ .chain(33..=47)
+ .chain(58..=64)
+ .chain(91..=96)
+ .chain(123..=126)
+ .chain(std::iter::once(32))
+ .map(Self::Char), // space
+ ),
+ Class::Print => Box::new(
+ (48..=57) // digit
+ .chain(65..=90) // uppercase
+ .chain(97..=122) // lowercase
+ // punctuations
+ .chain(33..=47)
+ .chain(58..=64)
+ .chain(91..=96)
+ .chain(123..=126)
+ .map(Self::Char),
+ ),
+ Class::Punct => Box::new(
+ (33..=47)
+ .chain(58..=64)
+ .chain(91..=96)
+ .chain(123..=126)
+ .map(Self::Char),
+ ),
+ Class::Space => Box::new(unicode_table::SPACES.iter().cloned().map(Self::Char)),
+ Class::Xdigit => Box::new(
+ (b'0'..=b'9')
+ .chain(b'A'..=b'F')
+ .chain(b'a'..=b'f')
+ .map(Self::Char),
+ ),
+ s => Box::new(std::iter::once(Self::Class(*s))),
+ },
+ s => Box::new(std::iter::once(*s)),
+ }
+ }
+
+ pub fn flatten_all(&self) -> Box<dyn Iterator<Item = Self>> {
+ match self {
+ Self::Class(class) => match class {
+ Class::Lower => Box::new((b'a'..=b'z').map(Self::Char)),
+ Class::Upper => Box::new((b'A'..=b'Z').map(Self::Char)),
+ s => Self::Class(*s).flatten_non_lower_upper(),
+ },
+ s => s.flatten_non_lower_upper(),
}
}
// Hide all the nasty sh*t in here
- // TODO: Make the 2 set lazily generate the character mapping as necessary.
pub fn solve_set_characters(
- set1_str: &str,
- set2_str: &str,
+ set1_str: &[u8],
+ set2_str: &[u8],
+ complement_flag: bool,
truncate_set1_flag: bool,
- ) -> Result<(Vec<char>, Vec<char>), BadSequence> {
+ translating: bool,
+ ) -> Result<(Vec<u8>, Vec<u8>), BadSequence> {
+ let is_char_star = |s: &&Self| -> bool { matches!(s, Self::CharStar(_)) };
+ let to_u8 = |s: Self| -> Option<u8> {
+ match s {
+ Self::Char(c) => Some(c),
+ _ => None,
+ }
+ };
+
let set1 = Self::from_str(set1_str)?;
- let set2 = Self::from_str(set2_str)?;
+ if set1.iter().filter(is_char_star).count() != 0 {
+ return Err(BadSequence::CharRepeatInSet1);
+ }
- let is_char_star = |s: &&Self| -> bool { matches!(s, Self::CharStar(_)) };
- let set1_star_count = set1.iter().filter(is_char_star).count();
- if set1_star_count == 0 {
- let set2_star_count = set2.iter().filter(is_char_star).count();
- if set2_star_count < 2 {
- let char_star = set2.iter().find_map(|s| match s {
- Self::CharStar(c) => Some(c),
- _ => None,
- });
- let mut partition = set2.as_slice().split(|s| matches!(s, Self::CharStar(_)));
- let set1_len = set1.iter().flat_map(Self::flatten).count();
- let set2_len = set2
+ let mut set2 = Self::from_str(set2_str)?;
+ if set2.iter().filter(is_char_star).count() > 1 {
+ return Err(BadSequence::MultipleCharRepeatInSet2);
+ }
+
+ if translating
+ && set2.iter().any(|&x| {
+ matches!(x, Self::Class(_))
+ && !matches!(x, Self::Class(Class::Upper) | Self::Class(Class::Lower))
+ })
+ {
+ return Err(BadSequence::ClassExceptLowerUpperInSet2);
+ }
+
+ let mut set1_solved: Vec<u8> = set1
+ .iter()
+ .flat_map(Self::flatten_all)
+ .filter_map(to_u8)
+ .collect();
+ if complement_flag {
+ set1_solved = (0..=u8::MAX).filter(|x| !set1_solved.contains(x)).collect();
+ }
+ let set1_len = set1_solved.len();
+
+ let set2_len = set2
+ .iter()
+ .filter_map(|s| match s {
+ Self::CharStar(_) => None,
+ r => Some(r),
+ })
+ .flat_map(Self::flatten_all)
+ .count();
+
+ let star_compensate_len = set1_len.saturating_sub(set2_len);
+ //Replace CharStar with CharRepeat
+ set2 = set2
+ .iter()
+ .filter_map(|s| match s {
+ Self::CharStar(0) => None,
+ Self::CharStar(c) => Some(Self::CharRepeat(*c, star_compensate_len)),
+ r => Some(*r),
+ })
+ .collect();
+
+ //Flatten everything but upper/lower into Char
+ let set1_flattened: Vec<_> = set1
+ .iter()
+ .flat_map(Self::flatten_non_lower_upper)
+ .collect();
+ set2 = set2
+ .iter()
+ .flat_map(Self::flatten_non_lower_upper)
+ .collect();
+
+ if set2
+ .iter()
+ .zip(
+ set1_flattened
.iter()
- .filter_map(|s| match s {
- Self::CharStar(_) => None,
- r => Some(r),
- })
- .flat_map(Self::flatten)
- .count();
- let star_compensate_len = set1_len.saturating_sub(set2_len);
- let (left, right) = (partition.next(), partition.next());
- let set2_solved: Vec<char> = match (left, right) {
- (None, None) => match char_star {
- Some(c) => std::iter::repeat(*c).take(star_compensate_len).collect(),
- None => std::iter::empty().collect(),
- },
- (None, Some(set2_b)) => {
- if let Some(c) = char_star {
- std::iter::repeat(*c)
- .take(star_compensate_len)
- .chain(set2_b.iter().flat_map(Self::flatten))
- .collect()
- } else {
- set2_b.iter().flat_map(Self::flatten).collect()
- }
- }
- (Some(set2_a), None) => match char_star {
- Some(c) => set2_a
- .iter()
- .flat_map(Self::flatten)
- .chain(std::iter::repeat(*c).take(star_compensate_len))
- .collect(),
- None => set2_a.iter().flat_map(Self::flatten).collect(),
- },
- (Some(set2_a), Some(set2_b)) => match char_star {
- Some(c) => set2_a
- .iter()
- .flat_map(Self::flatten)
- .chain(std::iter::repeat(*c).take(star_compensate_len))
- .chain(set2_b.iter().flat_map(Self::flatten))
- .collect(),
- None => set2_a
- .iter()
- .chain(set2_b.iter())
- .flat_map(Self::flatten)
- .collect(),
- },
- };
- let mut set1_solved: Vec<char> = set1.iter().flat_map(Self::flatten).collect();
- if truncate_set1_flag {
- set1_solved.truncate(set2_solved.len());
- }
- Ok((set1_solved, set2_solved))
- } else {
- Err(BadSequence::MultipleCharRepeatInSet2)
- }
- } else {
- Err(BadSequence::CharRepeatInSet1)
+ .chain(std::iter::repeat(&Self::Char(0))),
+ )
+ .any(|x| matches!(x.0, Self::Class(_)) && !matches!(x.1, Self::Class(_)))
+ {
+ return Err(BadSequence::ClassInSet2NotMatchedBySet1);
+ }
+
+ let set2_solved: Vec<_> = set2
+ .iter()
+ .flat_map(Self::flatten_all)
+ .filter_map(to_u8)
+ .collect();
+
+ // Calculate the set of unique characters in set2
+ let mut set2_uniques = set2_solved.clone();
+ set2_uniques.sort();
+ set2_uniques.dedup();
+
+ //If the complement flag is used in translate mode, only one unique character may appear in
+ //set2. Validate this with the set of uniques in set2 that we just generated.
+ if set1.iter().any(|x| matches!(x, Self::Class(_)))
+ && translating
+ && complement_flag
+ && set2_uniques.len() > 1
+ {
+ return Err(BadSequence::ComplementMoreThanOneUniqueInSet2);
+ }
+
+ if set2_solved.len() < set1_solved.len()
+ && !truncate_set1_flag
+ && matches!(
+ set2.last().copied(),
+ Some(Self::Class(Class::Upper)) | Some(Self::Class(Class::Lower))
+ )
+ {
+ return Err(BadSequence::Set1LongerSet2EndsInClass);
+ }
+ //Truncation is done dead last. It has no influence on the other conversion steps
+ if truncate_set1_flag {
+ set1_solved.truncate(set2_solved.len());
}
+ Ok((set1_solved, set2_solved))
}
}
impl Sequence {
- pub fn from_str(input: &str) -> Result<Vec<Self>, BadSequence> {
+ pub fn from_str(input: &[u8]) -> Result<Vec<Self>, BadSequence> {
many0(alt((
Self::parse_char_range,
Self::parse_char_star,
@@ -232,27 +315,38 @@ impl Sequence {
.collect::<Result<Vec<_>, _>>()
}
- fn parse_backslash(input: &str) -> IResult<&str, char> {
- preceded(tag("\\"), anychar)(input).map(|(l, a)| {
+ fn parse_octal(input: &[u8]) -> IResult<&[u8], u8> {
+ map_opt(
+ preceded(tag("\\"), recognize(many_m_n(1, 3, one_of("01234567")))),
+ |out: &[u8]| u8::from_str_radix(std::str::from_utf8(out).expect("boop"), 8).ok(),
+ )(input)
+ }
+
+ fn parse_backslash(input: &[u8]) -> IResult<&[u8], u8> {
+ preceded(tag("\\"), Self::single_char)(input).map(|(l, a)| {
let c = match a {
- 'a' => unicode_table::BEL,
- 'b' => unicode_table::BS,
- 'f' => unicode_table::FF,
- 'n' => unicode_table::LF,
- 'r' => unicode_table::CR,
- 't' => unicode_table::HT,
- 'v' => unicode_table::VT,
+ b'a' => unicode_table::BEL,
+ b'b' => unicode_table::BS,
+ b'f' => unicode_table::FF,
+ b'n' => unicode_table::LF,
+ b'r' => unicode_table::CR,
+ b't' => unicode_table::HT,
+ b'v' => unicode_table::VT,
x => x,
};
(l, c)
})
}
- fn parse_backslash_or_char(input: &str) -> IResult<&str, char> {
- alt((Self::parse_backslash, anychar))(input)
+ fn parse_backslash_or_char(input: &[u8]) -> IResult<&[u8], u8> {
+ alt((Self::parse_octal, Self::parse_backslash, Self::single_char))(input)
+ }
+
+ fn single_char(input: &[u8]) -> IResult<&[u8], u8> {
+ take(1usize)(input).map(|(l, a)| (l, a[0]))
}
- fn parse_char_range(input: &str) -> IResult<&str, Result<Self, BadSequence>> {
+ fn parse_char_range(input: &[u8]) -> IResult<&[u8], Result<Self, BadSequence>> {
separated_pair(
Self::parse_backslash_or_char,
tag("-"),
@@ -261,58 +355,59 @@ impl Sequence {
.map(|(l, (a, b))| {
(l, {
let (start, end) = (u32::from(a), u32::from(b));
- Ok(Self::CharRange(start, end))
+ Ok(Self::CharRange(start as u8, end as u8))
})
})
}
- fn parse_char_star(input: &str) -> IResult<&str, Result<Self, BadSequence>> {
+ fn parse_char_star(input: &[u8]) -> IResult<&[u8], Result<Self, BadSequence>> {
delimited(tag("["), Self::parse_backslash_or_char, tag("*]"))(input)
.map(|(l, a)| (l, Ok(Self::CharStar(a))))
}
- fn parse_char_repeat(input: &str) -> IResult<&str, Result<Self, BadSequence>> {
+ fn parse_char_repeat(input: &[u8]) -> IResult<&[u8], Result<Self, BadSequence>> {
delimited(
tag("["),
separated_pair(Self::parse_backslash_or_char, tag("*"), digit1),
tag("]"),
)(input)
.map(|(l, (c, cnt_str))| {
- let result = if cnt_str.starts_with('0') {
- match usize::from_str_radix(cnt_str, 8) {
+ let s = String::from_utf8_lossy(cnt_str);
+ let result = if cnt_str.starts_with(b"0") {
+ match usize::from_str_radix(&s, 8) {
Ok(0) => Ok(Self::CharStar(c)),
Ok(count) => Ok(Self::CharRepeat(c, count)),
- Err(_) => Err(BadSequence::InvalidRepeatCount(cnt_str.to_string())),
+ Err(_) => Err(BadSequence::InvalidRepeatCount(s.to_string())),
}
} else {
- match cnt_str.parse::<usize>() {
+ match s.parse::<usize>() {
Ok(0) => Ok(Self::CharStar(c)),
Ok(count) => Ok(Self::CharRepeat(c, count)),
- Err(_) => Err(BadSequence::InvalidRepeatCount(cnt_str.to_string())),
+ Err(_) => Err(BadSequence::InvalidRepeatCount(s.to_string())),
}
};
(l, result)
})
}
- fn parse_class(input: &str) -> IResult<&str, Result<Self, BadSequence>> {
+ fn parse_class(input: &[u8]) -> IResult<&[u8], Result<Self, BadSequence>> {
delimited(
tag("[:"),
alt((
map(
alt((
- value(Self::Alnum, tag("alnum")),
- value(Self::Alpha, tag("alpha")),
- value(Self::Blank, tag("blank")),
- value(Self::Control, tag("cntrl")),
- value(Self::Digit, tag("digit")),
- value(Self::Graph, tag("graph")),
- value(Self::Lower, tag("lower")),
- value(Self::Print, tag("print")),
- value(Self::Punct, tag("punct")),
- value(Self::Space, tag("space")),
- value(Self::Upper, tag("upper")),
- value(Self::Xdigit, tag("xdigit")),
+ value(Self::Class(Class::Alnum), tag("alnum")),
+ value(Self::Class(Class::Alpha), tag("alpha")),
+ value(Self::Class(Class::Blank), tag("blank")),
+ value(Self::Class(Class::Control), tag("cntrl")),
+ value(Self::Class(Class::Digit), tag("digit")),
+ value(Self::Class(Class::Graph), tag("graph")),
+ value(Self::Class(Class::Lower), tag("lower")),
+ value(Self::Class(Class::Print), tag("print")),
+ value(Self::Class(Class::Punct), tag("punct")),
+ value(Self::Class(Class::Space), tag("space")),
+ value(Self::Class(Class::Upper), tag("upper")),
+ value(Self::Class(Class::Xdigit), tag("xdigit")),
)),
Ok,
),
@@ -322,7 +417,7 @@ impl Sequence {
)(input)
}
- fn parse_char_equal(input: &str) -> IResult<&str, Result<Self, BadSequence>> {
+ fn parse_char_equal(input: &[u8]) -> IResult<&[u8], Result<Self, BadSequence>> {
delimited(
tag("[="),
alt((
@@ -338,62 +433,60 @@ impl Sequence {
}
pub trait SymbolTranslator {
- fn translate(&mut self, current: char) -> Option<char>;
+ fn translate(&mut self, current: u8) -> Option<u8>;
+
+ /// Takes two SymbolTranslators and creates a new SymbolTranslator over both in sequence.
+ ///
+ /// This behaves pretty much identical to [`Iterator::chain`].
+ fn chain<T>(self, other: T) -> ChainedSymbolTranslator<Self, T>
+ where
+ Self: Sized,
+ {
+ ChainedSymbolTranslator::<Self, T> {
+ stage_a: self,
+ stage_b: other,
+ }
+ }
}
-#[derive(Debug)]
-pub struct DeleteOperation {
- set: Vec<char>,
- complement_flag: bool,
+pub struct ChainedSymbolTranslator<A, B> {
+ stage_a: A,
+ stage_b: B,
}
-impl DeleteOperation {
- pub fn new(set: Vec<char>, complement_flag: bool) -> Self {
- Self {
- set,
- complement_flag,
- }
+impl<A: SymbolTranslator, B: SymbolTranslator> SymbolTranslator for ChainedSymbolTranslator<A, B> {
+ fn translate(&mut self, current: u8) -> Option<u8> {
+ self.stage_a
+ .translate(current)
+ .and_then(|c| self.stage_b.translate(c))
}
}
-impl SymbolTranslator for DeleteOperation {
- fn translate(&mut self, current: char) -> Option<char> {
- let found = self.set.iter().any(|sequence| sequence.eq(¤t));
- if self.complement_flag == found {
- Some(current)
- } else {
- None
- }
- }
+#[derive(Debug)]
+pub struct DeleteOperation {
+ set: Vec<u8>,
}
-pub struct TranslateOperationComplement {
- iter: u32,
- set2_iter: usize,
- set1: Vec<char>,
- set2: Vec<char>,
- translation_map: HashMap<char, char>,
+impl DeleteOperation {
+ pub fn new(set: Vec<u8>) -> Self {
+ Self { set }
+ }
}
-impl TranslateOperationComplement {
- fn new(set1: Vec<char>, set2: Vec<char>) -> Self {
- Self {
- iter: 0,
- set2_iter: 0,
- set1,
- set2,
- translation_map: HashMap::new(),
- }
+impl SymbolTranslator for DeleteOperation {
+ fn translate(&mut self, current: u8) -> Option<u8> {
+ // keep if not present in the set
+ self.set.contains(¤t).not().then_some(current)
}
}
#[derive(Debug)]
-pub struct TranslateOperationStandard {
- translation_map: HashMap<char, char>,
+pub struct TranslateOperation {
+ translation_map: HashMap<u8, u8>,
}
-impl TranslateOperationStandard {
- fn new(set1: Vec<char>, set2: Vec<char>) -> Result<Self, BadSequence> {
+impl TranslateOperation {
+ pub fn new(set1: Vec<u8>, set2: Vec<u8>) -> Result<Self, BadSequence> {
if let Some(fallback) = set2.last().copied() {
Ok(Self {
translation_map: set1
@@ -411,123 +504,44 @@ impl TranslateOperationStandard {
}
}
-pub enum TranslateOperation {
- Standard(TranslateOperationStandard),
- Complement(TranslateOperationComplement),
-}
-
-impl TranslateOperation {
- fn next_complement_char(iter: u32, ignore_list: &[char]) -> (u32, char) {
- (iter..)
- .filter_map(std::char::from_u32)
- .filter(|c| !ignore_list.iter().any(|s| s.eq(c)))
- .map(|c| (u32::from(c) + 1, c))
- .next()
- .expect("exhausted all possible characters")
- }
-}
-
-impl TranslateOperation {
- pub fn new(set1: Vec<char>, set2: Vec<char>, complement: bool) -> Result<Self, BadSequence> {
- if complement {
- Ok(Self::Complement(TranslateOperationComplement::new(
- set1, set2,
- )))
- } else {
- Ok(Self::Standard(TranslateOperationStandard::new(set1, set2)?))
- }
- }
-}
-
impl SymbolTranslator for TranslateOperation {
- fn translate(&mut self, current: char) -> Option<char> {
- match self {
- Self::Standard(TranslateOperationStandard { translation_map }) => Some(
- translation_map
- .iter()
- .find_map(|(l, r)| if l.eq(¤t) { Some(*r) } else { None })
- .unwrap_or(current),
- ),
- Self::Complement(TranslateOperationComplement {
- iter,
- set2_iter,
- set1,
- set2,
- translation_map,
- }) => {
- // First, try to see if current char is already mapped
- // If so, return the mapped char
- // Else, pop from set2
- // If we popped something, map the next complement character to this value
- // If set2 is empty, we just map the current char directly to fallback --- to avoid looping unnecessarily
- if let Some(c) = set1.iter().find(|c| c.eq(&¤t)) {
- Some(*c)
- } else {
- while translation_map.get(¤t).is_none() {
- if let Some(value) = set2.get(*set2_iter) {
- let (next_iter, next_key) = Self::next_complement_char(*iter, &*set1);
- *iter = next_iter;
- *set2_iter = set2_iter.saturating_add(1);
- translation_map.insert(next_key, *value);
- } else {
- translation_map.insert(current, *set2.last().unwrap());
- }
- }
- Some(*translation_map.get(¤t).unwrap())
- }
- }
- }
+ fn translate(&mut self, current: u8) -> Option<u8> {
+ Some(
+ self.translation_map
+ .get(¤t)
+ .copied()
+ .unwrap_or(current),
+ )
}
}
#[derive(Debug, Clone)]
pub struct SqueezeOperation {
- set1: HashSet<char>,
- complement: bool,
- previous: Option<char>,
+ set1: HashSet<u8>,
+ previous: Option<u8>,
}
impl SqueezeOperation {
- pub fn new(set1: Vec<char>, complement: bool) -> Self {
+ pub fn new(set1: Vec<u8>) -> Self {
Self {
set1: set1.into_iter().collect(),
- complement,
previous: None,
}
}
}
impl SymbolTranslator for SqueezeOperation {
- fn translate(&mut self, current: char) -> Option<char> {
- if self.complement {
- let next = if self.set1.contains(¤t) {
- Some(current)
- } else {
- match self.previous {
- Some(v) => {
- if v.eq(¤t) {
- None
- } else {
- Some(current)
- }
- }
- None => Some(current),
- }
- };
- self.previous = Some(current);
- next
+ fn translate(&mut self, current: u8) -> Option<u8> {
+ let next = if self.set1.contains(¤t) {
+ match self.previous {
+ Some(v) if v == current => None,
+ _ => Some(current),
+ }
} else {
- let next = if self.set1.contains(¤t) {
- match self.previous {
- Some(v) if v == current => None,
- _ => Some(current),
- }
- } else {
- Some(current)
- };
- self.previous = Some(current);
- next
- }
+ Some(current)
+ };
+ self.previous = Some(current);
+ next
}
}
@@ -537,15 +551,15 @@ where
R: BufRead,
W: Write,
{
- let mut buf = String::new();
- let mut output_buf = String::new();
- while let Ok(length) = input.read_line(&mut buf) {
+ let mut buf = Vec::new();
+ let mut output_buf = Vec::new();
+ while let Ok(length) = input.read_until(b'\n', &mut buf) {
if length == 0 {
break;
} else {
- let filtered = buf.chars().filter_map(|c| translator.translate(c));
+ let filtered = buf.iter().filter_map(|c| translator.translate(*c));
output_buf.extend(filtered);
- output.write_all(output_buf.as_bytes()).unwrap();
+ output.write_all(&output_buf).unwrap();
}
buf.clear();
output_buf.clear();
diff --git a/src/uu/tr/src/tr.rs b/src/uu/tr/src/tr.rs
index 8ca128a09952db8ba361bf40b64fa5b2dda6e3f7..4c0389bd2b805ecbc57e047f7ff1d7f4167b9e37 100644
--- a/src/uu/tr/src/tr.rs
+++ b/src/uu/tr/src/tr.rs
@@ -1,26 +1,27 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) allocs bset dflag cflag sflag tflag
-mod convert;
mod operation;
mod unicode_table;
use clap::{crate_version, Arg, ArgAction, Command};
-use nom::AsBytes;
-use operation::{translate_input, Sequence, SqueezeOperation, TranslateOperation};
-use std::io::{stdin, stdout, BufReader, BufWriter};
-use uucore::{format_usage, show};
+use operation::{
+ translate_input, Sequence, SqueezeOperation, SymbolTranslator, TranslateOperation,
+};
+use std::io::{stdin, stdout, BufWriter};
+use uucore::{format_usage, help_about, help_section, help_usage, show};
use crate::operation::DeleteOperation;
use uucore::display::Quotable;
use uucore::error::{UResult, USimpleError, UUsageError};
-static ABOUT: &str = "translate or delete characters";
-const USAGE: &str = "{} [OPTION]... SET1 [SET2]";
+const ABOUT: &str = help_about!("tr.md");
+const AFTER_HELP: &str = help_section!("after help", "tr.md");
+const USAGE: &str = help_usage!("tr.md");
mod options {
pub const COMPLEMENT: &str = "complement";
@@ -30,33 +31,24 @@ mod options {
pub const SETS: &str = "sets";
}
-fn get_long_usage() -> String {
- "Translate, squeeze, and/or delete characters from standard input, \
- writing to standard output."
- .to_string()
-}
-
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_lossy();
-
- let matches = uu_app()
- .after_help(get_long_usage())
- .try_get_matches_from(args)?;
+ let matches = uu_app().after_help(AFTER_HELP).try_get_matches_from(args)?;
let delete_flag = matches.get_flag(options::DELETE);
let complement_flag = matches.get_flag(options::COMPLEMENT);
let squeeze_flag = matches.get_flag(options::SQUEEZE);
let truncate_set1_flag = matches.get_flag(options::TRUNCATE_SET1);
- let sets = matches
+ // Ultimately this should be OsString, but we might want to wait for the
+ // pattern API on OsStr
+ let sets: Vec<_> = matches
.get_many::<String>(options::SETS)
- .map(|v| {
- v.map(ToString::to_string)
- .map(|input| convert::reduce_octal_to_char(&input))
- .collect::<Vec<_>>()
- })
- .unwrap_or_default();
+ .into_iter()
+ .flatten()
+ .map(ToOwned::to_owned)
+ .collect();
+
let sets_len = sets.len();
if sets.is_empty() {
@@ -66,11 +58,45 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
if !(delete_flag || squeeze_flag) && sets_len < 2 {
return Err(UUsageError::new(
1,
- format!("missing operand after {}", sets[0].quote()),
+ format!(
+ "missing operand after {}\nTwo strings must be given when translating.",
+ sets[0].quote()
+ ),
+ ));
+ }
+
+ if delete_flag & squeeze_flag && sets_len < 2 {
+ return Err(UUsageError::new(
+ 1,
+ format!(
+ "missing operand after {}\nTwo strings must be given when deleting and squeezing.",
+ sets[0].quote()
+ ),
));
}
- if let Some(first) = sets.get(0) {
+ if sets_len > 1 {
+ let start = "extra operand";
+ if delete_flag && !squeeze_flag {
+ let op = sets[1].quote();
+ let msg = if sets_len == 2 {
+ format!(
+ "{} {}\nOnly one string may be given when deleting without squeezing repeats.",
+ start, op,
+ )
+ } else {
+ format!("{} {}", start, op,)
+ };
+ return Err(UUsageError::new(1, msg));
+ }
+ if sets_len > 2 {
+ let op = sets[2].quote();
+ let msg = format!("{} {}", start, op);
+ return Err(UUsageError::new(1, msg));
+ }
+ }
+
+ if let Some(first) = sets.first() {
if first.ends_with('\\') {
show!(USimpleError::new(
0,
@@ -85,49 +111,41 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let locked_stdout = stdout.lock();
let mut buffered_stdout = BufWriter::new(locked_stdout);
+ // According to the man page: translating only happens if deleting or if a second set is given
+ let translating = !delete_flag && sets.len() > 1;
let mut sets_iter = sets.iter().map(|c| c.as_str());
let (set1, set2) = Sequence::solve_set_characters(
- sets_iter.next().unwrap_or_default(),
- sets_iter.next().unwrap_or_default(),
- truncate_set1_flag,
+ sets_iter.next().unwrap_or_default().as_bytes(),
+ sets_iter.next().unwrap_or_default().as_bytes(),
+ complement_flag,
+ // if we are not translating then we don't truncate set1
+ truncate_set1_flag && translating,
+ translating,
)?;
+ // '*_op' are the operations that need to be applied, in order.
if delete_flag {
if squeeze_flag {
- let mut delete_buffer = vec![];
- {
- let mut delete_writer = BufWriter::new(&mut delete_buffer);
- let delete_op = DeleteOperation::new(set1, complement_flag);
- translate_input(&mut locked_stdin, &mut delete_writer, delete_op);
- }
- {
- let mut squeeze_reader = BufReader::new(delete_buffer.as_bytes());
- let op = SqueezeOperation::new(set2, complement_flag);
- translate_input(&mut squeeze_reader, &mut buffered_stdout, op);
- }
+ let delete_op = DeleteOperation::new(set1);
+ let squeeze_op = SqueezeOperation::new(set2);
+ let op = delete_op.chain(squeeze_op);
+ translate_input(&mut locked_stdin, &mut buffered_stdout, op);
} else {
- let op = DeleteOperation::new(set1, complement_flag);
+ let op = DeleteOperation::new(set1);
translate_input(&mut locked_stdin, &mut buffered_stdout, op);
}
} else if squeeze_flag {
if sets_len < 2 {
- let op = SqueezeOperation::new(set1, complement_flag);
+ let op = SqueezeOperation::new(set1);
translate_input(&mut locked_stdin, &mut buffered_stdout, op);
} else {
- let mut translate_buffer = vec![];
- {
- let mut writer = BufWriter::new(&mut translate_buffer);
- let op = TranslateOperation::new(set1, set2.clone(), complement_flag)?;
- translate_input(&mut locked_stdin, &mut writer, op);
- }
- {
- let mut reader = BufReader::new(translate_buffer.as_bytes());
- let squeeze_op = SqueezeOperation::new(set2, false);
- translate_input(&mut reader, &mut buffered_stdout, squeeze_op);
- }
+ let translate_op = TranslateOperation::new(set1, set2.clone())?;
+ let squeeze_op = SqueezeOperation::new(set2);
+ let op = translate_op.chain(squeeze_op);
+ translate_input(&mut locked_stdin, &mut buffered_stdout, op);
}
} else {
- let op = TranslateOperation::new(set1, set2, complement_flag)?;
+ let op = TranslateOperation::new(set1, set2)?;
translate_input(&mut locked_stdin, &mut buffered_stdout, op);
}
Ok(())
@@ -139,20 +157,23 @@ pub fn uu_app() -> Command {
.about(ABOUT)
.override_usage(format_usage(USAGE))
.infer_long_args(true)
+ .trailing_var_arg(true)
.arg(
Arg::new(options::COMPLEMENT)
.visible_short_alias('C')
.short('c')
.long(options::COMPLEMENT)
.help("use the complement of SET1")
- .action(ArgAction::SetTrue),
+ .action(ArgAction::SetTrue)
+ .overrides_with(options::COMPLEMENT),
)
.arg(
Arg::new(options::DELETE)
.short('d')
.long(options::DELETE)
.help("delete characters in SET1, do not translate")
- .action(ArgAction::SetTrue),
+ .action(ArgAction::SetTrue)
+ .overrides_with(options::DELETE),
)
.arg(
Arg::new(options::SQUEEZE)
@@ -163,14 +184,16 @@ pub fn uu_app() -> Command {
listed in the last specified SET, with a single occurrence \
of that character",
)
- .action(ArgAction::SetTrue),
+ .action(ArgAction::SetTrue)
+ .overrides_with(options::SQUEEZE),
)
.arg(
Arg::new(options::TRUNCATE_SET1)
.long(options::TRUNCATE_SET1)
.short('t')
.help("first truncate SET1 to length of SET2")
- .action(ArgAction::SetTrue),
+ .action(ArgAction::SetTrue)
+ .overrides_with(options::TRUNCATE_SET1),
)
- .arg(Arg::new(options::SETS).num_args(1..=2))
+ .arg(Arg::new(options::SETS).num_args(1..))
}
diff --git a/src/uu/tr/src/unicode_table.rs b/src/uu/tr/src/unicode_table.rs
index 43d9fd6f4b7d6111bebc45b577d0f5c29315f78e..06687c3926e0411a5ce53f1794cc2527a781c784 100644
--- a/src/uu/tr/src/unicode_table.rs
+++ b/src/uu/tr/src/unicode_table.rs
@@ -1,15 +1,15 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-pub static BEL: char = '\u{0007}';
-pub static BS: char = '\u{0008}';
-pub static HT: char = '\u{0009}';
-pub static LF: char = '\u{000A}';
-pub static VT: char = '\u{000B}';
-pub static FF: char = '\u{000C}';
-pub static CR: char = '\u{000D}';
-pub static SPACE: char = '\u{0020}';
-pub static SPACES: &[char] = &[HT, LF, VT, FF, CR, SPACE];
-pub static BLANK: &[char] = &[SPACE, HT];
+pub static BEL: u8 = 0x7;
+pub static BS: u8 = 0x8;
+pub static HT: u8 = 0x9;
+pub static LF: u8 = 0xA;
+pub static VT: u8 = 0xB;
+pub static FF: u8 = 0xC;
+pub static CR: u8 = 0xD;
+pub static SPACE: u8 = 0x20;
+pub static SPACES: &[u8] = &[HT, LF, VT, FF, CR, SPACE];
+pub static BLANK: &[u8] = &[HT, SPACE];
diff --git a/src/uu/tr/tr.md b/src/uu/tr/tr.md
new file mode 100644
index 0000000000000000000000000000000000000000..93349eeaa84979cf5850a8e24a1185955f6ed37b
--- /dev/null
+++ b/src/uu/tr/tr.md
@@ -0,0 +1,11 @@
+# tr
+
+```
+tr [OPTION]... SET1 [SET2]
+```
+
+Translate or delete characters
+
+## After help
+
+Translate, squeeze, and/or delete characters from standard input, writing to standard output.
diff --git a/src/uu/true/Cargo.toml b/src/uu/true/Cargo.toml
index ef92d33a4d6ac294cfd1bdf1ff567c5ea4fff24b..b65da88bedc8d248b9922489e242ca14cdee7b16 100644
--- a/src/uu/true/Cargo.toml
+++ b/src/uu/true/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_true"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "true ~ (uutils) do nothing and succeed"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/true.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "true"
diff --git a/src/uu/true/src/true.rs b/src/uu/true/src/true.rs
index 7c373fb7abd54edb491a435f56a847214b610325..637758625d378feb6490c0a6fa67451ce0f246ac 100644
--- a/src/uu/true/src/true.rs
+++ b/src/uu/true/src/true.rs
@@ -1,20 +1,13 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Jordi Boggiano <j.boggiano@seld.be>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use clap::{Arg, ArgAction, Command};
use std::{ffi::OsString, io::Write};
use uucore::error::{set_exit_code, UResult};
+use uucore::help_about;
-static ABOUT: &str = "\
-Returns true, a successful exit status.
-
-Immediately returns with the exit status `0`, except when invoked with one of the recognized
-options. In those cases it will try to write the help or version text. Any IO error during this
-operation causes the program to return `1` instead.
-";
+const ABOUT: &str = help_about!("true.md");
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
diff --git a/src/uu/true/true.md b/src/uu/true/true.md
new file mode 100644
index 0000000000000000000000000000000000000000..b21c9616e1430c429cfd02c6d5f3ea3be54d84e6
--- /dev/null
+++ b/src/uu/true/true.md
@@ -0,0 +1,11 @@
+# true
+
+```
+true
+```
+
+Returns true, a successful exit status.
+
+Immediately returns with the exit status `0`, except when invoked with one of the recognized
+options. In those cases it will try to write the help or version text. Any IO error during this
+operation causes the program to return `1` instead.
diff --git a/src/uu/truncate/Cargo.toml b/src/uu/truncate/Cargo.toml
index 919ab4fabd86eb1672070d641fa6aefd10e5f719..be578193e0e16e1c0d4a263b735e2f726fedb4e0 100644
--- a/src/uu/truncate/Cargo.toml
+++ b/src/uu/truncate/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_truncate"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "truncate ~ (uutils) truncate (or extend) FILE to SIZE"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/truncate.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "truncate"
diff --git a/src/uu/truncate/src/truncate.rs b/src/uu/truncate/src/truncate.rs
index 517d766e3ee6bc3f388cb0b3db78d65132a641b4..7af25085f492d7379fc7150f825911e5b683cff9 100644
--- a/src/uu/truncate/src/truncate.rs
+++ b/src/uu/truncate/src/truncate.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Alex Lyon <arcterus@mail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) RFILE refsize rfilename fsize tsize
use clap::{crate_version, Arg, ArgAction, Command};
@@ -14,8 +12,8 @@ use std::os::unix::fs::FileTypeExt;
use std::path::Path;
use uucore::display::Quotable;
use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
-use uucore::format_usage;
-use uucore::parse_size::{parse_size, ParseSizeError};
+use uucore::parse_size::{parse_size_u64, ParseSizeError};
+use uucore::{format_usage, help_about, help_section, help_usage};
#[derive(Debug, Eq, PartialEq)]
enum TruncateMode {
@@ -73,8 +71,9 @@ impl TruncateMode {
}
}
-static ABOUT: &str = "Shrink or extend the size of each file to the specified size.";
-const USAGE: &str = "{} [OPTION]... [FILE]...";
+const ABOUT: &str = help_about!("truncate.md");
+const AFTER_HELP: &str = help_section!("after help", "truncate.md");
+const USAGE: &str = help_usage!("truncate.md");
pub mod options {
pub static IO_BLOCKS: &str = "io-blocks";
@@ -84,32 +83,10 @@ pub mod options {
pub static ARG_FILES: &str = "files";
}
-fn get_long_usage() -> String {
- String::from(
- "
- SIZE is an integer with an optional prefix and optional unit.
- The available units (K, M, G, T, P, E, Z, and Y) use the following format:
- 'KB' => 1000 (kilobytes)
- 'K' => 1024 (kibibytes)
- 'MB' => 1000*1000 (megabytes)
- 'M' => 1024*1024 (mebibytes)
- 'GB' => 1000*1000*1000 (gigabytes)
- 'G' => 1024*1024*1024 (gibibytes)
- SIZE may also be prefixed by one of the following to adjust the size of each
- file based on its current size:
- '+' => extend by
- '-' => reduce by
- '<' => at most
- '>' => at least
- '/' => round down to multiple of
- '%' => round up to multiple of",
- )
-}
-
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let matches = uu_app()
- .after_help(get_long_usage())
+ .after_help(AFTER_HELP)
.try_get_matches_from(args)
.map_err(|e| {
e.print().expect("Error writing clap::Error");
@@ -125,7 +102,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
.unwrap_or_default();
if files.is_empty() {
- return Err(UUsageError::new(1, "missing file operand"));
+ Err(UUsageError::new(1, "missing file operand"))
} else {
let io_blocks = matches.get_flag(options::IO_BLOCKS);
let no_create = matches.get_flag(options::NO_CREATE);
@@ -201,10 +178,26 @@ pub fn uu_app() -> Command {
///
/// If the file could not be opened, or there was a problem setting the
/// size of the file.
-fn file_truncate(filename: &str, create: bool, size: u64) -> std::io::Result<()> {
+fn file_truncate(filename: &str, create: bool, size: u64) -> UResult<()> {
+ #[cfg(unix)]
+ if let Ok(metadata) = std::fs::metadata(filename) {
+ if metadata.file_type().is_fifo() {
+ return Err(USimpleError::new(
+ 1,
+ format!(
+ "cannot open {} for writing: No such device or address",
+ filename.quote()
+ ),
+ ));
+ }
+ }
let path = Path::new(filename);
- let f = OpenOptions::new().write(true).create(create).open(path)?;
- f.set_len(size)
+ match OpenOptions::new().write(true).create(create).open(path) {
+ Ok(file) => file.set_len(size),
+ Err(e) if e.kind() == ErrorKind::NotFound && !create => Ok(()),
+ Err(e) => Err(e),
+ }
+ .map_err_context(|| format!("cannot open {} for writing", filename.quote()))
}
/// Truncate files to a size relative to a given file.
@@ -231,7 +224,7 @@ fn truncate_reference_and_size(
create: bool,
) -> UResult<()> {
let mode = match parse_mode_and_size(size_string) {
- Err(e) => return Err(USimpleError::new(1, format!("Invalid number: {}", e))),
+ Err(e) => return Err(USimpleError::new(1, format!("Invalid number: {e}"))),
Ok(TruncateMode::Absolute(_)) => {
return Err(USimpleError::new(
1,
@@ -256,19 +249,7 @@ fn truncate_reference_and_size(
let fsize = metadata.len();
let tsize = mode.to_size(fsize);
for filename in filenames {
- #[cfg(unix)]
- if std::fs::metadata(filename)?.file_type().is_fifo() {
- return Err(USimpleError::new(
- 1,
- format!(
- "cannot open {} for writing: No such device or address",
- filename.quote()
- ),
- ));
- }
-
- file_truncate(filename, create, tsize)
- .map_err_context(|| format!("cannot open {} for writing", filename.quote()))?;
+ file_truncate(filename, create, tsize)?;
}
Ok(())
}
@@ -303,18 +284,7 @@ fn truncate_reference_file_only(
})?;
let tsize = metadata.len();
for filename in filenames {
- #[cfg(unix)]
- if std::fs::metadata(filename)?.file_type().is_fifo() {
- return Err(USimpleError::new(
- 1,
- format!(
- "cannot open {} for writing: No such device or address",
- filename.quote()
- ),
- ));
- }
- file_truncate(filename, create, tsize)
- .map_err_context(|| format!("cannot open {} for writing", filename.quote()))?;
+ file_truncate(filename, create, tsize)?;
}
Ok(())
}
@@ -338,7 +308,7 @@ fn truncate_reference_file_only(
/// If at least one file is a named pipe (also known as a fifo).
fn truncate_size_only(size_string: &str, filenames: &[String], create: bool) -> UResult<()> {
let mode = parse_mode_and_size(size_string)
- .map_err(|e| USimpleError::new(1, format!("Invalid number: {}", e)))?;
+ .map_err(|e| USimpleError::new(1, format!("Invalid number: {e}")))?;
if let TruncateMode::RoundDown(0) | TruncateMode::RoundUp(0) = mode {
return Err(USimpleError::new(1, "division by zero"));
}
@@ -360,15 +330,8 @@ fn truncate_size_only(size_string: &str, filenames: &[String], create: bool) ->
Err(_) => 0,
};
let tsize = mode.to_size(fsize);
- match file_truncate(filename, create, tsize) {
- Ok(_) => continue,
- Err(e) if e.kind() == ErrorKind::NotFound && !create => continue,
- Err(e) => {
- return Err(
- e.map_err_context(|| format!("cannot open {} for writing", filename.quote()))
- )
- }
- }
+ // TODO: Fix duplicate call to stat
+ file_truncate(filename, create, tsize)?;
}
Ok(())
}
@@ -403,7 +366,7 @@ fn is_modifier(c: char) -> bool {
/// Parse a size string with optional modifier symbol as its first character.
///
-/// A size string is as described in [`parse_size`]. The first character
+/// A size string is as described in [`parse_size_u64`]. The first character
/// of `size_string` might be a modifier symbol, like `'+'` or
/// `'<'`. The first element of the pair returned by this function
/// indicates which modifier symbol was present, or
@@ -429,7 +392,7 @@ fn parse_mode_and_size(size_string: &str) -> Result<TruncateMode, ParseSizeError
if is_modifier(c) {
size_string = &size_string[1..];
}
- parse_size(size_string).map(match c {
+ parse_size_u64(size_string).map(match c {
'+' => TruncateMode::Extend,
'-' => TruncateMode::Reduce,
'<' => TruncateMode::AtMost,
diff --git a/src/uu/truncate/truncate.md b/src/uu/truncate/truncate.md
new file mode 100644
index 0000000000000000000000000000000000000000..d60a6b7b200e5cff21330c2d1d629ba167e568c5
--- /dev/null
+++ b/src/uu/truncate/truncate.md
@@ -0,0 +1,26 @@
+# truncate
+
+```
+truncate [OPTION]... [FILE]...
+```
+
+Shrink or extend the size of each file to the specified size.
+
+## After help
+
+SIZE is an integer with an optional prefix and optional unit.
+The available units (K, M, G, T, P, E, Z, and Y) use the following format:
+ 'KB' => 1000 (kilobytes)
+ 'K' => 1024 (kibibytes)
+ 'MB' => 1000*1000 (megabytes)
+ 'M' => 1024*1024 (mebibytes)
+ 'GB' => 1000*1000*1000 (gigabytes)
+ 'G' => 1024*1024*1024 (gibibytes)
+SIZE may also be prefixed by one of the following to adjust the size of each
+file based on its current size:
+ '+' => extend by
+ '-' => reduce by
+ '<' => at most
+ '>' => at least
+ '/' => round down to multiple of
+ '%' => round up to multiple of
diff --git a/src/uu/tsort/Cargo.toml b/src/uu/tsort/Cargo.toml
index 63eeb111acb0f2588a1840cda08f40d45bc5028c..2343fdaaf2a7292dd04ee24047ad5b8e14607f4b 100644
--- a/src/uu/tsort/Cargo.toml
+++ b/src/uu/tsort/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_tsort"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "tsort ~ (uutils) topologically sort input (partially ordered) pairs"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/tsort.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "tsort"
diff --git a/src/uu/tsort/src/tsort.rs b/src/uu/tsort/src/tsort.rs
index 1ef853706a259ff21c500ccd1892080fe38de315..cd0b2030ae3a1f662157c29a0c4ecd3fedca951c 100644
--- a/src/uu/tsort/src/tsort.rs
+++ b/src/uu/tsort/src/tsort.rs
@@ -1,23 +1,18 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Ben Eggers <ben.eggers36@gmail.com>
-// * (c) Akira Hayakawa <ruby.wktk@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use clap::{crate_version, Arg, Command};
-use std::collections::{HashMap, HashSet};
+use std::collections::{BTreeMap, BTreeSet};
use std::fs::File;
-use std::io::{stdin, BufRead, BufReader, Read};
+use std::io::{stdin, BufReader, Read};
use std::path::Path;
use uucore::display::Quotable;
use uucore::error::{FromIo, UResult, USimpleError};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
-static ABOUT: &str = "Topological sort the strings in FILE.
-Strings are defined as any sequence of tokens separated by whitespace (tab, space, or newline).
-If FILE is not passed in, stdin is used instead.";
-static USAGE: &str = "{} [OPTIONS] FILE";
+const ABOUT: &str = help_about!("tsort.md");
+const USAGE: &str = help_usage!("tsort.md");
mod options {
pub const FILE: &str = "file";
@@ -25,8 +20,6 @@ mod options {
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_lossy();
-
let matches = uu_app().try_get_matches_from(args)?;
let input = matches
@@ -39,35 +32,39 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
stdin_buf = stdin();
&mut stdin_buf as &mut dyn Read
} else {
- file_buf = File::open(Path::new(&input)).map_err_context(|| input.to_string())?;
+ let path = Path::new(&input);
+ if path.is_dir() {
+ return Err(USimpleError::new(
+ 1,
+ format!("{}: read error: Is a directory", input),
+ ));
+ }
+ file_buf = File::open(path).map_err_context(|| input.to_string())?;
&mut file_buf as &mut dyn Read
});
+ let mut input_buffer = String::new();
+ reader.read_to_string(&mut input_buffer)?;
let mut g = Graph::new();
- loop {
- let mut line = String::new();
- match reader.read_line(&mut line) {
- Ok(_) => {
- let tokens: Vec<String> = line.split_whitespace().map(|s| s.to_owned()).collect();
- if tokens.is_empty() {
- break;
- }
- for ab in tokens.chunks(2) {
- match ab.len() {
- 2 => g.add_edge(&ab[0], &ab[1]),
- _ => {
- return Err(USimpleError::new(
- 1,
- format!(
- "{}: input contains an odd number of tokens",
- input.maybe_quote()
- ),
- ))
- }
- }
+
+ for line in input_buffer.lines() {
+ let tokens: Vec<_> = line.split_whitespace().collect();
+ if tokens.is_empty() {
+ break;
+ }
+ for ab in tokens.chunks(2) {
+ match ab.len() {
+ 2 => g.add_edge(ab[0], ab[1]),
+ _ => {
+ return Err(USimpleError::new(
+ 1,
+ format!(
+ "{}: input contains an odd number of tokens",
+ input.maybe_quote()
+ ),
+ ))
}
}
- _ => break,
}
}
@@ -76,12 +73,12 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
if !g.is_acyclic() {
return Err(USimpleError::new(
1,
- format!("{}, input contains a loop:", input),
+ format!("{input}, input contains a loop:"),
));
}
for x in &g.result {
- println!("{}", x);
+ println!("{x}");
}
Ok(())
@@ -104,13 +101,13 @@ pub fn uu_app() -> Command {
// We use String as a representation of node here
// but using integer may improve performance.
#[derive(Default)]
-struct Graph {
- in_edges: HashMap<String, HashSet<String>>,
- out_edges: HashMap<String, Vec<String>>,
- result: Vec<String>,
+struct Graph<'input> {
+ in_edges: BTreeMap<&'input str, BTreeSet<&'input str>>,
+ out_edges: BTreeMap<&'input str, Vec<&'input str>>,
+ result: Vec<&'input str>,
}
-impl Graph {
+impl<'input> Graph<'input> {
fn new() -> Self {
Self::default()
}
@@ -123,12 +120,12 @@ impl Graph {
self.in_edges[to].contains(from)
}
- fn init_node(&mut self, n: &str) {
- self.in_edges.insert(n.to_string(), HashSet::new());
- self.out_edges.insert(n.to_string(), vec![]);
+ fn init_node(&mut self, n: &'input str) {
+ self.in_edges.insert(n, BTreeSet::new());
+ self.out_edges.insert(n, vec![]);
}
- fn add_edge(&mut self, from: &str, to: &str) {
+ fn add_edge(&mut self, from: &'input str, to: &'input str) {
if !self.has_node(to) {
self.init_node(to);
}
@@ -138,8 +135,8 @@ impl Graph {
}
if from != to && !self.has_edge(from, to) {
- self.in_edges.get_mut(to).unwrap().insert(from.to_string());
- self.out_edges.get_mut(from).unwrap().push(to.to_string());
+ self.in_edges.get_mut(to).unwrap().insert(from);
+ self.out_edges.get_mut(from).unwrap().push(to);
}
}
@@ -149,23 +146,24 @@ impl Graph {
let mut start_nodes = vec![];
for (n, edges) in &self.in_edges {
if edges.is_empty() {
- start_nodes.push(n.clone());
+ start_nodes.push(*n);
}
}
while !start_nodes.is_empty() {
let n = start_nodes.remove(0);
- self.result.push(n.clone());
+ self.result.push(n);
let n_out_edges = self.out_edges.get_mut(&n).unwrap();
+ #[allow(clippy::explicit_iter_loop)]
for m in n_out_edges.iter() {
let m_in_edges = self.in_edges.get_mut(m).unwrap();
m_in_edges.remove(&n);
// If m doesn't have other in-coming edges add it to start_nodes
if m_in_edges.is_empty() {
- start_nodes.push(m.clone());
+ start_nodes.push(m);
}
}
n_out_edges.clear();
@@ -173,11 +171,6 @@ impl Graph {
}
fn is_acyclic(&self) -> bool {
- for edges in self.out_edges.values() {
- if !edges.is_empty() {
- return false;
- }
- }
- true
+ self.out_edges.values().all(|edge| edge.is_empty())
}
}
diff --git a/src/uu/tsort/tsort.md b/src/uu/tsort/tsort.md
new file mode 100644
index 0000000000000000000000000000000000000000..5effbf1e705929623ee1ffe2bc99ce3148ec1a73
--- /dev/null
+++ b/src/uu/tsort/tsort.md
@@ -0,0 +1,10 @@
+# tsort
+
+```
+tsort [OPTIONS] FILE
+```
+
+Topological sort the strings in FILE.
+Strings are defined as any sequence of tokens separated by whitespace (tab, space, or newline), ordering them based on dependencies in a directed acyclic graph (DAG).
+Useful for scheduling and determining execution order.
+If FILE is not passed in, stdin is used instead.
diff --git a/src/uu/tty/Cargo.toml b/src/uu/tty/Cargo.toml
index d71f08d10090cbcbb781ae84becbde592c310f0e..3682d76aaff9c164d00b2dfb6cc6e4ce07d229fe 100644
--- a/src/uu/tty/Cargo.toml
+++ b/src/uu/tty/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_tty"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "tty ~ (uutils) display the name of the terminal connected to standard input"
@@ -15,10 +15,9 @@ edition = "2021"
path = "src/tty.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-nix = "0.25"
-atty = "0.2"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["fs"] }
+clap = { workspace = true }
+nix = { workspace = true, features = ["term"] }
+uucore = { workspace = true, features = ["fs"] }
[[bin]]
name = "tty"
diff --git a/src/uu/tty/src/tty.rs b/src/uu/tty/src/tty.rs
index ad41c323cc313a553b3cdad9fcebda845c9c62bd..b7d3aedcd22808d3c53adbbdea5e238ab472cc3c 100644
--- a/src/uu/tty/src/tty.rs
+++ b/src/uu/tty/src/tty.rs
@@ -1,22 +1,19 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Jordi Boggiano <j.boggiano@seld.be>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// *
// * Synced with http://lingrok.org/xref/coreutils/src/tty.c
// spell-checker:ignore (ToDO) ttyname filedesc
use clap::{crate_version, Arg, ArgAction, Command};
-use std::io::Write;
-use std::os::unix::io::AsRawFd;
+use std::io::{IsTerminal, Write};
use uucore::error::{set_exit_code, UResult};
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
-static ABOUT: &str = "Print the file name of the terminal connected to standard input.";
-const USAGE: &str = "{} [OPTION]...";
+const ABOUT: &str = help_about!("tty.md");
+const USAGE: &str = help_usage!("tty.md");
mod options {
pub const SILENT: &str = "silent";
@@ -30,7 +27,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
// If silent, we don't need the name, only whether or not stdin is a tty.
if silent {
- return if atty::is(atty::Stream::Stdin) {
+ return if std::io::stdin().is_terminal() {
Ok(())
} else {
Err(1.into())
@@ -39,8 +36,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let mut stdout = std::io::stdout();
- // Get the ttyname via nix
- let name = nix::unistd::ttyname(std::io::stdin().as_raw_fd());
+ let name = nix::unistd::ttyname(std::io::stdin());
let write_result = match name {
Ok(name) => writeln!(stdout, "{}", name.display()),
diff --git a/src/uu/tty/tty.md b/src/uu/tty/tty.md
new file mode 100644
index 0000000000000000000000000000000000000000..230399a20694d34ae79862fcb9f94df568e6c9ce
--- /dev/null
+++ b/src/uu/tty/tty.md
@@ -0,0 +1,7 @@
+# tty
+
+```
+tty [OPTION]...
+```
+
+Print the file name of the terminal connected to standard input.
diff --git a/src/uu/uname/Cargo.toml b/src/uu/uname/Cargo.toml
index bcd68f1e85ca7cb1d8d07c6510baa6a34e6eef3c..345eda90816c855e352668168946d711d7b72998 100644
--- a/src/uu/uname/Cargo.toml
+++ b/src/uu/uname/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_uname"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "uname ~ (uutils) display system information"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/uname.rs"
[dependencies]
-platform-info = "1.0.2"
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+platform-info = { workspace = true }
+clap = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "uname"
diff --git a/src/uu/uname/src/uname.rs b/src/uu/uname/src/uname.rs
index f74f187724bf780b750fe2c38841baeb69347f07..4a7c3f460c694300c63fb2038265c8d85e623de8 100644
--- a/src/uu/uname/src/uname.rs
+++ b/src/uu/uname/src/uname.rs
@@ -1,25 +1,19 @@
// This file is part of the uutils coreutils package.
//
-// (c) Joao Oliveira <joaoxsouls@gmail.com>
-// (c) Jian Zeng <anonymousknight96 AT gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
-// last synced with: uname (GNU coreutils) 8.21
-
// spell-checker:ignore (API) nodename osname sysname (options) mnrsv mnrsvo
use clap::{crate_version, Arg, ArgAction, Command};
use platform_info::*;
use uucore::{
- error::{FromIo, UResult},
- format_usage,
+ error::{UResult, USimpleError},
+ format_usage, help_about, help_usage,
};
-const ABOUT: &str = r#"Print certain system information.
-With no OPTION, same as -s."#;
-const USAGE: &str = "{} [OPTION]...";
+const ABOUT: &str = help_about!("uname.md");
+const USAGE: &str = help_usage!("uname.md");
pub mod options {
pub static ALL: &str = "all";
@@ -33,81 +27,119 @@ pub mod options {
pub static OS: &str = "operating-system";
}
-#[uucore::main]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let matches = uu_app().try_get_matches_from(args)?;
-
- let uname =
- PlatformInfo::new().map_err_context(|| "failed to create PlatformInfo".to_string())?;
- let mut output = String::new();
-
- let all = matches.get_flag(options::ALL);
- let kernel_name = matches.get_flag(options::KERNEL_NAME);
- let nodename = matches.get_flag(options::NODENAME);
- let kernel_release = matches.get_flag(options::KERNEL_RELEASE);
- let kernel_version = matches.get_flag(options::KERNEL_VERSION);
- let machine = matches.get_flag(options::MACHINE);
- let processor = matches.get_flag(options::PROCESSOR);
- let hardware_platform = matches.get_flag(options::HARDWARE_PLATFORM);
- let os = matches.get_flag(options::OS);
-
- let none = !(all
- || kernel_name
- || nodename
- || kernel_release
- || kernel_version
- || machine
- || os
- || processor
- || hardware_platform);
-
- if kernel_name || all || none {
- output.push_str(&uname.sysname());
- output.push(' ');
- }
-
- if nodename || all {
- // maint: [2023-01-14; rivy] remove `.trim_end_matches('\0')` when platform-info nodename-NUL bug is fixed (see GH:uutils/platform-info/issues/32)
- output.push_str(uname.nodename().trim_end_matches('\0'));
- output.push(' ');
- }
-
- if kernel_release || all {
- output.push_str(&uname.release());
- output.push(' ');
- }
-
- if kernel_version || all {
- output.push_str(&uname.version());
- output.push(' ');
- }
-
- if machine || all {
- output.push_str(&uname.machine());
- output.push(' ');
- }
+pub struct UNameOutput {
+ pub kernel_name: Option<String>,
+ pub nodename: Option<String>,
+ pub kernel_release: Option<String>,
+ pub kernel_version: Option<String>,
+ pub machine: Option<String>,
+ pub os: Option<String>,
+ pub processor: Option<String>,
+ pub hardware_platform: Option<String>,
+}
- if os || all {
- output.push_str(&uname.osname());
- output.push(' ');
+impl UNameOutput {
+ fn display(&self) -> String {
+ let mut output = String::new();
+ for name in [
+ self.kernel_name.as_ref(),
+ self.nodename.as_ref(),
+ self.kernel_release.as_ref(),
+ self.kernel_version.as_ref(),
+ self.machine.as_ref(),
+ self.os.as_ref(),
+ self.processor.as_ref(),
+ self.hardware_platform.as_ref(),
+ ]
+ .into_iter()
+ .flatten()
+ {
+ output.push_str(name);
+ output.push(' ');
+ }
+ output
}
- // This option is unsupported on modern Linux systems
- // See: https://lists.gnu.org/archive/html/bug-coreutils/2005-09/msg00063.html
- if processor {
- output.push_str("unknown");
- output.push(' ');
+ pub fn new(opts: &Options) -> UResult<Self> {
+ let uname =
+ PlatformInfo::new().map_err(|_e| USimpleError::new(1, "cannot get system name"))?;
+ let none = !(opts.all
+ || opts.kernel_name
+ || opts.nodename
+ || opts.kernel_release
+ || opts.kernel_version
+ || opts.machine
+ || opts.os
+ || opts.processor
+ || opts.hardware_platform);
+
+ let kernel_name = (opts.kernel_name || opts.all || none)
+ .then(|| uname.sysname().to_string_lossy().to_string());
+
+ let nodename =
+ (opts.nodename || opts.all).then(|| uname.nodename().to_string_lossy().to_string());
+
+ let kernel_release = (opts.kernel_release || opts.all)
+ .then(|| uname.release().to_string_lossy().to_string());
+
+ let kernel_version = (opts.kernel_version || opts.all)
+ .then(|| uname.version().to_string_lossy().to_string());
+
+ let machine =
+ (opts.machine || opts.all).then(|| uname.machine().to_string_lossy().to_string());
+
+ let os = (opts.os || opts.all).then(|| uname.osname().to_string_lossy().to_string());
+
+ // This option is unsupported on modern Linux systems
+ // See: https://lists.gnu.org/archive/html/bug-coreutils/2005-09/msg00063.html
+ let processor = opts.processor.then(|| "unknown".to_string());
+
+ // This option is unsupported on modern Linux systems
+ // See: https://lists.gnu.org/archive/html/bug-coreutils/2005-09/msg00063.html
+ let hardware_platform = opts.hardware_platform.then(|| "unknown".to_string());
+
+ Ok(Self {
+ kernel_name,
+ nodename,
+ kernel_release,
+ kernel_version,
+ machine,
+ os,
+ processor,
+ hardware_platform,
+ })
}
+}
- // This option is unsupported on modern Linux systems
- // See: https://lists.gnu.org/archive/html/bug-coreutils/2005-09/msg00063.html
- if hardware_platform {
- output.push_str("unknown");
- output.push(' ');
- }
+pub struct Options {
+ pub all: bool,
+ pub kernel_name: bool,
+ pub nodename: bool,
+ pub kernel_version: bool,
+ pub kernel_release: bool,
+ pub machine: bool,
+ pub processor: bool,
+ pub hardware_platform: bool,
+ pub os: bool,
+}
- println!("{}", output.trim_end());
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+ let matches = uu_app().try_get_matches_from(args)?;
+ let options = Options {
+ all: matches.get_flag(options::ALL),
+ kernel_name: matches.get_flag(options::KERNEL_NAME),
+ nodename: matches.get_flag(options::NODENAME),
+ kernel_release: matches.get_flag(options::KERNEL_RELEASE),
+ kernel_version: matches.get_flag(options::KERNEL_VERSION),
+ machine: matches.get_flag(options::MACHINE),
+ processor: matches.get_flag(options::PROCESSOR),
+ hardware_platform: matches.get_flag(options::HARDWARE_PLATFORM),
+ os: matches.get_flag(options::OS),
+ };
+ let output = UNameOutput::new(&options)?;
+ println!("{}", output.display().trim_end());
Ok(())
}
diff --git a/src/uu/uname/uname.md b/src/uu/uname/uname.md
new file mode 100644
index 0000000000000000000000000000000000000000..b90c54cfcc3d9d4179aa86452661001cea5b7944
--- /dev/null
+++ b/src/uu/uname/uname.md
@@ -0,0 +1,8 @@
+# uname
+
+```
+uname [OPTION]...
+```
+
+Print certain system information.
+With no OPTION, same as -s.
diff --git a/src/uu/unexpand/Cargo.toml b/src/uu/unexpand/Cargo.toml
index bd858732e5c3546b2337937bc7c33b242e3b727b..729ff2ee25977c4298fed35b852c8e5bb35faa1e 100644
--- a/src/uu/unexpand/Cargo.toml
+++ b/src/uu/unexpand/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_unexpand"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "unexpand ~ (uutils) convert input spaces to tabs"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/unexpand.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-unicode-width = "0.1.5"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+unicode-width = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "unexpand"
diff --git a/src/uu/unexpand/src/unexpand.rs b/src/uu/unexpand/src/unexpand.rs
index 030e090fcae6aa41f2e74206e8b47a72370aedfe..7336376eb6cbf773b8b48b5c47602e2c6ccda33f 100644
--- a/src/uu/unexpand/src/unexpand.rs
+++ b/src/uu/unexpand/src/unexpand.rs
@@ -1,11 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Virgile Andreani <virgile.andreani@anbuco.fr>
-// * (c) kwantam <kwantam@gmail.com>
-// * * 2015-04-28 ~ updated to work with both UTF-8 and non-UTF-8 encodings
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) nums aflag uflag scol prevtab amode ctype cwidth nbytes lastcol pctype Preprocess
@@ -15,15 +11,15 @@ use std::fmt;
use std::fs::File;
use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Stdout, Write};
use std::num::IntErrorKind;
+use std::path::Path;
use std::str::from_utf8;
use unicode_width::UnicodeWidthChar;
use uucore::display::Quotable;
-use uucore::error::{FromIo, UError, UResult};
-use uucore::{crash, crash_if_err, format_usage};
+use uucore::error::{FromIo, UError, UResult, USimpleError};
+use uucore::{crash_if_err, format_usage, help_about, help_usage, show};
-static USAGE: &str = "{} [OPTION]... [FILE]...";
-static ABOUT: &str = "Convert blanks in each FILE to tabs, writing to standard output.\n\n\
- With no FILE, or when FILE is -, read standard input.";
+const USAGE: &str = help_usage!("unexpand.md");
+const ABOUT: &str = help_about!("unexpand.md");
const DEFAULT_TABSTOP: usize = 8;
@@ -110,8 +106,8 @@ impl Options {
&& !matches.get_flag(options::FIRST_ONLY);
let uflag = !matches.get_flag(options::NO_UTF8);
- let files = match matches.get_one::<String>(options::FILE) {
- Some(v) => vec![v.to_string()],
+ let files = match matches.get_many::<String>(options::FILE) {
+ Some(v) => v.cloned().collect(),
None => vec!["-".to_owned()],
};
@@ -142,7 +138,7 @@ fn expand_shortcuts(args: &[String]) -> Vec<String> {
arg[1..]
.split(',')
.filter(|s| !s.is_empty())
- .for_each(|s| processed_args.push(format!("--tabs={}", s)));
+ .for_each(|s| processed_args.push(format!("--tabs={s}")));
has_shortcuts = true;
} else {
processed_args.push(arg.to_string());
@@ -166,7 +162,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let matches = uu_app().try_get_matches_from(expand_shortcuts(&args))?;
- unexpand(&Options::new(&matches)?).map_err_context(String::new)
+ unexpand(&Options::new(&matches)?)
}
pub fn uu_app() -> Command {
@@ -214,16 +210,19 @@ pub fn uu_app() -> Command {
)
}
-fn open(path: &str) -> BufReader<Box<dyn Read + 'static>> {
+fn open(path: &str) -> UResult<BufReader<Box<dyn Read + 'static>>> {
let file_buf;
- if path == "-" {
- BufReader::new(Box::new(stdin()) as Box<dyn Read>)
+ let filename = Path::new(path);
+ if filename.is_dir() {
+ Err(Box::new(USimpleError {
+ code: 1,
+ message: format!("{}: Is a directory", filename.display()),
+ }))
+ } else if path == "-" {
+ Ok(BufReader::new(Box::new(stdin()) as Box<dyn Read>))
} else {
- file_buf = match File::open(path) {
- Ok(a) => a,
- Err(e) => crash!(1, "{}: {}", path.maybe_quote(), e),
- };
- BufReader::new(Box::new(file_buf) as Box<dyn Read>)
+ file_buf = File::open(path).map_err_context(|| path.to_string())?;
+ Ok(BufReader::new(Box::new(file_buf) as Box<dyn Read>))
}
}
@@ -319,106 +318,109 @@ fn next_char_info(uflag: bool, buf: &[u8], byte: usize) -> (CharType, usize, usi
(ctype, cwidth, nbytes)
}
-fn unexpand(options: &Options) -> std::io::Result<()> {
+#[allow(clippy::cognitive_complexity)]
+fn unexpand_line(
+ buf: &mut Vec<u8>,
+ output: &mut BufWriter<std::io::Stdout>,
+ options: &Options,
+ lastcol: usize,
+ ts: &[usize],
+) -> std::io::Result<()> {
+ let mut byte = 0; // offset into the buffer
+ let mut col = 0; // the current column
+ let mut scol = 0; // the start col for the current span, i.e., the already-printed width
+ let mut init = true; // are we at the start of the line?
+ let mut pctype = CharType::Other;
+
+ while byte < buf.len() {
+ // when we have a finite number of columns, never convert past the last column
+ if lastcol > 0 && col >= lastcol {
+ write_tabs(output, ts, scol, col, pctype == CharType::Tab, init, true);
+ output.write_all(&buf[byte..])?;
+ scol = col;
+ break;
+ }
+
+ // figure out how big the next char is, if it's UTF-8
+ let (ctype, cwidth, nbytes) = next_char_info(options.uflag, buf, byte);
+
+ // now figure out how many columns this char takes up, and maybe print it
+ let tabs_buffered = init || options.aflag;
+ match ctype {
+ CharType::Space | CharType::Tab => {
+ // compute next col, but only write space or tab chars if not buffering
+ col += if ctype == CharType::Space {
+ 1
+ } else {
+ next_tabstop(ts, col).unwrap_or(1)
+ };
+
+ if !tabs_buffered {
+ output.write_all(&buf[byte..byte + nbytes])?;
+ scol = col; // now printed up to this column
+ }
+ }
+ CharType::Other | CharType::Backspace => {
+ // always
+ write_tabs(
+ output,
+ ts,
+ scol,
+ col,
+ pctype == CharType::Tab,
+ init,
+ options.aflag,
+ );
+ init = false; // no longer at the start of a line
+ col = if ctype == CharType::Other {
+ // use computed width
+ col + cwidth
+ } else if col > 0 {
+ // Backspace case, but only if col > 0
+ col - 1
+ } else {
+ 0
+ };
+ output.write_all(&buf[byte..byte + nbytes])?;
+ scol = col; // we've now printed up to this column
+ }
+ }
+
+ byte += nbytes; // move on to next char
+ pctype = ctype; // save the previous type
+ }
+
+ // write out anything remaining
+ write_tabs(output, ts, scol, col, pctype == CharType::Tab, init, true);
+ output.flush()?;
+ buf.truncate(0); // clear out the buffer
+
+ Ok(())
+}
+
+fn unexpand(options: &Options) -> UResult<()> {
let mut output = BufWriter::new(stdout());
let ts = &options.tabstops[..];
let mut buf = Vec::new();
let lastcol = if ts.len() > 1 { *ts.last().unwrap() } else { 0 };
for file in &options.files {
- let mut fh = open(file);
+ let mut fh = match open(file) {
+ Ok(reader) => reader,
+ Err(err) => {
+ show!(err);
+ continue;
+ }
+ };
while match fh.read_until(b'\n', &mut buf) {
Ok(s) => s > 0,
Err(_) => !buf.is_empty(),
} {
- let mut byte = 0; // offset into the buffer
- let mut col = 0; // the current column
- let mut scol = 0; // the start col for the current span, i.e., the already-printed width
- let mut init = true; // are we at the start of the line?
- let mut pctype = CharType::Other;
-
- while byte < buf.len() {
- // when we have a finite number of columns, never convert past the last column
- if lastcol > 0 && col >= lastcol {
- write_tabs(
- &mut output,
- ts,
- scol,
- col,
- pctype == CharType::Tab,
- init,
- true,
- );
- output.write_all(&buf[byte..])?;
- scol = col;
- break;
- }
-
- // figure out how big the next char is, if it's UTF-8
- let (ctype, cwidth, nbytes) = next_char_info(options.uflag, &buf, byte);
-
- // now figure out how many columns this char takes up, and maybe print it
- let tabs_buffered = init || options.aflag;
- match ctype {
- CharType::Space | CharType::Tab => {
- // compute next col, but only write space or tab chars if not buffering
- col += if ctype == CharType::Space {
- 1
- } else {
- next_tabstop(ts, col).unwrap_or(1)
- };
-
- if !tabs_buffered {
- output.write_all(&buf[byte..byte + nbytes])?;
- scol = col; // now printed up to this column
- }
- }
- CharType::Other | CharType::Backspace => {
- // always
- write_tabs(
- &mut output,
- ts,
- scol,
- col,
- pctype == CharType::Tab,
- init,
- options.aflag,
- );
- init = false; // no longer at the start of a line
- col = if ctype == CharType::Other {
- // use computed width
- col + cwidth
- } else if col > 0 {
- // Backspace case, but only if col > 0
- col - 1
- } else {
- 0
- };
- output.write_all(&buf[byte..byte + nbytes])?;
- scol = col; // we've now printed up to this column
- }
- }
-
- byte += nbytes; // move on to next char
- pctype = ctype; // save the previous type
- }
-
- // write out anything remaining
- write_tabs(
- &mut output,
- ts,
- scol,
- col,
- pctype == CharType::Tab,
- init,
- true,
- );
- output.flush()?;
- buf.truncate(0); // clear out the buffer
+ unexpand_line(&mut buf, &mut output, options, lastcol, ts)?;
}
}
- output.flush()
+ Ok(())
}
#[cfg(test)]
diff --git a/src/uu/unexpand/unexpand.md b/src/uu/unexpand/unexpand.md
new file mode 100644
index 0000000000000000000000000000000000000000..6fc69b93a3acbbc170496bc25ea9cee06c80bf63
--- /dev/null
+++ b/src/uu/unexpand/unexpand.md
@@ -0,0 +1,8 @@
+# unexpand
+
+```
+unexpand [OPTION]... [FILE]...
+```
+
+Convert blanks in each `FILE` to tabs, writing to standard output.
+With no `FILE`, or when `FILE` is `-`, read standard input.
diff --git a/src/uu/uniq/Cargo.toml b/src/uu/uniq/Cargo.toml
index 98432caf018c169a1ef6975c31665b8d360f5601..d7560a835cc323ec9f38d8ea6d0603b8da7dbf9d 100644
--- a/src/uu/uniq/Cargo.toml
+++ b/src/uu/uniq/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_uniq"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "uniq ~ (uutils) filter identical adjacent lines from input"
@@ -15,10 +15,8 @@ edition = "2021"
path = "src/uniq.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-strum = "0.24.1"
-strum_macros = "0.24.2"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "uniq"
diff --git a/src/uu/uniq/src/uniq.rs b/src/uu/uniq/src/uniq.rs
index a66393acb3389d50576ea7947f7a1ea790075d4d..4084a7b3f2284ea6ce94b6d3aeeab2701065c9fb 100644
--- a/src/uu/uniq/src/uniq.rs
+++ b/src/uu/uniq/src/uniq.rs
@@ -1,25 +1,26 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Chirag B Jadwani <chirag.jadwani@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
-
-// TODO remove this when https://github.com/rust-lang/rust-clippy/issues/6902 is fixed
-#![allow(clippy::use_self)]
-
-use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore badoption
+use clap::{
+ builder::ValueParser, crate_version, error::ContextKind, error::Error, error::ErrorKind, Arg,
+ ArgAction, ArgMatches, Command,
+};
+use std::ffi::{OsStr, OsString};
use std::fs::File;
-use std::io::{self, stdin, stdout, BufRead, BufReader, BufWriter, Read, Write};
-use std::path::Path;
-use std::str::FromStr;
-use strum_macros::{AsRefStr, EnumString};
+use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Write};
+use std::num::IntErrorKind;
use uucore::display::Quotable;
-use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
-use uucore::format_usage;
+use uucore::error::{FromIo, UError, UResult, USimpleError};
+use uucore::posix::{posix_version, OBSOLETE};
+use uucore::shortcut_value_parser::ShortcutValueParser;
+use uucore::{format_usage, help_about, help_section, help_usage};
+
+const ABOUT: &str = help_about!("uniq.md");
+const USAGE: &str = help_usage!("uniq.md");
+const AFTER_HELP: &str = help_section!("after help", "uniq.md");
-static ABOUT: &str = "Report or omit repeated lines.";
-const USAGE: &str = "{} [OPTION]... [INPUT [OUTPUT]]...";
pub mod options {
pub static ALL_REPEATED: &str = "all-repeated";
pub static CHECK_CHARS: &str = "check-chars";
@@ -35,8 +36,7 @@ pub mod options {
static ARG_FILES: &str = "files";
-#[derive(PartialEq, Clone, Copy, AsRefStr, EnumString)]
-#[strum(serialize_all = "snake_case")]
+#[derive(PartialEq, Clone, Copy)]
enum Delimiters {
Append,
Prepend,
@@ -67,20 +67,18 @@ macro_rules! write_line_terminator {
}
impl Uniq {
- pub fn print_uniq<R: Read, W: Write>(
- &self,
- reader: &mut BufReader<R>,
- writer: &mut BufWriter<W>,
- ) -> UResult<()> {
+ pub fn print_uniq(&self, reader: impl BufRead, mut writer: impl Write) -> UResult<()> {
let mut first_line_printed = false;
let mut group_count = 1;
let line_terminator = self.get_line_terminator();
- let mut lines = reader.split(line_terminator).map(get_line_string);
+ let mut lines = reader.split(line_terminator);
let mut line = match lines.next() {
Some(l) => l?,
None => return Ok(()),
};
+ let writer = &mut writer;
+
// compare current `line` with consecutive lines (`next_line`) of the input
// and if needed, print `line` based on the command line options provided
for next_line in lines {
@@ -115,23 +113,28 @@ impl Uniq {
Ok(())
}
- fn skip_fields<'a>(&self, line: &'a str) -> &'a str {
+ fn skip_fields(&self, line: &[u8]) -> Vec<u8> {
if let Some(skip_fields) = self.skip_fields {
- let mut i = 0;
- let mut char_indices = line.char_indices();
+ let mut line = line.iter();
+ let mut line_after_skipped_field: Vec<u8>;
for _ in 0..skip_fields {
- if char_indices.all(|(_, c)| c.is_whitespace()) {
- return "";
+ if line.all(|u| u.is_ascii_whitespace()) {
+ return Vec::new();
}
- match char_indices.find(|(_, c)| c.is_whitespace()) {
- None => return "",
-
- Some((next_field_i, _)) => i = next_field_i,
+ line_after_skipped_field = line
+ .by_ref()
+ .skip_while(|u| !u.is_ascii_whitespace())
+ .copied()
+ .collect::<Vec<u8>>();
+
+ if line_after_skipped_field.is_empty() {
+ return Vec::new();
}
+ line = line_after_skipped_field.iter();
}
- &line[i..]
+ line.copied().collect::<Vec<u8>>()
} else {
- line
+ line.to_vec()
}
}
@@ -143,15 +146,15 @@ impl Uniq {
}
}
- fn cmp_keys(&self, first: &str, second: &str) -> bool {
+ fn cmp_keys(&self, first: &[u8], second: &[u8]) -> bool {
self.cmp_key(first, |first_iter| {
self.cmp_key(second, |second_iter| first_iter.ne(second_iter))
})
}
- fn cmp_key<F>(&self, line: &str, mut closure: F) -> bool
+ fn cmp_key<F>(&self, line: &[u8], mut closure: F) -> bool
where
- F: FnMut(&mut dyn Iterator<Item = char>) -> bool,
+ F: FnMut(&mut dyn Iterator<Item = u8>) -> bool,
{
let fields_to_check = self.skip_fields(line);
let len = fields_to_check.len();
@@ -160,28 +163,34 @@ impl Uniq {
if len > 0 {
// fast path: avoid doing any work if there is no need to skip or map to lower-case
if !self.ignore_case && slice_start == 0 && slice_stop == len {
- return closure(&mut fields_to_check.chars());
+ return closure(&mut fields_to_check.iter().copied());
}
// fast path: avoid skipping
if self.ignore_case && slice_start == 0 && slice_stop == len {
- return closure(&mut fields_to_check.chars().flat_map(|c| c.to_uppercase()));
+ return closure(&mut fields_to_check.iter().map(|u| u.to_ascii_lowercase()));
}
- // fast path: we can avoid mapping chars to upper-case, if we don't want to ignore the case
+ // fast path: we can avoid mapping chars to lower-case, if we don't want to ignore the case
if !self.ignore_case {
- return closure(&mut fields_to_check.chars().skip(slice_start).take(slice_stop));
+ return closure(
+ &mut fields_to_check
+ .iter()
+ .skip(slice_start)
+ .take(slice_stop)
+ .copied(),
+ );
}
closure(
&mut fields_to_check
- .chars()
+ .iter()
.skip(slice_start)
.take(slice_stop)
- .flat_map(|c| c.to_uppercase()),
+ .map(|u| u.to_ascii_lowercase()),
)
} else {
- closure(&mut fields_to_check.chars())
+ closure(&mut fields_to_check.iter().copied())
}
}
@@ -198,10 +207,10 @@ impl Uniq {
|| self.delimiters == Delimiters::Both)
}
- fn print_line<W: Write>(
+ fn print_line(
&self,
- writer: &mut BufWriter<W>,
- line: &str,
+ writer: &mut impl Write,
+ line: &[u8],
count: usize,
first_line_printed: bool,
) -> UResult<()> {
@@ -212,9 +221,16 @@ impl Uniq {
}
if self.show_counts {
- writer.write_all(format!("{:7} {}", count, line).as_bytes())
+ let prefix = format!("{count:7} ");
+ let out = prefix
+ .as_bytes()
+ .iter()
+ .chain(line.iter())
+ .copied()
+ .collect::<Vec<u8>>();
+ writer.write_all(out.as_slice())
} else {
- writer.write_all(line.as_bytes())
+ writer.write_all(line)
}
.map_err_context(|| "Failed to write line".to_string())?;
@@ -222,56 +238,338 @@ impl Uniq {
}
}
-fn get_line_string(io_line: io::Result<Vec<u8>>) -> UResult<String> {
- let line_bytes = io_line.map_err_context(|| "failed to split lines".to_string())?;
- String::from_utf8(line_bytes)
- .map_err(|e| USimpleError::new(1, format!("failed to convert line to utf8: {}", e)))
+fn opt_parsed(opt_name: &str, matches: &ArgMatches) -> UResult<Option<usize>> {
+ match matches.get_one::<String>(opt_name) {
+ Some(arg_str) => match arg_str.parse::<usize>() {
+ Ok(v) => Ok(Some(v)),
+ Err(e) => match e.kind() {
+ IntErrorKind::PosOverflow => Ok(Some(usize::MAX)),
+ _ => Err(USimpleError::new(
+ 1,
+ format!(
+ "Invalid argument for {}: {}",
+ opt_name,
+ arg_str.maybe_quote()
+ ),
+ )),
+ },
+ },
+ None => Ok(None),
+ }
}
-fn opt_parsed<T: FromStr>(opt_name: &str, matches: &ArgMatches) -> UResult<Option<T>> {
- Ok(match matches.get_one::<String>(opt_name) {
- Some(arg_str) => Some(arg_str.parse().map_err(|_| {
- USimpleError::new(
- 1,
- format!(
- "Invalid argument for {}: {}",
- opt_name,
- arg_str.maybe_quote()
- ),
+/// Extract obsolete shorthands (if any) for skip fields and skip chars options
+/// following GNU `uniq` behavior
+///
+/// Examples for obsolete skip fields option
+/// `uniq -1 file` would equal `uniq -f1 file`
+/// `uniq -1 -2 -3 file` would equal `uniq -f123 file`
+/// `uniq -1 -2 -f5 file` would equal `uniq -f5 file`
+/// `uniq -u20s4 file` would equal `uniq -u -f20 -s4 file`
+/// `uniq -D1w3 -3 file` would equal `uniq -D -f3 -w3 file`
+///
+/// Examples for obsolete skip chars option
+/// `uniq +1 file` would equal `uniq -s1 file`
+/// `uniq +1 -s2 file` would equal `uniq -s2 file`
+/// `uniq -s2 +3 file` would equal `uniq -s3 file`
+///
+fn handle_obsolete(args: impl uucore::Args) -> (Vec<OsString>, Option<usize>, Option<usize>) {
+ let mut skip_fields_old = None;
+ let mut skip_chars_old = None;
+ let mut preceding_long_opt_req_value = false;
+ let mut preceding_short_opt_req_value = false;
+
+ let filtered_args = args
+ .filter_map(|os_slice| {
+ filter_args(
+ os_slice,
+ &mut skip_fields_old,
+ &mut skip_chars_old,
+ &mut preceding_long_opt_req_value,
+ &mut preceding_short_opt_req_value,
)
- })?),
- None => None,
- })
+ })
+ .collect();
+
+ // exacted String values (if any) for skip_fields_old and skip_chars_old
+ // are guaranteed to consist of ascii digit chars only at this point
+ // so, it is safe to parse into usize and collapse Result into Option
+ let skip_fields_old: Option<usize> = skip_fields_old.and_then(|v| v.parse::<usize>().ok());
+ let skip_chars_old: Option<usize> = skip_chars_old.and_then(|v| v.parse::<usize>().ok());
+
+ (filtered_args, skip_fields_old, skip_chars_old)
}
-fn get_long_usage() -> String {
- String::from(
- "Filter adjacent matching lines from INPUT (or standard input),\n\
- writing to OUTPUT (or standard output).
- Note: 'uniq' does not detect repeated lines unless they are adjacent.\n\
- You may want to sort the input first, or use 'sort -u' without 'uniq'.\n",
- )
+fn filter_args(
+ os_slice: OsString,
+ skip_fields_old: &mut Option<String>,
+ skip_chars_old: &mut Option<String>,
+ preceding_long_opt_req_value: &mut bool,
+ preceding_short_opt_req_value: &mut bool,
+) -> Option<OsString> {
+ let filter: Option<OsString>;
+ if let Some(slice) = os_slice.to_str() {
+ if should_extract_obs_skip_fields(
+ slice,
+ preceding_long_opt_req_value,
+ preceding_short_opt_req_value,
+ ) {
+ // start of the short option string
+ // that can have obsolete skip fields option value in it
+ filter = handle_extract_obs_skip_fields(slice, skip_fields_old);
+ } else if should_extract_obs_skip_chars(
+ slice,
+ preceding_long_opt_req_value,
+ preceding_short_opt_req_value,
+ ) {
+ // the obsolete skip chars option
+ filter = handle_extract_obs_skip_chars(slice, skip_chars_old);
+ } else {
+ // either not a short option
+ // or a short option that cannot have obsolete lines value in it
+ filter = Some(OsString::from(slice));
+ // Check and reset to None obsolete values extracted so far
+ // if corresponding new/documented options are encountered next.
+ // NOTE: For skip fields - occurrences of corresponding new/documented options
+ // inside combined short options ike '-u20s4' or '-D1w3', etc
+ // are also covered in `handle_extract_obs_skip_fields()` function
+ if slice.starts_with("-f") {
+ *skip_fields_old = None;
+ }
+ if slice.starts_with("-s") {
+ *skip_chars_old = None;
+ }
+ }
+ handle_preceding_options(
+ slice,
+ preceding_long_opt_req_value,
+ preceding_short_opt_req_value,
+ );
+ } else {
+ // Cannot cleanly convert os_slice to UTF-8
+ // Do not process and return as-is
+ // This will cause failure later on, but we should not handle it here
+ // and let clap panic on invalid UTF-8 argument
+ filter = Some(os_slice);
+ }
+ filter
+}
+
+/// Helper function to [`filter_args`]
+/// Checks if the slice is a true short option (and not hyphen prefixed value of an option)
+/// and if so, a short option that can contain obsolete skip fields value
+fn should_extract_obs_skip_fields(
+ slice: &str,
+ preceding_long_opt_req_value: &bool,
+ preceding_short_opt_req_value: &bool,
+) -> bool {
+ slice.starts_with('-')
+ && !slice.starts_with("--")
+ && !preceding_long_opt_req_value
+ && !preceding_short_opt_req_value
+ && !slice.starts_with("-s")
+ && !slice.starts_with("-f")
+ && !slice.starts_with("-w")
+}
+
+/// Helper function to [`filter_args`]
+/// Checks if the slice is a true obsolete skip chars short option
+fn should_extract_obs_skip_chars(
+ slice: &str,
+ preceding_long_opt_req_value: &bool,
+ preceding_short_opt_req_value: &bool,
+) -> bool {
+ slice.starts_with('+')
+ && posix_version().is_some_and(|v| v <= OBSOLETE)
+ && !preceding_long_opt_req_value
+ && !preceding_short_opt_req_value
+ && slice.chars().nth(1).map_or(false, |c| c.is_ascii_digit())
+}
+
+/// Helper function to [`filter_args`]
+/// Captures if current slice is a preceding option
+/// that requires value
+fn handle_preceding_options(
+ slice: &str,
+ preceding_long_opt_req_value: &mut bool,
+ preceding_short_opt_req_value: &mut bool,
+) {
+ // capture if current slice is a preceding long option that requires value and does not use '=' to assign that value
+ // following slice should be treaded as value for this option
+ // even if it starts with '-' (which would be treated as hyphen prefixed value)
+ if slice.starts_with("--") {
+ use options as O;
+ *preceding_long_opt_req_value = &slice[2..] == O::SKIP_CHARS
+ || &slice[2..] == O::SKIP_FIELDS
+ || &slice[2..] == O::CHECK_CHARS
+ || &slice[2..] == O::GROUP
+ || &slice[2..] == O::ALL_REPEATED;
+ }
+ // capture if current slice is a preceding short option that requires value and does not have value in the same slice (value separated by whitespace)
+ // following slice should be treaded as value for this option
+ // even if it starts with '-' (which would be treated as hyphen prefixed value)
+ *preceding_short_opt_req_value = slice == "-s" || slice == "-f" || slice == "-w";
+ // slice is a value
+ // reset preceding option flags
+ if !slice.starts_with('-') {
+ *preceding_short_opt_req_value = false;
+ *preceding_long_opt_req_value = false;
+ }
+}
+
+/// Helper function to [`filter_args`]
+/// Extracts obsolete skip fields numeric part from argument slice
+/// and filters it out
+fn handle_extract_obs_skip_fields(
+ slice: &str,
+ skip_fields_old: &mut Option<String>,
+) -> Option<OsString> {
+ let mut obs_extracted: Vec<char> = vec![];
+ let mut obs_end_reached = false;
+ let mut obs_overwritten_by_new = false;
+ let filtered_slice: Vec<char> = slice
+ .chars()
+ .filter(|c| {
+ if c.eq(&'f') {
+ // any extracted obsolete skip fields value up to this point should be discarded
+ // as the new/documented option for skip fields was used after it
+ // i.e. in situation like `-u12f3`
+ // The obsolete skip fields value should still be extracted, filtered out
+ // but the skip_fields_old should be set to None instead of Some(String) later on
+ obs_overwritten_by_new = true;
+ }
+ // To correctly process scenario like '-u20s4' or '-D1w3', etc
+ // we need to stop extracting digits once alphabetic character is encountered
+ // after we already have something in obs_extracted
+ if c.is_ascii_digit() && !obs_end_reached {
+ obs_extracted.push(*c);
+ false
+ } else {
+ if !obs_extracted.is_empty() {
+ obs_end_reached = true;
+ }
+ true
+ }
+ })
+ .collect();
+
+ if obs_extracted.is_empty() {
+ // no obsolete value found/extracted
+ Some(OsString::from(slice))
+ } else {
+ // obsolete value was extracted
+ // unless there was new/documented option for skip fields used after it
+ // set the skip_fields_old value (concatenate to it if there was a value there already)
+ if obs_overwritten_by_new {
+ *skip_fields_old = None;
+ } else {
+ let mut extracted: String = obs_extracted.iter().collect();
+ if let Some(val) = skip_fields_old {
+ extracted.push_str(val);
+ }
+ *skip_fields_old = Some(extracted);
+ }
+ if filtered_slice.get(1).is_some() {
+ // there were some short options in front of or after obsolete lines value
+ // i.e. '-u20s4' or '-D1w3' or similar, which after extraction of obsolete lines value
+ // would look like '-us4' or '-Dw3' or similar
+ let filtered_slice: String = filtered_slice.iter().collect();
+ Some(OsString::from(filtered_slice))
+ } else {
+ None
+ }
+ }
+}
+
+/// Helper function to [`filter_args`]
+/// Extracts obsolete skip chars numeric part from argument slice
+fn handle_extract_obs_skip_chars(
+ slice: &str,
+ skip_chars_old: &mut Option<String>,
+) -> Option<OsString> {
+ let mut obs_extracted: Vec<char> = vec![];
+ let mut slice_chars = slice.chars();
+ slice_chars.next(); // drop leading '+' character
+ for c in slice_chars {
+ if c.is_ascii_digit() {
+ obs_extracted.push(c);
+ } else {
+ // for obsolete skip chars option the whole value after '+' should be numeric
+ // so, if any non-digit characters are encountered in the slice (i.e. `+1q`, etc)
+ // set skip_chars_old to None and return whole slice back.
+ // It will be parsed by clap and panic with appropriate error message
+ *skip_chars_old = None;
+ return Some(OsString::from(slice));
+ }
+ }
+ if obs_extracted.is_empty() {
+ // no obsolete value found/extracted
+ // i.e. it was just '+' character alone
+ Some(OsString::from(slice))
+ } else {
+ // successfully extracted numeric value
+ // capture it and return None to filter out the whole slice
+ *skip_chars_old = Some(obs_extracted.iter().collect());
+ None
+ }
+}
+
+/// Maps Clap errors to USimpleError and overrides 3 specific ones
+/// to meet requirements of GNU tests for `uniq`.
+/// Unfortunately these overrides are necessary, since several GNU tests
+/// for `uniq` hardcode and require the exact wording of the error message
+/// and it is not compatible with how Clap formats and displays those error messages.
+fn map_clap_errors(clap_error: Error) -> Box<dyn UError> {
+ let footer = "Try 'uniq --help' for more information.";
+ let override_arg_conflict =
+ "--group is mutually exclusive with -c/-d/-D/-u\n".to_string() + footer;
+ let override_group_badoption = "invalid argument 'badoption' for '--group'\nValid arguments are:\n - 'prepend'\n - 'append'\n - 'separate'\n - 'both'\n".to_string() + footer;
+ let override_all_repeated_badoption = "invalid argument 'badoption' for '--all-repeated'\nValid arguments are:\n - 'none'\n - 'prepend'\n - 'separate'\n".to_string() + footer;
+
+ let error_message = match clap_error.kind() {
+ ErrorKind::ArgumentConflict => override_arg_conflict,
+ ErrorKind::InvalidValue
+ if clap_error
+ .get(ContextKind::InvalidValue)
+ .is_some_and(|v| v.to_string() == "badoption")
+ && clap_error
+ .get(ContextKind::InvalidArg)
+ .is_some_and(|v| v.to_string().starts_with("--group")) =>
+ {
+ override_group_badoption
+ }
+ ErrorKind::InvalidValue
+ if clap_error
+ .get(ContextKind::InvalidValue)
+ .is_some_and(|v| v.to_string() == "badoption")
+ && clap_error
+ .get(ContextKind::InvalidArg)
+ .is_some_and(|v| v.to_string().starts_with("--all-repeated")) =>
+ {
+ override_all_repeated_badoption
+ }
+ _ => return clap_error.into(),
+ };
+ USimpleError::new(1, error_message)
}
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+ let (args, skip_fields_old, skip_chars_old) = handle_obsolete(args);
+
let matches = uu_app()
- .after_help(get_long_usage())
- .try_get_matches_from(args)?;
+ .try_get_matches_from(args)
+ .map_err(map_clap_errors)?;
- let files: Vec<String> = matches
- .get_many::<String>(ARG_FILES)
- .map(|v| v.map(ToString::to_string).collect())
+ let files = matches.get_many::<OsString>(ARG_FILES);
+
+ let (in_file_name, out_file_name) = files
+ .map(|fi| fi.map(AsRef::as_ref))
+ .map(|mut fi| (fi.next(), fi.next()))
.unwrap_or_default();
- let (in_file_name, out_file_name) = match files.len() {
- 0 => ("-".to_owned(), "-".to_owned()),
- 1 => (files[0].clone(), "-".to_owned()),
- 2 => (files[0].clone(), files[1].clone()),
- _ => {
- unreachable!() // Cannot happen as clap will fail earlier
- }
- };
+ let skip_fields_modern: Option<usize> = opt_parsed(options::SKIP_FIELDS, &matches)?;
+ let skip_chars_modern: Option<usize> = opt_parsed(options::SKIP_CHARS, &matches)?;
let uniq = Uniq {
repeats_only: matches.get_flag(options::REPEATED)
@@ -281,23 +579,23 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
|| matches.contains_id(options::GROUP),
delimiters: get_delimiter(&matches),
show_counts: matches.get_flag(options::COUNT),
- skip_fields: opt_parsed(options::SKIP_FIELDS, &matches)?,
- slice_start: opt_parsed(options::SKIP_CHARS, &matches)?,
+ skip_fields: skip_fields_modern.or(skip_fields_old),
+ slice_start: skip_chars_modern.or(skip_chars_old),
slice_stop: opt_parsed(options::CHECK_CHARS, &matches)?,
ignore_case: matches.get_flag(options::IGNORE_CASE),
zero_terminated: matches.get_flag(options::ZERO_TERMINATED),
};
if uniq.show_counts && uniq.all_repeated {
- return Err(UUsageError::new(
+ return Err(USimpleError::new(
1,
- "printing all duplicated lines and repeat counts is meaningless",
+ "printing all duplicated lines and repeat counts is meaningless\nTry 'uniq --help' for more information.",
));
}
uniq.print_uniq(
- &mut open_input_file(&in_file_name)?,
- &mut open_output_file(&out_file_name)?,
+ open_input_file(in_file_name)?,
+ open_output_file(out_file_name)?,
)
}
@@ -307,15 +605,16 @@ pub fn uu_app() -> Command {
.about(ABOUT)
.override_usage(format_usage(USAGE))
.infer_long_args(true)
+ .after_help(AFTER_HELP)
.arg(
Arg::new(options::ALL_REPEATED)
.short('D')
.long(options::ALL_REPEATED)
- .value_parser([
+ .value_parser(ShortcutValueParser::new([
"none",
"prepend",
"separate"
- ])
+ ]))
.help("print all duplicate lines. Delimiting is done with blank lines. [default: none]")
.value_name("delimit-method")
.num_args(0..=1)
@@ -325,12 +624,12 @@ pub fn uu_app() -> Command {
.arg(
Arg::new(options::GROUP)
.long(options::GROUP)
- .value_parser([
+ .value_parser(ShortcutValueParser::new([
"separate",
"prepend",
"append",
"both",
- ])
+ ]))
.help("show all items, separating groups with an empty line. [default: separate]")
.value_name("group-method")
.num_args(0..=1)
@@ -340,6 +639,7 @@ pub fn uu_app() -> Command {
options::REPEATED,
options::ALL_REPEATED,
options::UNIQUE,
+ options::COUNT
]),
)
.arg(
@@ -401,7 +701,9 @@ pub fn uu_app() -> Command {
.arg(
Arg::new(ARG_FILES)
.action(ArgAction::Append)
+ .value_parser(ValueParser::os_string())
.num_args(0..=2)
+ .hide(true)
.value_hint(clap::ValueHint::FilePath),
)
}
@@ -411,7 +713,14 @@ fn get_delimiter(matches: &ArgMatches) -> Delimiters {
.get_one::<String>(options::ALL_REPEATED)
.or_else(|| matches.get_one::<String>(options::GROUP));
if let Some(delimiter_arg) = value {
- Delimiters::from_str(delimiter_arg).unwrap() // All possible values for ALL_REPEATED are Delimiters (of type `&str`)
+ match delimiter_arg.as_ref() {
+ "append" => Delimiters::Append,
+ "prepend" => Delimiters::Prepend,
+ "separate" => Delimiters::Separate,
+ "both" => Delimiters::Both,
+ "none" => Delimiters::None,
+ _ => unreachable!("Should have been caught by possible values in clap"),
+ }
} else if matches.contains_id(options::GROUP) {
Delimiters::Separate
} else {
@@ -419,26 +728,26 @@ fn get_delimiter(matches: &ArgMatches) -> Delimiters {
}
}
-fn open_input_file(in_file_name: &str) -> UResult<BufReader<Box<dyn Read + 'static>>> {
- let in_file = if in_file_name == "-" {
- Box::new(stdin()) as Box<dyn Read>
- } else {
- let path = Path::new(in_file_name);
- let in_file = File::open(path)
- .map_err_context(|| format!("Could not open {}", in_file_name.maybe_quote()))?;
- Box::new(in_file) as Box<dyn Read>
- };
- Ok(BufReader::new(in_file))
+// None or "-" means stdin.
+fn open_input_file(in_file_name: Option<&OsStr>) -> UResult<Box<dyn BufRead>> {
+ Ok(match in_file_name {
+ Some(path) if path != "-" => {
+ let in_file = File::open(path)
+ .map_err_context(|| format!("Could not open {}", path.maybe_quote()))?;
+ Box::new(BufReader::new(in_file))
+ }
+ _ => Box::new(stdin().lock()),
+ })
}
-fn open_output_file(out_file_name: &str) -> UResult<BufWriter<Box<dyn Write + 'static>>> {
- let out_file = if out_file_name == "-" {
- Box::new(stdout()) as Box<dyn Write>
- } else {
- let path = Path::new(out_file_name);
- let out_file = File::create(path)
- .map_err_context(|| format!("Could not create {}", out_file_name.maybe_quote()))?;
- Box::new(out_file) as Box<dyn Write>
- };
- Ok(BufWriter::new(out_file))
+// None or "-" means stdout.
+fn open_output_file(out_file_name: Option<&OsStr>) -> UResult<Box<dyn Write>> {
+ Ok(match out_file_name {
+ Some(path) if path != "-" => {
+ let out_file = File::create(path)
+ .map_err_context(|| format!("Could not open {}", path.maybe_quote()))?;
+ Box::new(BufWriter::new(out_file))
+ }
+ _ => Box::new(stdout().lock()),
+ })
}
diff --git a/src/uu/uniq/uniq.md b/src/uu/uniq/uniq.md
new file mode 100644
index 0000000000000000000000000000000000000000..20de52395bada34b491a52576af6ada6d474b0a7
--- /dev/null
+++ b/src/uu/uniq/uniq.md
@@ -0,0 +1,15 @@
+# uniq
+
+```
+uniq [OPTION]... [INPUT [OUTPUT]]
+```
+
+Report or omit repeated lines.
+
+## After help
+
+Filter adjacent matching lines from `INPUT` (or standard input),
+writing to `OUTPUT` (or standard output).
+
+Note: `uniq` does not detect repeated lines unless they are adjacent.
+You may want to sort the input first, or use `sort -u` without `uniq`.
diff --git a/src/uu/unlink/Cargo.toml b/src/uu/unlink/Cargo.toml
index f63757fba6e82431f9e41a1bc2500043f71479d7..cf18a8b5089daf2515df468039107903da9b5d51 100644
--- a/src/uu/unlink/Cargo.toml
+++ b/src/uu/unlink/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_unlink"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "unlink ~ (uutils) remove a (file system) link to FILE"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/unlink.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore" }
+clap = { workspace = true }
+uucore = { workspace = true }
[[bin]]
name = "unlink"
diff --git a/src/uu/unlink/src/unlink.rs b/src/uu/unlink/src/unlink.rs
index 99dd5579182be6add35d1aac57605bc11625f988..4c9f2d82940f694fcb8ee31428c00ac9ed97de33 100644
--- a/src/uu/unlink/src/unlink.rs
+++ b/src/uu/unlink/src/unlink.rs
@@ -1,11 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Colin Warren <me@zv.ms>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
-
-/* last synced with: unlink (GNU coreutils) 8.21 */
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::ffi::OsString;
use std::fs::remove_file;
@@ -16,8 +12,10 @@ use clap::{crate_version, Arg, Command};
use uucore::display::Quotable;
use uucore::error::{FromIo, UResult};
+use uucore::{format_usage, help_about, help_usage};
-static ABOUT: &str = "Unlink the file at FILE.";
+const ABOUT: &str = help_about!("unlink.md");
+const USAGE: &str = help_usage!("unlink.md");
static OPT_PATH: &str = "FILE";
#[uucore::main]
@@ -33,6 +31,7 @@ pub fn uu_app() -> Command {
Command::new(uucore::util_name())
.version(crate_version!())
.about(ABOUT)
+ .override_usage(format_usage(USAGE))
.infer_long_args(true)
.arg(
Arg::new(OPT_PATH)
diff --git a/src/uu/unlink/unlink.md b/src/uu/unlink/unlink.md
new file mode 100644
index 0000000000000000000000000000000000000000..eebcd9ef31df27d614f58ab19917fae79530a76d
--- /dev/null
+++ b/src/uu/unlink/unlink.md
@@ -0,0 +1,8 @@
+# unlink
+
+```
+unlink [FILE]
+unlink OPTION
+```
+
+Unlink the file at `FILE`.
diff --git a/src/uu/uptime/Cargo.toml b/src/uu/uptime/Cargo.toml
index 99d60c309555ea8067538e3f72c706261baea296..d5f5710d5e8cc478b185a3be1d96c93a0db68a26 100644
--- a/src/uu/uptime/Cargo.toml
+++ b/src/uu/uptime/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_uptime"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "uptime ~ (uutils) display dynamic system information"
@@ -15,9 +15,10 @@ edition = "2021"
path = "src/uptime.rs"
[dependencies]
-chrono = { version="^0.4.23", default-features=false, features=["std", "alloc", "clock"]}
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["libc", "utmpx"] }
+chrono = { workspace = true }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["libc", "utmpx"] }
+thiserror = { workspace = true }
[[bin]]
name = "uptime"
diff --git a/src/uu/uptime/src/platform/mod.rs b/src/uu/uptime/src/platform/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e0e87dca1bffedbe7294e28e91972aabbe174c11
--- /dev/null
+++ b/src/uu/uptime/src/platform/mod.rs
@@ -0,0 +1,14 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+#[cfg(not(target_os = "openbsd"))]
+mod unix;
+#[cfg(not(target_os = "openbsd"))]
+pub use self::unix::*;
+
+#[cfg(target_os = "openbsd")]
+mod openbsd;
+#[cfg(target_os = "openbsd")]
+pub use self::openbsd::*;
diff --git a/src/uu/uptime/src/platform/openbsd.rs b/src/uu/uptime/src/platform/openbsd.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7e6970c1f0992b3954bcb9b7548e371adcef6d30
--- /dev/null
+++ b/src/uu/uptime/src/platform/openbsd.rs
@@ -0,0 +1,17 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// Specific implementation for OpenBSD: tool unsupported (utmpx not supported)
+
+use crate::uu_app;
+
+use uucore::error::UResult;
+
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+ let _matches = uu_app().try_get_matches_from(args)?;
+
+ println!("unsupported command on OpenBSD");
+ Ok(())
+}
diff --git a/src/uu/uptime/src/platform/unix.rs b/src/uu/uptime/src/platform/unix.rs
new file mode 100644
index 0000000000000000000000000000000000000000..14c5c77b2c77a8ef4a4a9d385bce149ef29a37ec
--- /dev/null
+++ b/src/uu/uptime/src/platform/unix.rs
@@ -0,0 +1,309 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore getloadavg behaviour loadavg uptime upsecs updays upmins uphours boottime nusers utmpxname
+
+use crate::options;
+use crate::uu_app;
+use chrono::{Local, TimeZone, Utc};
+use clap::ArgMatches;
+use std::ffi::OsString;
+use std::fs;
+use std::io;
+use std::os::unix::fs::FileTypeExt;
+use thiserror::Error;
+use uucore::error::set_exit_code;
+use uucore::error::UError;
+use uucore::show_error;
+
+use uucore::libc::time_t;
+
+use uucore::error::{UResult, USimpleError};
+
+#[cfg(unix)]
+use uucore::libc::getloadavg;
+#[cfg(windows)]
+extern "C" {
+ fn GetTickCount() -> uucore::libc::uint32_t;
+}
+#[derive(Debug, Error)]
+pub enum UptimeError {
+ // io::Error wrapper
+ #[error("couldn't get boot time: {0}")]
+ IoErr(#[from] io::Error),
+
+ #[error("couldn't get boot time: Is a directory")]
+ TargetIsDir,
+
+ #[error("couldn't get boot time: Illegal seek")]
+ TargetIsFifo,
+ #[error("extra operand '{0}'")]
+ ExtraOperandError(String),
+}
+impl UError for UptimeError {
+ fn code(&self) -> i32 {
+ 1
+ }
+}
+
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+ let matches = uu_app().try_get_matches_from(args)?;
+ let argument = matches.get_many::<OsString>(options::PATH);
+
+ // Switches to default uptime behaviour if there is no argument
+ if argument.is_none() {
+ return default_uptime(&matches);
+ }
+ let mut arg_iter = argument.unwrap();
+
+ let file_path = arg_iter.next().unwrap();
+ if let Some(path) = arg_iter.next() {
+ // Uptime doesn't attempt to calculate boot time if there is extra arguments.
+ // Its a fatal error
+ show_error!(
+ "{}",
+ UptimeError::ExtraOperandError(path.to_owned().into_string().unwrap())
+ );
+ set_exit_code(1);
+ return Ok(());
+ }
+ uptime_with_file(file_path)
+}
+
+#[cfg(unix)]
+fn uptime_with_file(file_path: &OsString) -> UResult<()> {
+ // Uptime will print loadavg and time to stderr unless we encounter an extra operand.
+ let mut non_fatal_error = false;
+
+ // process_utmpx_from_file() doesn't detect or report failures, we check if the path is valid
+ // before proceeding with more operations.
+ let md_res = fs::metadata(file_path);
+ if let Ok(md) = md_res {
+ if md.is_dir() {
+ show_error!("{}", UptimeError::TargetIsDir);
+ non_fatal_error = true;
+ set_exit_code(1);
+ }
+ if md.file_type().is_fifo() {
+ show_error!("{}", UptimeError::TargetIsFifo);
+ non_fatal_error = true;
+ set_exit_code(1);
+ }
+ } else if let Err(e) = md_res {
+ non_fatal_error = true;
+ set_exit_code(1);
+ show_error!("{}", UptimeError::IoErr(e));
+ }
+ // utmpxname() returns an -1 , when filename doesn't end with 'x' or its too long.
+ // Reference: `<https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/utmpxname.3.html>`
+
+ #[cfg(target_os = "macos")]
+ {
+ use std::os::unix::ffi::OsStrExt;
+ let bytes = file_path.as_os_str().as_bytes();
+
+ if bytes[bytes.len() - 1] != b'x' {
+ show_error!("couldn't get boot time");
+ print_time();
+ print!("up ???? days ??:??,");
+ print_nusers(0);
+ print_loadavg();
+ set_exit_code(1);
+ return Ok(());
+ }
+ }
+
+ if non_fatal_error {
+ print_time();
+ print!("up ???? days ??:??,");
+ print_nusers(0);
+ print_loadavg();
+ return Ok(());
+ }
+
+ print_time();
+ let (boot_time, user_count) = process_utmpx_from_file(file_path);
+ if let Some(time) = boot_time {
+ let upsecs = get_uptime_from_boot_time(time);
+ print_uptime(upsecs);
+ } else {
+ show_error!("couldn't get boot time");
+ set_exit_code(1);
+
+ print!("up ???? days ??:??,");
+ }
+
+ print_nusers(user_count);
+ print_loadavg();
+
+ Ok(())
+}
+
+/// Default uptime behaviour i.e. when no file argument is given.
+fn default_uptime(matches: &ArgMatches) -> UResult<()> {
+ let (boot_time, user_count) = process_utmpx();
+ let uptime = get_uptime(boot_time);
+ if matches.get_flag(options::SINCE) {
+ let initial_date = Local
+ .timestamp_opt(Utc::now().timestamp() - uptime, 0)
+ .unwrap();
+ println!("{}", initial_date.format("%Y-%m-%d %H:%M:%S"));
+ return Ok(());
+ }
+
+ if uptime < 0 {
+ return Err(USimpleError::new(1, "could not retrieve system uptime"));
+ }
+ print_time();
+ let upsecs = uptime;
+ print_uptime(upsecs);
+ print_nusers(user_count);
+ print_loadavg();
+
+ Ok(())
+}
+
+#[cfg(unix)]
+fn print_loadavg() {
+ use uucore::libc::c_double;
+
+ let mut avg: [c_double; 3] = [0.0; 3];
+ let loads: i32 = unsafe { getloadavg(avg.as_mut_ptr(), 3) };
+
+ if loads == -1 {
+ println!();
+ } else {
+ print!("load average: ");
+ for n in 0..loads {
+ print!(
+ "{:.2}{}",
+ avg[n as usize],
+ if n == loads - 1 { "\n" } else { ", " }
+ );
+ }
+ }
+}
+
+#[cfg(windows)]
+fn print_loadavg() {
+ // XXX: currently this is a noop as Windows does not seem to have anything comparable to
+ // getloadavg()
+}
+
+#[cfg(unix)]
+fn process_utmpx() -> (Option<time_t>, usize) {
+ use uucore::utmpx::*;
+
+ let mut nusers = 0;
+ let mut boot_time = None;
+
+ for line in Utmpx::iter_all_records() {
+ match line.record_type() {
+ USER_PROCESS => nusers += 1,
+ BOOT_TIME => {
+ let dt = line.login_time();
+ if dt.unix_timestamp() > 0 {
+ boot_time = Some(dt.unix_timestamp() as time_t);
+ }
+ }
+ _ => continue,
+ }
+ }
+ (boot_time, nusers)
+}
+
+#[cfg(unix)]
+fn process_utmpx_from_file(file: &OsString) -> (Option<time_t>, usize) {
+ use uucore::utmpx::*;
+
+ let mut nusers = 0;
+ let mut boot_time = None;
+
+ for line in Utmpx::iter_all_records_from(file) {
+ match line.record_type() {
+ USER_PROCESS => nusers += 1,
+ BOOT_TIME => {
+ let dt = line.login_time();
+ if dt.unix_timestamp() > 0 {
+ boot_time = Some(dt.unix_timestamp() as time_t);
+ }
+ }
+ _ => continue,
+ }
+ }
+ (boot_time, nusers)
+}
+
+#[cfg(windows)]
+fn process_utmpx() -> (Option<time_t>, usize) {
+ (None, 0) // TODO: change 0 to number of users
+}
+
+fn print_nusers(nusers: usize) {
+ match nusers.cmp(&1) {
+ std::cmp::Ordering::Less => print!(" 0 users, "),
+ std::cmp::Ordering::Equal => print!("1 user, "),
+ std::cmp::Ordering::Greater => print!("{nusers} users, "),
+ };
+}
+
+fn print_time() {
+ let local_time = Local::now().time();
+
+ print!(" {} ", local_time.format("%H:%M:%S"));
+}
+
+fn get_uptime_from_boot_time(boot_time: time_t) -> i64 {
+ let now = Local::now().timestamp();
+ #[cfg(target_pointer_width = "64")]
+ let boottime: i64 = boot_time;
+ #[cfg(not(target_pointer_width = "64"))]
+ let boottime: i64 = boot_time.into();
+ now - boottime
+}
+
+#[cfg(unix)]
+fn get_uptime(boot_time: Option<time_t>) -> i64 {
+ use std::fs::File;
+ use std::io::Read;
+
+ let mut proc_uptime_s = String::new();
+
+ let proc_uptime = File::open("/proc/uptime")
+ .ok()
+ .and_then(|mut f| f.read_to_string(&mut proc_uptime_s).ok())
+ .and_then(|_| proc_uptime_s.split_whitespace().next())
+ .and_then(|s| s.split('.').next().unwrap_or("0").parse().ok());
+
+ proc_uptime.unwrap_or_else(|| match boot_time {
+ Some(t) => {
+ let now = Local::now().timestamp();
+ #[cfg(target_pointer_width = "64")]
+ let boottime: i64 = t;
+ #[cfg(not(target_pointer_width = "64"))]
+ let boottime: i64 = t.into();
+ now - boottime
+ }
+ None => -1,
+ })
+}
+
+#[cfg(windows)]
+fn get_uptime(_boot_time: Option<time_t>) -> i64 {
+ unsafe { GetTickCount() as i64 }
+}
+
+fn print_uptime(upsecs: i64) {
+ let updays = upsecs / 86400;
+ let uphours = (upsecs - (updays * 86400)) / 3600;
+ let upmins = (upsecs - (updays * 86400) - (uphours * 3600)) / 60;
+ match updays.cmp(&1) {
+ std::cmp::Ordering::Equal => print!("up {updays:1} day, {uphours:2}:{upmins:02}, "),
+ std::cmp::Ordering::Greater => {
+ print!("up {updays:1} days {uphours:2}:{upmins:02}, ");
+ }
+ _ => print!("up {uphours:2}:{upmins:02}, "),
+ };
+}
diff --git a/src/uu/uptime/src/uptime.rs b/src/uu/uptime/src/uptime.rs
index 0751cbe9d459f9ce162ccaadc1a9b908f00f9293..4e9acd6991af7f51f53c19e361c5538bbba50b98 100644
--- a/src/uu/uptime/src/uptime.rs
+++ b/src/uu/uptime/src/uptime.rs
@@ -1,65 +1,23 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Jordi Boggiano <j.boggiano@seld.be>
-// * (c) Jian Zeng <anonymousknight86@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-// spell-checker:ignore (ToDO) getloadavg upsecs updays nusers loadavg boottime uphours upmins
+use clap::{builder::ValueParser, crate_version, Arg, ArgAction, Command, ValueHint};
-use chrono::{Local, TimeZone, Utc};
-use clap::{crate_version, Arg, ArgAction, Command};
+use uucore::{format_usage, help_about, help_usage};
-use uucore::format_usage;
-// import crate time from utmpx
-pub use uucore::libc;
-use uucore::libc::time_t;
+mod platform;
-use uucore::error::{UResult, USimpleError};
-
-static ABOUT: &str = "Display the current time, the length of time the system has been up,\n\
- the number of users on the system, and the average number of jobs\n\
- in the run queue over the last 1, 5 and 15 minutes.";
-const USAGE: &str = "{} [OPTION]...";
+const ABOUT: &str = help_about!("uptime.md");
+const USAGE: &str = help_usage!("uptime.md");
pub mod options {
pub static SINCE: &str = "since";
-}
-
-#[cfg(unix)]
-use uucore::libc::getloadavg;
-
-#[cfg(windows)]
-extern "C" {
- fn GetTickCount() -> uucore::libc::uint32_t;
+ pub static PATH: &str = "path";
}
#[uucore::main]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let matches = uu_app().try_get_matches_from(args)?;
-
- let (boot_time, user_count) = process_utmpx();
- let uptime = get_uptime(boot_time);
- if uptime < 0 {
- Err(USimpleError::new(1, "could not retrieve system uptime"))
- } else {
- if matches.get_flag(options::SINCE) {
- let initial_date = Local
- .timestamp_opt(Utc::now().timestamp() - uptime, 0)
- .unwrap();
- println!("{}", initial_date.format("%Y-%m-%d %H:%M:%S"));
- return Ok(());
- }
-
- print_time();
- let upsecs = uptime;
- print_uptime(upsecs);
- print_nusers(user_count);
- print_loadavg();
-
- Ok(())
- }
-}
+use platform::uumain;
pub fn uu_app() -> Command {
Command::new(uucore::util_name())
@@ -74,116 +32,11 @@ pub fn uu_app() -> Command {
.help("system up since")
.action(ArgAction::SetTrue),
)
-}
-
-#[cfg(unix)]
-fn print_loadavg() {
- use uucore::libc::c_double;
-
- let mut avg: [c_double; 3] = [0.0; 3];
- let loads: i32 = unsafe { getloadavg(avg.as_mut_ptr(), 3) };
-
- if loads == -1 {
- println!();
- } else {
- print!("load average: ");
- for n in 0..loads {
- print!(
- "{:.2}{}",
- avg[n as usize],
- if n == loads - 1 { "\n" } else { ", " }
- );
- }
- }
-}
-
-#[cfg(windows)]
-fn print_loadavg() {
- // XXX: currently this is a noop as Windows does not seem to have anything comparable to
- // getloadavg()
-}
-
-#[cfg(unix)]
-fn process_utmpx() -> (Option<time_t>, usize) {
- use uucore::utmpx::*;
-
- let mut nusers = 0;
- let mut boot_time = None;
-
- for line in Utmpx::iter_all_records() {
- match line.record_type() {
- USER_PROCESS => nusers += 1,
- BOOT_TIME => {
- let dt = line.login_time();
- if dt.second() > 0 {
- boot_time = Some(dt.second() as time_t);
- }
- }
- _ => continue,
- }
- }
- (boot_time, nusers)
-}
-
-#[cfg(windows)]
-fn process_utmpx() -> (Option<time_t>, usize) {
- (None, 0) // TODO: change 0 to number of users
-}
-
-fn print_nusers(nusers: usize) {
- match nusers.cmp(&1) {
- std::cmp::Ordering::Equal => print!("1 user, "),
- std::cmp::Ordering::Greater => print!("{} users, ", nusers),
- _ => {}
- };
-}
-
-fn print_time() {
- let local_time = Local::now().time();
-
- print!(" {} ", local_time.format("%H:%M:%S"));
-}
-
-#[cfg(unix)]
-fn get_uptime(boot_time: Option<time_t>) -> i64 {
- use std::fs::File;
- use std::io::Read;
-
- let mut proc_uptime_s = String::new();
-
- let proc_uptime = File::open("/proc/uptime")
- .ok()
- .and_then(|mut f| f.read_to_string(&mut proc_uptime_s).ok())
- .and_then(|_| proc_uptime_s.split_whitespace().next())
- .and_then(|s| s.split('.').next().unwrap_or("0").parse().ok());
-
- proc_uptime.unwrap_or_else(|| match boot_time {
- Some(t) => {
- let now = Local::now().timestamp();
- #[cfg(target_pointer_width = "64")]
- let boottime: i64 = t;
- #[cfg(not(target_pointer_width = "64"))]
- let boottime: i64 = t.into();
- now - boottime
- }
- None => -1,
- })
-}
-
-#[cfg(windows)]
-fn get_uptime(_boot_time: Option<time_t>) -> i64 {
- unsafe { GetTickCount() as i64 }
-}
-
-fn print_uptime(upsecs: i64) {
- let updays = upsecs / 86400;
- let uphours = (upsecs - (updays * 86400)) / 3600;
- let upmins = (upsecs - (updays * 86400) - (uphours * 3600)) / 60;
- match updays.cmp(&1) {
- std::cmp::Ordering::Equal => print!("up {:1} day, {:2}:{:02}, ", updays, uphours, upmins),
- std::cmp::Ordering::Greater => {
- print!("up {:1} days, {:2}:{:02}, ", updays, uphours, upmins);
- }
- _ => print!("up {:2}:{:02}, ", uphours, upmins),
- };
+ .arg(
+ Arg::new(options::PATH)
+ .help("file to search boot time from")
+ .action(ArgAction::Append)
+ .value_parser(ValueParser::os_string())
+ .value_hint(ValueHint::AnyPath),
+ )
}
diff --git a/src/uu/uptime/uptime.md b/src/uu/uptime/uptime.md
new file mode 100644
index 0000000000000000000000000000000000000000..fd9c8fd2f5947d94289a457920560d35f8dd9e18
--- /dev/null
+++ b/src/uu/uptime/uptime.md
@@ -0,0 +1,9 @@
+# uptime
+
+```
+uptime [OPTION]...
+```
+
+Display the current time, the length of time the system has been up,
+the number of users on the system, and the average number of jobs
+in the run queue over the last 1, 5 and 15 minutes.
diff --git a/src/uu/users/Cargo.toml b/src/uu/users/Cargo.toml
index 658c3c25acd65a19febfc99f8058bc1d9ede5653..8b280c7a6d635de10cbab41b37b6120d253a7736 100644
--- a/src/uu/users/Cargo.toml
+++ b/src/uu/users/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_users"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "users ~ (uutils) display names of currently logged-in users"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/users.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["utmpx"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["utmpx"] }
[[bin]]
name = "users"
diff --git a/src/uu/users/src/platform/mod.rs b/src/uu/users/src/platform/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e0e87dca1bffedbe7294e28e91972aabbe174c11
--- /dev/null
+++ b/src/uu/users/src/platform/mod.rs
@@ -0,0 +1,14 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+#[cfg(not(target_os = "openbsd"))]
+mod unix;
+#[cfg(not(target_os = "openbsd"))]
+pub use self::unix::*;
+
+#[cfg(target_os = "openbsd")]
+mod openbsd;
+#[cfg(target_os = "openbsd")]
+pub use self::openbsd::*;
diff --git a/src/uu/users/src/platform/openbsd.rs b/src/uu/users/src/platform/openbsd.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7e6970c1f0992b3954bcb9b7548e371adcef6d30
--- /dev/null
+++ b/src/uu/users/src/platform/openbsd.rs
@@ -0,0 +1,17 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// Specific implementation for OpenBSD: tool unsupported (utmpx not supported)
+
+use crate::uu_app;
+
+use uucore::error::UResult;
+
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+ let _matches = uu_app().try_get_matches_from(args)?;
+
+ println!("unsupported command on OpenBSD");
+ Ok(())
+}
diff --git a/src/uu/users/src/platform/unix.rs b/src/uu/users/src/platform/unix.rs
new file mode 100644
index 0000000000000000000000000000000000000000..99c9ce776bbf25599d871b77122d5754a47367f0
--- /dev/null
+++ b/src/uu/users/src/platform/unix.rs
@@ -0,0 +1,53 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore (paths) wtmp
+
+use crate::uu_app;
+
+use std::ffi::OsString;
+use std::path::Path;
+
+use uucore::error::UResult;
+use uucore::utmpx::{self, Utmpx};
+
+static ARG_FILES: &str = "files";
+
+fn get_long_usage() -> String {
+ format!(
+ "Output who is currently logged in according to FILE.
+If FILE is not specified, use {}. /var/log/wtmp as FILE is common.",
+ utmpx::DEFAULT_FILE
+ )
+}
+
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+ let matches = uu_app()
+ .after_help(get_long_usage())
+ .try_get_matches_from(args)?;
+
+ let files: Vec<&Path> = matches
+ .get_many::<OsString>(ARG_FILES)
+ .map(|v| v.map(AsRef::as_ref).collect())
+ .unwrap_or_default();
+
+ let filename = if files.is_empty() {
+ utmpx::DEFAULT_FILE.as_ref()
+ } else {
+ files[0]
+ };
+
+ let mut users = Utmpx::iter_all_records_from(filename)
+ .filter(Utmpx::is_user_process)
+ .map(|ut| ut.user())
+ .collect::<Vec<_>>();
+
+ if !users.is_empty() {
+ users.sort();
+ println!("{}", users.join(" "));
+ }
+
+ Ok(())
+}
diff --git a/src/uu/users/src/users.rs b/src/uu/users/src/users.rs
index b812bfea18d56e88f9622512f9cb6805420773af..d299399f311dfedd90577347f4ec09cf945e75dd 100644
--- a/src/uu/users/src/users.rs
+++ b/src/uu/users/src/users.rs
@@ -1,64 +1,23 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) KokaKiwi <kokakiwi@kokakiwi.net>
-// * (c) Jian Zeng <anonymousknight86@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (paths) wtmp
-use std::ffi::OsString;
-use std::path::Path;
-
use clap::builder::ValueParser;
use clap::{crate_version, Arg, Command};
-use uucore::error::UResult;
-use uucore::format_usage;
-use uucore::utmpx::{self, Utmpx};
+use uucore::{format_usage, help_about, help_usage};
-static ABOUT: &str = "Print the user names of users currently logged in to the current host";
-const USAGE: &str = "{} [FILE]";
+mod platform;
-static ARG_FILES: &str = "files";
+const ABOUT: &str = help_about!("users.md");
+const USAGE: &str = help_usage!("users.md");
-fn get_long_usage() -> String {
- format!(
- "Output who is currently logged in according to FILE.
-If FILE is not specified, use {}. /var/log/wtmp as FILE is common.",
- utmpx::DEFAULT_FILE
- )
-}
+static ARG_FILES: &str = "files";
#[uucore::main]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let matches = uu_app()
- .after_help(get_long_usage())
- .try_get_matches_from(args)?;
-
- let files: Vec<&Path> = matches
- .get_many::<OsString>(ARG_FILES)
- .map(|v| v.map(AsRef::as_ref).collect())
- .unwrap_or_default();
-
- let filename = if !files.is_empty() {
- files[0]
- } else {
- utmpx::DEFAULT_FILE.as_ref()
- };
-
- let mut users = Utmpx::iter_all_records_from(filename)
- .filter(Utmpx::is_user_process)
- .map(|ut| ut.user())
- .collect::<Vec<_>>();
-
- if !users.is_empty() {
- users.sort();
- println!("{}", users.join(" "));
- }
-
- Ok(())
-}
+use platform::uumain;
pub fn uu_app() -> Command {
Command::new(uucore::util_name())
diff --git a/src/uu/users/users.md b/src/uu/users/users.md
new file mode 100644
index 0000000000000000000000000000000000000000..7b126a0f0beb936b8bc1e68a9f9ada59e859db48
--- /dev/null
+++ b/src/uu/users/users.md
@@ -0,0 +1,7 @@
+# users
+
+```
+users [FILE]
+```
+
+Print the user names of users currently logged in to the current host.
diff --git a/src/uu/vdir/Cargo.toml b/src/uu/vdir/Cargo.toml
index 9576770abac380f42130f87600df5e50c47b16e5..7c720857281d0e80d8fabef33a7a30408f784d8c 100644
--- a/src/uu/vdir/Cargo.toml
+++ b/src/uu/vdir/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_vdir"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "shortcut to ls -l -b"
@@ -15,9 +15,9 @@ edition = "2021"
path = "src/vdir.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo", "env"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["entries", "fs"] }
-uu_ls = { version = ">=0.0.17", path="../ls"}
+clap = { workspace = true, features = ["env"] }
+uucore = { workspace = true, features = ["entries", "fs", "quoting-style"] }
+uu_ls = { workspace = true }
[[bin]]
name = "vdir"
diff --git a/src/uu/vdir/src/vdir.rs b/src/uu/vdir/src/vdir.rs
index c49a3f1b3796b59e8f9e6789fad9c02dc0ddb2a6..b9d80c401d6e5c5af4b573b9be978783136b4504 100644
--- a/src/uu/vdir/src/vdir.rs
+++ b/src/uu/vdir/src/vdir.rs
@@ -1,9 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) gmnsii <gmnsii@protonmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE file
-// * that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use clap::Command;
use std::ffi::OsString;
diff --git a/src/uu/vdir/vdir.md b/src/uu/vdir/vdir.md
new file mode 100644
index 0000000000000000000000000000000000000000..c7a0cae36439e200ed935988d752d8a7f34aed81
--- /dev/null
+++ b/src/uu/vdir/vdir.md
@@ -0,0 +1,10 @@
+# vdir
+
+```
+vdir [OPTION]... [FILE]...
+```
+
+List directory contents.
+Ignore files and directories starting with a '.' by default.
+
+Mandatory arguments to long options are mandatory for short options too.
diff --git a/src/uu/wc/BENCHMARKING.md b/src/uu/wc/BENCHMARKING.md
index b9d8cc22d8cded766c7ec4bb3aba3138573d23a8..953e9038c81360f86eb1e3f05e1b39703c5a84f6 100644
--- a/src/uu/wc/BENCHMARKING.md
+++ b/src/uu/wc/BENCHMARKING.md
@@ -2,45 +2,59 @@
<!-- spell-checker:ignore (words) uuwc uucat largefile somefile Mshortlines moby lwcm cmds tablefmt -->
-Much of what makes wc fast is avoiding unnecessary work. It has multiple strategies, depending on which data is requested.
+Much of what makes wc fast is avoiding unnecessary work. It has multiple strategies,
+depending on which data is requested.
## Strategies
### Counting bytes
-In the case of `wc -c` the content of the input doesn't have to be inspected at all, only the size has to be known. That enables a few optimizations.
+In the case of `wc -c` the content of the input doesn't have to be inspected at all,
+only the size has to be known. That enables a few optimizations.
#### File size
-If it can, wc reads the file size directly. This is not interesting to benchmark, except to see if it still works. Try `wc -c largefile`.
+If it can, wc reads the file size directly. This is not interesting to benchmark,
+except to see if it still works. Try `wc -c largefile`.
#### `splice()`
On Linux `splice()` is used to get the input's length while discarding it directly.
-The best way I've found to generate a fast input to test `splice()` is to pipe the output of uutils `cat` into it. Note that GNU `cat` is slower and therefore less suitable, and that if a file is given as its input directly (as in `wc -c < largefile`) the first strategy kicks in. Try `uucat somefile | wc -c`.
+The best way I've found to generate a fast input to test `splice()` is to pipe the
+output of uutils `cat` into it. Note that GNU `cat` is slower and therefore less
+suitable, and that if a file is given as its input directly (as in
+`wc -c < largefile`) the first strategy kicks in. Try `uucat somefile | wc -c`.
### Counting lines
-In the case of `wc -l` or `wc -cl` the input doesn't have to be decoded. It's read in chunks and the `bytecount` crate is used to count the newlines.
+In the case of `wc -l` or `wc -cl` the input doesn't have to be decoded. It's
+read in chunks and the `bytecount` crate is used to count the newlines.
-It's useful to vary the line length in the input. GNU wc seems particularly bad at short lines.
+It's useful to vary the line length in the input. GNU wc seems particularly
+bad at short lines.
### Processing unicode
-This is the most general strategy, and it's necessary for counting words, characters, and line lengths. Individual steps are still switched on and off depending on what must be reported.
+This is the most general strategy, and it's necessary for counting words,
+characters, and line lengths. Individual steps are still switched on and off
+depending on what must be reported.
-Try varying which of the `-w`, `-m`, `-l` and `-L` flags are used. (The `-c` flag is unlikely to make a difference.)
+Try varying which of the `-w`, `-m`, `-l` and `-L` flags are used.
+(The `-c` flag is unlikely to make a difference.)
-Passing no flags is equivalent to passing `-wcl`. That case should perhaps be given special attention as it's the default.
+Passing no flags is equivalent to passing `-wcl`. That case should perhaps be
+given special attention as it's the default.
## Generating files
-To generate a file with many very short lines, run `yes | head -c50000000 > 25Mshortlines`.
+To generate a file with many very short lines, run
+`yes | head -c50000000 > 25Mshortlines`.
-To get a file with less artificial contents, download a book from Project Gutenberg and concatenate it a lot of times:
+To get a file with less artificial contents, download a book from
+Project Gutenberg and concatenate it a lot of times:
-```
+```shell
wget https://www.gutenberg.org/files/2701/2701-0.txt -O moby.txt
cat moby.txt moby.txt moby.txt moby.txt > moby4.txt
cat moby4.txt moby4.txt moby4.txt moby4.txt > moby16.txt
@@ -49,7 +63,7 @@ cat moby16.txt moby16.txt moby16.txt moby16.txt > moby64.txt
And get one with lots of unicode too:
-```
+```shell
wget https://www.gutenberg.org/files/30613/30613-0.txt -O odyssey.txt
cat odyssey.txt odyssey.txt odyssey.txt odyssey.txt > odyssey4.txt
cat odyssey4.txt odyssey4.txt odyssey4.txt odyssey4.txt > odyssey16.txt
@@ -57,11 +71,14 @@ cat odyssey16.txt odyssey16.txt odyssey16.txt odyssey16.txt > odyssey64.txt
cat odyssey64.txt odyssey64.txt odyssey64.txt odyssey64.txt > odyssey256.txt
```
-Finally, it's interesting to try a binary file. Look for one with `du -sh /usr/bin/* | sort -h`. On my system `/usr/bin/docker` is a good candidate as it's fairly large.
+Finally, it's interesting to try a binary file. Look for one with
+`du -sh /usr/bin/* | sort -h`. On my system `/usr/bin/docker` is a good
+candidate as it's fairly large.
## Running benchmarks
-Use [`hyperfine`](https://github.com/sharkdp/hyperfine) to compare the performance. For example, `hyperfine 'wc somefile' 'uuwc somefile'`.
+Use [`hyperfine`](https://github.com/sharkdp/hyperfine) to compare the
+performance. For example, `hyperfine 'wc somefile' 'uuwc somefile'`.
If you want to get fancy and exhaustive, generate a table:
@@ -69,7 +86,7 @@ If you want to get fancy and exhaustive, generate a table:
|------------------------|--------------|------------------|-----------------|-------------------|
| `wc <FILE>` | 1.3965 | 1.6182 | 5.2967 | 2.2294 |
| `wc -c <FILE>` | 0.8134 | 1.2774 | 0.7732 | 0.9106 |
-| `uucat <FILE> | wc -c` | 2.7760 | 2.5565 | 2.3769 | 2.3982 |
+| `uucat <FILE> \| wc -c` | 2.7760 | 2.5565 | 2.3769 | 2.3982 |
| `wc -l <FILE>` | 1.1441 | 1.2854 | 2.9681 | 1.1493 |
| `wc -L <FILE>` | 2.1087 | 1.2551 | 5.4577 | 2.1490 |
| `wc -m <FILE>` | 2.7272 | 2.1704 | 7.3371 | 3.4347 |
@@ -77,12 +94,16 @@ If you want to get fancy and exhaustive, generate a table:
| `wc -lwcmL <FILE>` | 1.1687 | 0.9169 | 4.4092 | 2.0663 |
Beware that:
+
- Results are fuzzy and change from run to run
-- You'll often want to check versions of uutils wc against each other instead of against GNU
+- You'll often want to check versions of uutils wc against each other instead
+ of against GNU
- This takes a lot of time to generate
-- This only shows the relative speedup, not the absolute time, which may be misleading if the time is very short
+- This only shows the relative speedup, not the absolute time, which may be
+ misleading if the time is very short
Created by the following Python script:
+
```python
import json
import subprocess
@@ -121,4 +142,6 @@ for cmd in cmds:
table.append(row)
print(tabulate(table, [""] + files, tablefmt="github"))
```
-(You may have to adjust the `bins` and `files` variables depending on your setup, and please do add other interesting cases to `cmds`.)
+
+(You may have to adjust the `bins` and `files` variables depending on your
+setup, and please do add other interesting cases to `cmds`.)
diff --git a/src/uu/wc/Cargo.toml b/src/uu/wc/Cargo.toml
index 6d30267a8dbd4d1680cce921f4b6162f82bb316c..50d5fefbfed57d7c0fe8f5d802fbc3c1d076aff0 100644
--- a/src/uu/wc/Cargo.toml
+++ b/src/uu/wc/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_wc"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "wc ~ (uutils) display newline, word, and byte counts for input"
@@ -15,15 +15,15 @@ edition = "2021"
path = "src/wc.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["pipes"] }
-bytecount = "0.6.3"
-utf-8 = "0.7.6"
-unicode-width = "0.1.8"
+clap = { workspace = true }
+uucore = { workspace = true, features = ["pipes", "quoting-style"] }
+bytecount = { workspace = true }
+thiserror = { workspace = true }
+unicode-width = { workspace = true }
[target.'cfg(unix)'.dependencies]
-nix = { version = "0.25", default-features = false }
-libc = "0.2"
+nix = { workspace = true }
+libc = { workspace = true }
[[bin]]
name = "wc"
diff --git a/src/uu/wc/src/count_fast.rs b/src/uu/wc/src/count_fast.rs
index d151c9c90744d3ea47bebc4c8c382e6220670f50..85d3d1d2b36e76268e8553d30a2dab6c566ff276 100644
--- a/src/uu/wc/src/count_fast.rs
+++ b/src/uu/wc/src/count_fast.rs
@@ -1,3 +1,9 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// cSpell:ignore sysconf
use crate::word_count::WordCount;
use super::WordCountable;
@@ -7,11 +13,19 @@ use std::fs::OpenOptions;
use std::io::{self, ErrorKind, Read};
#[cfg(unix)]
-use libc::S_IFREG;
+use libc::{sysconf, S_IFREG, _SC_PAGESIZE};
#[cfg(unix)]
use nix::sys::stat;
+#[cfg(unix)]
+use std::io::{Seek, SeekFrom};
#[cfg(any(target_os = "linux", target_os = "android"))]
use std::os::unix::io::AsRawFd;
+#[cfg(windows)]
+use std::os::windows::fs::MetadataExt;
+#[cfg(windows)]
+const FILE_ATTRIBUTE_ARCHIVE: u32 = 32;
+#[cfg(windows)]
+const FILE_ATTRIBUTE_NORMAL: u32 = 128;
#[cfg(any(target_os = "linux", target_os = "android"))]
use libc::S_IFIFO;
@@ -68,6 +82,8 @@ fn count_bytes_using_splice(fd: &impl AsRawFd) -> Result<usize, usize> {
/// 1. On Unix, we can simply `stat` the file if it is regular.
/// 2. On Linux -- if the above did not work -- we can use splice to count
/// the number of bytes if the file is a FIFO.
+/// 3. On Windows we can use `std::os::windows::fs::MetadataExt` to get file size
+/// for regular files
/// 3. Otherwise, we just read normally, but without the overhead of counting
/// other things such as lines and words.
#[inline]
@@ -83,11 +99,60 @@ pub(crate) fn count_bytes_fast<T: WordCountable>(handle: &mut T) -> (usize, Opti
// If stat.st_size = 0 then
// - either the size is 0
// - or the size is unknown.
- // The second case happens for files in pseudo-filesystems. For
- // example with /proc/version and /sys/kernel/profiling. So,
- // if it is 0 we don't report that and instead do a full read.
- if (stat.st_mode as libc::mode_t & S_IFREG) != 0 && stat.st_size > 0 {
- return (stat.st_size as usize, None);
+ // The second case happens for files in pseudo-filesystems.
+ // For example with /proc/version.
+ // So, if it is 0 we don't report that and instead do a full read.
+ //
+ // Another thing to consider for files in pseudo-filesystems like /proc, /sys
+ // and similar is that they could report `st_size` greater than actual content.
+ // For example /sys/kernel/profiling could report `st_size` equal to
+ // system page size (typically 4096 on 64bit system), while it's file content
+ // would count up only to a couple of bytes.
+ // This condition usually occurs for files in pseudo-filesystems like /proc, /sys
+ // that report `st_size` in the multiples of system page size.
+ // In such cases - attempt `seek()` almost to the end of the file
+ // and then fall back on read to count the rest.
+ //
+ // And finally a special case of input redirection in *nix shell:
+ // `( wc -c ; wc -c ) < file` should return
+ // ```
+ // size_of_file
+ // 0
+ // ```
+ // Similarly
+ // `( head -c1 ; wc -c ) < file` should return
+ // ```
+ // first_byte_of_file
+ // size_of_file - 1
+ // ```
+ // Since the input stream from file is treated as continuous across both commands inside ().
+ // In cases like this, due to `<` redirect, the `stat.st_mode` would report input as a regular file
+ // and `stat.st_size` would report the size of file on disk
+ // and NOT the remaining number of bytes in the input stream.
+ // However, the raw file descriptor in this situation would be equal to `0`
+ // for STDIN in both invocations.
+ // Therefore we cannot rely of `st_size` here and should fall back on full read.
+ if fd > 0 && (stat.st_mode as libc::mode_t & S_IFREG) != 0 && stat.st_size > 0 {
+ let sys_page_size = unsafe { sysconf(_SC_PAGESIZE) as usize };
+ if stat.st_size as usize % sys_page_size > 0 {
+ // regular file or file from /proc, /sys and similar pseudo-filesystems
+ // with size that is NOT a multiple of system page size
+ return (stat.st_size as usize, None);
+ } else if let Some(file) = handle.inner_file() {
+ // On some platforms `stat.st_blksize` and `stat.st_size`
+ // are of different types: i64 vs i32
+ // i.e. MacOS on Apple Silicon (aarch64-apple-darwin),
+ // Debian Linux on ARM (aarch64-unknown-linux-gnu),
+ // 32bit i686 targets, etc.
+ // While on the others they are of the same type.
+ #[allow(clippy::unnecessary_cast)]
+ let offset =
+ stat.st_size as i64 - stat.st_size as i64 % (stat.st_blksize as i64 + 1);
+
+ if let Ok(n) = file.seek(SeekFrom::Start(offset as u64)) {
+ byte_count = n as usize;
+ }
+ }
}
#[cfg(any(target_os = "linux", target_os = "android"))]
{
@@ -103,6 +168,21 @@ pub(crate) fn count_bytes_fast<T: WordCountable>(handle: &mut T) -> (usize, Opti
}
}
+ #[cfg(windows)]
+ {
+ if let Some(file) = handle.inner_file() {
+ if let Ok(metadata) = file.metadata() {
+ let attributes = metadata.file_attributes();
+
+ if (attributes & FILE_ATTRIBUTE_ARCHIVE) != 0
+ || (attributes & FILE_ATTRIBUTE_NORMAL) != 0
+ {
+ return (metadata.file_size() as usize, None);
+ }
+ }
+ }
+ }
+
// Fall back on `read`, but without the overhead of counting words and lines.
let mut buf = [0_u8; BUF_SIZE];
loop {
diff --git a/src/uu/wc/src/countable.rs b/src/uu/wc/src/countable.rs
index 5596decb3e42b469f6c09949e79e0cb9580eba37..d27c7fb5968e009536583f748bce76049603bdff 100644
--- a/src/uu/wc/src/countable.rs
+++ b/src/uu/wc/src/countable.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//! Traits and implementations for iterating over lines in a file-like object.
//!
//! This module provides a [`WordCountable`] trait and implementations
@@ -13,12 +17,14 @@ use std::os::unix::io::AsRawFd;
pub trait WordCountable: AsRawFd + Read {
type Buffered: BufRead;
fn buffered(self) -> Self::Buffered;
+ fn inner_file(&mut self) -> Option<&mut File>;
}
#[cfg(not(unix))]
pub trait WordCountable: Read {
type Buffered: BufRead;
fn buffered(self) -> Self::Buffered;
+ fn inner_file(&mut self) -> Option<&mut File>;
}
impl WordCountable for StdinLock<'_> {
@@ -27,11 +33,19 @@ impl WordCountable for StdinLock<'_> {
fn buffered(self) -> Self::Buffered {
self
}
+ fn inner_file(&mut self) -> Option<&mut File> {
+ None
+ }
}
+
impl WordCountable for File {
type Buffered = BufReader<Self>;
fn buffered(self) -> Self::Buffered {
BufReader::new(self)
}
+
+ fn inner_file(&mut self) -> Option<&mut File> {
+ Some(self)
+ }
}
diff --git a/src/uu/wc/src/utf8/LICENSE b/src/uu/wc/src/utf8/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..6f3c83e687222f494c0b907470be4aca664a90f4
--- /dev/null
+++ b/src/uu/wc/src/utf8/LICENSE
@@ -0,0 +1,26 @@
+// spell-checker:ignore Sapin
+Copyright (c) Simon Sapin and many others
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/src/uu/wc/src/utf8/mod.rs b/src/uu/wc/src/utf8/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ea4f19392dffe4706247eb7534b6273f98f6a24f
--- /dev/null
+++ b/src/uu/wc/src/utf8/mod.rs
@@ -0,0 +1,97 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore Sapin
+mod read;
+
+pub use read::{BufReadDecoder, BufReadDecoderError};
+
+use std::cmp;
+use std::str;
+
+///
+/// Incremental, zero-copy UTF-8 decoding with error handling
+///
+/// The original implementation was written by Simon Sapin in the utf-8 crate <https://crates.io/crates/utf-8>.
+/// uu_wc used to depend on that crate.
+/// The author archived the repository <https://github.com/SimonSapin/rust-utf8>.
+/// They suggested incorporating the source directly into uu_wc <https://github.com/uutils/coreutils/issues/4289>.
+///
+
+#[derive(Debug, Copy, Clone)]
+pub struct Incomplete {
+ pub buffer: [u8; 4],
+ pub buffer_len: u8,
+}
+
+impl Incomplete {
+ pub fn empty() -> Self {
+ Self {
+ buffer: [0, 0, 0, 0],
+ buffer_len: 0,
+ }
+ }
+
+ pub fn is_empty(&self) -> bool {
+ self.buffer_len == 0
+ }
+
+ pub fn new(bytes: &[u8]) -> Self {
+ let mut buffer = [0, 0, 0, 0];
+ let len = bytes.len();
+ buffer[..len].copy_from_slice(bytes);
+ Self {
+ buffer,
+ buffer_len: len as u8,
+ }
+ }
+
+ fn take_buffer(&mut self) -> &[u8] {
+ let len = self.buffer_len as usize;
+ self.buffer_len = 0;
+ &self.buffer[..len]
+ }
+
+ /// (consumed_from_input, None): not enough input
+ /// (consumed_from_input, Some(Err(()))): error bytes in buffer
+ /// (consumed_from_input, Some(Ok(()))): UTF-8 string in buffer
+ fn try_complete_offsets(&mut self, input: &[u8]) -> (usize, Option<Result<(), ()>>) {
+ let initial_buffer_len = self.buffer_len as usize;
+ let copied_from_input;
+ {
+ let unwritten = &mut self.buffer[initial_buffer_len..];
+ copied_from_input = cmp::min(unwritten.len(), input.len());
+ unwritten[..copied_from_input].copy_from_slice(&input[..copied_from_input]);
+ }
+ let spliced = &self.buffer[..initial_buffer_len + copied_from_input];
+ match str::from_utf8(spliced) {
+ Ok(_) => {
+ self.buffer_len = spliced.len() as u8;
+ (copied_from_input, Some(Ok(())))
+ }
+ Err(error) => {
+ let valid_up_to = error.valid_up_to();
+ if valid_up_to > 0 {
+ let consumed = valid_up_to.checked_sub(initial_buffer_len).unwrap();
+ self.buffer_len = valid_up_to as u8;
+ (consumed, Some(Ok(())))
+ } else {
+ match error.error_len() {
+ Some(invalid_sequence_length) => {
+ let consumed = invalid_sequence_length
+ .checked_sub(initial_buffer_len)
+ .unwrap();
+ self.buffer_len = invalid_sequence_length as u8;
+ (consumed, Some(Err(())))
+ }
+ None => {
+ self.buffer_len = spliced.len() as u8;
+ (copied_from_input, None)
+ }
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/src/uu/wc/src/utf8/read.rs b/src/uu/wc/src/utf8/read.rs
new file mode 100644
index 0000000000000000000000000000000000000000..819b0a6891c539241554bf98469c643857599cfa
--- /dev/null
+++ b/src/uu/wc/src/utf8/read.rs
@@ -0,0 +1,141 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore bytestream
+use super::*;
+use std::error::Error;
+use std::fmt;
+use std::io::{self, BufRead};
+
+/// Wraps a `std::io::BufRead` buffered byte stream and decode it as UTF-8.
+pub struct BufReadDecoder<B: BufRead> {
+ buf_read: B,
+ bytes_consumed: usize,
+ incomplete: Incomplete,
+}
+
+#[derive(Debug)]
+pub enum BufReadDecoderError<'a> {
+ /// Represents one UTF-8 error in the byte stream.
+ ///
+ /// In lossy decoding, each such error should be replaced with U+FFFD.
+ /// (See `BufReadDecoder::next_lossy` and `BufReadDecoderError::lossy`.)
+ InvalidByteSequence(&'a [u8]),
+
+ /// An I/O error from the underlying byte stream
+ Io(io::Error),
+}
+
+impl<'a> fmt::Display for BufReadDecoderError<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ BufReadDecoderError::InvalidByteSequence(bytes) => {
+ write!(f, "invalid byte sequence: {bytes:02x?}")
+ }
+ BufReadDecoderError::Io(ref err) => write!(f, "underlying bytestream error: {err}"),
+ }
+ }
+}
+
+impl<'a> Error for BufReadDecoderError<'a> {
+ fn source(&self) -> Option<&(dyn Error + 'static)> {
+ match *self {
+ BufReadDecoderError::InvalidByteSequence(_) => None,
+ BufReadDecoderError::Io(ref err) => Some(err),
+ }
+ }
+}
+
+impl<B: BufRead> BufReadDecoder<B> {
+ pub fn new(buf_read: B) -> Self {
+ Self {
+ buf_read,
+ bytes_consumed: 0,
+ incomplete: Incomplete::empty(),
+ }
+ }
+
+ /// Decode and consume the next chunk of UTF-8 input.
+ ///
+ /// This method is intended to be called repeatedly until it returns `None`,
+ /// which represents EOF from the underlying byte stream.
+ /// This is similar to `Iterator::next`,
+ /// except that decoded chunks borrow the decoder (~iterator)
+ /// so they need to be handled or copied before the next chunk can start decoding.
+ #[allow(clippy::cognitive_complexity)]
+ pub fn next_strict(&mut self) -> Option<Result<&str, BufReadDecoderError>> {
+ enum BytesSource {
+ BufRead(usize),
+ Incomplete,
+ }
+ macro_rules! try_io {
+ ($io_result: expr) => {
+ match $io_result {
+ Ok(value) => value,
+ Err(error) => return Some(Err(BufReadDecoderError::Io(error))),
+ }
+ };
+ }
+ let (source, result) = loop {
+ if self.bytes_consumed > 0 {
+ self.buf_read.consume(self.bytes_consumed);
+ self.bytes_consumed = 0;
+ }
+ let buf = try_io!(self.buf_read.fill_buf());
+
+ // Force loop iteration to go through an explicit `continue`
+ enum Unreachable {}
+ let _: Unreachable = if self.incomplete.is_empty() {
+ if buf.is_empty() {
+ return None; // EOF
+ }
+ match str::from_utf8(buf) {
+ Ok(_) => break (BytesSource::BufRead(buf.len()), Ok(())),
+ Err(error) => {
+ let valid_up_to = error.valid_up_to();
+ if valid_up_to > 0 {
+ break (BytesSource::BufRead(valid_up_to), Ok(()));
+ }
+ match error.error_len() {
+ Some(invalid_sequence_length) => {
+ break (BytesSource::BufRead(invalid_sequence_length), Err(()))
+ }
+ None => {
+ self.bytes_consumed = buf.len();
+ self.incomplete = Incomplete::new(buf);
+ // need more input bytes
+ continue;
+ }
+ }
+ }
+ }
+ } else {
+ if buf.is_empty() {
+ break (BytesSource::Incomplete, Err(())); // EOF with incomplete code point
+ }
+ let (consumed, opt_result) = self.incomplete.try_complete_offsets(buf);
+ self.bytes_consumed = consumed;
+ match opt_result {
+ None => {
+ // need more input bytes
+ continue;
+ }
+ Some(result) => break (BytesSource::Incomplete, result),
+ }
+ };
+ };
+ let bytes = match source {
+ BytesSource::BufRead(byte_count) => {
+ self.bytes_consumed = byte_count;
+ let buf = try_io!(self.buf_read.fill_buf());
+ &buf[..byte_count]
+ }
+ BytesSource::Incomplete => self.incomplete.take_buffer(),
+ };
+ match result {
+ Ok(()) => Some(Ok(unsafe { str::from_utf8_unchecked(bytes) })),
+ Err(()) => Some(Err(BufReadDecoderError::InvalidByteSequence(bytes))),
+ }
+ }
+}
diff --git a/src/uu/wc/src/wc.rs b/src/uu/wc/src/wc.rs
index 135575d71b9086c5c4f9bd33407c2c88b0da4654..33b70ee62f5ba98b743c07fb0f43429be1250e65 100644
--- a/src/uu/wc/src/wc.rs
+++ b/src/uu/wc/src/wc.rs
@@ -1,61 +1,82 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Boden Garman <bpgarman@gmail.com>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-// cSpell:ignore wc wc's
+// cSpell:ignore ilog wc wc's
mod count_fast;
mod countable;
+mod utf8;
mod word_count;
-use clap::builder::ValueParser;
-use count_fast::{count_bytes_chars_and_lines_fast, count_bytes_fast};
-use countable::WordCountable;
+
+use std::{
+ borrow::{Borrow, Cow},
+ cmp::max,
+ ffi::OsString,
+ fs::{self, File},
+ io::{self, Write},
+ iter,
+ path::{Path, PathBuf},
+};
+
+use clap::{builder::ValueParser, crate_version, Arg, ArgAction, ArgMatches, Command};
+use thiserror::Error;
use unicode_width::UnicodeWidthChar;
use utf8::{BufReadDecoder, BufReadDecoderError};
-use uucore::{format_usage, show};
-use word_count::{TitledWordCount, WordCount};
-
-use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
-use std::cmp::max;
-use std::error::Error;
-use std::ffi::{OsStr, OsString};
-use std::fmt::Display;
-use std::fs::{self, File};
-use std::io::{self, Read, Write};
-use std::path::PathBuf;
+use uucore::{
+ error::{FromIo, UError, UResult},
+ format_usage, help_about, help_usage,
+ quoting_style::{escape_name, QuotingStyle},
+ shortcut_value_parser::ShortcutValueParser,
+ show,
+};
-use uucore::error::{UError, UResult, USimpleError};
-use uucore::quoting_style::{escape_name, QuotingStyle};
+use crate::{
+ count_fast::{count_bytes_chars_and_lines_fast, count_bytes_fast},
+ countable::WordCountable,
+ word_count::WordCount,
+};
/// The minimum character width for formatting counts when reading from stdin.
const MINIMUM_WIDTH: usize = 7;
-struct Settings {
+struct Settings<'a> {
show_bytes: bool,
show_chars: bool,
show_lines: bool,
show_words: bool,
show_max_line_length: bool,
- files0_from_stdin_mode: bool,
- title_quoting_style: QuotingStyle,
+ files0_from: Option<Input<'a>>,
+ total_when: TotalWhen,
}
-impl Settings {
- fn new(matches: &ArgMatches) -> Self {
- let title_quoting_style = QuotingStyle::Shell {
- escape: true,
- always_quote: false,
- show_control: false,
- };
+impl Default for Settings<'_> {
+ fn default() -> Self {
+ // Defaults if none of -c, -m, -l, -w, nor -L are specified.
+ Self {
+ show_bytes: true,
+ show_chars: false,
+ show_lines: true,
+ show_words: true,
+ show_max_line_length: false,
+ files0_from: None,
+ total_when: TotalWhen::default(),
+ }
+ }
+}
- let files0_from_stdin_mode = match matches.get_one::<String>(options::FILES0_FROM) {
- Some(files_0_from) => files_0_from == STDIN_REPR,
- None => false,
- };
+impl<'a> Settings<'a> {
+ fn new(matches: &'a ArgMatches) -> Self {
+ let files0_from = matches
+ .get_one::<OsString>(options::FILES0_FROM)
+ .map(Into::into);
+
+ let total_when = matches
+ .get_one::<String>(options::TOTAL)
+ .map(Into::into)
+ .unwrap_or_default();
let settings = Self {
show_bytes: matches.get_flag(options::BYTES),
@@ -63,141 +84,308 @@ impl Settings {
show_lines: matches.get_flag(options::LINES),
show_words: matches.get_flag(options::WORDS),
show_max_line_length: matches.get_flag(options::MAX_LINE_LENGTH),
- files0_from_stdin_mode,
- title_quoting_style,
+ files0_from,
+ total_when,
};
- if settings.show_bytes
- || settings.show_chars
- || settings.show_lines
- || settings.show_words
- || settings.show_max_line_length
- {
- return settings;
- }
-
- Self {
- show_bytes: true,
- show_chars: false,
- show_lines: true,
- show_words: true,
- show_max_line_length: false,
- files0_from_stdin_mode,
- title_quoting_style: settings.title_quoting_style,
+ if settings.number_enabled() > 0 {
+ settings
+ } else {
+ Self {
+ files0_from: settings.files0_from,
+ total_when,
+ ..Default::default()
+ }
}
}
fn number_enabled(&self) -> u32 {
- let mut result = 0;
- result += self.show_bytes as u32;
- result += self.show_chars as u32;
- result += self.show_lines as u32;
- result += self.show_max_line_length as u32;
- result += self.show_words as u32;
- result
+ [
+ self.show_bytes,
+ self.show_chars,
+ self.show_lines,
+ self.show_max_line_length,
+ self.show_words,
+ ]
+ .into_iter()
+ .map(Into::<u32>::into)
+ .sum()
}
}
-static ABOUT: &str = "Display newline, word, and byte counts for each FILE, and a total line if
-more than one FILE is specified. With no FILE, or when FILE is -, read standard input.";
-const USAGE: &str = "{} [OPTION]... [FILE]...";
+const ABOUT: &str = help_about!("wc.md");
+const USAGE: &str = help_usage!("wc.md");
-pub mod options {
+mod options {
pub static BYTES: &str = "bytes";
pub static CHAR: &str = "chars";
pub static FILES0_FROM: &str = "files0-from";
pub static LINES: &str = "lines";
pub static MAX_LINE_LENGTH: &str = "max-line-length";
+ pub static TOTAL: &str = "total";
pub static WORDS: &str = "words";
}
-
static ARG_FILES: &str = "files";
static STDIN_REPR: &str = "-";
+static QS_ESCAPE: &QuotingStyle = &QuotingStyle::Shell {
+ escape: true,
+ always_quote: false,
+ show_control: false,
+};
+static QS_QUOTE_ESCAPE: &QuotingStyle = &QuotingStyle::Shell {
+ escape: true,
+ always_quote: true,
+ show_control: false,
+};
+
+/// Supported inputs.
+#[derive(Debug)]
+enum Inputs<'a> {
+ /// Default Standard input, i.e. no arguments.
+ Stdin,
+ /// Files; "-" means stdin, possibly multiple times!
+ Paths(Vec<Input<'a>>),
+ /// --files0-from; "-" means stdin.
+ Files0From(Input<'a>),
+}
+
+impl<'a> Inputs<'a> {
+ fn new(matches: &'a ArgMatches) -> UResult<Self> {
+ let arg_files = matches.get_many::<OsString>(ARG_FILES);
+ let files0_from = matches.get_one::<OsString>(options::FILES0_FROM);
+
+ match (arg_files, files0_from) {
+ (None, None) => Ok(Self::Stdin),
+ (Some(files), None) => Ok(Self::Paths(files.map(Into::into).collect())),
+ (None, Some(path)) => {
+ // If path is a file, and the file isn't too large, we'll load it ahead
+ // of time. Every path within the file will have its length checked to
+ // hopefully better align the output columns.
+ let input = Input::from(path);
+ match input.try_as_files0()? {
+ Some(paths) => Ok(Self::Paths(paths)),
+ None => Ok(Self::Files0From(input)),
+ }
+ }
+ (Some(mut files), Some(_)) => {
+ Err(WcError::files_disabled(files.next().unwrap()).into())
+ }
+ }
+ }
+
+ // Creates an iterator which yields values borrowed from the command line arguments.
+ // Returns an error if the file specified in --files0-from cannot be opened.
+ fn try_iter(
+ &'a self,
+ settings: &'a Settings<'a>,
+ ) -> UResult<impl Iterator<Item = InputIterItem<'a>>> {
+ let base: Box<dyn Iterator<Item = _>> = match self {
+ Self::Stdin => Box::new(iter::once(Ok(Input::Stdin(StdinKind::Implicit)))),
+ Self::Paths(inputs) => Box::new(inputs.iter().map(|i| Ok(i.as_borrowed()))),
+ Self::Files0From(input) => match input {
+ Input::Path(path) => Box::new(files0_iter_file(path)?),
+ Input::Stdin(_) => Box::new(files0_iter_stdin()),
+ },
+ };
+
+ // The 1-based index of each yielded item must be tracked for error reporting.
+ let mut with_idx = base.enumerate().map(|(i, v)| (i + 1, v));
+ let files0_from_path = settings.files0_from.as_ref().map(Input::as_borrowed);
+
+ let iter = iter::from_fn(move || {
+ let (idx, next) = with_idx.next()?;
+ match next {
+ // filter zero length file names...
+ Ok(Input::Path(p)) if p.as_os_str().is_empty() => Some(Err({
+ let maybe_ctx = files0_from_path.as_ref().map(|p| (p, idx));
+ WcError::zero_len(maybe_ctx).into()
+ })),
+ _ => Some(next),
+ }
+ });
+ Ok(iter)
+ }
+}
+
+#[derive(Clone, Copy, Debug)]
enum StdinKind {
- /// Stdin specified on command-line with "-".
+ /// Specified on command-line with "-" (STDIN_REPR)
Explicit,
-
- /// Stdin implicitly specified on command-line by not passing any positional argument.
+ /// Implied by the lack of any arguments
Implicit,
}
-/// Supported inputs.
-enum Input {
- /// A regular file.
- Path(PathBuf),
-
- /// Standard input.
+/// Represents a single input, either to be counted or processed for other files names via
+/// --files0-from.
+#[derive(Debug)]
+enum Input<'a> {
+ Path(Cow<'a, Path>),
Stdin(StdinKind),
}
-impl From<&OsStr> for Input {
- fn from(input: &OsStr) -> Self {
- if input == STDIN_REPR {
+impl From<PathBuf> for Input<'_> {
+ fn from(p: PathBuf) -> Self {
+ if p.as_os_str() == STDIN_REPR {
+ Self::Stdin(StdinKind::Explicit)
+ } else {
+ Self::Path(Cow::Owned(p))
+ }
+ }
+}
+
+impl<'a, T: AsRef<Path> + ?Sized> From<&'a T> for Input<'a> {
+ fn from(p: &'a T) -> Self {
+ let p = p.as_ref();
+ if p.as_os_str() == STDIN_REPR {
Self::Stdin(StdinKind::Explicit)
} else {
- Self::Path(input.into())
+ Self::Path(Cow::Borrowed(p))
}
}
}
-impl Input {
+impl<'a> Input<'a> {
+ /// Translates Path(Cow::Owned(_)) to Path(Cow::Borrowed(_)).
+ fn as_borrowed(&'a self) -> Self {
+ match self {
+ Self::Path(p) => Self::Path(Cow::Borrowed(p.borrow())),
+ Self::Stdin(k) => Self::Stdin(*k),
+ }
+ }
+
/// Converts input to title that appears in stats.
- fn to_title(&self, quoting_style: &QuotingStyle) -> Option<String> {
+ fn to_title(&self) -> Option<Cow<str>> {
match self {
- Self::Path(path) => Some(escape_name(&path.clone().into_os_string(), quoting_style)),
- Self::Stdin(StdinKind::Explicit) => {
- Some(escape_name(OsStr::new(STDIN_REPR), quoting_style))
- }
+ Self::Path(path) => Some(match path.to_str() {
+ Some(s) if !s.contains('\n') => Cow::Borrowed(s),
+ _ => Cow::Owned(escape_name(path.as_os_str(), QS_ESCAPE)),
+ }),
+ Self::Stdin(StdinKind::Explicit) => Some(Cow::Borrowed(STDIN_REPR)),
Self::Stdin(StdinKind::Implicit) => None,
}
}
- fn path_display(&self, quoting_style: &QuotingStyle) -> String {
+ /// Converts input into the form that appears in errors.
+ fn path_display(&self) -> String {
match self {
- Self::Path(path) => escape_name(&path.clone().into_os_string(), quoting_style),
- Self::Stdin(_) => escape_name(OsStr::new("standard input"), quoting_style),
+ Self::Path(path) => escape_name(path.as_os_str(), QS_ESCAPE),
+ Self::Stdin(_) => String::from("standard input"),
+ }
+ }
+
+ /// When given --files0-from, we may be given a path or stdin. Either may be a stream or
+ /// a regular file. If given a file less than 10 MiB, it will be consumed and turned into
+ /// a Vec of Input::Paths which can be scanned to determine the widths of the columns that
+ /// will ultimately be printed.
+ fn try_as_files0(&self) -> UResult<Option<Vec<Input<'static>>>> {
+ match self {
+ Self::Path(path) => match fs::metadata(path) {
+ Ok(meta) if meta.is_file() && meta.len() <= (10 << 20) => Ok(Some(
+ files0_iter_file(path)?.collect::<Result<Vec<_>, _>>()?,
+ )),
+ _ => Ok(None),
+ },
+ Self::Stdin(_) if is_stdin_small_file() => {
+ Ok(Some(files0_iter_stdin().collect::<Result<Vec<_>, _>>()?))
+ }
+ Self::Stdin(_) => Ok(None),
}
}
}
-#[derive(Debug)]
-enum WcError {
- FilesDisabled(String),
- StdinReprNotAllowed(String),
+#[cfg(unix)]
+fn is_stdin_small_file() -> bool {
+ use std::os::unix::io::{AsRawFd, FromRawFd};
+ // Safety: we'll rely on Rust to give us a valid RawFd for stdin with which we can attempt to
+ // open a File, but only for the sake of fetching .metadata(). ManuallyDrop will ensure we
+ // don't do anything else to the FD if anything unexpected happens.
+ let f = std::mem::ManuallyDrop::new(unsafe { File::from_raw_fd(io::stdin().as_raw_fd()) });
+ matches!(f.metadata(), Ok(meta) if meta.is_file() && meta.len() <= (10 << 20))
}
-impl UError for WcError {
- fn code(&self) -> i32 {
- match self {
- Self::FilesDisabled(_) | Self::StdinReprNotAllowed(_) => 1,
+#[cfg(not(unix))]
+// Windows presents a piped stdin as a "normal file" with a length equal to however many bytes
+// have been buffered at the time it's checked. To be safe, we must never assume it's a file.
+fn is_stdin_small_file() -> bool {
+ false
+}
+
+/// When to show the "total" line
+#[derive(Clone, Copy, Default, PartialEq)]
+enum TotalWhen {
+ #[default]
+ Auto,
+ Always,
+ Only,
+ Never,
+}
+
+impl<T: AsRef<str>> From<T> for TotalWhen {
+ fn from(s: T) -> Self {
+ match s.as_ref() {
+ "auto" => Self::Auto,
+ "always" => Self::Always,
+ "only" => Self::Only,
+ "never" => Self::Never,
+ _ => unreachable!("Should have been caught by clap"),
}
}
+}
- fn usage(&self) -> bool {
- matches!(self, Self::FilesDisabled(_))
+impl TotalWhen {
+ fn is_total_row_visible(&self, num_inputs: usize) -> bool {
+ match self {
+ Self::Auto => num_inputs > 1,
+ Self::Always | Self::Only => true,
+ Self::Never => false,
+ }
}
}
-impl Error for WcError {}
+#[derive(Debug, Error)]
+enum WcError {
+ #[error("extra operand '{extra}'\nfile operands cannot be combined with --files0-from")]
+ FilesDisabled { extra: Cow<'static, str> },
+ #[error("when reading file names from stdin, no file name of '-' allowed")]
+ StdinReprNotAllowed,
+ #[error("invalid zero-length file name")]
+ ZeroLengthFileName,
+ #[error("{path}:{idx}: invalid zero-length file name")]
+ ZeroLengthFileNameCtx { path: Cow<'static, str>, idx: usize },
+}
-impl Display for WcError {
- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- match self {
- Self::FilesDisabled(message) | Self::StdinReprNotAllowed(message) => {
- write!(f, "{}", message)
+impl WcError {
+ fn zero_len(ctx: Option<(&Input, usize)>) -> Self {
+ match ctx {
+ Some((input, idx)) => {
+ let path = match input {
+ Input::Stdin(_) => STDIN_REPR.into(),
+ Input::Path(path) => escape_name(path.as_os_str(), QS_ESCAPE).into(),
+ };
+ Self::ZeroLengthFileNameCtx { path, idx }
}
+ None => Self::ZeroLengthFileName,
}
}
+ fn files_disabled(first_extra: &OsString) -> Self {
+ let extra = first_extra.to_string_lossy().into_owned().into();
+ Self::FilesDisabled { extra }
+ }
+}
+
+impl UError for WcError {
+ fn usage(&self) -> bool {
+ matches!(self, Self::FilesDisabled { .. })
+ }
}
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let matches = uu_app().try_get_matches_from(args)?;
- let inputs = inputs(&matches)?;
-
let settings = Settings::new(&matches);
+ let inputs = Inputs::new(&matches)?;
wc(&inputs, &settings)
}
@@ -208,6 +396,7 @@ pub fn uu_app() -> Command {
.about(ABOUT)
.override_usage(format_usage(USAGE))
.infer_long_args(true)
+ .args_override_self(true)
.arg(
Arg::new(options::BYTES)
.short('c')
@@ -226,11 +415,12 @@ pub fn uu_app() -> Command {
Arg::new(options::FILES0_FROM)
.long(options::FILES0_FROM)
.value_name("F")
- .help(
- "read input from the files specified by
- NUL-terminated names in file F;
- If F is - then read names from standard input",
- )
+ .help(concat!(
+ "read input from the files specified by\n",
+ " NUL-terminated names in file F;\n",
+ " If F is - then read names from standard input"
+ ))
+ .value_parser(ValueParser::os_string())
.value_hint(clap::ValueHint::FilePath),
)
.arg(
@@ -247,6 +437,19 @@ pub fn uu_app() -> Command {
.help("print the length of the longest line")
.action(ArgAction::SetTrue),
)
+ .arg(
+ Arg::new(options::TOTAL)
+ .long(options::TOTAL)
+ .value_parser(ShortcutValueParser::new([
+ "auto", "always", "only", "never",
+ ]))
+ .value_name("WHEN")
+ .hide_possible_values(true)
+ .help(concat!(
+ "when to print a line with total counts;\n",
+ " WHEN can be: auto, always, only, never"
+ )),
+ )
.arg(
Arg::new(options::WORDS)
.short('w')
@@ -262,47 +465,6 @@ pub fn uu_app() -> Command {
)
}
-fn inputs(matches: &ArgMatches) -> UResult<Vec<Input>> {
- match matches.get_many::<OsString>(ARG_FILES) {
- Some(os_values) => {
- if matches.contains_id(options::FILES0_FROM) {
- return Err(WcError::FilesDisabled(
- "file operands cannot be combined with --files0-from".into(),
- )
- .into());
- }
-
- Ok(os_values.map(|s| Input::from(s.as_os_str())).collect())
- }
- None => match matches.get_one::<String>(options::FILES0_FROM) {
- Some(files_0_from) => create_paths_from_files0(files_0_from),
- None => Ok(vec![Input::Stdin(StdinKind::Implicit)]),
- },
- }
-}
-
-fn create_paths_from_files0(files_0_from: &str) -> UResult<Vec<Input>> {
- let mut paths = String::new();
- let read_from_stdin = files_0_from == STDIN_REPR;
-
- if read_from_stdin {
- io::stdin().lock().read_to_string(&mut paths)?;
- } else {
- File::open(files_0_from)?.read_to_string(&mut paths)?;
- }
-
- let paths: Vec<&str> = paths.split_terminator('\0').collect();
-
- if read_from_stdin && paths.contains(&STDIN_REPR) {
- return Err(WcError::StdinReprNotAllowed(
- "when reading file names from stdin, no file name of '-' allowed".into(),
- )
- .into());
- }
-
- Ok(paths.iter().map(OsStr::new).map(Input::from).collect())
-}
-
fn word_count_from_reader<T: WordCountable>(
mut reader: T,
settings: &Settings,
@@ -367,11 +529,11 @@ fn word_count_from_reader<T: WordCountable>(
(_, false, false, true, true) => {
word_count_from_reader_specialized::<_, false, false, true, true>(reader)
}
- // show_chars, show_words
+ // show_lines, show_words
(_, false, true, false, true) => {
word_count_from_reader_specialized::<_, false, true, false, true>(reader)
}
- // show_chars, show_lines
+ // show_lines, show_max_line_length
(_, false, true, true, false) => {
word_count_from_reader_specialized::<_, false, true, true, false>(reader)
}
@@ -406,6 +568,64 @@ fn word_count_from_reader<T: WordCountable>(
}
}
+fn process_chunk<
+ const SHOW_CHARS: bool,
+ const SHOW_LINES: bool,
+ const SHOW_MAX_LINE_LENGTH: bool,
+ const SHOW_WORDS: bool,
+>(
+ total: &mut WordCount,
+ text: &str,
+ current_len: &mut usize,
+ in_word: &mut bool,
+) {
+ for ch in text.chars() {
+ if SHOW_WORDS {
+ if ch.is_whitespace() {
+ *in_word = false;
+ } else if !(*in_word) {
+ // This also counts control characters! (As of GNU coreutils 9.5)
+ *in_word = true;
+ total.words += 1;
+ }
+ }
+ if SHOW_MAX_LINE_LENGTH {
+ match ch {
+ '\n' | '\r' | '\x0c' => {
+ total.max_line_length = max(*current_len, total.max_line_length);
+ *current_len = 0;
+ }
+ '\t' => {
+ *current_len -= *current_len % 8;
+ *current_len += 8;
+ }
+ _ => {
+ *current_len += ch.width().unwrap_or(0);
+ }
+ }
+ }
+ if SHOW_LINES && ch == '\n' {
+ total.lines += 1;
+ }
+ if SHOW_CHARS {
+ total.chars += 1;
+ }
+ }
+ total.bytes += text.len();
+
+ total.max_line_length = max(*current_len, total.max_line_length);
+}
+
+fn handle_error(error: BufReadDecoderError<'_>, total: &mut WordCount) -> Option<io::Error> {
+ match error {
+ BufReadDecoderError::InvalidByteSequence(bytes) => {
+ total.bytes += bytes.len();
+ }
+ BufReadDecoderError::Io(e) => return Some(e),
+ }
+ None
+}
+
fn word_count_from_reader_specialized<
T: WordCountable,
const SHOW_CHARS: bool,
@@ -419,58 +639,24 @@ fn word_count_from_reader_specialized<
let mut reader = BufReadDecoder::new(reader.buffered());
let mut in_word = false;
let mut current_len = 0;
-
while let Some(chunk) = reader.next_strict() {
match chunk {
Ok(text) => {
- for ch in text.chars() {
- if SHOW_WORDS {
- if ch.is_whitespace() {
- in_word = false;
- } else if ch.is_ascii_control() {
- // These count as characters but do not affect the word state
- } else if !in_word {
- in_word = true;
- total.words += 1;
- }
- }
- if SHOW_MAX_LINE_LENGTH {
- match ch {
- '\n' | '\r' | '\x0c' => {
- total.max_line_length = max(current_len, total.max_line_length);
- current_len = 0;
- }
- '\t' => {
- current_len -= current_len % 8;
- current_len += 8;
- }
- _ => {
- current_len += ch.width().unwrap_or(0);
- }
- }
- }
- if SHOW_LINES && ch == '\n' {
- total.lines += 1;
- }
- if SHOW_CHARS {
- total.chars += 1;
- }
- }
- total.bytes += text.len();
+ process_chunk::<SHOW_CHARS, SHOW_LINES, SHOW_MAX_LINE_LENGTH, SHOW_WORDS>(
+ &mut total,
+ text,
+ &mut current_len,
+ &mut in_word,
+ );
}
- Err(BufReadDecoderError::InvalidByteSequence(bytes)) => {
- // GNU wc treats invalid data as neither word nor char nor whitespace,
- // so no other counters are affected
- total.bytes += bytes.len();
- }
- Err(BufReadDecoderError::Io(e)) => {
- return (total, Some(e));
+ Err(e) => {
+ if let Some(e) = handle_error(e, &mut total) {
+ return (total, Some(e));
+ }
}
}
}
- total.max_line_length = max(current_len, total.max_line_length);
-
(total, None)
}
@@ -483,171 +669,224 @@ enum CountResult {
Failure(io::Error),
}
-/// If we fail opening a file we only show the error. If we fail reading it
-/// we show a count for what we managed to read.
+/// If we fail opening a file, we only show the error. If we fail reading the
+/// file, we show a count for what we managed to read.
///
-/// Therefore the reading implementations always return a total and sometimes
+/// Therefore, the reading implementations always return a total and sometimes
/// return an error: (WordCount, Option<io::Error>).
-fn word_count_from_input(input: &Input, settings: &Settings) -> CountResult {
- match input {
- Input::Stdin(_) => {
- let stdin = io::stdin();
- let stdin_lock = stdin.lock();
- let count = word_count_from_reader(stdin_lock, settings);
- match count {
- (total, Some(error)) => CountResult::Interrupted(total, error),
- (total, None) => CountResult::Success(total),
- }
- }
+fn word_count_from_input(input: &Input<'_>, settings: &Settings) -> CountResult {
+ let (total, maybe_err) = match input {
+ Input::Stdin(_) => word_count_from_reader(io::stdin().lock(), settings),
Input::Path(path) => match File::open(path) {
- Err(error) => CountResult::Failure(error),
- Ok(file) => match word_count_from_reader(file, settings) {
- (total, Some(error)) => CountResult::Interrupted(total, error),
- (total, None) => CountResult::Success(total),
- },
+ Ok(f) => word_count_from_reader(f, settings),
+ Err(err) => return CountResult::Failure(err),
},
+ };
+ match maybe_err {
+ None => CountResult::Success(total),
+ Some(err) => CountResult::Interrupted(total, err),
}
}
/// Compute the number of digits needed to represent all counts in all inputs.
///
-/// `inputs` may include zero or more [`Input::Stdin`] entries, each of
-/// which represents reading from `stdin`. The presence of any such
-/// entry causes this function to return a width that is at least
-/// [`MINIMUM_WIDTH`].
+/// For [`Inputs::Stdin`], [`MINIMUM_WIDTH`] is returned, unless there is only one counter number
+/// to be printed, in which case 1 is returned.
///
-/// If `input` is empty, or if only one number needs to be printed (for just
-/// one file) then this function is optimized to return 1 without making any
-/// calls to get file metadata.
+/// For [`Inputs::Files0From`], [`MINIMUM_WIDTH`] is returned.
///
-/// If file metadata could not be read from any of the [`Input::Path`] input,
-/// that input does not affect number width computation
+/// An [`Inputs::Paths`] may include zero or more "-" entries, each of which represents reading
+/// from `stdin`. The presence of any such entry causes this function to return a width that is at
+/// least [`MINIMUM_WIDTH`].
///
-/// Otherwise, the file sizes in the file metadata are summed and the number of
-/// digits in that total size is returned as the number width
+/// If an [`Inputs::Paths`] contains only one path and only one number needs to be printed then
+/// this function is optimized to return 1 without making any calls to get file metadata.
///
-/// To mirror GNU wc's behavior a special case is added. If --files0-from is
-/// used and input is read from stdin and there is only one calculation enabled
-/// columns will not be aligned. This is not exactly GNU wc's behavior, but it
-/// is close enough to pass the GNU test suite.
-fn compute_number_width(inputs: &[Input], settings: &Settings) -> usize {
- if inputs.is_empty()
- || (inputs.len() == 1 && settings.number_enabled() == 1)
- || (settings.files0_from_stdin_mode && settings.number_enabled() == 1)
- {
- return 1;
- }
-
- let mut minimum_width = 1;
- let mut total = 0;
-
- for input in inputs {
- match input {
- Input::Stdin(_) => {
- minimum_width = MINIMUM_WIDTH;
+/// If file metadata could not be read from any of the [`Input::Path`] input, that input does not
+/// affect number width computation. Otherwise, the file sizes from the files' metadata are summed
+/// and the number of digits in that total size is returned.
+fn compute_number_width(inputs: &Inputs, settings: &Settings) -> usize {
+ match inputs {
+ Inputs::Stdin if settings.number_enabled() == 1 => 1,
+ Inputs::Stdin => MINIMUM_WIDTH,
+ Inputs::Files0From(_) => 1,
+ Inputs::Paths(inputs) => {
+ if settings.number_enabled() == 1 && inputs.len() == 1 {
+ return 1;
}
- Input::Path(path) => {
- if let Ok(meta) = fs::metadata(path) {
- if meta.is_file() {
- total += meta.len();
- } else {
- minimum_width = MINIMUM_WIDTH;
+
+ let mut minimum_width = 1;
+ let mut total: u64 = 0;
+ for input in inputs {
+ match input {
+ Input::Stdin(_) => minimum_width = MINIMUM_WIDTH,
+ Input::Path(path) => {
+ if let Ok(meta) = fs::metadata(path) {
+ if meta.is_file() {
+ total += meta.len();
+ } else {
+ minimum_width = MINIMUM_WIDTH;
+ }
+ }
}
}
}
+
+ if total == 0 {
+ minimum_width
+ } else {
+ let total_width = (1 + total.ilog10())
+ .try_into()
+ .expect("ilog of a u64 should fit into a usize");
+ max(total_width, minimum_width)
+ }
}
}
+}
- max(minimum_width, total.to_string().len())
+type InputIterItem<'a> = Result<Input<'a>, Box<dyn UError>>;
+
+/// To be used with `--files0-from=-`, this applies a filter on the results of files0_iter to
+/// translate '-' into the appropriate error.
+fn files0_iter_stdin<'a>() -> impl Iterator<Item = InputIterItem<'a>> {
+ files0_iter(io::stdin().lock(), STDIN_REPR.into()).map(|i| match i {
+ Ok(Input::Stdin(_)) => Err(WcError::StdinReprNotAllowed.into()),
+ _ => i,
+ })
}
-fn wc(inputs: &[Input], settings: &Settings) -> UResult<()> {
- let number_width = compute_number_width(inputs, settings);
+fn files0_iter_file<'a>(path: &Path) -> UResult<impl Iterator<Item = InputIterItem<'a>>> {
+ match File::open(path) {
+ Ok(f) => Ok(files0_iter(f, path.into())),
+ Err(e) => Err(e.map_err_context(|| {
+ format!(
+ "cannot open {} for reading",
+ escape_name(path.as_os_str(), QS_QUOTE_ESCAPE)
+ )
+ })),
+ }
+}
+
+fn files0_iter<'a>(
+ r: impl io::Read + 'static,
+ err_path: OsString,
+) -> impl Iterator<Item = InputIterItem<'a>> {
+ use std::io::BufRead;
+ let mut i = Some(
+ io::BufReader::new(r)
+ .split(b'\0')
+ .map(move |res| match res {
+ Ok(p) if p == STDIN_REPR.as_bytes() => Ok(Input::Stdin(StdinKind::Explicit)),
+ Ok(p) => {
+ // On Unix systems, OsStrings are just strings of bytes, not necessarily UTF-8.
+ #[cfg(unix)]
+ {
+ use std::os::unix::ffi::OsStringExt;
+ Ok(Input::Path(PathBuf::from(OsString::from_vec(p)).into()))
+ }
+ // ...Windows does not, we must go through Strings.
+ #[cfg(not(unix))]
+ {
+ let s = String::from_utf8(p)
+ .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+ Ok(Input::Path(PathBuf::from(s).into()))
+ }
+ }
+ Err(e) => Err(e.map_err_context(|| {
+ format!("{}: read error", escape_name(&err_path, QS_ESCAPE))
+ }) as Box<dyn UError>),
+ }),
+ );
+ // Loop until there is an error; yield that error and then nothing else.
+ std::iter::from_fn(move || {
+ let next = i.as_mut().and_then(Iterator::next);
+ if matches!(next, Some(Err(_)) | None) {
+ i = None;
+ }
+ next
+ })
+}
+
+fn wc(inputs: &Inputs, settings: &Settings) -> UResult<()> {
let mut total_word_count = WordCount::default();
+ let mut num_inputs: usize = 0;
+
+ let (number_width, are_stats_visible) = match settings.total_when {
+ TotalWhen::Only => (1, false),
+ _ => (compute_number_width(inputs, settings), true),
+ };
- let num_inputs = inputs.len();
+ for maybe_input in inputs.try_iter(settings)? {
+ num_inputs += 1;
+
+ let input = match maybe_input {
+ Ok(input) => input,
+ Err(err) => {
+ show!(err);
+ continue;
+ }
+ };
- for input in inputs {
- let word_count = match word_count_from_input(input, settings) {
+ let word_count = match word_count_from_input(&input, settings) {
CountResult::Success(word_count) => word_count,
- CountResult::Interrupted(word_count, error) => {
- show!(USimpleError::new(
- 1,
- format!(
- "{}: {}",
- input.path_display(&settings.title_quoting_style),
- error
- )
- ));
+ CountResult::Interrupted(word_count, err) => {
+ show!(err.map_err_context(|| input.path_display()));
word_count
}
- CountResult::Failure(error) => {
- show!(USimpleError::new(
- 1,
- format!(
- "{}: {}",
- input.path_display(&settings.title_quoting_style),
- error
- )
- ));
+ CountResult::Failure(err) => {
+ show!(err.map_err_context(|| input.path_display()));
continue;
}
};
total_word_count += word_count;
- let result = word_count.with_title(input.to_title(&settings.title_quoting_style));
- if let Err(err) = print_stats(settings, &result, number_width) {
- show!(USimpleError::new(
- 1,
- format!(
- "failed to print result for {}: {}",
- &result.title.unwrap_or_else(|| String::from("<stdin>")),
- err,
- ),
- ));
+ if are_stats_visible {
+ let maybe_title = input.to_title();
+ let maybe_title_str = maybe_title.as_deref();
+ if let Err(err) = print_stats(settings, &word_count, maybe_title_str, number_width) {
+ let title = maybe_title_str.unwrap_or("<stdin>");
+ show!(err.map_err_context(|| format!("failed to print result for {title}")));
+ }
}
}
- if num_inputs > 1 {
- let total_result = total_word_count.with_title(Some(String::from("total")));
- if let Err(err) = print_stats(settings, &total_result, number_width) {
- show!(USimpleError::new(
- 1,
- format!("failed to print total: {}", err)
- ));
+ if settings.total_when.is_total_row_visible(num_inputs) {
+ let title = are_stats_visible.then_some("total");
+ if let Err(err) = print_stats(settings, &total_word_count, title, number_width) {
+ show!(err.map_err_context(|| "failed to print total".into()));
}
}
- // Although this appears to be returning `Ok`, the exit code may
- // have been set to a non-zero value by a call to `show!()` above.
+ // Although this appears to be returning `Ok`, the exit code may have been set to a non-zero
+ // value by a call to `record_error!()` above.
Ok(())
}
fn print_stats(
settings: &Settings,
- result: &TitledWordCount,
+ result: &WordCount,
+ title: Option<&str>,
number_width: usize,
) -> io::Result<()> {
- let mut columns = Vec::new();
-
- if settings.show_lines {
- columns.push(format!("{:1$}", result.count.lines, number_width));
- }
- if settings.show_words {
- columns.push(format!("{:1$}", result.count.words, number_width));
- }
- if settings.show_chars {
- columns.push(format!("{:1$}", result.count.chars, number_width));
- }
- if settings.show_bytes {
- columns.push(format!("{:1$}", result.count.bytes, number_width));
- }
- if settings.show_max_line_length {
- columns.push(format!("{:1$}", result.count.max_line_length, number_width));
- }
- if let Some(title) = &result.title {
- columns.push(title.clone());
+ let mut stdout = io::stdout().lock();
+
+ let maybe_cols = [
+ (settings.show_lines, result.lines),
+ (settings.show_words, result.words),
+ (settings.show_chars, result.chars),
+ (settings.show_bytes, result.bytes),
+ (settings.show_max_line_length, result.max_line_length),
+ ];
+
+ let mut space = "";
+ for (_, num) in maybe_cols.iter().filter(|(show, _)| *show) {
+ write!(stdout, "{space}{num:number_width$}")?;
+ space = " ";
}
- writeln!(io::stdout().lock(), "{}", columns.join(" "))
+ if let Some(title) = title {
+ writeln!(stdout, "{space}{title}")
+ } else {
+ writeln!(stdout)
+ }
}
diff --git a/src/uu/wc/src/word_count.rs b/src/uu/wc/src/word_count.rs
index b2dd70450246ce48b282a5c598b676ffea715ab3..3c18d692b2cd77303aff168e98e0d295108a81d5 100644
--- a/src/uu/wc/src/word_count.rs
+++ b/src/uu/wc/src/word_count.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::cmp::max;
use std::ops::{Add, AddAssign};
@@ -29,19 +33,3 @@ impl AddAssign for WordCount {
*self = *self + other;
}
}
-
-impl WordCount {
- pub fn with_title(self, title: Option<String>) -> TitledWordCount {
- TitledWordCount { title, count: self }
- }
-}
-
-/// This struct supplements the actual word count with an optional title that is
-/// displayed to the user at the end of the program.
-/// The reason we don't simply include title in the `WordCount` struct is that
-/// it would result in unnecessary copying of `String`.
-#[derive(Debug, Default, Clone)]
-pub struct TitledWordCount {
- pub title: Option<String>,
- pub count: WordCount,
-}
diff --git a/src/uu/wc/wc.md b/src/uu/wc/wc.md
new file mode 100644
index 0000000000000000000000000000000000000000..c7aaf8545f205620c45d37892ba251730bae5f0c
--- /dev/null
+++ b/src/uu/wc/wc.md
@@ -0,0 +1,8 @@
+# wc
+
+```
+wc [OPTION]... [FILE]...
+```
+
+Display newline, word, and byte counts for each FILE, and a total line if
+more than one FILE is specified. With no FILE, or when FILE is -, read standard input.
diff --git a/src/uu/who/Cargo.toml b/src/uu/who/Cargo.toml
index cd1af860de45331f497eaf8d90d83efa82ce574e..016552360dfb3adfd397cb2a6e61a6fd5e9b48b7 100644
--- a/src/uu/who/Cargo.toml
+++ b/src/uu/who/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_who"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "who ~ (uutils) display information about currently logged-in users"
@@ -15,8 +15,8 @@ edition = "2021"
path = "src/who.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["utmpx"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["utmpx"] }
[[bin]]
name = "who"
diff --git a/src/uu/who/src/platform/mod.rs b/src/uu/who/src/platform/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e0e87dca1bffedbe7294e28e91972aabbe174c11
--- /dev/null
+++ b/src/uu/who/src/platform/mod.rs
@@ -0,0 +1,14 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+#[cfg(not(target_os = "openbsd"))]
+mod unix;
+#[cfg(not(target_os = "openbsd"))]
+pub use self::unix::*;
+
+#[cfg(target_os = "openbsd")]
+mod openbsd;
+#[cfg(target_os = "openbsd")]
+pub use self::openbsd::*;
diff --git a/src/uu/who/src/platform/openbsd.rs b/src/uu/who/src/platform/openbsd.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7e6970c1f0992b3954bcb9b7548e371adcef6d30
--- /dev/null
+++ b/src/uu/who/src/platform/openbsd.rs
@@ -0,0 +1,17 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// Specific implementation for OpenBSD: tool unsupported (utmpx not supported)
+
+use crate::uu_app;
+
+use uucore::error::UResult;
+
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+ let _matches = uu_app().try_get_matches_from(args)?;
+
+ println!("unsupported command on OpenBSD");
+ Ok(())
+}
diff --git a/src/uu/who/src/platform/unix.rs b/src/uu/who/src/platform/unix.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b59b73a5703d600e2916d99d2b5a8d1132c6841f
--- /dev/null
+++ b/src/uu/who/src/platform/unix.rs
@@ -0,0 +1,430 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore (ToDO) ttyname hostnames runlevel mesg wtmp statted boottime deadprocs initspawn clockchange curr runlvline pidstr exitstr hoststr
+
+use crate::options;
+use crate::uu_app;
+
+use uucore::display::Quotable;
+use uucore::error::{FromIo, UResult};
+use uucore::libc::{ttyname, STDIN_FILENO, S_IWGRP};
+use uucore::utmpx::{self, time, Utmpx};
+
+use std::borrow::Cow;
+use std::ffi::CStr;
+use std::fmt::Write;
+use std::os::unix::fs::MetadataExt;
+use std::path::PathBuf;
+
+fn get_long_usage() -> String {
+ format!(
+ "If FILE is not specified, use {}. /var/log/wtmp as FILE is common.\n\
+ If ARG1 ARG2 given, -m presumed: 'am i' or 'mom likes' are usual.",
+ utmpx::DEFAULT_FILE,
+ )
+}
+
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+ let matches = uu_app()
+ .after_help(get_long_usage())
+ .try_get_matches_from(args)?;
+
+ let files: Vec<String> = matches
+ .get_many::<String>(options::FILE)
+ .map(|v| v.map(ToString::to_string).collect())
+ .unwrap_or_default();
+
+ // If true, attempt to canonicalize hostnames via a DNS lookup.
+ let do_lookup = matches.get_flag(options::LOOKUP);
+
+ // If true, display only a list of usernames and count of
+ // the users logged on.
+ // Ignored for 'who am i'.
+ let short_list = matches.get_flag(options::COUNT);
+
+ let all = matches.get_flag(options::ALL);
+
+ // If true, display a line at the top describing each field.
+ let include_heading = matches.get_flag(options::HEADING);
+
+ // If true, display a '+' for each user if mesg y, a '-' if mesg n,
+ // or a '?' if their tty cannot be statted.
+ let include_mesg = all || matches.get_flag(options::MESG);
+
+ // If true, display the last boot time.
+ let need_boottime = all || matches.get_flag(options::BOOT);
+
+ // If true, display dead processes.
+ let need_deadprocs = all || matches.get_flag(options::DEAD);
+
+ // If true, display processes waiting for user login.
+ let need_login = all || matches.get_flag(options::LOGIN);
+
+ // If true, display processes started by init.
+ let need_initspawn = all || matches.get_flag(options::PROCESS);
+
+ // If true, display the last clock change.
+ let need_clockchange = all || matches.get_flag(options::TIME);
+
+ // If true, display the current runlevel.
+ let need_runlevel = all || matches.get_flag(options::RUNLEVEL);
+
+ let use_defaults = !(all
+ || need_boottime
+ || need_deadprocs
+ || need_login
+ || need_initspawn
+ || need_runlevel
+ || need_clockchange
+ || matches.get_flag(options::USERS));
+
+ // If true, display user processes.
+ let need_users = all || matches.get_flag(options::USERS) || use_defaults;
+
+ // If true, display the hours:minutes since each user has touched
+ // the keyboard, or "." if within the last minute, or "old" if
+ // not within the last day.
+ let include_idle = need_deadprocs || need_login || need_runlevel || need_users;
+
+ // If true, display process termination & exit status.
+ let include_exit = need_deadprocs;
+
+ // If true, display only name, line, and time fields.
+ let short_output = !include_exit && use_defaults;
+
+ // If true, display info only for the controlling tty.
+ let my_line_only = matches.get_flag(options::ONLY_HOSTNAME_USER) || files.len() == 2;
+
+ let mut who = Who {
+ do_lookup,
+ short_list,
+ short_output,
+ include_idle,
+ include_heading,
+ include_mesg,
+ include_exit,
+ need_boottime,
+ need_deadprocs,
+ need_login,
+ need_initspawn,
+ need_clockchange,
+ need_runlevel,
+ need_users,
+ my_line_only,
+ args: files,
+ };
+
+ who.exec()
+}
+
+struct Who {
+ do_lookup: bool,
+ short_list: bool,
+ short_output: bool,
+ include_idle: bool,
+ include_heading: bool,
+ include_mesg: bool,
+ include_exit: bool,
+ need_boottime: bool,
+ need_deadprocs: bool,
+ need_login: bool,
+ need_initspawn: bool,
+ need_clockchange: bool,
+ need_runlevel: bool,
+ need_users: bool,
+ my_line_only: bool,
+ args: Vec<String>,
+}
+
+fn idle_string<'a>(when: i64, boottime: i64) -> Cow<'a, str> {
+ thread_local! {
+ static NOW: time::OffsetDateTime = time::OffsetDateTime::now_local().unwrap();
+ }
+ NOW.with(|n| {
+ let now = n.unix_timestamp();
+ if boottime < when && now - 24 * 3600 < when && when <= now {
+ let seconds_idle = now - when;
+ if seconds_idle < 60 {
+ " . ".into()
+ } else {
+ format!(
+ "{:02}:{:02}",
+ seconds_idle / 3600,
+ (seconds_idle % 3600) / 60
+ )
+ .into()
+ }
+ } else {
+ " old ".into()
+ }
+ })
+}
+
+fn time_string(ut: &Utmpx) -> String {
+ // "%b %e %H:%M"
+ let time_format: Vec<time::format_description::FormatItem> =
+ time::format_description::parse("[month repr:short] [day padding:space] [hour]:[minute]")
+ .unwrap();
+ ut.login_time().format(&time_format).unwrap() // LC_ALL=C
+}
+
+#[inline]
+fn current_tty() -> String {
+ unsafe {
+ let res = ttyname(STDIN_FILENO);
+ if res.is_null() {
+ String::new()
+ } else {
+ CStr::from_ptr(res as *const _)
+ .to_string_lossy()
+ .trim_start_matches("/dev/")
+ .to_owned()
+ }
+ }
+}
+
+impl Who {
+ #[allow(clippy::cognitive_complexity)]
+ fn exec(&mut self) -> UResult<()> {
+ let run_level_chk = |_record: i16| {
+ #[cfg(not(target_os = "linux"))]
+ return false;
+
+ #[cfg(target_os = "linux")]
+ return _record == utmpx::RUN_LVL;
+ };
+
+ let f = if self.args.len() == 1 {
+ self.args[0].as_ref()
+ } else {
+ utmpx::DEFAULT_FILE
+ };
+ if self.short_list {
+ let users = Utmpx::iter_all_records_from(f)
+ .filter(Utmpx::is_user_process)
+ .map(|ut| ut.user())
+ .collect::<Vec<_>>();
+ println!("{}", users.join(" "));
+ println!("# users={}", users.len());
+ } else {
+ let records = Utmpx::iter_all_records_from(f);
+
+ if self.include_heading {
+ self.print_heading();
+ }
+ let cur_tty = if self.my_line_only {
+ current_tty()
+ } else {
+ String::new()
+ };
+
+ for ut in records {
+ if !self.my_line_only || cur_tty == ut.tty_device() {
+ if self.need_users && ut.is_user_process() {
+ self.print_user(&ut)?;
+ } else if self.need_runlevel && run_level_chk(ut.record_type()) {
+ if cfg!(target_os = "linux") {
+ self.print_runlevel(&ut);
+ }
+ } else if self.need_boottime && ut.record_type() == utmpx::BOOT_TIME {
+ self.print_boottime(&ut);
+ } else if self.need_clockchange && ut.record_type() == utmpx::NEW_TIME {
+ self.print_clockchange(&ut);
+ } else if self.need_initspawn && ut.record_type() == utmpx::INIT_PROCESS {
+ self.print_initspawn(&ut);
+ } else if self.need_login && ut.record_type() == utmpx::LOGIN_PROCESS {
+ self.print_login(&ut);
+ } else if self.need_deadprocs && ut.record_type() == utmpx::DEAD_PROCESS {
+ self.print_deadprocs(&ut);
+ }
+ }
+
+ if ut.record_type() == utmpx::BOOT_TIME {}
+ }
+ }
+ Ok(())
+ }
+
+ #[inline]
+ fn print_runlevel(&self, ut: &Utmpx) {
+ let last = (ut.pid() / 256) as u8 as char;
+ let curr = (ut.pid() % 256) as u8 as char;
+ let runlvline = format!("run-level {curr}");
+ let comment = format!("last={}", if last == 'N' { 'S' } else { 'N' });
+
+ self.print_line(
+ "",
+ ' ',
+ &runlvline,
+ &time_string(ut),
+ "",
+ "",
+ if last.is_control() { "" } else { &comment },
+ "",
+ );
+ }
+
+ #[inline]
+ fn print_clockchange(&self, ut: &Utmpx) {
+ self.print_line("", ' ', "clock change", &time_string(ut), "", "", "", "");
+ }
+
+ #[inline]
+ fn print_login(&self, ut: &Utmpx) {
+ let comment = format!("id={}", ut.terminal_suffix());
+ let pidstr = format!("{}", ut.pid());
+ self.print_line(
+ "LOGIN",
+ ' ',
+ &ut.tty_device(),
+ &time_string(ut),
+ "",
+ &pidstr,
+ &comment,
+ "",
+ );
+ }
+
+ #[inline]
+ fn print_deadprocs(&self, ut: &Utmpx) {
+ let comment = format!("id={}", ut.terminal_suffix());
+ let pidstr = format!("{}", ut.pid());
+ let e = ut.exit_status();
+ let exitstr = format!("term={} exit={}", e.0, e.1);
+ self.print_line(
+ "",
+ ' ',
+ &ut.tty_device(),
+ &time_string(ut),
+ "",
+ &pidstr,
+ &comment,
+ &exitstr,
+ );
+ }
+
+ #[inline]
+ fn print_initspawn(&self, ut: &Utmpx) {
+ let comment = format!("id={}", ut.terminal_suffix());
+ let pidstr = format!("{}", ut.pid());
+ self.print_line(
+ "",
+ ' ',
+ &ut.tty_device(),
+ &time_string(ut),
+ "",
+ &pidstr,
+ &comment,
+ "",
+ );
+ }
+
+ #[inline]
+ fn print_boottime(&self, ut: &Utmpx) {
+ self.print_line("", ' ', "system boot", &time_string(ut), "", "", "", "");
+ }
+
+ fn print_user(&self, ut: &Utmpx) -> UResult<()> {
+ let mut p = PathBuf::from("/dev");
+ p.push(ut.tty_device().as_str());
+ let mesg;
+ let last_change;
+ match p.metadata() {
+ Ok(meta) => {
+ #[cfg(all(
+ not(target_os = "android"),
+ not(target_os = "freebsd"),
+ not(target_vendor = "apple")
+ ))]
+ let iwgrp = S_IWGRP;
+ #[cfg(any(target_os = "android", target_os = "freebsd", target_vendor = "apple"))]
+ let iwgrp = S_IWGRP as u32;
+ mesg = if meta.mode() & iwgrp == 0 { '-' } else { '+' };
+ last_change = meta.atime();
+ }
+ _ => {
+ mesg = '?';
+ last_change = 0;
+ }
+ }
+
+ let idle = if last_change == 0 {
+ " ?".into()
+ } else {
+ idle_string(last_change, 0)
+ };
+
+ let s = if self.do_lookup {
+ ut.canon_host().map_err_context(|| {
+ let host = ut.host();
+ format!(
+ "failed to canonicalize {}",
+ host.split(':').next().unwrap_or(&host).quote()
+ )
+ })?
+ } else {
+ ut.host()
+ };
+ let hoststr = if s.is_empty() { s } else { format!("({s})") };
+
+ self.print_line(
+ ut.user().as_ref(),
+ mesg,
+ ut.tty_device().as_ref(),
+ time_string(ut).as_str(),
+ idle.as_ref(),
+ format!("{}", ut.pid()).as_str(),
+ hoststr.as_str(),
+ "",
+ );
+
+ Ok(())
+ }
+
+ #[allow(clippy::too_many_arguments)]
+ fn print_line(
+ &self,
+ user: &str,
+ state: char,
+ line: &str,
+ time: &str,
+ idle: &str,
+ pid: &str,
+ comment: &str,
+ exit: &str,
+ ) {
+ let mut buf = String::with_capacity(64);
+ let msg = vec![' ', state].into_iter().collect::<String>();
+
+ write!(buf, "{user:<8}").unwrap();
+ if self.include_mesg {
+ buf.push_str(&msg);
+ }
+ write!(buf, " {line:<12}").unwrap();
+ // "%b %e %H:%M" (LC_ALL=C)
+ let time_size = 3 + 2 + 2 + 1 + 2;
+ write!(buf, " {time:<time_size$}").unwrap();
+
+ if !self.short_output {
+ if self.include_idle {
+ write!(buf, " {idle:<6}").unwrap();
+ }
+ write!(buf, " {pid:>10}").unwrap();
+ }
+ write!(buf, " {comment:<8}").unwrap();
+ if self.include_exit {
+ write!(buf, " {exit:<12}").unwrap();
+ }
+ println!("{}", buf.trim_end());
+ }
+
+ #[inline]
+ fn print_heading(&self) {
+ self.print_line(
+ "NAME", ' ', "LINE", "TIME", "IDLE", "PID", "COMMENT", "EXIT",
+ );
+ }
+}
diff --git a/src/uu/who/src/who.rs b/src/uu/who/src/who.rs
index 85ad435e5f9131c48dba8b67938b8482f12933d6..1eb28e874e8451d85a2047551127ae75f88334b3 100644
--- a/src/uu/who/src/who.rs
+++ b/src/uu/who/src/who.rs
@@ -1,24 +1,14 @@
// This file is part of the uutils coreutils package.
//
-// (c) Jian Zeng <anonymousknight96@gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
// spell-checker:ignore (ToDO) ttyname hostnames runlevel mesg wtmp statted boottime deadprocs initspawn clockchange curr runlvline pidstr exitstr hoststr
-use uucore::display::Quotable;
-use uucore::error::{FromIo, UResult};
-use uucore::libc::{ttyname, STDIN_FILENO, S_IWGRP};
-use uucore::utmpx::{self, time, Utmpx};
-
use clap::{crate_version, Arg, ArgAction, Command};
-use std::borrow::Cow;
-use std::ffi::CStr;
-use std::fmt::Write;
-use std::os::unix::fs::MetadataExt;
-use std::path::PathBuf;
-use uucore::format_usage;
+use uucore::{format_usage, help_about, help_usage};
+
+mod platform;
mod options {
pub const ALL: &str = "all";
@@ -38,117 +28,16 @@ mod options {
pub const FILE: &str = "FILE"; // if length=1: FILE, if length=2: ARG1 ARG2
}
-static ABOUT: &str = "Print information about users who are currently logged in.";
-const USAGE: &str = "{} [OPTION]... [ FILE | ARG1 ARG2 ]";
+const ABOUT: &str = help_about!("who.md");
+const USAGE: &str = help_usage!("who.md");
#[cfg(target_os = "linux")]
static RUNLEVEL_HELP: &str = "print current runlevel";
#[cfg(not(target_os = "linux"))]
static RUNLEVEL_HELP: &str = "print current runlevel (This is meaningless on non Linux)";
-fn get_long_usage() -> String {
- format!(
- "If FILE is not specified, use {}. /var/log/wtmp as FILE is common.\n\
- If ARG1 ARG2 given, -m presumed: 'am i' or 'mom likes' are usual.",
- utmpx::DEFAULT_FILE,
- )
-}
-
#[uucore::main]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
- let args = args.collect_ignore();
-
- let matches = uu_app()
- .after_help(get_long_usage())
- .try_get_matches_from(args)?;
-
- let files: Vec<String> = matches
- .get_many::<String>(options::FILE)
- .map(|v| v.map(ToString::to_string).collect())
- .unwrap_or_default();
-
- // If true, attempt to canonicalize hostnames via a DNS lookup.
- let do_lookup = matches.get_flag(options::LOOKUP);
-
- // If true, display only a list of usernames and count of
- // the users logged on.
- // Ignored for 'who am i'.
- let short_list = matches.get_flag(options::COUNT);
-
- let all = matches.get_flag(options::ALL);
-
- // If true, display a line at the top describing each field.
- let include_heading = matches.get_flag(options::HEADING);
-
- // If true, display a '+' for each user if mesg y, a '-' if mesg n,
- // or a '?' if their tty cannot be statted.
- let include_mesg = all || matches.get_flag(options::MESG);
-
- // If true, display the last boot time.
- let need_boottime = all || matches.get_flag(options::BOOT);
-
- // If true, display dead processes.
- let need_deadprocs = all || matches.get_flag(options::DEAD);
-
- // If true, display processes waiting for user login.
- let need_login = all || matches.get_flag(options::LOGIN);
-
- // If true, display processes started by init.
- let need_initspawn = all || matches.get_flag(options::PROCESS);
-
- // If true, display the last clock change.
- let need_clockchange = all || matches.get_flag(options::TIME);
-
- // If true, display the current runlevel.
- let need_runlevel = all || matches.get_flag(options::RUNLEVEL);
-
- let use_defaults = !(all
- || need_boottime
- || need_deadprocs
- || need_login
- || need_initspawn
- || need_runlevel
- || need_clockchange
- || matches.get_flag(options::USERS));
-
- // If true, display user processes.
- let need_users = all || matches.get_flag(options::USERS) || use_defaults;
-
- // If true, display the hours:minutes since each user has touched
- // the keyboard, or "." if within the last minute, or "old" if
- // not within the last day.
- let include_idle = need_deadprocs || need_login || need_runlevel || need_users;
-
- // If true, display process termination & exit status.
- let include_exit = need_deadprocs;
-
- // If true, display only name, line, and time fields.
- let short_output = !include_exit && use_defaults;
-
- // If true, display info only for the controlling tty.
- let my_line_only = matches.get_flag(options::ONLY_HOSTNAME_USER) || files.len() == 2;
-
- let mut who = Who {
- do_lookup,
- short_list,
- short_output,
- include_idle,
- include_heading,
- include_mesg,
- include_exit,
- need_boottime,
- need_deadprocs,
- need_login,
- need_initspawn,
- need_clockchange,
- need_runlevel,
- need_users,
- my_line_only,
- args: files,
- };
-
- who.exec()
-}
+use platform::uumain;
pub fn uu_app() -> Command {
Command::new(uucore::util_name())
@@ -260,311 +149,3 @@ pub fn uu_app() -> Command {
.value_hint(clap::ValueHint::FilePath),
)
}
-
-struct Who {
- do_lookup: bool,
- short_list: bool,
- short_output: bool,
- include_idle: bool,
- include_heading: bool,
- include_mesg: bool,
- include_exit: bool,
- need_boottime: bool,
- need_deadprocs: bool,
- need_login: bool,
- need_initspawn: bool,
- need_clockchange: bool,
- need_runlevel: bool,
- need_users: bool,
- my_line_only: bool,
- args: Vec<String>,
-}
-
-fn idle_string<'a>(when: i64, boottime: i64) -> Cow<'a, str> {
- thread_local! {
- static NOW: time::OffsetDateTime = time::OffsetDateTime::now_local().unwrap();
- }
- NOW.with(|n| {
- let now = n.unix_timestamp();
- if boottime < when && now - 24 * 3600 < when && when <= now {
- let seconds_idle = now - when;
- if seconds_idle < 60 {
- " . ".into()
- } else {
- format!(
- "{:02}:{:02}",
- seconds_idle / 3600,
- (seconds_idle % 3600) / 60
- )
- .into()
- }
- } else {
- " old ".into()
- }
- })
-}
-
-fn time_string(ut: &Utmpx) -> String {
- // "%b %e %H:%M"
- let time_format: Vec<time::format_description::FormatItem> =
- time::format_description::parse("[month repr:short] [day padding:space] [hour]:[minute]")
- .unwrap();
- ut.login_time().format(&time_format).unwrap() // LC_ALL=C
-}
-
-#[inline]
-fn current_tty() -> String {
- unsafe {
- let res = ttyname(STDIN_FILENO);
- if !res.is_null() {
- CStr::from_ptr(res as *const _)
- .to_string_lossy()
- .trim_start_matches("/dev/")
- .to_owned()
- } else {
- String::new()
- }
- }
-}
-
-impl Who {
- fn exec(&mut self) -> UResult<()> {
- let run_level_chk = |_record: i16| {
- #[cfg(not(target_os = "linux"))]
- return false;
-
- #[cfg(target_os = "linux")]
- return _record == utmpx::RUN_LVL;
- };
-
- let f = if self.args.len() == 1 {
- self.args[0].as_ref()
- } else {
- utmpx::DEFAULT_FILE
- };
- if self.short_list {
- let users = Utmpx::iter_all_records_from(f)
- .filter(Utmpx::is_user_process)
- .map(|ut| ut.user())
- .collect::<Vec<_>>();
- println!("{}", users.join(" "));
- println!("# users={}", users.len());
- } else {
- let records = Utmpx::iter_all_records_from(f);
-
- if self.include_heading {
- self.print_heading();
- }
- let cur_tty = if self.my_line_only {
- current_tty()
- } else {
- String::new()
- };
-
- for ut in records {
- if !self.my_line_only || cur_tty == ut.tty_device() {
- if self.need_users && ut.is_user_process() {
- self.print_user(&ut)?;
- } else if self.need_runlevel && run_level_chk(ut.record_type()) {
- if cfg!(target_os = "linux") {
- self.print_runlevel(&ut);
- }
- } else if self.need_boottime && ut.record_type() == utmpx::BOOT_TIME {
- self.print_boottime(&ut);
- } else if self.need_clockchange && ut.record_type() == utmpx::NEW_TIME {
- self.print_clockchange(&ut);
- } else if self.need_initspawn && ut.record_type() == utmpx::INIT_PROCESS {
- self.print_initspawn(&ut);
- } else if self.need_login && ut.record_type() == utmpx::LOGIN_PROCESS {
- self.print_login(&ut);
- } else if self.need_deadprocs && ut.record_type() == utmpx::DEAD_PROCESS {
- self.print_deadprocs(&ut);
- }
- }
-
- if ut.record_type() == utmpx::BOOT_TIME {}
- }
- }
- Ok(())
- }
-
- #[inline]
- fn print_runlevel(&self, ut: &Utmpx) {
- let last = (ut.pid() / 256) as u8 as char;
- let curr = (ut.pid() % 256) as u8 as char;
- let runlvline = format!("run-level {}", curr);
- let comment = format!("last={}", if last == 'N' { 'S' } else { 'N' });
-
- self.print_line(
- "",
- ' ',
- &runlvline,
- &time_string(ut),
- "",
- "",
- if !last.is_control() { &comment } else { "" },
- "",
- );
- }
-
- #[inline]
- fn print_clockchange(&self, ut: &Utmpx) {
- self.print_line("", ' ', "clock change", &time_string(ut), "", "", "", "");
- }
-
- #[inline]
- fn print_login(&self, ut: &Utmpx) {
- let comment = format!("id={}", ut.terminal_suffix());
- let pidstr = format!("{}", ut.pid());
- self.print_line(
- "LOGIN",
- ' ',
- &ut.tty_device(),
- &time_string(ut),
- "",
- &pidstr,
- &comment,
- "",
- );
- }
-
- #[inline]
- fn print_deadprocs(&self, ut: &Utmpx) {
- let comment = format!("id={}", ut.terminal_suffix());
- let pidstr = format!("{}", ut.pid());
- let e = ut.exit_status();
- let exitstr = format!("term={} exit={}", e.0, e.1);
- self.print_line(
- "",
- ' ',
- &ut.tty_device(),
- &time_string(ut),
- "",
- &pidstr,
- &comment,
- &exitstr,
- );
- }
-
- #[inline]
- fn print_initspawn(&self, ut: &Utmpx) {
- let comment = format!("id={}", ut.terminal_suffix());
- let pidstr = format!("{}", ut.pid());
- self.print_line(
- "",
- ' ',
- &ut.tty_device(),
- &time_string(ut),
- "",
- &pidstr,
- &comment,
- "",
- );
- }
-
- #[inline]
- fn print_boottime(&self, ut: &Utmpx) {
- self.print_line("", ' ', "system boot", &time_string(ut), "", "", "", "");
- }
-
- fn print_user(&self, ut: &Utmpx) -> UResult<()> {
- let mut p = PathBuf::from("/dev");
- p.push(ut.tty_device().as_str());
- let mesg;
- let last_change;
- match p.metadata() {
- Ok(meta) => {
- #[cfg(all(
- not(target_os = "android"),
- not(target_os = "freebsd"),
- not(target_vendor = "apple")
- ))]
- let iwgrp = S_IWGRP;
- #[cfg(any(target_os = "android", target_os = "freebsd", target_vendor = "apple"))]
- let iwgrp = S_IWGRP as u32;
- mesg = if meta.mode() & iwgrp != 0 { '+' } else { '-' };
- last_change = meta.atime();
- }
- _ => {
- mesg = '?';
- last_change = 0;
- }
- }
-
- let idle = if last_change != 0 {
- idle_string(last_change, 0)
- } else {
- " ?".into()
- };
-
- let s = if self.do_lookup {
- ut.canon_host().map_err_context(|| {
- let host = ut.host();
- format!(
- "failed to canonicalize {}",
- host.split(':').next().unwrap_or(&host).quote()
- )
- })?
- } else {
- ut.host()
- };
- let hoststr = if s.is_empty() { s } else { format!("({})", s) };
-
- self.print_line(
- ut.user().as_ref(),
- mesg,
- ut.tty_device().as_ref(),
- time_string(ut).as_str(),
- idle.as_ref(),
- format!("{}", ut.pid()).as_str(),
- hoststr.as_str(),
- "",
- );
-
- Ok(())
- }
-
- #[allow(clippy::too_many_arguments)]
- fn print_line(
- &self,
- user: &str,
- state: char,
- line: &str,
- time: &str,
- idle: &str,
- pid: &str,
- comment: &str,
- exit: &str,
- ) {
- let mut buf = String::with_capacity(64);
- let msg = vec![' ', state].into_iter().collect::<String>();
-
- write!(buf, "{:<8}", user).unwrap();
- if self.include_mesg {
- buf.push_str(&msg);
- }
- write!(buf, " {:<12}", line).unwrap();
- // "%b %e %H:%M" (LC_ALL=C)
- let time_size = 3 + 2 + 2 + 1 + 2;
- write!(buf, " {:<1$}", time, time_size).unwrap();
-
- if !self.short_output {
- if self.include_idle {
- write!(buf, " {:<6}", idle).unwrap();
- }
- write!(buf, " {:>10}", pid).unwrap();
- }
- write!(buf, " {:<8}", comment).unwrap();
- if self.include_exit {
- write!(buf, " {:<12}", exit).unwrap();
- }
- println!("{}", buf.trim_end());
- }
-
- #[inline]
- fn print_heading(&self) {
- self.print_line(
- "NAME", ' ', "LINE", "TIME", "IDLE", "PID", "COMMENT", "EXIT",
- );
- }
-}
diff --git a/src/uu/who/who.md b/src/uu/who/who.md
new file mode 100644
index 0000000000000000000000000000000000000000..6adc265973396d546641a89833955f44ce51db04
--- /dev/null
+++ b/src/uu/who/who.md
@@ -0,0 +1,8 @@
+# who
+
+```
+who [OPTION]... [ FILE | ARG1 ARG2 ]
+```
+
+Print information about users who are currently logged in.
+
diff --git a/src/uu/whoami/Cargo.toml b/src/uu/whoami/Cargo.toml
index 9d576453f133fe4fdb36c8123d1f0ad57bed16fe..28670bf6c667b606c3000443be50fdd1bd721c7f 100644
--- a/src/uu/whoami/Cargo.toml
+++ b/src/uu/whoami/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_whoami"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "whoami ~ (uutils) display user name of current effective user ID"
@@ -15,14 +15,18 @@ edition = "2021"
path = "src/whoami.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["entries"] }
+clap = { workspace = true }
+uucore = { workspace = true, features = ["entries", "process"] }
[target.'cfg(target_os = "windows")'.dependencies]
-windows-sys = { version = "0.42.0", default-features = false, features = ["Win32_NetworkManagement_NetManagement", "Win32_System_WindowsProgramming", "Win32_Foundation"] }
+windows-sys = { workspace = true, features = [
+ "Win32_NetworkManagement_NetManagement",
+ "Win32_System_WindowsProgramming",
+ "Win32_Foundation",
+] }
[target.'cfg(unix)'.dependencies]
-libc = "0.2.137"
+libc = { workspace = true }
[[bin]]
name = "whoami"
diff --git a/src/uu/whoami/src/platform/mod.rs b/src/uu/whoami/src/platform/mod.rs
index b5064a8d2e92e127e5e7be1d00671e966f948b5c..bc6b2888c37574ef94b4443bf1bf635ef82c6bd1 100644
--- a/src/uu/whoami/src/platform/mod.rs
+++ b/src/uu/whoami/src/platform/mod.rs
@@ -1,11 +1,7 @@
-/*
- * This file is part of the uutils coreutils package.
- *
- * (c) Jordi Boggiano <j.boggiano@seld.be>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) getusername
diff --git a/src/uu/whoami/src/platform/unix.rs b/src/uu/whoami/src/platform/unix.rs
index 1c0ea15d56d67a9be91e6b66aab2d333c74ab735..9310a6de0a2d324312c538d1b07ec1c99163eed7 100644
--- a/src/uu/whoami/src/platform/unix.rs
+++ b/src/uu/whoami/src/platform/unix.rs
@@ -1,21 +1,15 @@
-/*
- * This file is part of the uutils coreutils package.
- *
- * (c) Jordi Boggiano <j.boggiano@seld.be>
- * (c) Jian Zeng <anonymousknight96 AT gmail.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::ffi::OsString;
use std::io;
use uucore::entries::uid2usr;
+use uucore::process::geteuid;
pub fn get_username() -> io::Result<OsString> {
- // SAFETY: getuid() does nothing with memory and is always successful.
- let uid = unsafe { libc::geteuid() };
// uid2usr should arguably return an OsString but currently doesn't
- uid2usr(uid).map(Into::into)
+ uid2usr(geteuid()).map(Into::into)
}
diff --git a/src/uu/whoami/src/platform/windows.rs b/src/uu/whoami/src/platform/windows.rs
index 3bad1eb212f20106bc5680c4f839d8aa3f5782bb..aad2eed3d138ee7be843e64cb36194f0a3b2ebcc 100644
--- a/src/uu/whoami/src/platform/windows.rs
+++ b/src/uu/whoami/src/platform/windows.rs
@@ -1,11 +1,7 @@
-/*
- * This file is part of the uutils coreutils package.
- *
- * (c) Jordi Boggiano <j.boggiano@seld.be>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::ffi::OsString;
use std::io;
diff --git a/src/uu/whoami/src/whoami.rs b/src/uu/whoami/src/whoami.rs
index 18c61e28e16d9768b24d5d2d60b7dd865d754133..294c9132841478584a47630bb998a57c6445b24d 100644
--- a/src/uu/whoami/src/whoami.rs
+++ b/src/uu/whoami/src/whoami.rs
@@ -1,32 +1,38 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Jordi Boggiano <j.boggiano@seld.be>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-/* last synced with: whoami (GNU coreutils) 8.21 */
+use std::ffi::OsString;
use clap::{crate_version, Command};
use uucore::display::println_verbatim;
use uucore::error::{FromIo, UResult};
+use uucore::{format_usage, help_about, help_usage};
mod platform;
-static ABOUT: &str = "Print the current username.";
+const ABOUT: &str = help_about!("whoami.md");
+const USAGE: &str = help_usage!("whoami.md");
#[uucore::main]
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
uu_app().try_get_matches_from(args)?;
- let username = platform::get_username().map_err_context(|| "failed to get username".into())?;
+ let username = whoami()?;
println_verbatim(username).map_err_context(|| "failed to print username".into())?;
Ok(())
}
+/// Get the current username
+pub fn whoami() -> UResult<OsString> {
+ platform::get_username().map_err_context(|| "failed to get username".into())
+}
+
pub fn uu_app() -> Command {
Command::new(uucore::util_name())
.version(crate_version!())
.about(ABOUT)
+ .override_usage(format_usage(USAGE))
.infer_long_args(true)
}
diff --git a/src/uu/whoami/whoami.md b/src/uu/whoami/whoami.md
new file mode 100644
index 0000000000000000000000000000000000000000..6106d24ee7e9dfd956e062eb893af687cdb2affe
--- /dev/null
+++ b/src/uu/whoami/whoami.md
@@ -0,0 +1,7 @@
+# whoami
+
+```
+whoami
+```
+
+Print the current username.
diff --git a/src/uu/yes/Cargo.toml b/src/uu/yes/Cargo.toml
index ff52de0310c71911dece1c462fb5af24a40dc9da..9d627504be4b77854364fcb6879304e80df03ca1 100644
--- a/src/uu/yes/Cargo.toml
+++ b/src/uu/yes/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "uu_yes"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "yes ~ (uutils) repeatedly display a line with STRING (or 'y')"
@@ -15,12 +15,15 @@ edition = "2021"
path = "src/yes.rs"
[dependencies]
-clap = { version = "4.0", features = ["wrap_help", "cargo"] }
-libc = "0.2.137"
-uucore = { version=">=0.0.17", package="uucore", path="../../uucore", features=["pipes"] }
+clap = { workspace = true }
+itertools = { workspace = true }
-[target.'cfg(any(target_os = "linux", target_os = "android"))'.dependencies]
-nix = { version = "0.25", default-features = false }
+[target.'cfg(unix)'.dependencies]
+uucore = { workspace = true, features = ["pipes", "signals"] }
+nix = { workspace = true }
+
+[target.'cfg(not(unix))'.dependencies]
+uucore = { workspace = true, features = ["pipes"] }
[[bin]]
name = "yes"
diff --git a/src/uu/yes/src/splice.rs b/src/uu/yes/src/splice.rs
index a0d41e06fa99630a07f73b08e77243a1cb486960..a95fc35af476f3b69d0d68f5dd75c79036af9a99 100644
--- a/src/uu/yes/src/splice.rs
+++ b/src/uu/yes/src/splice.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//! On Linux we can use vmsplice() to write data more efficiently.
//!
//! This does not always work. We're not allowed to splice to some targets,
diff --git a/src/uu/yes/src/yes.rs b/src/uu/yes/src/yes.rs
index cc04d26bc6e98592bba2cb646190378f1514e777..b1d8f9f491df4d87aa5a004867f4a960c3aca209 100644
--- a/src/uu/yes/src/yes.rs
+++ b/src/uu/yes/src/yes.rs
@@ -1,24 +1,23 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * (c) Jordi Boggiano <j.boggiano@seld.be>
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-/* last synced with: yes (GNU coreutils) 8.13 */
+// cSpell:ignore strs
-use std::borrow::Cow;
-use std::io::{self, Result, Write};
-
-use clap::{Arg, ArgAction, Command};
+use clap::{builder::ValueParser, crate_version, Arg, ArgAction, Command};
+use std::error::Error;
+use std::ffi::OsString;
+use std::io::{self, Write};
use uucore::error::{UResult, USimpleError};
-use uucore::format_usage;
-
+#[cfg(unix)]
+use uucore::signals::enable_pipe_errors;
+use uucore::{format_usage, help_about, help_usage};
#[cfg(any(target_os = "linux", target_os = "android"))]
mod splice;
-const ABOUT: &str = "repeatedly display a line with STRING (or 'y')";
-const USAGE: &str = "{} [STRING]...";
+const ABOUT: &str = help_about!("yes.md");
+const USAGE: &str = help_usage!("yes.md");
// it's possible that using a smaller or larger buffer might provide better performance on some
// systems, but honestly this is good enough
@@ -28,66 +27,93 @@ const BUF_SIZE: usize = 16 * 1024;
pub fn uumain(args: impl uucore::Args) -> UResult<()> {
let matches = uu_app().try_get_matches_from(args)?;
- let string = if let Some(values) = matches.get_many::<String>("STRING") {
- let mut result = values.fold(String::new(), |res, s| res + s + " ");
- result.pop();
- result.push('\n');
- Cow::from(result)
- } else {
- Cow::from("y\n")
- };
-
- let mut buffer = [0; BUF_SIZE];
- let bytes = prepare_buffer(&string, &mut buffer);
+ let mut buffer = Vec::with_capacity(BUF_SIZE);
+ args_into_buffer(&mut buffer, matches.get_many::<OsString>("STRING")).unwrap();
+ prepare_buffer(&mut buffer);
- match exec(bytes) {
+ match exec(&buffer) {
Ok(()) => Ok(()),
Err(err) if err.kind() == io::ErrorKind::BrokenPipe => Ok(()),
- Err(err) => Err(USimpleError::new(1, format!("standard output: {}", err))),
+ Err(err) => Err(USimpleError::new(1, format!("standard output: {err}"))),
}
}
pub fn uu_app() -> Command {
Command::new(uucore::util_name())
+ .version(crate_version!())
.about(ABOUT)
.override_usage(format_usage(USAGE))
- .arg(Arg::new("STRING").action(ArgAction::Append))
+ .arg(
+ Arg::new("STRING")
+ .value_parser(ValueParser::os_string())
+ .action(ArgAction::Append),
+ )
.infer_long_args(true)
}
-fn prepare_buffer<'a>(input: &'a str, buffer: &'a mut [u8; BUF_SIZE]) -> &'a [u8] {
- if input.len() < BUF_SIZE / 2 {
- let mut size = 0;
- while size < BUF_SIZE - input.len() {
- let (_, right) = buffer.split_at_mut(size);
- right[..input.len()].copy_from_slice(input.as_bytes());
- size += input.len();
+// Copies words from `i` into `buf`, separated by spaces.
+fn args_into_buffer<'a>(
+ buf: &mut Vec<u8>,
+ i: Option<impl Iterator<Item = &'a OsString>>,
+) -> Result<(), Box<dyn Error>> {
+ let Some(i) = i else {
+ buf.extend_from_slice(b"y\n");
+ return Ok(());
+ };
+
+ // On Unix (and wasi), OsStrs are just &[u8]'s underneath...
+ #[cfg(any(unix, target_os = "wasi"))]
+ {
+ #[cfg(unix)]
+ use std::os::unix::ffi::OsStrExt;
+ #[cfg(target_os = "wasi")]
+ use std::os::wasi::ffi::OsStrExt;
+
+ for part in itertools::intersperse(i.map(|a| a.as_bytes()), b" ") {
+ buf.extend_from_slice(part);
}
- &buffer[..size]
- } else {
- input.as_bytes()
}
-}
-#[cfg(unix)]
-fn enable_pipe_errors() -> Result<()> {
- let ret = unsafe { libc::signal(libc::SIGPIPE, libc::SIG_DFL) };
- if ret == libc::SIG_ERR {
- return Err(io::Error::new(io::ErrorKind::Other, ""));
+ // But, on Windows, we must hop through a String.
+ #[cfg(not(any(unix, target_os = "wasi")))]
+ {
+ for part in itertools::intersperse(i.map(|a| a.to_str()), Some(" ")) {
+ let bytes = match part {
+ Some(part) => part.as_bytes(),
+ None => return Err("arguments contain invalid UTF-8".into()),
+ };
+ buf.extend_from_slice(bytes);
+ }
}
+
+ buf.push(b'\n');
+
Ok(())
}
-#[cfg(not(unix))]
-fn enable_pipe_errors() -> Result<()> {
- // Do nothing.
- Ok(())
+// Assumes buf holds a single output line forged from the command line arguments, copies it
+// repeatedly until the buffer holds as many copies as it can under BUF_SIZE.
+fn prepare_buffer(buf: &mut Vec<u8>) {
+ if buf.len() * 2 > BUF_SIZE {
+ return;
+ }
+
+ assert!(!buf.is_empty());
+
+ let line_len = buf.len();
+ let target_size = line_len * (BUF_SIZE / line_len);
+
+ while buf.len() < target_size {
+ let to_copy = std::cmp::min(target_size - buf.len(), buf.len());
+ debug_assert_eq!(to_copy % line_len, 0);
+ buf.extend_from_within(..to_copy);
+ }
}
pub fn exec(bytes: &[u8]) -> io::Result<()> {
let stdout = io::stdout();
let mut stdout = stdout.lock();
-
+ #[cfg(unix)]
enable_pipe_errors()?;
#[cfg(any(target_os = "linux", target_os = "android"))]
@@ -103,3 +129,67 @@ pub fn exec(bytes: &[u8]) -> io::Result<()> {
stdout.write_all(bytes)?;
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_prepare_buffer() {
+ let tests = [
+ (150, 16350),
+ (1000, 16000),
+ (4093, 16372),
+ (4099, 12297),
+ (4111, 12333),
+ (2, 16384),
+ (3, 16383),
+ (4, 16384),
+ (5, 16380),
+ (8192, 16384),
+ (8191, 16382),
+ (8193, 8193),
+ (10000, 10000),
+ (15000, 15000),
+ (25000, 25000),
+ ];
+
+ for (line, final_len) in tests {
+ let mut v = std::iter::repeat(b'a').take(line).collect::<Vec<_>>();
+ prepare_buffer(&mut v);
+ assert_eq!(v.len(), final_len);
+ }
+ }
+
+ #[test]
+ fn test_args_into_buf() {
+ {
+ let mut v = Vec::with_capacity(BUF_SIZE);
+ args_into_buffer(&mut v, None::<std::slice::Iter<OsString>>).unwrap();
+ assert_eq!(String::from_utf8(v).unwrap(), "y\n");
+ }
+
+ {
+ let mut v = Vec::with_capacity(BUF_SIZE);
+ args_into_buffer(&mut v, Some([OsString::from("foo")].iter())).unwrap();
+ assert_eq!(String::from_utf8(v).unwrap(), "foo\n");
+ }
+
+ {
+ let mut v = Vec::with_capacity(BUF_SIZE);
+ args_into_buffer(
+ &mut v,
+ Some(
+ [
+ OsString::from("foo"),
+ OsString::from("bar baz"),
+ OsString::from("qux"),
+ ]
+ .iter(),
+ ),
+ )
+ .unwrap();
+ assert_eq!(String::from_utf8(v).unwrap(), "foo bar baz qux\n");
+ }
+ }
+}
diff --git a/src/uu/yes/yes.md b/src/uu/yes/yes.md
new file mode 100644
index 0000000000000000000000000000000000000000..ad2da7dc9afbe959c6f865d18d29a292632580a9
--- /dev/null
+++ b/src/uu/yes/yes.md
@@ -0,0 +1,7 @@
+# yes
+
+```
+yes [STRING]...
+```
+
+Repeatedly display a line with STRING (or 'y')
diff --git a/src/uucore/Cargo.toml b/src/uucore/Cargo.toml
index 6264d7665a6c06aff6bccb9fc32adc0bd9ddcbc8..069ec3e59e082f32fc047eccab790535add4ea31 100644
--- a/src/uucore/Cargo.toml
+++ b/src/uucore/Cargo.toml
@@ -2,7 +2,7 @@
[package]
name = "uucore"
-version = "0.0.17"
+version = "0.0.27"
authors = ["uutils developers"]
license = "MIT"
description = "uutils ~ 'core' uutils code library (cross-platform)"
@@ -15,54 +15,97 @@ categories = ["command-line-utilities"]
edition = "2021"
[lib]
-path="src/lib/lib.rs"
+path = "src/lib/lib.rs"
[dependencies]
-uucore_procs = { version=">=0.0.17", path="../uucore_procs" }
-clap = "4.0"
-dns-lookup = { version="1.0.5", optional=true }
-dunce = "1.0.3"
-wild = "2.0"
-glob = "0.3.0"
+clap = { workspace = true }
+uucore_procs = { workspace = true }
+number_prefix = { workspace = true }
+dns-lookup = { version = "2.0.4", optional = true }
+dunce = { version = "1.0.4", optional = true }
+wild = "2.2.1"
+glob = { workspace = true }
# * optional
-itertools = { version="0.10.0", optional=true }
-thiserror = { version="1.0", optional=true }
-time = { version="0.3", optional=true, features = ["formatting", "local-offset", "macros"] }
+itertools = { workspace = true, optional = true }
+thiserror = { workspace = true, optional = true }
+time = { workspace = true, optional = true, features = [
+ "formatting",
+ "local-offset",
+ "macros",
+] }
# * "problem" dependencies (pinned)
-data-encoding = { version="2.1", optional=true }
-data-encoding-macro = { version="0.1.12", optional=true }
-z85 = { version="3.0.5", optional=true }
-libc = { version="0.2.137", optional=true }
-once_cell = "1.13.1"
+data-encoding = { version = "2.6", optional = true }
+data-encoding-macro = { version = "0.1.15", optional = true }
+z85 = { version = "3.0.5", optional = true }
+libc = { workspace = true, optional = true }
+once_cell = { workspace = true }
os_display = "0.1.3"
+digest = { workspace = true, optional = true }
+hex = { workspace = true, optional = true }
+memchr = { workspace = true, optional = true }
+md-5 = { workspace = true, optional = true }
+sha1 = { workspace = true, optional = true }
+sha2 = { workspace = true, optional = true }
+sha3 = { workspace = true, optional = true }
+blake2b_simd = { workspace = true, optional = true }
+blake3 = { workspace = true, optional = true }
+sm3 = { workspace = true, optional = true }
+regex = { workspace = true, optional = true }
+
[target.'cfg(unix)'.dependencies]
-walkdir = { version="2.3.2", optional=true }
-nix = { version = "0.25", default-features = false, features = ["fs", "uio", "zerocopy"] }
+walkdir = { workspace = true, optional = true }
+nix = { workspace = true, features = ["fs", "uio", "zerocopy", "signal"] }
+xattr = { workspace = true, optional = true }
[dev-dependencies]
-clap = "4.0"
-once_cell = "1.13"
+clap = { workspace = true }
+once_cell = { workspace = true }
+tempfile = { workspace = true }
[target.'cfg(target_os = "windows")'.dependencies]
-winapi-util = { version= "0.1.5", optional=true }
-windows-sys = { version = "0.42.0", optional = true, default-features = false, features = ["Win32_Storage_FileSystem", "Win32_Foundation", "Win32_System_WindowsProgramming"] }
+winapi-util = { workspace = true, optional = true }
+windows-sys = { workspace = true, optional = true, default-features = false, features = [
+ "Win32_Storage_FileSystem",
+ "Win32_Foundation",
+ "Win32_System_WindowsProgramming",
+] }
[features]
default = []
# * non-default features
+backup-control = []
+colors = []
+checksum = ["regex", "sum"]
encoding = ["data-encoding", "data-encoding-macro", "z85", "thiserror"]
entries = ["libc"]
-fs = ["libc", "winapi-util", "windows-sys"]
-fsext = ["libc", "time", "windows-sys"]
+fs = ["dunce", "libc", "winapi-util", "windows-sys"]
+fsext = ["libc", "windows-sys"]
+fsxattr = ["xattr"]
lines = []
-memo = ["itertools"]
+format = ["itertools", "quoting-style"]
mode = ["libc"]
perms = ["libc", "walkdir"]
+pipes = []
process = ["libc"]
+quoting-style = []
+ranges = []
ringbuffer = []
signals = []
+sum = [
+ "digest",
+ "hex",
+ "memchr",
+ "md-5",
+ "sha1",
+ "sha2",
+ "sha3",
+ "blake2b_simd",
+ "blake3",
+ "sm3",
+]
+update-control = []
utf8 = []
utmpx = ["time", "time/macros", "libc", "dns-lookup"]
+version-cmp = []
wide = []
-pipes = []
diff --git a/src/uucore/src/lib/features.rs b/src/uucore/src/lib/features.rs
index 2e5aea1e2afe71b8aad1d14029eb9dd22786f0d4..ef7b17b3156aa48fe2001b2c10a1091197e34e73 100644
--- a/src/uucore/src/lib/features.rs
+++ b/src/uucore/src/lib/features.rs
@@ -1,19 +1,37 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// features ~ feature-gated modules (core/bundler file)
+#[cfg(feature = "backup-control")]
+pub mod backup_control;
+#[cfg(feature = "checksum")]
+pub mod checksum;
+#[cfg(feature = "colors")]
+pub mod colors;
#[cfg(feature = "encoding")]
pub mod encoding;
+#[cfg(feature = "format")]
+pub mod format;
#[cfg(feature = "fs")]
pub mod fs;
#[cfg(feature = "fsext")]
pub mod fsext;
#[cfg(feature = "lines")]
pub mod lines;
-#[cfg(feature = "memo")]
-pub mod memo;
+#[cfg(feature = "quoting-style")]
+pub mod quoting_style;
+#[cfg(feature = "ranges")]
+pub mod ranges;
#[cfg(feature = "ringbuffer")]
pub mod ringbuffer;
-#[cfg(feature = "memo")]
-mod tokenize;
+#[cfg(feature = "sum")]
+pub mod sum;
+#[cfg(feature = "update-control")]
+pub mod update_control;
+#[cfg(feature = "version-cmp")]
+pub mod version_cmp;
// * (platform-specific) feature-gated modules
// ** non-windows (i.e. Unix + Fuchsia)
@@ -30,12 +48,15 @@ pub mod pipes;
#[cfg(all(unix, feature = "process"))]
pub mod process;
+#[cfg(all(unix, not(target_os = "macos"), feature = "fsxattr"))]
+pub mod fsxattr;
#[cfg(all(unix, not(target_os = "fuchsia"), feature = "signals"))]
pub mod signals;
#[cfg(all(
unix,
not(target_os = "android"),
not(target_os = "fuchsia"),
+ not(target_os = "openbsd"),
not(target_os = "redox"),
not(target_env = "musl"),
feature = "utmpx"
diff --git a/src/uucore/src/lib/mods/backup_control.rs b/src/uucore/src/lib/features/backup_control.rs
similarity index 89%
rename from src/uucore/src/lib/mods/backup_control.rs
rename to src/uucore/src/lib/features/backup_control.rs
index 52b2771c6a76b82a1b715c6644acfb48f54f7080..9086acb197e4e3bb1b1a3f8d11ff7c120513208e 100644
--- a/src/uucore/src/lib/mods/backup_control.rs
+++ b/src/uucore/src/lib/features/backup_control.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//! Implement GNU-style backup functionality.
//!
//! This module implements the backup functionality as described in the [GNU
@@ -200,8 +204,6 @@ impl Display for BackupError {
pub mod arguments {
use clap::ArgAction;
- extern crate clap;
-
pub static OPT_BACKUP: &str = "backupopt_backup";
pub static OPT_BACKUP_NO_ARG: &str = "backupopt_b";
pub static OPT_SUFFIX: &str = "backupopt_suffix";
@@ -352,8 +354,13 @@ pub fn determine_backup_mode(matches: &ArgMatches) -> UResult<BackupMode> {
}
} else if matches.get_flag(arguments::OPT_BACKUP_NO_ARG) {
// the short form of this option, -b does not accept any argument.
- // Using -b is equivalent to using --backup=existing.
- Ok(BackupMode::ExistingBackup)
+ // if VERSION_CONTROL is not set then using -b is equivalent to
+ // using --backup=existing.
+ if let Ok(method) = env::var("VERSION_CONTROL") {
+ match_method(&method, "$VERSION_CONTROL")
+ } else {
+ Ok(BackupMode::ExistingBackup)
+ }
} else {
// No option was present at all
Ok(BackupMode::NoBackup)
@@ -440,13 +447,38 @@ fn existing_backup_path(path: &Path, suffix: &str) -> PathBuf {
}
}
+/// Returns true if the source file is likely to be the simple backup file for the target file.
+///
+/// # Arguments
+///
+/// * `source` - A Path reference that holds the source (backup) file path.
+/// * `target` - A Path reference that holds the target file path.
+/// * `suffix` - Str that holds the backup suffix.
+///
+/// # Examples
+///
+/// ```
+/// use std::path::Path;
+/// use uucore::backup_control::source_is_target_backup;
+/// let source = Path::new("data.txt~");
+/// let target = Path::new("data.txt");
+/// let suffix = String::from("~");
+///
+/// assert_eq!(source_is_target_backup(&source, &target, &suffix), true);
+/// ```
+///
+pub fn source_is_target_backup(source: &Path, target: &Path, suffix: &str) -> bool {
+ let source_filename = source.to_string_lossy();
+ let target_backup_filename = format!("{}{suffix}", target.to_string_lossy());
+ source_filename == target_backup_filename
+}
+
//
// Tests for this module
//
#[cfg(test)]
mod tests {
use super::*;
- use std::env;
// Required to instantiate mutex in shared context
use clap::Command;
use once_cell::sync::Lazy;
@@ -551,16 +583,16 @@ mod tests {
assert_eq!(result, BackupMode::SimpleBackup);
}
- // -b ignores the "VERSION_CONTROL" environment variable
+ // -b doesn't ignores the "VERSION_CONTROL" environment variable
#[test]
- fn test_backup_mode_short_only_ignore_env() {
+ fn test_backup_mode_short_does_not_ignore_env() {
let _dummy = TEST_MUTEX.lock().unwrap();
- env::set_var(ENV_VERSION_CONTROL, "none");
+ env::set_var(ENV_VERSION_CONTROL, "numbered");
let matches = make_app().get_matches_from(vec!["command", "-b"]);
let result = determine_backup_mode(&matches).unwrap();
- assert_eq!(result, BackupMode::ExistingBackup);
+ assert_eq!(result, BackupMode::NumberedBackup);
env::remove_var(ENV_VERSION_CONTROL);
}
@@ -628,4 +660,30 @@ mod tests {
let result = determine_backup_suffix(&matches);
assert_eq!(result, "-v");
}
+ #[test]
+ fn test_source_is_target_backup() {
+ let source = Path::new("data.txt.bak");
+ let target = Path::new("data.txt");
+ let suffix = String::from(".bak");
+
+ assert!(source_is_target_backup(source, target, &suffix));
+ }
+
+ #[test]
+ fn test_source_is_not_target_backup() {
+ let source = Path::new("data.txt");
+ let target = Path::new("backup.txt");
+ let suffix = String::from(".bak");
+
+ assert!(!source_is_target_backup(source, target, &suffix));
+ }
+
+ #[test]
+ fn test_source_is_target_backup_with_tilde_suffix() {
+ let source = Path::new("example~");
+ let target = Path::new("example");
+ let suffix = String::from("~");
+
+ assert!(source_is_target_backup(source, target, &suffix));
+ }
}
diff --git a/src/uucore/src/lib/features/checksum.rs b/src/uucore/src/lib/features/checksum.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8de289483c6c14f28175b1c7d66aa778289ec803
--- /dev/null
+++ b/src/uucore/src/lib/features/checksum.rs
@@ -0,0 +1,967 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore anotherfile invalidchecksum
+
+use os_display::Quotable;
+use regex::Regex;
+use std::{
+ error::Error,
+ ffi::OsStr,
+ fmt::Display,
+ fs::File,
+ io::{self, BufReader, Read},
+ path::Path,
+};
+
+use crate::{
+ error::{set_exit_code, FromIo, UError, UResult, USimpleError},
+ show, show_error, show_warning_caps,
+ sum::{
+ Blake2b, Blake3, Digest, DigestWriter, Md5, Sha1, Sha224, Sha256, Sha384, Sha3_224,
+ Sha3_256, Sha3_384, Sha3_512, Sha512, Shake128, Shake256, Sm3, BSD, CRC, SYSV,
+ },
+ util_name,
+};
+use std::io::stdin;
+use std::io::BufRead;
+
+pub const ALGORITHM_OPTIONS_SYSV: &str = "sysv";
+pub const ALGORITHM_OPTIONS_BSD: &str = "bsd";
+pub const ALGORITHM_OPTIONS_CRC: &str = "crc";
+pub const ALGORITHM_OPTIONS_MD5: &str = "md5";
+pub const ALGORITHM_OPTIONS_SHA1: &str = "sha1";
+pub const ALGORITHM_OPTIONS_SHA3: &str = "sha3";
+
+pub const ALGORITHM_OPTIONS_SHA224: &str = "sha224";
+pub const ALGORITHM_OPTIONS_SHA256: &str = "sha256";
+pub const ALGORITHM_OPTIONS_SHA384: &str = "sha384";
+pub const ALGORITHM_OPTIONS_SHA512: &str = "sha512";
+pub const ALGORITHM_OPTIONS_BLAKE2B: &str = "blake2b";
+pub const ALGORITHM_OPTIONS_BLAKE3: &str = "blake3";
+pub const ALGORITHM_OPTIONS_SM3: &str = "sm3";
+pub const ALGORITHM_OPTIONS_SHAKE128: &str = "shake128";
+pub const ALGORITHM_OPTIONS_SHAKE256: &str = "shake256";
+
+pub const SUPPORTED_ALGORITHMS: [&str; 15] = [
+ ALGORITHM_OPTIONS_SYSV,
+ ALGORITHM_OPTIONS_BSD,
+ ALGORITHM_OPTIONS_CRC,
+ ALGORITHM_OPTIONS_MD5,
+ ALGORITHM_OPTIONS_SHA1,
+ ALGORITHM_OPTIONS_SHA3,
+ ALGORITHM_OPTIONS_SHA224,
+ ALGORITHM_OPTIONS_SHA256,
+ ALGORITHM_OPTIONS_SHA384,
+ ALGORITHM_OPTIONS_SHA512,
+ ALGORITHM_OPTIONS_BLAKE2B,
+ ALGORITHM_OPTIONS_BLAKE3,
+ ALGORITHM_OPTIONS_SM3,
+ ALGORITHM_OPTIONS_SHAKE128,
+ ALGORITHM_OPTIONS_SHAKE256,
+];
+
+pub struct HashAlgorithm {
+ pub name: &'static str,
+ pub create_fn: Box<dyn Fn() -> Box<dyn Digest + 'static>>,
+ pub bits: usize,
+}
+
+#[derive(Debug)]
+pub enum ChecksumError {
+ RawMultipleFiles,
+ IgnoreNotCheck,
+ InvalidOutputSizeForSha3,
+ BitsRequiredForSha3,
+ BitsRequiredForShake128,
+ BitsRequiredForShake256,
+ UnknownAlgorithm,
+ InvalidLength,
+ LengthOnlyForBlake2b,
+ BinaryTextConflict,
+ AlgorithmNotSupportedWithCheck,
+ CombineMultipleAlgorithms,
+ NeedAlgorithmToHash,
+ NoProperlyFormattedChecksumLinesFound(String),
+}
+
+impl Error for ChecksumError {}
+
+impl UError for ChecksumError {
+ fn code(&self) -> i32 {
+ 1
+ }
+}
+
+impl Display for ChecksumError {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ Self::RawMultipleFiles => {
+ write!(f, "the --raw option is not supported with multiple files")
+ }
+ Self::IgnoreNotCheck => write!(
+ f,
+ "the --ignore-missing option is meaningful only when verifying checksums"
+ ),
+ Self::InvalidOutputSizeForSha3 => write!(
+ f,
+ "Invalid output size for SHA3 (expected 224, 256, 384, or 512)"
+ ),
+ Self::BitsRequiredForSha3 => write!(f, "--bits required for SHA3"),
+ Self::BitsRequiredForShake128 => write!(f, "--bits required for SHAKE128"),
+ Self::BitsRequiredForShake256 => write!(f, "--bits required for SHAKE256"),
+ Self::UnknownAlgorithm => {
+ write!(f, "unknown algorithm: clap should have prevented this case")
+ }
+ Self::InvalidLength => write!(f, "length is not a multiple of 8"),
+ Self::LengthOnlyForBlake2b => {
+ write!(f, "--length is only supported with --algorithm=blake2b")
+ }
+ Self::BinaryTextConflict => write!(
+ f,
+ "the --binary and --text options are meaningless when verifying checksums"
+ ),
+ Self::AlgorithmNotSupportedWithCheck => write!(
+ f,
+ "--check is not supported with --algorithm={{bsd,sysv,crc}}"
+ ),
+ Self::CombineMultipleAlgorithms => {
+ write!(f, "You cannot combine multiple hash algorithms!")
+ }
+ Self::NeedAlgorithmToHash => write!(
+ f,
+ "Needs an algorithm to hash with.\nUse --help for more information."
+ ),
+ Self::NoProperlyFormattedChecksumLinesFound(filename) => {
+ write!(
+ f,
+ "{}: no properly formatted checksum lines found",
+ filename
+ )
+ }
+ }
+ }
+}
+
+/// Creates a SHA3 hasher instance based on the specified bits argument.
+///
+/// # Returns
+///
+/// Returns a UResult of a tuple containing the algorithm name, the hasher instance, and
+/// the output length in bits or an Err if an unsupported output size is provided, or if
+/// the `--bits` flag is missing.
+pub fn create_sha3(bits: Option<usize>) -> UResult<HashAlgorithm> {
+ match bits {
+ Some(224) => Ok(HashAlgorithm {
+ name: "SHA3_224",
+ create_fn: Box::new(|| Box::new(Sha3_224::new())),
+ bits: 224,
+ }),
+ Some(256) => Ok(HashAlgorithm {
+ name: "SHA3_256",
+ create_fn: Box::new(|| Box::new(Sha3_256::new())),
+ bits: 256,
+ }),
+ Some(384) => Ok(HashAlgorithm {
+ name: "SHA3_384",
+ create_fn: Box::new(|| Box::new(Sha3_384::new())),
+ bits: 384,
+ }),
+ Some(512) => Ok(HashAlgorithm {
+ name: "SHA3_512",
+ create_fn: Box::new(|| Box::new(Sha3_512::new())),
+ bits: 512,
+ }),
+
+ Some(_) => Err(ChecksumError::InvalidOutputSizeForSha3.into()),
+ None => Err(ChecksumError::BitsRequiredForSha3.into()),
+ }
+}
+
+#[allow(clippy::comparison_chain)]
+pub fn cksum_output(
+ bad_format: i32,
+ failed_cksum: i32,
+ failed_open_file: i32,
+ ignore_missing: bool,
+ status: bool,
+) {
+ if bad_format == 1 {
+ show_warning_caps!("{} line is improperly formatted", bad_format);
+ } else if bad_format > 1 {
+ show_warning_caps!("{} lines are improperly formatted", bad_format);
+ }
+
+ if !status {
+ if failed_cksum == 1 {
+ show_warning_caps!("{} computed checksum did NOT match", failed_cksum);
+ } else if failed_cksum > 1 {
+ show_warning_caps!("{} computed checksums did NOT match", failed_cksum);
+ }
+ }
+ if !ignore_missing {
+ if failed_open_file == 1 {
+ show_warning_caps!("{} listed file could not be read", failed_open_file);
+ } else if failed_open_file > 1 {
+ show_warning_caps!("{} listed files could not be read", failed_open_file);
+ }
+ }
+}
+
+pub fn detect_algo(algo: &str, length: Option<usize>) -> UResult<HashAlgorithm> {
+ match algo {
+ ALGORITHM_OPTIONS_SYSV => Ok(HashAlgorithm {
+ name: ALGORITHM_OPTIONS_SYSV,
+ create_fn: Box::new(|| Box::new(SYSV::new())),
+ bits: 512,
+ }),
+ ALGORITHM_OPTIONS_BSD => Ok(HashAlgorithm {
+ name: ALGORITHM_OPTIONS_BSD,
+ create_fn: Box::new(|| Box::new(BSD::new())),
+ bits: 1024,
+ }),
+ ALGORITHM_OPTIONS_CRC => Ok(HashAlgorithm {
+ name: ALGORITHM_OPTIONS_CRC,
+ create_fn: Box::new(|| Box::new(CRC::new())),
+ bits: 256,
+ }),
+ ALGORITHM_OPTIONS_MD5 | "md5sum" => Ok(HashAlgorithm {
+ name: ALGORITHM_OPTIONS_MD5,
+ create_fn: Box::new(|| Box::new(Md5::new())),
+ bits: 128,
+ }),
+ ALGORITHM_OPTIONS_SHA1 | "sha1sum" => Ok(HashAlgorithm {
+ name: ALGORITHM_OPTIONS_SHA1,
+ create_fn: Box::new(|| Box::new(Sha1::new())),
+ bits: 160,
+ }),
+ ALGORITHM_OPTIONS_SHA224 | "sha224sum" => Ok(HashAlgorithm {
+ name: ALGORITHM_OPTIONS_SHA224,
+ create_fn: Box::new(|| Box::new(Sha224::new())),
+ bits: 224,
+ }),
+ ALGORITHM_OPTIONS_SHA256 | "sha256sum" => Ok(HashAlgorithm {
+ name: ALGORITHM_OPTIONS_SHA256,
+ create_fn: Box::new(|| Box::new(Sha256::new())),
+ bits: 256,
+ }),
+ ALGORITHM_OPTIONS_SHA384 | "sha384sum" => Ok(HashAlgorithm {
+ name: ALGORITHM_OPTIONS_SHA384,
+ create_fn: Box::new(|| Box::new(Sha384::new())),
+ bits: 384,
+ }),
+ ALGORITHM_OPTIONS_SHA512 | "sha512sum" => Ok(HashAlgorithm {
+ name: ALGORITHM_OPTIONS_SHA512,
+ create_fn: Box::new(|| Box::new(Sha512::new())),
+ bits: 512,
+ }),
+ ALGORITHM_OPTIONS_BLAKE2B | "b2sum" => {
+ // Set default length to 512 if None
+ let bits = length.unwrap_or(512);
+ if bits == 512 {
+ Ok(HashAlgorithm {
+ name: ALGORITHM_OPTIONS_BLAKE2B,
+ create_fn: Box::new(move || Box::new(Blake2b::new())),
+ bits: 512,
+ })
+ } else {
+ Ok(HashAlgorithm {
+ name: ALGORITHM_OPTIONS_BLAKE2B,
+ create_fn: Box::new(move || Box::new(Blake2b::with_output_bytes(bits))),
+ bits,
+ })
+ }
+ }
+ ALGORITHM_OPTIONS_BLAKE3 | "b3sum" => Ok(HashAlgorithm {
+ name: ALGORITHM_OPTIONS_BLAKE3,
+ create_fn: Box::new(|| Box::new(Blake3::new())),
+ bits: 256,
+ }),
+ ALGORITHM_OPTIONS_SM3 => Ok(HashAlgorithm {
+ name: ALGORITHM_OPTIONS_SM3,
+ create_fn: Box::new(|| Box::new(Sm3::new())),
+ bits: 512,
+ }),
+ ALGORITHM_OPTIONS_SHAKE128 | "shake128sum" => {
+ let bits =
+ length.ok_or_else(|| USimpleError::new(1, "--bits required for SHAKE128"))?;
+ Ok(HashAlgorithm {
+ name: ALGORITHM_OPTIONS_SHAKE128,
+ create_fn: Box::new(|| Box::new(Shake128::new())),
+ bits,
+ })
+ }
+ ALGORITHM_OPTIONS_SHAKE256 | "shake256sum" => {
+ let bits =
+ length.ok_or_else(|| USimpleError::new(1, "--bits required for SHAKE256"))?;
+ Ok(HashAlgorithm {
+ name: ALGORITHM_OPTIONS_SHAKE256,
+ create_fn: Box::new(|| Box::new(Shake256::new())),
+ bits,
+ })
+ }
+ //ALGORITHM_OPTIONS_SHA3 | "sha3" => (
+ _ if algo.starts_with("sha3") => create_sha3(length),
+
+ _ => Err(ChecksumError::UnknownAlgorithm.into()),
+ }
+}
+
+// Regexp to handle the three input formats:
+// 1. <algo>[-<bits>] (<filename>) = <checksum>
+// algo must be uppercase or b (for blake2b)
+// 2. <checksum> [* ]<filename>
+// 3. <checksum> [*]<filename> (only one space)
+const ALGO_BASED_REGEX: &str = r"^\s*\\?(?P<algo>(?:[A-Z0-9]+|BLAKE2b))(?:-(?P<bits>\d+))?\s?\((?P<filename>.*)\)\s*=\s*(?P<checksum>[a-fA-F0-9]+)$";
+const DOUBLE_SPACE_REGEX: &str = r"^(?P<checksum>[a-fA-F0-9]+)\s{2}(?P<filename>.*)$";
+
+// In this case, we ignore the *
+const SINGLE_SPACE_REGEX: &str = r"^(?P<checksum>[a-fA-F0-9]+)\s(?P<filename>\*?.*)$";
+
+fn get_filename_for_output(filename: &OsStr, input_is_stdin: bool) -> String {
+ if input_is_stdin {
+ "standard input"
+ } else {
+ filename.to_str().unwrap()
+ }
+ .maybe_quote()
+ .to_string()
+}
+
+/// Determines the appropriate regular expression to use based on the provided lines.
+fn determine_regex(
+ filename: &OsStr,
+ input_is_stdin: bool,
+ lines: &[String],
+) -> UResult<(Regex, bool)> {
+ let algo_based_regex = Regex::new(ALGO_BASED_REGEX).unwrap();
+ let double_space_regex = Regex::new(DOUBLE_SPACE_REGEX).unwrap();
+ let single_space_regex = Regex::new(SINGLE_SPACE_REGEX).unwrap();
+
+ for line in lines {
+ let line_trim = line.trim();
+ if algo_based_regex.is_match(line_trim) {
+ return Ok((algo_based_regex, true));
+ } else if double_space_regex.is_match(line_trim) {
+ return Ok((double_space_regex, false));
+ } else if single_space_regex.is_match(line_trim) {
+ return Ok((single_space_regex, false));
+ }
+ }
+
+ Err(
+ ChecksumError::NoProperlyFormattedChecksumLinesFound(get_filename_for_output(
+ filename,
+ input_is_stdin,
+ ))
+ .into(),
+ )
+}
+
+/***
+ * Do the checksum validation (can be strict or not)
+*/
+#[allow(clippy::too_many_arguments)]
+#[allow(clippy::cognitive_complexity)]
+pub fn perform_checksum_validation<'a, I>(
+ files: I,
+ strict: bool,
+ status: bool,
+ warn: bool,
+ binary: bool,
+ ignore_missing: bool,
+ quiet: bool,
+ algo_name_input: Option<&str>,
+ length_input: Option<usize>,
+) -> UResult<()>
+where
+ I: Iterator<Item = &'a OsStr>,
+{
+ // if cksum has several input files, it will print the result for each file
+ for filename_input in files {
+ let mut bad_format = 0;
+ let mut failed_cksum = 0;
+ let mut failed_open_file = 0;
+ let mut correct_format = 0;
+ let mut properly_formatted = false;
+ let input_is_stdin = filename_input == OsStr::new("-");
+
+ let file: Box<dyn Read> = if input_is_stdin {
+ Box::new(stdin()) // Use stdin if "-" is specified
+ } else {
+ match File::open(filename_input) {
+ Ok(f) => Box::new(f),
+ Err(_) => {
+ return Err(io::Error::new(
+ io::ErrorKind::Other,
+ format!(
+ "{}: No such file or directory",
+ filename_input.to_string_lossy()
+ ),
+ )
+ .into());
+ }
+ }
+ };
+
+ let reader = BufReader::new(file);
+ let lines: Vec<String> = reader.lines().collect::<Result<_, _>>()?;
+ let (chosen_regex, is_algo_based_format) =
+ determine_regex(filename_input, input_is_stdin, &lines)?;
+
+ for (i, line) in lines.iter().enumerate() {
+ if let Some(caps) = chosen_regex.captures(line) {
+ properly_formatted = true;
+
+ let mut filename_to_check = caps.name("filename").unwrap().as_str();
+ if filename_to_check.starts_with('*')
+ && i == 0
+ && chosen_regex.as_str() == SINGLE_SPACE_REGEX
+ {
+ // Remove the leading asterisk if present - only for the first line
+ filename_to_check = &filename_to_check[1..];
+ }
+
+ let expected_checksum = caps.name("checksum").unwrap().as_str();
+
+ // If the algo_name is provided, we use it, otherwise we try to detect it
+ let (algo_name, length) = if is_algo_based_format {
+ // When the algo-based format is matched, extract details from regex captures
+ let algorithm = caps.name("algo").map_or("", |m| m.as_str()).to_lowercase();
+
+ // check if we are called with XXXsum (example: md5sum) but we detected a different algo parsing the file
+ // (for example SHA1 (f) = d...)
+ // Also handle the case cksum -s sm3 but the file contains other formats
+ if algo_name_input.is_some() && algo_name_input != Some(&algorithm) {
+ bad_format += 1;
+ properly_formatted = false;
+ continue;
+ }
+
+ if !SUPPORTED_ALGORITHMS.contains(&algorithm.as_str()) {
+ // Not supported algo, leave early
+ properly_formatted = false;
+ continue;
+ }
+
+ let bits = caps.name("bits").map_or(Some(None), |m| {
+ let bits_value = m.as_str().parse::<usize>().unwrap();
+ if bits_value % 8 == 0 {
+ Some(Some(bits_value / 8))
+ } else {
+ properly_formatted = false;
+ None // Return None to signal a divisibility issue
+ }
+ });
+
+ if bits.is_none() {
+ // If bits is None, we have a parsing or divisibility issue
+ // Exit the loop outside of the closure
+ continue;
+ }
+
+ (algorithm, bits.unwrap())
+ } else if let Some(a) = algo_name_input {
+ // When a specific algorithm name is input, use it and use the provided bits
+ (a.to_lowercase(), length_input)
+ } else {
+ // Default case if no algorithm is specified and non-algo based format is matched
+ (String::new(), None)
+ };
+
+ if is_algo_based_format && algo_name_input.map_or(false, |input| algo_name != input)
+ {
+ bad_format += 1;
+ continue;
+ }
+
+ if algo_name.is_empty() {
+ // we haven't been able to detect the algo name. No point to continue
+ properly_formatted = false;
+ continue;
+ }
+ let mut algo = detect_algo(&algo_name, length)?;
+
+ let (filename_to_check_unescaped, prefix) = unescape_filename(filename_to_check);
+
+ // manage the input file
+ let file_to_check: Box<dyn Read> = if filename_to_check == "-" {
+ Box::new(stdin()) // Use stdin if "-" is specified in the checksum file
+ } else {
+ match File::open(&filename_to_check_unescaped) {
+ Ok(f) => {
+ if f.metadata()?.is_dir() {
+ show!(USimpleError::new(
+ 1,
+ format!("{}: Is a directory", filename_to_check_unescaped)
+ ));
+ continue;
+ }
+ Box::new(f)
+ }
+ Err(err) => {
+ if !ignore_missing {
+ // yes, we have both stderr and stdout here
+ show!(err.map_err_context(|| filename_to_check.to_string()));
+ println!("{}: FAILED open or read", filename_to_check);
+ }
+ failed_open_file += 1;
+ // we could not open the file but we want to continue
+
+ continue;
+ }
+ }
+ };
+
+ let mut file_reader = BufReader::new(file_to_check);
+ // Read the file and calculate the checksum
+ let create_fn = &mut algo.create_fn;
+ let mut digest = create_fn();
+ let (calculated_checksum, _) =
+ digest_reader(&mut digest, &mut file_reader, binary, algo.bits).unwrap();
+
+ // Do the checksum validation
+ if expected_checksum == calculated_checksum {
+ if !quiet && !status {
+ println!("{prefix}{filename_to_check}: OK");
+ }
+ correct_format += 1;
+ } else {
+ if !status {
+ println!("{prefix}{filename_to_check}: FAILED");
+ }
+ failed_cksum += 1;
+ }
+ } else {
+ if line.is_empty() {
+ // Don't show any warning for empty lines
+ continue;
+ }
+ if warn {
+ let algo = if let Some(algo_name_input) = algo_name_input {
+ algo_name_input.to_uppercase()
+ } else {
+ "Unknown algorithm".to_string()
+ };
+ eprintln!(
+ "{}: {}: {}: improperly formatted {} checksum line",
+ util_name(),
+ &filename_input.maybe_quote(),
+ i + 1,
+ algo
+ );
+ }
+
+ bad_format += 1;
+ }
+ }
+
+ // not a single line correctly formatted found
+ // return an error
+ if !properly_formatted {
+ if !status {
+ return Err(ChecksumError::NoProperlyFormattedChecksumLinesFound(
+ get_filename_for_output(filename_input, input_is_stdin),
+ )
+ .into());
+ }
+ set_exit_code(1);
+
+ return Ok(());
+ }
+
+ if ignore_missing && correct_format == 0 {
+ // we have only bad format
+ // and we had ignore-missing
+ eprintln!(
+ "{}: {}: no file was verified",
+ util_name(),
+ filename_input.maybe_quote(),
+ );
+ set_exit_code(1);
+ }
+
+ // strict means that we should have an exit code.
+ if strict && bad_format > 0 {
+ set_exit_code(1);
+ }
+
+ // if we have any failed checksum verification, we set an exit code
+ // except if we have ignore_missing
+ if (failed_cksum > 0 || failed_open_file > 0) && !ignore_missing {
+ set_exit_code(1);
+ }
+
+ // if any incorrectly formatted line, show it
+ cksum_output(
+ bad_format,
+ failed_cksum,
+ failed_open_file,
+ ignore_missing,
+ status,
+ );
+ }
+ Ok(())
+}
+
+pub fn digest_reader<T: Read>(
+ digest: &mut Box<dyn Digest>,
+ reader: &mut BufReader<T>,
+ binary: bool,
+ output_bits: usize,
+) -> io::Result<(String, usize)> {
+ digest.reset();
+
+ // Read bytes from `reader` and write those bytes to `digest`.
+ //
+ // If `binary` is `false` and the operating system is Windows, then
+ // `DigestWriter` replaces "\r\n" with "\n" before it writes the
+ // bytes into `digest`. Otherwise, it just inserts the bytes as-is.
+ //
+ // In order to support replacing "\r\n", we must call `finalize()`
+ // in order to support the possibility that the last character read
+ // from the reader was "\r". (This character gets buffered by
+ // `DigestWriter` and only written if the following character is
+ // "\n". But when "\r" is the last character read, we need to force
+ // it to be written.)
+ let mut digest_writer = DigestWriter::new(digest, binary);
+ let output_size = std::io::copy(reader, &mut digest_writer)? as usize;
+ digest_writer.finalize();
+
+ if digest.output_bits() > 0 {
+ Ok((digest.result_str(), output_size))
+ } else {
+ // Assume it's SHAKE. result_str() doesn't work with shake (as of 8/30/2016)
+ let mut bytes = vec![0; (output_bits + 7) / 8];
+ digest.hash_finalize(&mut bytes);
+ Ok((hex::encode(bytes), output_size))
+ }
+}
+
+/// Calculates the length of the digest.
+pub fn calculate_blake2b_length(length: usize) -> UResult<Option<usize>> {
+ match length {
+ 0 => Ok(None),
+ n if n % 8 != 0 => {
+ show_error!("invalid length: \u{2018}{length}\u{2019}");
+ Err(io::Error::new(io::ErrorKind::InvalidInput, "length is not a multiple of 8").into())
+ }
+ n if n > 512 => {
+ show_error!("invalid length: \u{2018}{length}\u{2019}");
+ Err(io::Error::new(
+ io::ErrorKind::InvalidInput,
+ "maximum digest length for \u{2018}BLAKE2b\u{2019} is 512 bits",
+ )
+ .into())
+ }
+ n => {
+ // Divide by 8, as our blake2b implementation expects bytes instead of bits.
+ if n == 512 {
+ // When length is 512, it is blake2b's default.
+ // So, don't show it
+ Ok(None)
+ } else {
+ Ok(Some(n / 8))
+ }
+ }
+ }
+}
+
+pub fn unescape_filename(filename: &str) -> (String, &'static str) {
+ let unescaped = filename
+ .replace("\\\\", "\\")
+ .replace("\\n", "\n")
+ .replace("\\r", "\r");
+ let prefix = if unescaped == filename { "" } else { "\\" };
+ (unescaped, prefix)
+}
+
+pub fn escape_filename(filename: &Path) -> (String, &'static str) {
+ let original = filename.as_os_str().to_string_lossy();
+ let escaped = original
+ .replace('\\', "\\\\")
+ .replace('\n', "\\n")
+ .replace('\r', "\\r");
+ let prefix = if escaped == original { "" } else { "\\" };
+ (escaped, prefix)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_unescape_filename() {
+ let (unescaped, prefix) = unescape_filename("test\\nfile.txt");
+ assert_eq!(unescaped, "test\nfile.txt");
+ assert_eq!(prefix, "\\");
+ let (unescaped, prefix) = unescape_filename("test\\nfile.txt");
+ assert_eq!(unescaped, "test\nfile.txt");
+ assert_eq!(prefix, "\\");
+
+ let (unescaped, prefix) = unescape_filename("test\\rfile.txt");
+ assert_eq!(unescaped, "test\rfile.txt");
+ assert_eq!(prefix, "\\");
+
+ let (unescaped, prefix) = unescape_filename("test\\\\file.txt");
+ assert_eq!(unescaped, "test\\file.txt");
+ assert_eq!(prefix, "\\");
+ }
+
+ #[test]
+ fn test_escape_filename() {
+ let (escaped, prefix) = escape_filename(Path::new("testfile.txt"));
+ assert_eq!(escaped, "testfile.txt");
+ assert_eq!(prefix, "");
+
+ let (escaped, prefix) = escape_filename(Path::new("test\nfile.txt"));
+ assert_eq!(escaped, "test\\nfile.txt");
+ assert_eq!(prefix, "\\");
+
+ let (escaped, prefix) = escape_filename(Path::new("test\rfile.txt"));
+ assert_eq!(escaped, "test\\rfile.txt");
+ assert_eq!(prefix, "\\");
+
+ let (escaped, prefix) = escape_filename(Path::new("test\\file.txt"));
+ assert_eq!(escaped, "test\\\\file.txt");
+ assert_eq!(prefix, "\\");
+ }
+
+ #[test]
+ fn test_calculate_blake2b_length() {
+ assert_eq!(calculate_blake2b_length(0).unwrap(), None);
+ assert!(calculate_blake2b_length(10).is_err());
+ assert!(calculate_blake2b_length(520).is_err());
+ assert_eq!(calculate_blake2b_length(512).unwrap(), None);
+ assert_eq!(calculate_blake2b_length(256).unwrap(), Some(32));
+ }
+
+ #[test]
+ fn test_detect_algo() {
+ assert_eq!(
+ detect_algo(ALGORITHM_OPTIONS_SYSV, None).unwrap().name,
+ ALGORITHM_OPTIONS_SYSV
+ );
+ assert_eq!(
+ detect_algo(ALGORITHM_OPTIONS_BSD, None).unwrap().name,
+ ALGORITHM_OPTIONS_BSD
+ );
+ assert_eq!(
+ detect_algo(ALGORITHM_OPTIONS_CRC, None).unwrap().name,
+ ALGORITHM_OPTIONS_CRC
+ );
+ assert_eq!(
+ detect_algo(ALGORITHM_OPTIONS_MD5, None).unwrap().name,
+ ALGORITHM_OPTIONS_MD5
+ );
+ assert_eq!(
+ detect_algo(ALGORITHM_OPTIONS_SHA1, None).unwrap().name,
+ ALGORITHM_OPTIONS_SHA1
+ );
+ assert_eq!(
+ detect_algo(ALGORITHM_OPTIONS_SHA224, None).unwrap().name,
+ ALGORITHM_OPTIONS_SHA224
+ );
+ assert_eq!(
+ detect_algo(ALGORITHM_OPTIONS_SHA256, None).unwrap().name,
+ ALGORITHM_OPTIONS_SHA256
+ );
+ assert_eq!(
+ detect_algo(ALGORITHM_OPTIONS_SHA384, None).unwrap().name,
+ ALGORITHM_OPTIONS_SHA384
+ );
+ assert_eq!(
+ detect_algo(ALGORITHM_OPTIONS_SHA512, None).unwrap().name,
+ ALGORITHM_OPTIONS_SHA512
+ );
+ assert_eq!(
+ detect_algo(ALGORITHM_OPTIONS_BLAKE2B, None).unwrap().name,
+ ALGORITHM_OPTIONS_BLAKE2B
+ );
+ assert_eq!(
+ detect_algo(ALGORITHM_OPTIONS_BLAKE3, None).unwrap().name,
+ ALGORITHM_OPTIONS_BLAKE3
+ );
+ assert_eq!(
+ detect_algo(ALGORITHM_OPTIONS_SM3, None).unwrap().name,
+ ALGORITHM_OPTIONS_SM3
+ );
+ assert_eq!(
+ detect_algo(ALGORITHM_OPTIONS_SHAKE128, Some(128))
+ .unwrap()
+ .name,
+ ALGORITHM_OPTIONS_SHAKE128
+ );
+ assert_eq!(
+ detect_algo(ALGORITHM_OPTIONS_SHAKE256, Some(256))
+ .unwrap()
+ .name,
+ ALGORITHM_OPTIONS_SHAKE256
+ );
+ assert_eq!(detect_algo("sha3_224", Some(224)).unwrap().name, "SHA3_224");
+ assert_eq!(detect_algo("sha3_256", Some(256)).unwrap().name, "SHA3_256");
+ assert_eq!(detect_algo("sha3_384", Some(384)).unwrap().name, "SHA3_384");
+ assert_eq!(detect_algo("sha3_512", Some(512)).unwrap().name, "SHA3_512");
+
+ assert!(detect_algo("sha3_512", None).is_err());
+ }
+
+ #[test]
+ fn test_algo_based_regex() {
+ let algo_based_regex = Regex::new(ALGO_BASED_REGEX).unwrap();
+ let test_cases = vec![
+ ("SHA256 (example.txt) = d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2", Some(("SHA256", None, "example.txt", "d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2"))),
+ // cspell:disable-next-line
+ ("BLAKE2b-512 (file) = abcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdef", Some(("BLAKE2b", Some("512"), "file", "abcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdef"))),
+ (" MD5 (test) = 9e107d9d372bb6826bd81d3542a419d6", Some(("MD5", None, "test", "9e107d9d372bb6826bd81d3542a419d6"))),
+ ("SHA-1 (anotherfile) = a9993e364706816aba3e25717850c26c9cd0d89d", Some(("SHA", Some("1"), "anotherfile", "a9993e364706816aba3e25717850c26c9cd0d89d"))),
+ ];
+
+ for (input, expected) in test_cases {
+ let captures = algo_based_regex.captures(input);
+ match expected {
+ Some((algo, bits, filename, checksum)) => {
+ assert!(captures.is_some());
+ let captures = captures.unwrap();
+ assert_eq!(captures.name("algo").unwrap().as_str(), algo);
+ assert_eq!(captures.name("bits").map(|m| m.as_str()), bits);
+ assert_eq!(captures.name("filename").unwrap().as_str(), filename);
+ assert_eq!(captures.name("checksum").unwrap().as_str(), checksum);
+ }
+ None => {
+ assert!(captures.is_none());
+ }
+ }
+ }
+ }
+
+ #[test]
+ fn test_double_space_regex() {
+ let double_space_regex = Regex::new(DOUBLE_SPACE_REGEX).unwrap();
+
+ let test_cases = vec![
+ (
+ "60b725f10c9c85c70d97880dfe8191b3 a",
+ Some(("60b725f10c9c85c70d97880dfe8191b3", "a")),
+ ),
+ (
+ "bf35d7536c785cf06730d5a40301eba2 b",
+ Some(("bf35d7536c785cf06730d5a40301eba2", " b")),
+ ),
+ (
+ "f5b61709718c1ecf8db1aea8547d4698 *c",
+ Some(("f5b61709718c1ecf8db1aea8547d4698", "*c")),
+ ),
+ (
+ "b064a020db8018f18ff5ae367d01b212 dd",
+ Some(("b064a020db8018f18ff5ae367d01b212", "dd")),
+ ),
+ (
+ "b064a020db8018f18ff5ae367d01b212 ",
+ Some(("b064a020db8018f18ff5ae367d01b212", " ")),
+ ),
+ ("invalidchecksum test", None),
+ ];
+
+ for (input, expected) in test_cases {
+ let captures = double_space_regex.captures(input);
+ match expected {
+ Some((checksum, filename)) => {
+ assert!(captures.is_some());
+ let captures = captures.unwrap();
+ assert_eq!(captures.name("checksum").unwrap().as_str(), checksum);
+ assert_eq!(captures.name("filename").unwrap().as_str(), filename);
+ }
+ None => {
+ assert!(captures.is_none());
+ }
+ }
+ }
+ }
+
+ #[test]
+ fn test_single_space_regex() {
+ let single_space_regex = Regex::new(SINGLE_SPACE_REGEX).unwrap();
+ let test_cases = vec![
+ (
+ "60b725f10c9c85c70d97880dfe8191b3 a",
+ Some(("60b725f10c9c85c70d97880dfe8191b3", "a")),
+ ),
+ (
+ "bf35d7536c785cf06730d5a40301eba2 b",
+ Some(("bf35d7536c785cf06730d5a40301eba2", "b")),
+ ),
+ (
+ "f5b61709718c1ecf8db1aea8547d4698 *c",
+ Some(("f5b61709718c1ecf8db1aea8547d4698", "*c")),
+ ),
+ (
+ "b064a020db8018f18ff5ae367d01b212 dd",
+ Some(("b064a020db8018f18ff5ae367d01b212", "dd")),
+ ),
+ ("invalidchecksum test", None),
+ ];
+
+ for (input, expected) in test_cases {
+ let captures = single_space_regex.captures(input);
+ match expected {
+ Some((checksum, filename)) => {
+ assert!(captures.is_some());
+ let captures = captures.unwrap();
+ assert_eq!(captures.name("checksum").unwrap().as_str(), checksum);
+ assert_eq!(captures.name("filename").unwrap().as_str(), filename);
+ }
+ None => {
+ assert!(captures.is_none());
+ }
+ }
+ }
+ }
+
+ #[test]
+ fn test_determine_regex() {
+ let filename = std::ffi::OsStr::new("test.txt");
+ // Test algo-based regex
+ let lines_algo_based =
+ vec!["MD5 (example.txt) = d41d8cd98f00b204e9800998ecf8427e".to_string()];
+ let result = determine_regex(filename, false, &lines_algo_based);
+ assert!(result.is_ok());
+ let (regex, algo_based) = result.unwrap();
+ assert!(algo_based);
+ assert!(regex.is_match(&lines_algo_based[0]));
+
+ // Test double-space regex
+ let lines_double_space = vec!["d41d8cd98f00b204e9800998ecf8427e example.txt".to_string()];
+ let result = determine_regex(filename, false, &lines_double_space);
+ assert!(result.is_ok());
+ let (regex, algo_based) = result.unwrap();
+ assert!(!algo_based);
+ assert!(regex.is_match(&lines_double_space[0]));
+
+ // Test single-space regex
+ let lines_single_space = vec!["d41d8cd98f00b204e9800998ecf8427e example.txt".to_string()];
+ let result = determine_regex(filename, false, &lines_single_space);
+ assert!(result.is_ok());
+ let (regex, algo_based) = result.unwrap();
+ assert!(!algo_based);
+ assert!(regex.is_match(&lines_single_space[0]));
+
+ // Test double-space regex start with invalid
+ let lines_double_space = vec![
+ "ERR".to_string(),
+ "d41d8cd98f00b204e9800998ecf8427e example.txt".to_string(),
+ ];
+ let result = determine_regex(filename, false, &lines_double_space);
+ assert!(result.is_ok());
+ let (regex, algo_based) = result.unwrap();
+ assert!(!algo_based);
+ assert!(!regex.is_match(&lines_double_space[0]));
+ assert!(regex.is_match(&lines_double_space[1]));
+
+ // Test invalid checksum line
+ let lines_invalid = vec!["invalid checksum line".to_string()];
+ let result = determine_regex(filename, false, &lines_invalid);
+ assert!(result.is_err());
+ }
+}
diff --git a/src/uucore/src/lib/features/colors.rs b/src/uucore/src/lib/features/colors.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e0de8b1e3e3a4ba991883b85c3bfac0fd328c7dd
--- /dev/null
+++ b/src/uucore/src/lib/features/colors.rs
@@ -0,0 +1,264 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// cSpell:disable
+
+/// The keywords COLOR, OPTIONS, and EIGHTBIT (honored by the
+/// slackware version of dircolors) are recognized but ignored.
+/// Global config options can be specified before TERM or COLORTERM entries
+/// below are TERM or COLORTERM entries, which can be glob patterns, which
+/// restrict following config to systems with matching environment variables.
+pub static TERMS: &[&str] = &[
+ "Eterm",
+ "ansi",
+ "*color*",
+ "con[0-9]*x[0-9]*",
+ "cons25",
+ "console",
+ "cygwin",
+ "*direct*",
+ "dtterm",
+ "gnome",
+ "hurd",
+ "jfbterm",
+ "konsole",
+ "kterm",
+ "linux",
+ "linux-c",
+ "mlterm",
+ "putty",
+ "rxvt*",
+ "screen*",
+ "st",
+ "terminator",
+ "tmux*",
+ "vt100",
+ "xterm*",
+];
+
+/// Below are the color init strings for the basic file types.
+/// One can use codes for 256 or more colors supported by modern terminals.
+/// The default color codes use the capabilities of an 8 color terminal
+/// with some additional attributes as per the following codes:
+/// Attribute codes:
+/// 00=none 01=bold 04=underscore 05=blink 07=reverse 08=concealed
+/// Text color codes:
+/// 30=black 31=red 32=green 33=yellow 34=blue 35=magenta 36=cyan 37=white
+/// Background color codes:
+/// 40=black 41=red 42=green 43=yellow 44=blue 45=magenta 46=cyan 47=white
+/// #NORMAL 00 /// no color code at all
+/// #FILE 00 /// regular file: use no color at all
+pub static FILE_TYPES: &[(&str, &str, &str)] = &[
+ ("RESET", "rs", "0"), // reset to "normal" color
+ ("DIR", "di", "01;34"), // directory
+ ("LINK", "ln", "01;36"), // symbolic link
+ ("MULTIHARDLINK", "mh", "00"), // regular file with more than one link
+ ("FIFO", "pi", "40;33"), // pipe
+ ("SOCK", "so", "01;35"), // socket
+ ("DOOR", "do", "01;35"), // door
+ ("BLK", "bd", "40;33;01"), // block device driver
+ ("CHR", "cd", "40;33;01"), // character device driver
+ ("ORPHAN", "or", "40;31;01"), // symlink to nonexistent file, or non-stat'able file
+ ("MISSING", "mi", "00"), // ... and the files they point to
+ ("SETUID", "su", "37;41"), // file that is setuid (u+s)
+ ("SETGID", "sg", "30;43"), // file that is setgid (g+s)
+ ("CAPABILITY", "ca", "00"), // file with capability
+ ("STICKY_OTHER_WRITABLE", "tw", "30;42"), // dir that is sticky and other-writable (+t,o+w)
+ ("OTHER_WRITABLE", "ow", "34;42"), // dir that is other-writable (o+w) and not sticky
+ ("STICKY", "st", "37;44"), // dir with the sticky bit set (+t) and not other-writable
+ ("EXEC", "ex", "01;32"), // files with execute permission
+];
+
+/// Colors for file types
+///
+/// List any file extensions like '.gz' or '.tar' that you would like ls
+/// to color below. Put the extension, a space, and the color init string.
+/// (and any comments you want to add after a '#')
+pub static FILE_COLORS: &[(&str, &str)] = &[
+ /*
+ // Executables (Windows)
+ (".cmd", "01;32"),
+ (".exe", "01;32"),
+ (".com", "01;32"),
+ (".btm", "01;32"),
+ (".bat", "01;32"),
+ (".sh", "01;32"),
+ (".csh", "01;32"),*/
+ // Archives or compressed
+ (".tar", "01;31"),
+ (".tgz", "01;31"),
+ (".arc", "01;31"),
+ (".arj", "01;31"),
+ (".taz", "01;31"),
+ (".lha", "01;31"),
+ (".lz4", "01;31"),
+ (".lzh", "01;31"),
+ (".lzma", "01;31"),
+ (".tlz", "01;31"),
+ (".txz", "01;31"),
+ (".tzo", "01;31"),
+ (".t7z", "01;31"),
+ (".zip", "01;31"),
+ (".z", "01;31"),
+ (".dz", "01;31"),
+ (".gz", "01;31"),
+ (".lrz", "01;31"),
+ (".lz", "01;31"),
+ (".lzo", "01;31"),
+ (".xz", "01;31"),
+ (".zst", "01;31"),
+ (".tzst", "01;31"),
+ (".bz2", "01;31"),
+ (".bz", "01;31"),
+ (".tbz", "01;31"),
+ (".tbz2", "01;31"),
+ (".tz", "01;31"),
+ (".deb", "01;31"),
+ (".rpm", "01;31"),
+ (".jar", "01;31"),
+ (".war", "01;31"),
+ (".ear", "01;31"),
+ (".sar", "01;31"),
+ (".rar", "01;31"),
+ (".alz", "01;31"),
+ (".ace", "01;31"),
+ (".zoo", "01;31"),
+ (".cpio", "01;31"),
+ (".7z", "01;31"),
+ (".rz", "01;31"),
+ (".cab", "01;31"),
+ (".wim", "01;31"),
+ (".swm", "01;31"),
+ (".dwm", "01;31"),
+ (".esd", "01;31"),
+ // Image formats
+ (".avif", "01;35"),
+ (".jpg", "01;35"),
+ (".jpeg", "01;35"),
+ (".mjpg", "01;35"),
+ (".mjpeg", "01;35"),
+ (".gif", "01;35"),
+ (".bmp", "01;35"),
+ (".pbm", "01;35"),
+ (".pgm", "01;35"),
+ (".ppm", "01;35"),
+ (".tga", "01;35"),
+ (".xbm", "01;35"),
+ (".xpm", "01;35"),
+ (".tif", "01;35"),
+ (".tiff", "01;35"),
+ (".png", "01;35"),
+ (".svg", "01;35"),
+ (".svgz", "01;35"),
+ (".mng", "01;35"),
+ (".pcx", "01;35"),
+ (".mov", "01;35"),
+ (".mpg", "01;35"),
+ (".mpeg", "01;35"),
+ (".m2v", "01;35"),
+ (".mkv", "01;35"),
+ (".webm", "01;35"),
+ (".webp", "01;35"),
+ (".ogm", "01;35"),
+ (".mp4", "01;35"),
+ (".m4v", "01;35"),
+ (".mp4v", "01;35"),
+ (".vob", "01;35"),
+ (".qt", "01;35"),
+ (".nuv", "01;35"),
+ (".wmv", "01;35"),
+ (".asf", "01;35"),
+ (".rm", "01;35"),
+ (".rmvb", "01;35"),
+ (".flc", "01;35"),
+ (".avi", "01;35"),
+ (".fli", "01;35"),
+ (".flv", "01;35"),
+ (".gl", "01;35"),
+ (".dl", "01;35"),
+ (".xcf", "01;35"),
+ (".xwd", "01;35"),
+ (".yuv", "01;35"),
+ (".cgm", "01;35"),
+ (".emf", "01;35"),
+ // https://wiki.xiph.org/MIME_Types_and_File_Extensions
+ (".ogv", "01;35"),
+ (".ogx", "01;35"),
+ // Audio formats
+ (".aac", "00;36"),
+ (".au", "00;36"),
+ (".flac", "00;36"),
+ (".m4a", "00;36"),
+ (".mid", "00;36"),
+ (".midi", "00;36"),
+ (".mka", "00;36"),
+ (".mp3", "00;36"),
+ (".mpc", "00;36"),
+ (".ogg", "00;36"),
+ (".ra", "00;36"),
+ (".wav", "00;36"),
+ // https://wiki.xiph.org/MIME_Types_and_File_Extensions
+ (".oga", "00;36"),
+ (".opus", "00;36"),
+ (".spx", "00;36"),
+ (".xspf", "00;36"),
+ // Backup files
+ ("*~", "00;90"),
+ ("*#", "00;90"),
+ (".bak", "00;90"),
+ (".old", "00;90"),
+ (".orig", "00;90"),
+ (".part", "00;90"),
+ (".rej", "00;90"),
+ (".swp", "00;90"),
+ (".tmp", "00;90"),
+ (".dpkg-dist", "00;90"),
+ (".dpkg-old", "00;90"),
+ (".ucf-dist", "00;90"),
+ (".ucf-new", "00;90"),
+ (".ucf-old", "00;90"),
+ (".rpmnew", "00;90"),
+ (".rpmorig", "00;90"),
+ (".rpmsave", "00;90"),
+];
+
+pub static FILE_ATTRIBUTE_CODES: &[(&str, &str)] = &[
+ ("normal", "no"),
+ ("norm", "no"),
+ ("file", "fi"),
+ ("reset", "rs"),
+ ("dir", "di"),
+ ("lnk", "ln"),
+ ("link", "ln"),
+ ("symlink", "ln"),
+ ("orphan", "or"),
+ ("missing", "mi"),
+ ("fifo", "pi"),
+ ("pipe", "pi"),
+ ("sock", "so"),
+ ("blk", "bd"),
+ ("block", "bd"),
+ ("chr", "cd"),
+ ("char", "cd"),
+ ("door", "do"),
+ ("exec", "ex"),
+ ("left", "lc"),
+ ("leftcode", "lc"),
+ ("right", "rc"),
+ ("rightcode", "rc"),
+ ("end", "ec"),
+ ("endcode", "ec"),
+ ("suid", "su"),
+ ("setuid", "su"),
+ ("sgid", "sg"),
+ ("setgid", "sg"),
+ ("sticky", "st"),
+ ("other_writable", "ow"),
+ ("owr", "ow"),
+ ("sticky_other_writable", "tw"),
+ ("owt", "tw"),
+ ("capability", "ca"),
+ ("multihardlink", "mh"),
+ ("clrtoeol", "cl"),
+];
diff --git a/src/uucore/src/lib/features/encoding.rs b/src/uucore/src/lib/features/encoding.rs
index e99017070e81df95600975f4f3b7935ba5361057..dd89c1f5201f9710470e1e660062a9e6db8af2cc 100644
--- a/src/uucore/src/lib/features/encoding.rs
+++ b/src/uucore/src/lib/features/encoding.rs
@@ -1,18 +1,14 @@
// This file is part of the uutils coreutils package.
//
-// (c) Jian Zeng <anonymousknight96@gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
// spell-checker:ignore (strings) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABCDEFGHIJKLMNOPQRSTUV
// spell-checker:ignore (encodings) lsbf msbf hexupper
-use data_encoding::{self, BASE32, BASE64};
-
use std::io::{self, Read, Write};
-use data_encoding::{Encoding, BASE32HEX, BASE64URL, HEXUPPER};
+use data_encoding::{Encoding, BASE32, BASE32HEX, BASE64, BASE64URL, HEXUPPER};
use data_encoding_macro::new_encoding;
#[cfg(feature = "thiserror")]
use thiserror::Error;
@@ -27,8 +23,10 @@ pub enum DecodeError {
Io(#[from] io::Error),
}
+#[derive(Debug)]
pub enum EncodeError {
Z85InputLenNotMultipleOf4,
+ InvalidInput,
}
pub type DecodeResult = Result<Vec<u8>, DecodeError>;
@@ -67,10 +65,10 @@ pub fn encode(f: Format, input: &[u8]) -> Result<String, EncodeError> {
Z85 => {
// According to the spec we should not accept inputs whose len is not a multiple of 4.
// However, the z85 crate implements a padded encoding and accepts such inputs. We have to manually check for them.
- if input.len() % 4 != 0 {
- return Err(EncodeError::Z85InputLenNotMultipleOf4);
- } else {
+ if input.len() % 4 == 0 {
z85::encode(input)
+ } else {
+ return Err(EncodeError::Z85InputLenNotMultipleOf4);
}
}
})
@@ -150,8 +148,10 @@ impl<R: Read> Data<R> {
pub fn encode(&mut self) -> Result<String, EncodeError> {
let mut buf: Vec<u8> = vec![];
- self.input.read_to_end(&mut buf).unwrap();
- encode(self.format, buf.as_slice())
+ match self.input.read_to_end(&mut buf) {
+ Ok(_) => encode(self.format, buf.as_slice()),
+ Err(_) => Err(EncodeError::InvalidInput),
+ }
}
}
@@ -165,7 +165,7 @@ pub fn wrap_write<W: Write>(mut writer: W, line_wrap: usize, res: &str) -> io::R
use std::cmp::min;
if line_wrap == 0 {
- return write!(writer, "{}", res);
+ return write!(writer, "{res}");
}
let mut start = 0;
diff --git a/src/uucore/src/lib/features/entries.rs b/src/uucore/src/lib/features/entries.rs
index 561de888bd24ff9c32ed4c6f85db358b2d3644bf..e2cbafa59c53971fc34db136ae694ee3287f02f3 100644
--- a/src/uucore/src/lib/features/entries.rs
+++ b/src/uucore/src/lib/features/entries.rs
@@ -1,7 +1,5 @@
// This file is part of the uutils coreutils package.
//
-// (c) Jian Zeng <anonymousknight96@gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
@@ -37,7 +35,6 @@
#[cfg(any(target_os = "freebsd", target_vendor = "apple"))]
use libc::time_t;
use libc::{c_char, c_int, gid_t, uid_t};
-#[cfg(not(target_os = "redox"))]
use libc::{getgrgid, getgrnam, getgroups};
use libc::{getpwnam, getpwuid, group, passwd};
@@ -69,7 +66,6 @@ extern "C" {
/// > supplementary group IDs for the process is returned. This allows
/// > the caller to determine the size of a dynamically allocated list
/// > to be used in a further call to getgroups().
-#[cfg(not(target_os = "redox"))]
pub fn get_groups() -> IOResult<Vec<gid_t>> {
let mut groups = Vec::new();
loop {
@@ -128,7 +124,7 @@ pub fn get_groups_gnu(arg_id: Option<u32>) -> IOResult<Vec<gid_t>> {
Ok(sort_groups(groups, egid))
}
-#[cfg(all(unix, feature = "process"))]
+#[cfg(all(unix, not(target_os = "redox"), feature = "process"))]
fn sort_groups(mut groups: Vec<gid_t>, egid: gid_t) -> Vec<gid_t> {
if let Some(index) = groups.iter().position(|&x| x == egid) {
groups[..=index].rotate_right(1);
@@ -168,10 +164,10 @@ pub struct Passwd {
/// SAFETY: ptr must point to a valid C string.
/// Returns None if ptr is null.
unsafe fn cstr2string(ptr: *const c_char) -> Option<String> {
- if !ptr.is_null() {
- Some(CStr::from_ptr(ptr).to_string_lossy().into_owned())
- } else {
+ if ptr.is_null() {
None
+ } else {
+ Some(CStr::from_ptr(ptr).to_string_lossy().into_owned())
}
}
@@ -220,7 +216,7 @@ impl Passwd {
let mut ngroups: c_int = 8;
let mut ngroups_old: c_int;
let mut groups = vec![0; ngroups.try_into().unwrap()];
- let name = CString::new(self.name.clone()).unwrap();
+ let name = CString::new(self.name.as_bytes()).unwrap();
loop {
ngroups_old = ngroups;
if unsafe { getgrouplist(name.as_ptr(), self.gid, groups.as_mut_ptr(), &mut ngroups) }
@@ -321,7 +317,8 @@ macro_rules! f {
} else {
// SAFETY: We're holding PW_LOCK.
unsafe {
- let data = $fnam(CString::new(k).unwrap().as_ptr());
+ let cstring = CString::new(k).unwrap();
+ let data = $fnam(cstring.as_ptr());
if !data.is_null() {
Ok($st::from_raw(ptr::read(data as *const _)))
} else {
@@ -338,7 +335,6 @@ macro_rules! f {
}
f!(getpwnam, getpwuid, uid_t, Passwd);
-#[cfg(not(target_os = "redox"))]
f!(getgrnam, getgrgid, gid_t, Group);
#[inline]
@@ -346,7 +342,6 @@ pub fn uid2usr(id: uid_t) -> IOResult<String> {
Passwd::locate(id).map(|p| p.name)
}
-#[cfg(not(target_os = "redox"))]
#[inline]
pub fn gid2grp(id: gid_t) -> IOResult<String> {
Group::locate(id).map(|p| p.name)
@@ -357,7 +352,6 @@ pub fn usr2uid(name: &str) -> IOResult<uid_t> {
Passwd::locate(name).map(|p| p.uid)
}
-#[cfg(not(target_os = "redox"))]
#[inline]
pub fn grp2gid(name: &str) -> IOResult<gid_t> {
Group::locate(name).map(|p| p.gid)
diff --git a/src/uucore/src/lib/features/format/argument.rs b/src/uucore/src/lib/features/format/argument.rs
new file mode 100644
index 0000000000000000000000000000000000000000..75851049895cc528eee5f34abafa018adb2587f4
--- /dev/null
+++ b/src/uucore/src/lib/features/format/argument.rs
@@ -0,0 +1,128 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use crate::{
+ error::set_exit_code,
+ features::format::num_parser::{ParseError, ParsedNumber},
+ quoting_style::{escape_name, Quotes, QuotingStyle},
+ show_error, show_warning,
+};
+use os_display::Quotable;
+use std::ffi::OsStr;
+
+/// An argument for formatting
+///
+/// Each of these variants is only accepted by their respective directives. For
+/// example, [`FormatArgument::Char`] requires a `%c` directive.
+///
+/// The [`FormatArgument::Unparsed`] variant contains a string that can be
+/// parsed into other types. This is used by the `printf` utility.
+#[derive(Clone, Debug)]
+pub enum FormatArgument {
+ Char(char),
+ String(String),
+ UnsignedInt(u64),
+ SignedInt(i64),
+ Float(f64),
+ /// Special argument that gets coerced into the other variants
+ Unparsed(String),
+}
+
+pub trait ArgumentIter<'a>: Iterator<Item = &'a FormatArgument> {
+ fn get_char(&mut self) -> u8;
+ fn get_i64(&mut self) -> i64;
+ fn get_u64(&mut self) -> u64;
+ fn get_f64(&mut self) -> f64;
+ fn get_str(&mut self) -> &'a str;
+}
+
+impl<'a, T: Iterator<Item = &'a FormatArgument>> ArgumentIter<'a> for T {
+ fn get_char(&mut self) -> u8 {
+ let Some(next) = self.next() else {
+ return b'\0';
+ };
+ match next {
+ FormatArgument::Char(c) => *c as u8,
+ FormatArgument::Unparsed(s) => s.bytes().next().unwrap_or(b'\0'),
+ _ => b'\0',
+ }
+ }
+
+ fn get_u64(&mut self) -> u64 {
+ let Some(next) = self.next() else {
+ return 0;
+ };
+ match next {
+ FormatArgument::UnsignedInt(n) => *n,
+ FormatArgument::Unparsed(s) => extract_value(ParsedNumber::parse_u64(s), s),
+ _ => 0,
+ }
+ }
+
+ fn get_i64(&mut self) -> i64 {
+ let Some(next) = self.next() else {
+ return 0;
+ };
+ match next {
+ FormatArgument::SignedInt(n) => *n,
+ FormatArgument::Unparsed(s) => extract_value(ParsedNumber::parse_i64(s), s),
+ _ => 0,
+ }
+ }
+
+ fn get_f64(&mut self) -> f64 {
+ let Some(next) = self.next() else {
+ return 0.0;
+ };
+ match next {
+ FormatArgument::Float(n) => *n,
+ FormatArgument::Unparsed(s) => extract_value(ParsedNumber::parse_f64(s), s),
+ _ => 0.0,
+ }
+ }
+
+ fn get_str(&mut self) -> &'a str {
+ match self.next() {
+ Some(FormatArgument::Unparsed(s) | FormatArgument::String(s)) => s,
+ _ => "",
+ }
+ }
+}
+
+fn extract_value<T: Default>(p: Result<T, ParseError<'_, T>>, input: &str) -> T {
+ match p {
+ Ok(v) => v,
+ Err(e) => {
+ set_exit_code(1);
+ let input = escape_name(
+ OsStr::new(input),
+ &QuotingStyle::C {
+ quotes: Quotes::None,
+ },
+ );
+ match e {
+ ParseError::Overflow => {
+ show_error!("{}: Numerical result out of range", input.quote());
+ Default::default()
+ }
+ ParseError::NotNumeric => {
+ show_error!("{}: expected a numeric value", input.quote());
+ Default::default()
+ }
+ ParseError::PartialMatch(v, rest) => {
+ if input.starts_with('\'') {
+ show_warning!(
+ "{}: character(s) following character constant have been ignored",
+ &rest,
+ );
+ } else {
+ show_error!("{}: value not completely converted", input.quote());
+ }
+ v
+ }
+ }
+ }
+ }
+}
diff --git a/src/uucore/src/lib/features/format/escape.rs b/src/uucore/src/lib/features/format/escape.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9420507f3e3737255acf85a9cd3df33d81c070fd
--- /dev/null
+++ b/src/uucore/src/lib/features/format/escape.rs
@@ -0,0 +1,136 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! Parsing of escape sequences
+
+#[derive(Debug)]
+pub enum EscapedChar {
+ /// A single byte
+ Byte(u8),
+ /// A unicode character
+ Char(char),
+ /// A character prefixed with a backslash (i.e. an invalid escape sequence)
+ Backslash(u8),
+ /// Specifies that the string should stop (`\c`)
+ End,
+}
+
+#[repr(u8)]
+#[derive(Clone, Copy)]
+enum Base {
+ Oct = 8,
+ Hex = 16,
+}
+
+impl Base {
+ fn max_digits(&self) -> u8 {
+ match self {
+ Self::Oct => 3,
+ Self::Hex => 2,
+ }
+ }
+
+ fn convert_digit(&self, c: u8) -> Option<u8> {
+ match self {
+ Self::Oct => {
+ if matches!(c, b'0'..=b'7') {
+ Some(c - b'0')
+ } else {
+ None
+ }
+ }
+ Self::Hex => match c {
+ b'0'..=b'9' => Some(c - b'0'),
+ b'A'..=b'F' => Some(c - b'A' + 10),
+ b'a'..=b'f' => Some(c - b'a' + 10),
+ _ => None,
+ },
+ }
+ }
+}
+
+/// Parse the numeric part of the `\xHHH` and `\0NNN` escape sequences
+fn parse_code(input: &mut &[u8], base: Base) -> Option<u8> {
+ // All arithmetic on `ret` needs to be wrapping, because octal input can
+ // take 3 digits, which is 9 bits, and therefore more than what fits in a
+ // `u8`. GNU just seems to wrap these values.
+ // Note that if we instead make `ret` a `u32` and use `char::from_u32` will
+ // yield incorrect results because it will interpret values larger than
+ // `u8::MAX` as unicode.
+ let [c, rest @ ..] = input else { return None };
+ let mut ret = base.convert_digit(*c)?;
+ *input = rest;
+
+ for _ in 1..base.max_digits() {
+ let [c, rest @ ..] = input else { break };
+ let Some(n) = base.convert_digit(*c) else {
+ break;
+ };
+ ret = ret.wrapping_mul(base as u8).wrapping_add(n);
+ *input = rest;
+ }
+
+ Some(ret)
+}
+
+// spell-checker:disable-next
+/// Parse `\uHHHH` and `\UHHHHHHHH`
+// TODO: This should print warnings and possibly halt execution when it fails to parse
+// TODO: If the character cannot be converted to u32, the input should be printed.
+fn parse_unicode(input: &mut &[u8], digits: u8) -> Option<char> {
+ let (c, rest) = input.split_first()?;
+ let mut ret = Base::Hex.convert_digit(*c)? as u32;
+ *input = rest;
+
+ for _ in 1..digits {
+ let (c, rest) = input.split_first()?;
+ let n = Base::Hex.convert_digit(*c)?;
+ ret = ret.wrapping_mul(Base::Hex as u32).wrapping_add(n as u32);
+ *input = rest;
+ }
+
+ char::from_u32(ret)
+}
+
+pub fn parse_escape_code(rest: &mut &[u8]) -> EscapedChar {
+ if let [c, new_rest @ ..] = rest {
+ // This is for the \NNN syntax for octal sequences.
+ // Note that '0' is intentionally omitted because that
+ // would be the \0NNN syntax.
+ if let b'1'..=b'7' = c {
+ if let Some(parsed) = parse_code(rest, Base::Oct) {
+ return EscapedChar::Byte(parsed);
+ }
+ }
+
+ *rest = new_rest;
+ match c {
+ b'\\' => EscapedChar::Byte(b'\\'),
+ b'"' => EscapedChar::Byte(b'"'),
+ b'a' => EscapedChar::Byte(b'\x07'),
+ b'b' => EscapedChar::Byte(b'\x08'),
+ b'c' => EscapedChar::End,
+ b'e' => EscapedChar::Byte(b'\x1b'),
+ b'f' => EscapedChar::Byte(b'\x0c'),
+ b'n' => EscapedChar::Byte(b'\n'),
+ b'r' => EscapedChar::Byte(b'\r'),
+ b't' => EscapedChar::Byte(b'\t'),
+ b'v' => EscapedChar::Byte(b'\x0b'),
+ b'x' => {
+ if let Some(c) = parse_code(rest, Base::Hex) {
+ EscapedChar::Byte(c)
+ } else {
+ EscapedChar::Backslash(b'x')
+ }
+ }
+ b'0' => EscapedChar::Byte(parse_code(rest, Base::Oct).unwrap_or(b'\0')),
+ b'u' => EscapedChar::Char(parse_unicode(rest, 4).unwrap_or('\0')),
+ b'U' => EscapedChar::Char(parse_unicode(rest, 8).unwrap_or('\0')),
+ c => EscapedChar::Backslash(*c),
+ }
+ } else {
+ EscapedChar::Byte(b'\\')
+ }
+}
diff --git a/src/uucore/src/lib/features/format/human.rs b/src/uucore/src/lib/features/format/human.rs
new file mode 100644
index 0000000000000000000000000000000000000000..28d143a42e3a8aa80e6926a3ae389c1fe5fe382d
--- /dev/null
+++ b/src/uucore/src/lib/features/format/human.rs
@@ -0,0 +1,65 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore gnulibs sfmt
+
+//! `human`-size formatting
+//!
+//! Format sizes like gnulibs human_readable() would
+
+use number_prefix::NumberPrefix;
+
+#[derive(Copy, Clone, PartialEq)]
+pub enum SizeFormat {
+ Bytes,
+ Binary, // Powers of 1024, --human-readable, -h
+ Decimal, // Powers of 1000, --si
+}
+
+// There are a few peculiarities to how GNU formats the sizes:
+// 1. One decimal place is given if and only if the size is smaller than 10
+// 2. It rounds sizes up.
+// 3. The human-readable format uses powers for 1024, but does not display the "i"
+// that is commonly used to denote Kibi, Mebi, etc.
+// 4. Kibi and Kilo are denoted differently ("k" and "K", respectively)
+fn format_prefixed(prefixed: &NumberPrefix<f64>) -> String {
+ match prefixed {
+ NumberPrefix::Standalone(bytes) => bytes.to_string(),
+ NumberPrefix::Prefixed(prefix, bytes) => {
+ // Remove the "i" from "Ki", "Mi", etc. if present
+ let prefix_str = prefix.symbol().trim_end_matches('i');
+
+ // Check whether we get more than 10 if we round up to the first decimal
+ // because we want do display 9.81 as "9.9", not as "10".
+ if (10.0 * bytes).ceil() >= 100.0 {
+ format!("{:.0}{}", bytes.ceil(), prefix_str)
+ } else {
+ format!("{:.1}{}", (10.0 * bytes).ceil() / 10.0, prefix_str)
+ }
+ }
+ }
+}
+
+pub fn human_readable(size: u64, sfmt: SizeFormat) -> String {
+ match sfmt {
+ SizeFormat::Binary => format_prefixed(&NumberPrefix::binary(size as f64)),
+ SizeFormat::Decimal => format_prefixed(&NumberPrefix::decimal(size as f64)),
+ SizeFormat::Bytes => size.to_string(),
+ }
+}
+
+#[cfg(test)]
+#[test]
+fn test_human_readable() {
+ let test_cases = [
+ (133456345, SizeFormat::Binary, "128M"),
+ (12 * 1024 * 1024, SizeFormat::Binary, "12M"),
+ (8500, SizeFormat::Binary, "8.4K"),
+ ];
+
+ for &(size, sfmt, expected_str) in &test_cases {
+ assert_eq!(human_readable(size, sfmt), expected_str);
+ }
+}
diff --git a/src/uucore/src/lib/features/format/mod.rs b/src/uucore/src/lib/features/format/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b82b5f62acffb88f01e3ef0fb47b7bb5158828fe
--- /dev/null
+++ b/src/uucore/src/lib/features/format/mod.rs
@@ -0,0 +1,345 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! `printf`-style formatting
+//!
+//! Rust has excellent formatting capabilities, but the coreutils require very
+//! specific formatting that needs to work exactly like the GNU utilities.
+//! Naturally, the GNU behavior is based on the C `printf` functionality.
+//!
+//! Additionally, we need support for escape sequences for the `printf` utility.
+//!
+//! The [`printf`] and [`sprintf`] functions closely match the behavior of the
+//! corresponding C functions: the former renders a formatted string
+//! to stdout, the latter renders to a new [`String`] object.
+//!
+//! There are three kinds of parsing that we might want to do:
+//!
+//! 1. Parse only `printf` directives (for e.g. `seq`, `dd`)
+//! 2. Parse only escape sequences (for e.g. `echo`)
+//! 3. Parse both `printf` specifiers and escape sequences (for e.g. `printf`)
+//!
+//! This module aims to combine all three use cases. An iterator parsing each
+//! of these cases is provided by [`parse_escape_only`], [`parse_spec_only`]
+//! and [`parse_spec_and_escape`], respectively.
+//!
+//! There is a special [`Format`] type, which can be used to parse a format
+//! string containing exactly one directive and does not use any `*` in that
+//! directive. This format can be printed in a type-safe manner without failing
+//! (modulo IO errors).
+
+mod argument;
+mod escape;
+pub mod human;
+pub mod num_format;
+pub mod num_parser;
+mod spec;
+
+pub use argument::*;
+use spec::Spec;
+use std::{
+ error::Error,
+ fmt::Display,
+ io::{stdout, Write},
+ ops::ControlFlow,
+};
+
+use crate::error::UError;
+
+use self::{
+ escape::{parse_escape_code, EscapedChar},
+ num_format::Formatter,
+};
+
+#[derive(Debug)]
+pub enum FormatError {
+ SpecError(Vec<u8>),
+ IoError(std::io::Error),
+ NoMoreArguments,
+ InvalidArgument(FormatArgument),
+ TooManySpecs(Vec<u8>),
+ NeedAtLeastOneSpec(Vec<u8>),
+ WrongSpecType,
+}
+
+impl Error for FormatError {}
+impl UError for FormatError {}
+
+impl From<std::io::Error> for FormatError {
+ fn from(value: std::io::Error) -> Self {
+ Self::IoError(value)
+ }
+}
+
+impl Display for FormatError {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ Self::SpecError(s) => write!(
+ f,
+ "%{}: invalid conversion specification",
+ String::from_utf8_lossy(s)
+ ),
+ Self::TooManySpecs(s) => write!(
+ f,
+ "format '{}' has too many % directives",
+ String::from_utf8_lossy(s)
+ ),
+ Self::NeedAtLeastOneSpec(s) => write!(
+ f,
+ "format '{}' has no % directive",
+ String::from_utf8_lossy(s)
+ ),
+ // TODO: Error message below needs some work
+ Self::WrongSpecType => write!(f, "wrong % directive type was given"),
+ Self::IoError(_) => write!(f, "io error"),
+ Self::NoMoreArguments => write!(f, "no more arguments"),
+ Self::InvalidArgument(_) => write!(f, "invalid argument"),
+ }
+ }
+}
+
+/// A single item to format
+pub enum FormatItem<C: FormatChar> {
+ /// A format specifier
+ Spec(Spec),
+ /// A single character
+ Char(C),
+}
+
+pub trait FormatChar {
+ fn write(&self, writer: impl Write) -> std::io::Result<ControlFlow<()>>;
+}
+
+impl FormatChar for u8 {
+ fn write(&self, mut writer: impl Write) -> std::io::Result<ControlFlow<()>> {
+ writer.write_all(&[*self])?;
+ Ok(ControlFlow::Continue(()))
+ }
+}
+
+impl FormatChar for EscapedChar {
+ fn write(&self, mut writer: impl Write) -> std::io::Result<ControlFlow<()>> {
+ match self {
+ Self::Byte(c) => {
+ writer.write_all(&[*c])?;
+ }
+ Self::Char(c) => {
+ write!(writer, "{c}")?;
+ }
+ Self::Backslash(c) => {
+ writer.write_all(&[b'\\', *c])?;
+ }
+ Self::End => return Ok(ControlFlow::Break(())),
+ }
+ Ok(ControlFlow::Continue(()))
+ }
+}
+
+impl<C: FormatChar> FormatItem<C> {
+ pub fn write<'a>(
+ &self,
+ writer: impl Write,
+ args: &mut impl Iterator<Item = &'a FormatArgument>,
+ ) -> Result<ControlFlow<()>, FormatError> {
+ match self {
+ Self::Spec(spec) => spec.write(writer, args)?,
+ Self::Char(c) => return c.write(writer).map_err(FormatError::IoError),
+ };
+ Ok(ControlFlow::Continue(()))
+ }
+}
+
+/// Parse a format string containing % directives and escape sequences
+pub fn parse_spec_and_escape(
+ fmt: &[u8],
+) -> impl Iterator<Item = Result<FormatItem<EscapedChar>, FormatError>> + '_ {
+ let mut current = fmt;
+ std::iter::from_fn(move || match current {
+ [] => None,
+ [b'%', b'%', rest @ ..] => {
+ current = rest;
+ Some(Ok(FormatItem::Char(EscapedChar::Byte(b'%'))))
+ }
+ [b'%', rest @ ..] => {
+ current = rest;
+ let spec = match Spec::parse(&mut current) {
+ Ok(spec) => spec,
+ Err(slice) => return Some(Err(FormatError::SpecError(slice.to_vec()))),
+ };
+ Some(Ok(FormatItem::Spec(spec)))
+ }
+ [b'\\', rest @ ..] => {
+ current = rest;
+ Some(Ok(FormatItem::Char(parse_escape_code(&mut current))))
+ }
+ [c, rest @ ..] => {
+ current = rest;
+ Some(Ok(FormatItem::Char(EscapedChar::Byte(*c))))
+ }
+ })
+}
+
+/// Parse a format string containing % directives
+pub fn parse_spec_only(
+ fmt: &[u8],
+) -> impl Iterator<Item = Result<FormatItem<u8>, FormatError>> + '_ {
+ let mut current = fmt;
+ std::iter::from_fn(move || match current {
+ [] => None,
+ [b'%', b'%', rest @ ..] => {
+ current = rest;
+ Some(Ok(FormatItem::Char(b'%')))
+ }
+ [b'%', rest @ ..] => {
+ current = rest;
+ let spec = match Spec::parse(&mut current) {
+ Ok(spec) => spec,
+ Err(slice) => return Some(Err(FormatError::SpecError(slice.to_vec()))),
+ };
+ Some(Ok(FormatItem::Spec(spec)))
+ }
+ [c, rest @ ..] => {
+ current = rest;
+ Some(Ok(FormatItem::Char(*c)))
+ }
+ })
+}
+
+/// Parse a format string containing escape sequences
+pub fn parse_escape_only(fmt: &[u8]) -> impl Iterator<Item = EscapedChar> + '_ {
+ let mut current = fmt;
+ std::iter::from_fn(move || match current {
+ [] => None,
+ [b'\\', rest @ ..] => {
+ current = rest;
+ Some(parse_escape_code(&mut current))
+ }
+ [c, rest @ ..] => {
+ current = rest;
+ Some(EscapedChar::Byte(*c))
+ }
+ })
+}
+
+/// Write a formatted string to stdout.
+///
+/// `format_string` contains the template and `args` contains the
+/// arguments to render into the template.
+///
+/// See also [`sprintf`], which creates a new formatted [`String`].
+///
+/// # Examples
+///
+/// ```rust
+/// use uucore::format::{printf, FormatArgument};
+///
+/// printf("hello %s", &[FormatArgument::String("world".into())]).unwrap();
+/// // prints "hello world"
+/// ```
+pub fn printf<'a>(
+ format_string: impl AsRef<[u8]>,
+ arguments: impl IntoIterator<Item = &'a FormatArgument>,
+) -> Result<(), FormatError> {
+ printf_writer(stdout(), format_string, arguments)
+}
+
+fn printf_writer<'a>(
+ mut writer: impl Write,
+ format_string: impl AsRef<[u8]>,
+ args: impl IntoIterator<Item = &'a FormatArgument>,
+) -> Result<(), FormatError> {
+ let mut args = args.into_iter();
+ for item in parse_spec_only(format_string.as_ref()) {
+ item?.write(&mut writer, &mut args)?;
+ }
+ Ok(())
+}
+
+/// Create a new formatted string.
+///
+/// `format_string` contains the template and `args` contains the
+/// arguments to render into the template.
+///
+/// See also [`printf`], which prints to stdout.
+///
+/// # Examples
+///
+/// ```rust
+/// use uucore::format::{sprintf, FormatArgument};
+///
+/// let s = sprintf("hello %s", &[FormatArgument::String("world".into())]).unwrap();
+/// let s = std::str::from_utf8(&s).unwrap();
+/// assert_eq!(s, "hello world");
+/// ```
+pub fn sprintf<'a>(
+ format_string: impl AsRef<[u8]>,
+ arguments: impl IntoIterator<Item = &'a FormatArgument>,
+) -> Result<Vec<u8>, FormatError> {
+ let mut writer = Vec::new();
+ printf_writer(&mut writer, format_string, arguments)?;
+ Ok(writer)
+}
+
+/// A parsed format for a single float value
+///
+/// This is used by `seq`. It can be constructed with [`Format::parse`]
+/// and can write a value with [`Format::fmt`].
+///
+/// It can only accept a single specification without any asterisk parameters.
+/// If it does get more specifications, it will return an error.
+pub struct Format<F: Formatter> {
+ prefix: Vec<u8>,
+ suffix: Vec<u8>,
+ formatter: F,
+}
+
+impl<F: Formatter> Format<F> {
+ pub fn parse(format_string: impl AsRef<[u8]>) -> Result<Self, FormatError> {
+ let mut iter = parse_spec_only(format_string.as_ref());
+
+ let mut prefix = Vec::new();
+ let mut spec = None;
+ for item in &mut iter {
+ match item? {
+ FormatItem::Spec(s) => {
+ spec = Some(s);
+ break;
+ }
+ FormatItem::Char(c) => prefix.push(c),
+ }
+ }
+
+ let Some(spec) = spec else {
+ return Err(FormatError::NeedAtLeastOneSpec(
+ format_string.as_ref().to_vec(),
+ ));
+ };
+
+ let formatter = F::try_from_spec(spec)?;
+
+ let mut suffix = Vec::new();
+ for item in &mut iter {
+ match item? {
+ FormatItem::Spec(_) => {
+ return Err(FormatError::TooManySpecs(format_string.as_ref().to_vec()));
+ }
+ FormatItem::Char(c) => suffix.push(c),
+ }
+ }
+
+ Ok(Self {
+ prefix,
+ suffix,
+ formatter,
+ })
+ }
+
+ pub fn fmt(&self, mut w: impl Write, f: F::Input) -> std::io::Result<()> {
+ w.write_all(&self.prefix)?;
+ self.formatter.fmt(&mut w, f)?;
+ w.write_all(&self.suffix)?;
+ Ok(())
+ }
+}
diff --git a/src/uucore/src/lib/features/format/num_format.rs b/src/uucore/src/lib/features/format/num_format.rs
new file mode 100644
index 0000000000000000000000000000000000000000..52551f10b869d6f985c3e8266284f8c5d7d714b9
--- /dev/null
+++ b/src/uucore/src/lib/features/format/num_format.rs
@@ -0,0 +1,641 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! Utilities for formatting numbers in various formats
+
+use std::io::Write;
+
+use super::{
+ spec::{CanAsterisk, Spec},
+ FormatError,
+};
+
+pub trait Formatter {
+ type Input;
+ fn fmt(&self, writer: impl Write, x: Self::Input) -> std::io::Result<()>;
+ fn try_from_spec(s: Spec) -> Result<Self, FormatError>
+ where
+ Self: Sized;
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum UnsignedIntVariant {
+ Decimal,
+ Octal(Prefix),
+ Hexadecimal(Case, Prefix),
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum FloatVariant {
+ Decimal,
+ Scientific,
+ Shortest,
+ Hexadecimal,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Case {
+ Lowercase,
+ Uppercase,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Prefix {
+ No,
+ Yes,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ForceDecimal {
+ No,
+ Yes,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum PositiveSign {
+ None,
+ Plus,
+ Space,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum NumberAlignment {
+ Left,
+ RightSpace,
+ RightZero,
+}
+
+pub struct SignedInt {
+ pub width: usize,
+ pub precision: usize,
+ pub positive_sign: PositiveSign,
+ pub alignment: NumberAlignment,
+}
+
+impl Formatter for SignedInt {
+ type Input = i64;
+
+ fn fmt(&self, mut writer: impl Write, x: Self::Input) -> std::io::Result<()> {
+ if x >= 0 {
+ match self.positive_sign {
+ PositiveSign::None => Ok(()),
+ PositiveSign::Plus => write!(writer, "+"),
+ PositiveSign::Space => write!(writer, " "),
+ }?;
+ }
+
+ let s = format!("{:0width$}", x, width = self.precision);
+
+ match self.alignment {
+ NumberAlignment::Left => write!(writer, "{s:<width$}", width = self.width),
+ NumberAlignment::RightSpace => write!(writer, "{s:>width$}", width = self.width),
+ NumberAlignment::RightZero => write!(writer, "{s:0>width$}", width = self.width),
+ }
+ }
+
+ fn try_from_spec(s: Spec) -> Result<Self, FormatError> {
+ let Spec::SignedInt {
+ width,
+ precision,
+ positive_sign,
+ alignment,
+ } = s
+ else {
+ return Err(FormatError::WrongSpecType);
+ };
+
+ let width = match width {
+ Some(CanAsterisk::Fixed(x)) => x,
+ None => 0,
+ Some(CanAsterisk::Asterisk) => return Err(FormatError::WrongSpecType),
+ };
+
+ let precision = match precision {
+ Some(CanAsterisk::Fixed(x)) => x,
+ None => 0,
+ Some(CanAsterisk::Asterisk) => return Err(FormatError::WrongSpecType),
+ };
+
+ Ok(Self {
+ width,
+ precision,
+ positive_sign,
+ alignment,
+ })
+ }
+}
+
+pub struct UnsignedInt {
+ pub variant: UnsignedIntVariant,
+ pub width: usize,
+ pub precision: usize,
+ pub alignment: NumberAlignment,
+}
+
+impl Formatter for UnsignedInt {
+ type Input = u64;
+
+ fn fmt(&self, mut writer: impl Write, x: Self::Input) -> std::io::Result<()> {
+ let mut s = match self.variant {
+ UnsignedIntVariant::Decimal => format!("{x}"),
+ UnsignedIntVariant::Octal(_) => format!("{x:o}"),
+ UnsignedIntVariant::Hexadecimal(Case::Lowercase, _) => {
+ format!("{x:x}")
+ }
+ UnsignedIntVariant::Hexadecimal(Case::Uppercase, _) => {
+ format!("{x:X}")
+ }
+ };
+
+ // Zeroes do not get a prefix. An octal value does also not get a
+ // prefix if the padded value will not start with a zero.
+ let prefix = match (x, self.variant) {
+ (1.., UnsignedIntVariant::Hexadecimal(Case::Lowercase, Prefix::Yes)) => "0x",
+ (1.., UnsignedIntVariant::Hexadecimal(Case::Uppercase, Prefix::Yes)) => "0X",
+ (1.., UnsignedIntVariant::Octal(Prefix::Yes)) if s.len() >= self.precision => "0",
+ _ => "",
+ };
+
+ s = format!("{prefix}{s:0>width$}", width = self.precision);
+
+ match self.alignment {
+ NumberAlignment::Left => write!(writer, "{s:<width$}", width = self.width),
+ NumberAlignment::RightSpace => write!(writer, "{s:>width$}", width = self.width),
+ NumberAlignment::RightZero => write!(writer, "{s:0>width$}", width = self.width),
+ }
+ }
+
+ fn try_from_spec(s: Spec) -> Result<Self, FormatError> {
+ // A signed int spec might be mapped to an unsigned int spec if no sign is specified
+ let s = if let Spec::SignedInt {
+ width,
+ precision,
+ positive_sign: PositiveSign::None,
+ alignment,
+ } = s
+ {
+ Spec::UnsignedInt {
+ variant: UnsignedIntVariant::Decimal,
+ width,
+ precision,
+ alignment,
+ }
+ } else {
+ s
+ };
+
+ let Spec::UnsignedInt {
+ variant,
+ width,
+ precision,
+ alignment,
+ } = s
+ else {
+ return Err(FormatError::WrongSpecType);
+ };
+
+ let width = match width {
+ Some(CanAsterisk::Fixed(x)) => x,
+ None => 0,
+ Some(CanAsterisk::Asterisk) => return Err(FormatError::WrongSpecType),
+ };
+
+ let precision = match precision {
+ Some(CanAsterisk::Fixed(x)) => x,
+ None => 0,
+ Some(CanAsterisk::Asterisk) => return Err(FormatError::WrongSpecType),
+ };
+
+ Ok(Self {
+ width,
+ precision,
+ variant,
+ alignment,
+ })
+ }
+}
+
+pub struct Float {
+ pub variant: FloatVariant,
+ pub case: Case,
+ pub force_decimal: ForceDecimal,
+ pub width: usize,
+ pub positive_sign: PositiveSign,
+ pub alignment: NumberAlignment,
+ pub precision: usize,
+}
+
+impl Default for Float {
+ fn default() -> Self {
+ Self {
+ variant: FloatVariant::Decimal,
+ case: Case::Lowercase,
+ force_decimal: ForceDecimal::No,
+ width: 0,
+ positive_sign: PositiveSign::None,
+ alignment: NumberAlignment::Left,
+ precision: 6,
+ }
+ }
+}
+
+impl Formatter for Float {
+ type Input = f64;
+
+ fn fmt(&self, mut writer: impl Write, x: Self::Input) -> std::io::Result<()> {
+ if x.is_sign_positive() {
+ match self.positive_sign {
+ PositiveSign::None => Ok(()),
+ PositiveSign::Plus => write!(writer, "+"),
+ PositiveSign::Space => write!(writer, " "),
+ }?;
+ }
+
+ let s = if x.is_finite() {
+ match self.variant {
+ FloatVariant::Decimal => {
+ format_float_decimal(x, self.precision, self.force_decimal)
+ }
+ FloatVariant::Scientific => {
+ format_float_scientific(x, self.precision, self.case, self.force_decimal)
+ }
+ FloatVariant::Shortest => {
+ format_float_shortest(x, self.precision, self.case, self.force_decimal)
+ }
+ FloatVariant::Hexadecimal => {
+ format_float_hexadecimal(x, self.precision, self.case, self.force_decimal)
+ }
+ }
+ } else {
+ format_float_non_finite(x, self.case)
+ };
+
+ match self.alignment {
+ NumberAlignment::Left => write!(writer, "{s:<width$}", width = self.width),
+ NumberAlignment::RightSpace => write!(writer, "{s:>width$}", width = self.width),
+ NumberAlignment::RightZero => write!(writer, "{s:0>width$}", width = self.width),
+ }
+ }
+
+ fn try_from_spec(s: Spec) -> Result<Self, FormatError>
+ where
+ Self: Sized,
+ {
+ let Spec::Float {
+ variant,
+ case,
+ force_decimal,
+ width,
+ positive_sign,
+ alignment,
+ precision,
+ } = s
+ else {
+ return Err(FormatError::WrongSpecType);
+ };
+
+ let width = match width {
+ Some(CanAsterisk::Fixed(x)) => x,
+ None => 0,
+ Some(CanAsterisk::Asterisk) => return Err(FormatError::WrongSpecType),
+ };
+
+ let precision = match precision {
+ Some(CanAsterisk::Fixed(x)) => x,
+ None => {
+ if matches!(variant, FloatVariant::Shortest) {
+ 6
+ } else {
+ 0
+ }
+ }
+ Some(CanAsterisk::Asterisk) => return Err(FormatError::WrongSpecType),
+ };
+
+ Ok(Self {
+ variant,
+ case,
+ force_decimal,
+ width,
+ positive_sign,
+ alignment,
+ precision,
+ })
+ }
+}
+
+fn format_float_non_finite(f: f64, case: Case) -> String {
+ debug_assert!(!f.is_finite());
+ let mut s = format!("{f}");
+ if case == Case::Uppercase {
+ s.make_ascii_uppercase();
+ }
+ s
+}
+
+fn format_float_decimal(f: f64, precision: usize, force_decimal: ForceDecimal) -> String {
+ if precision == 0 && force_decimal == ForceDecimal::Yes {
+ format!("{f:.0}.")
+ } else {
+ format!("{f:.*}", precision)
+ }
+}
+
+fn format_float_scientific(
+ f: f64,
+ precision: usize,
+ case: Case,
+ force_decimal: ForceDecimal,
+) -> String {
+ if f == 0.0 {
+ return if force_decimal == ForceDecimal::Yes && precision == 0 {
+ "0.e+00".into()
+ } else {
+ format!("{:.*}e+00", precision, 0.0)
+ };
+ }
+
+ let mut exponent: i32 = f.log10().floor() as i32;
+ let mut normalized = f / 10.0_f64.powi(exponent);
+
+ // If the normalized value will be rounded to a value greater than 10
+ // we need to correct.
+ if (normalized * 10_f64.powi(precision as i32)).round() / 10_f64.powi(precision as i32) >= 10.0
+ {
+ normalized /= 10.0;
+ exponent += 1;
+ }
+
+ let additional_dot = if precision == 0 && ForceDecimal::Yes == force_decimal {
+ "."
+ } else {
+ ""
+ };
+
+ let exp_char = match case {
+ Case::Lowercase => 'e',
+ Case::Uppercase => 'E',
+ };
+
+ format!(
+ "{normalized:.*}{additional_dot}{exp_char}{exponent:+03}",
+ precision
+ )
+}
+
+fn format_float_shortest(
+ f: f64,
+ precision: usize,
+ case: Case,
+ force_decimal: ForceDecimal,
+) -> String {
+ // Precision here is about how many digits should be displayed
+ // instead of how many digits for the fractional part, this means that if
+ // we pass this to rust's format string, it's always gonna be one less.
+ let precision = precision.saturating_sub(1);
+
+ if f == 0.0 {
+ return match (force_decimal, precision) {
+ (ForceDecimal::Yes, 0) => "0.".into(),
+ (ForceDecimal::Yes, _) => {
+ format!("{:.*}", precision, 0.0)
+ }
+ (ForceDecimal::No, _) => "0".into(),
+ };
+ }
+
+ let mut exponent = f.log10().floor() as i32;
+ if f != 0.0 && exponent <= -4 || exponent > precision as i32 {
+ // Scientific-ish notation (with a few differences)
+ let mut normalized = f / 10.0_f64.powi(exponent);
+
+ // If the normalized value will be rounded to a value greater than 10
+ // we need to correct.
+ if (normalized * 10_f64.powi(precision as i32)).round() / 10_f64.powi(precision as i32)
+ >= 10.0
+ {
+ normalized /= 10.0;
+ exponent += 1;
+ }
+
+ let additional_dot = if precision == 0 && ForceDecimal::Yes == force_decimal {
+ "."
+ } else {
+ ""
+ };
+
+ let mut normalized = format!("{normalized:.*}", precision);
+
+ if force_decimal == ForceDecimal::No {
+ strip_fractional_zeroes_and_dot(&mut normalized);
+ }
+
+ let exp_char = match case {
+ Case::Lowercase => 'e',
+ Case::Uppercase => 'E',
+ };
+
+ format!("{normalized}{additional_dot}{exp_char}{exponent:+03}")
+ } else {
+ // Decimal-ish notation with a few differences:
+ // - The precision works differently and specifies the total number
+ // of digits instead of the digits in the fractional part.
+ // - If we don't force the decimal, `.` and trailing `0` in the fractional part
+ // are trimmed.
+ let decimal_places = (precision as i32 - exponent) as usize;
+ let mut formatted = if decimal_places == 0 && force_decimal == ForceDecimal::Yes {
+ format!("{f:.0}.")
+ } else {
+ format!("{f:.*}", decimal_places)
+ };
+
+ if force_decimal == ForceDecimal::No {
+ strip_fractional_zeroes_and_dot(&mut formatted);
+ }
+
+ formatted
+ }
+}
+
+fn format_float_hexadecimal(
+ f: f64,
+ precision: usize,
+ case: Case,
+ force_decimal: ForceDecimal,
+) -> String {
+ let (first_digit, mantissa, exponent) = if f == 0.0 {
+ (0, 0, 0)
+ } else {
+ let bits = f.to_bits();
+ let exponent_bits = ((bits >> 52) & 0x7fff) as i64;
+ let exponent = exponent_bits - 1023;
+ let mantissa = bits & 0xf_ffff_ffff_ffff;
+ (1, mantissa, exponent)
+ };
+
+ let mut s = match (precision, force_decimal) {
+ (0, ForceDecimal::No) => format!("0x{first_digit}p{exponent:+x}"),
+ (0, ForceDecimal::Yes) => format!("0x{first_digit}.p{exponent:+x}"),
+ _ => format!("0x{first_digit}.{mantissa:0>13x}p{exponent:+x}"),
+ };
+
+ if case == Case::Uppercase {
+ s.make_ascii_uppercase();
+ }
+
+ s
+}
+
+fn strip_fractional_zeroes_and_dot(s: &mut String) {
+ let mut trim_to = s.len();
+ for (pos, c) in s.char_indices().rev() {
+ if pos + c.len_utf8() == trim_to && (c == '0' || c == '.') {
+ trim_to = pos;
+ }
+ if c == '.' {
+ s.truncate(trim_to);
+ break;
+ }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use crate::format::num_format::{Case, ForceDecimal};
+
+ #[test]
+ fn unsigned_octal() {
+ use super::{Formatter, NumberAlignment, Prefix, UnsignedInt, UnsignedIntVariant};
+ let f = |x| {
+ let mut s = Vec::new();
+ UnsignedInt {
+ variant: UnsignedIntVariant::Octal(Prefix::Yes),
+ width: 0,
+ precision: 0,
+ alignment: NumberAlignment::Left,
+ }
+ .fmt(&mut s, x)
+ .unwrap();
+ String::from_utf8(s).unwrap()
+ };
+
+ assert_eq!(f(0), "0");
+ assert_eq!(f(5), "05");
+ assert_eq!(f(8), "010");
+ }
+
+ #[test]
+ fn decimal_float() {
+ use super::format_float_decimal;
+ let f = |x| format_float_decimal(x, 6, ForceDecimal::No);
+ assert_eq!(f(0.0), "0.000000");
+ assert_eq!(f(1.0), "1.000000");
+ assert_eq!(f(100.0), "100.000000");
+ assert_eq!(f(123456.789), "123456.789000");
+ assert_eq!(f(12.3456789), "12.345679");
+ assert_eq!(f(1000000.0), "1000000.000000");
+ assert_eq!(f(99999999.0), "99999999.000000");
+ assert_eq!(f(1.9999995), "1.999999");
+ assert_eq!(f(1.9999996), "2.000000");
+ }
+
+ #[test]
+ fn scientific_float() {
+ use super::format_float_scientific;
+ let f = |x| format_float_scientific(x, 6, Case::Lowercase, ForceDecimal::No);
+ assert_eq!(f(0.0), "0.000000e+00");
+ assert_eq!(f(1.0), "1.000000e+00");
+ assert_eq!(f(100.0), "1.000000e+02");
+ assert_eq!(f(123456.789), "1.234568e+05");
+ assert_eq!(f(12.3456789), "1.234568e+01");
+ assert_eq!(f(1000000.0), "1.000000e+06");
+ assert_eq!(f(99999999.0), "1.000000e+08");
+ }
+
+ #[test]
+ fn scientific_float_zero_precision() {
+ use super::format_float_scientific;
+
+ let f = |x| format_float_scientific(x, 0, Case::Lowercase, ForceDecimal::No);
+ assert_eq!(f(0.0), "0e+00");
+ assert_eq!(f(1.0), "1e+00");
+ assert_eq!(f(100.0), "1e+02");
+ assert_eq!(f(123456.789), "1e+05");
+ assert_eq!(f(12.3456789), "1e+01");
+ assert_eq!(f(1000000.0), "1e+06");
+ assert_eq!(f(99999999.0), "1e+08");
+
+ let f = |x| format_float_scientific(x, 0, Case::Lowercase, ForceDecimal::Yes);
+ assert_eq!(f(0.0), "0.e+00");
+ assert_eq!(f(1.0), "1.e+00");
+ assert_eq!(f(100.0), "1.e+02");
+ assert_eq!(f(123456.789), "1.e+05");
+ assert_eq!(f(12.3456789), "1.e+01");
+ assert_eq!(f(1000000.0), "1.e+06");
+ assert_eq!(f(99999999.0), "1.e+08");
+ }
+
+ #[test]
+ fn shortest_float() {
+ use super::format_float_shortest;
+ let f = |x| format_float_shortest(x, 6, Case::Lowercase, ForceDecimal::No);
+ assert_eq!(f(0.0), "0");
+ assert_eq!(f(1.0), "1");
+ assert_eq!(f(100.0), "100");
+ assert_eq!(f(123456.789), "123457");
+ assert_eq!(f(12.3456789), "12.3457");
+ assert_eq!(f(1000000.0), "1e+06");
+ assert_eq!(f(99999999.0), "1e+08");
+ }
+
+ #[test]
+ fn shortest_float_force_decimal() {
+ use super::format_float_shortest;
+ let f = |x| format_float_shortest(x, 6, Case::Lowercase, ForceDecimal::Yes);
+ assert_eq!(f(0.0), "0.00000");
+ assert_eq!(f(1.0), "1.00000");
+ assert_eq!(f(100.0), "100.000");
+ assert_eq!(f(123456.789), "123457.");
+ assert_eq!(f(12.3456789), "12.3457");
+ assert_eq!(f(1000000.0), "1.00000e+06");
+ assert_eq!(f(99999999.0), "1.00000e+08");
+ }
+
+ #[test]
+ fn shortest_float_force_decimal_zero_precision() {
+ use super::format_float_shortest;
+ let f = |x| format_float_shortest(x, 0, Case::Lowercase, ForceDecimal::No);
+ assert_eq!(f(0.0), "0");
+ assert_eq!(f(1.0), "1");
+ assert_eq!(f(100.0), "1e+02");
+ assert_eq!(f(123456.789), "1e+05");
+ assert_eq!(f(12.3456789), "1e+01");
+ assert_eq!(f(1000000.0), "1e+06");
+ assert_eq!(f(99999999.0), "1e+08");
+
+ let f = |x| format_float_shortest(x, 0, Case::Lowercase, ForceDecimal::Yes);
+ assert_eq!(f(0.0), "0.");
+ assert_eq!(f(1.0), "1.");
+ assert_eq!(f(100.0), "1.e+02");
+ assert_eq!(f(123456.789), "1.e+05");
+ assert_eq!(f(12.3456789), "1.e+01");
+ assert_eq!(f(1000000.0), "1.e+06");
+ assert_eq!(f(99999999.0), "1.e+08");
+ }
+
+ #[test]
+ fn strip_insignificant_end() {
+ use super::strip_fractional_zeroes_and_dot;
+ let f = |s| {
+ let mut s = String::from(s);
+ strip_fractional_zeroes_and_dot(&mut s);
+ s
+ };
+ assert_eq!(&f("1000"), "1000");
+ assert_eq!(&f("1000."), "1000");
+ assert_eq!(&f("1000.02030"), "1000.0203");
+ assert_eq!(&f("1000.00000"), "1000");
+ }
+}
diff --git a/src/uucore/src/lib/features/format/num_parser.rs b/src/uucore/src/lib/features/format/num_parser.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0d65651d7e94aa9a9ab71f3781937b2dcc675cb1
--- /dev/null
+++ b/src/uucore/src/lib/features/format/num_parser.rs
@@ -0,0 +1,378 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! Utilities for parsing numbers in various formats
+
+// spell-checker:ignore powf copysign prec inity
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum Base {
+ Binary = 2,
+ Octal = 8,
+ Decimal = 10,
+ Hexadecimal = 16,
+}
+
+impl Base {
+ pub fn digit(&self, c: char) -> Option<u64> {
+ fn from_decimal(c: char) -> u64 {
+ u64::from(c) - u64::from('0')
+ }
+ match self {
+ Self::Binary => ('0'..='1').contains(&c).then(|| from_decimal(c)),
+ Self::Octal => ('0'..='7').contains(&c).then(|| from_decimal(c)),
+ Self::Decimal => c.is_ascii_digit().then(|| from_decimal(c)),
+ Self::Hexadecimal => match c.to_ascii_lowercase() {
+ '0'..='9' => Some(from_decimal(c)),
+ c @ 'a'..='f' => Some(u64::from(c) - u64::from('a') + 10),
+ _ => None,
+ },
+ }
+ }
+}
+
+/// Type returned if a number could not be parsed in its entirety
+#[derive(Debug, PartialEq)]
+pub enum ParseError<'a, T> {
+ /// The input as a whole makes no sense
+ NotNumeric,
+ /// The beginning of the input made sense and has been parsed,
+ /// while the remaining doesn't.
+ PartialMatch(T, &'a str),
+ /// The integral part has overflowed the requested type, or
+ /// has overflowed the `u64` internal storage when parsing the
+ /// integral part of a floating point number.
+ Overflow,
+}
+
+impl<'a, T> ParseError<'a, T> {
+ fn map<U>(self, f: impl FnOnce(T, &'a str) -> ParseError<'a, U>) -> ParseError<'a, U> {
+ match self {
+ Self::NotNumeric => ParseError::NotNumeric,
+ Self::Overflow => ParseError::Overflow,
+ Self::PartialMatch(v, s) => f(v, s),
+ }
+ }
+}
+
+/// A number parser for binary, octal, decimal, hexadecimal and single characters.
+///
+/// Internally, in order to get the maximum possible precision and cover the full
+/// range of u64 and i64 without losing precision for f64, the returned number is
+/// decomposed into:
+/// - A `base` value
+/// - A `neg` sign bit
+/// - A `integral` positive part
+/// - A `fractional` positive part
+/// - A `precision` representing the number of digits in the fractional part
+///
+/// If the fractional part cannot be represented on a `u64`, parsing continues
+/// silently by ignoring non-significant digits.
+pub struct ParsedNumber {
+ base: Base,
+ negative: bool,
+ integral: u64,
+ fractional: u64,
+ precision: usize,
+}
+
+impl ParsedNumber {
+ fn into_i64(self) -> Option<i64> {
+ if self.negative {
+ i64::try_from(-i128::from(self.integral)).ok()
+ } else {
+ i64::try_from(self.integral).ok()
+ }
+ }
+
+ /// Parse a number as i64. No fractional part is allowed.
+ pub fn parse_i64(input: &str) -> Result<i64, ParseError<'_, i64>> {
+ match Self::parse(input, true) {
+ Ok(v) => v.into_i64().ok_or(ParseError::Overflow),
+ Err(e) => Err(e.map(|v, rest| {
+ v.into_i64()
+ .map(|v| ParseError::PartialMatch(v, rest))
+ .unwrap_or(ParseError::Overflow)
+ })),
+ }
+ }
+
+ /// Parse a number as u64. No fractional part is allowed.
+ pub fn parse_u64(input: &str) -> Result<u64, ParseError<'_, u64>> {
+ match Self::parse(input, true) {
+ Ok(v) | Err(ParseError::PartialMatch(v, _)) if v.negative => {
+ Err(ParseError::NotNumeric)
+ }
+ Ok(v) => Ok(v.integral),
+ Err(e) => Err(e.map(|v, rest| ParseError::PartialMatch(v.integral, rest))),
+ }
+ }
+
+ fn into_f64(self) -> f64 {
+ let n = self.integral as f64
+ + (self.fractional as f64) / (self.base as u8 as f64).powf(self.precision as f64);
+ if self.negative {
+ -n
+ } else {
+ n
+ }
+ }
+
+ /// Parse a number as f64
+ pub fn parse_f64(input: &str) -> Result<f64, ParseError<'_, f64>> {
+ match Self::parse(input, false) {
+ Ok(v) => Ok(v.into_f64()),
+ Err(ParseError::NotNumeric) => Self::parse_f64_special_values(input),
+ Err(e) => Err(e.map(|v, rest| ParseError::PartialMatch(v.into_f64(), rest))),
+ }
+ }
+
+ fn parse_f64_special_values(input: &str) -> Result<f64, ParseError<'_, f64>> {
+ let (sign, rest) = if let Some(input) = input.strip_prefix('-') {
+ (-1.0, input)
+ } else {
+ (1.0, input)
+ };
+ let prefix = rest
+ .chars()
+ .take(3)
+ .map(|c| c.to_ascii_lowercase())
+ .collect::<String>();
+ let special = match prefix.as_str() {
+ "inf" => f64::INFINITY,
+ "nan" => f64::NAN,
+ _ => return Err(ParseError::NotNumeric),
+ }
+ .copysign(sign);
+ if rest.len() == 3 {
+ Ok(special)
+ } else {
+ Err(ParseError::PartialMatch(special, &rest[3..]))
+ }
+ }
+
+ #[allow(clippy::cognitive_complexity)]
+ fn parse(input: &str, integral_only: bool) -> Result<Self, ParseError<'_, Self>> {
+ // Parse the "'" prefix separately
+ if let Some(rest) = input.strip_prefix('\'') {
+ let mut chars = rest.char_indices().fuse();
+ let v = chars.next().map(|(_, c)| Self {
+ base: Base::Decimal,
+ negative: false,
+ integral: u64::from(c),
+ fractional: 0,
+ precision: 0,
+ });
+ return match (v, chars.next()) {
+ (Some(v), None) => Ok(v),
+ (Some(v), Some((i, _))) => Err(ParseError::PartialMatch(v, &rest[i..])),
+ (None, _) => Err(ParseError::NotNumeric),
+ };
+ }
+
+ // Initial minus sign
+ let (negative, unsigned) = if let Some(input) = input.strip_prefix('-') {
+ (true, input)
+ } else {
+ (false, input)
+ };
+
+ // Parse an optional base prefix ("0b" / "0B" / "0" / "0x" / "0X"). "0" is octal unless a
+ // fractional part is allowed in which case it is an insignificant leading 0. A "0" prefix
+ // will not be consumed in case the parsable string contains only "0": the leading extra "0"
+ // will have no influence on the result.
+ let (base, rest) = if let Some(rest) = unsigned.strip_prefix('0') {
+ if let Some(rest) = rest.strip_prefix(['b', 'B']) {
+ (Base::Binary, rest)
+ } else if let Some(rest) = rest.strip_prefix(['x', 'X']) {
+ (Base::Hexadecimal, rest)
+ } else if integral_only {
+ (Base::Octal, unsigned)
+ } else {
+ (Base::Decimal, unsigned)
+ }
+ } else {
+ (Base::Decimal, unsigned)
+ };
+ if rest.is_empty() {
+ return Err(ParseError::NotNumeric);
+ }
+
+ // Parse the integral part of the number
+ let mut chars = rest.chars().enumerate().fuse().peekable();
+ let mut integral = 0u64;
+ while let Some(d) = chars.peek().and_then(|&(_, c)| base.digit(c)) {
+ chars.next();
+ integral = integral
+ .checked_mul(base as u64)
+ .and_then(|n| n.checked_add(d))
+ .ok_or(ParseError::Overflow)?;
+ }
+
+ // Parse the fractional part of the number if there can be one and the input contains
+ // a '.' decimal separator.
+ let (mut fractional, mut precision) = (0u64, 0);
+ if matches!(chars.peek(), Some(&(_, '.')))
+ && matches!(base, Base::Decimal | Base::Hexadecimal)
+ && !integral_only
+ {
+ chars.next();
+ let mut ended = false;
+ while let Some(d) = chars.peek().and_then(|&(_, c)| base.digit(c)) {
+ chars.next();
+ if !ended {
+ if let Some(f) = fractional
+ .checked_mul(base as u64)
+ .and_then(|n| n.checked_add(d))
+ {
+ (fractional, precision) = (f, precision + 1);
+ } else {
+ ended = true;
+ }
+ }
+ }
+ }
+
+ // If nothing has been parsed, declare the parsing unsuccessful
+ if let Some((0, _)) = chars.peek() {
+ return Err(ParseError::NotNumeric);
+ }
+
+ // Return what has been parsed so far. It there are extra characters, mark the
+ // parsing as a partial match.
+ let parsed = Self {
+ base,
+ negative,
+ integral,
+ fractional,
+ precision,
+ };
+ if let Some((first_unparsed, _)) = chars.next() {
+ Err(ParseError::PartialMatch(parsed, &rest[first_unparsed..]))
+ } else {
+ Ok(parsed)
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::{ParseError, ParsedNumber};
+
+ #[test]
+ fn test_decimal_u64() {
+ assert_eq!(Ok(123), ParsedNumber::parse_u64("123"));
+ assert_eq!(
+ Ok(u64::MAX),
+ ParsedNumber::parse_u64(&format!("{}", u64::MAX))
+ );
+ assert!(matches!(
+ ParsedNumber::parse_u64("-123"),
+ Err(ParseError::NotNumeric)
+ ));
+ assert!(matches!(
+ ParsedNumber::parse_u64(""),
+ Err(ParseError::NotNumeric)
+ ));
+ assert!(matches!(
+ ParsedNumber::parse_u64("123.15"),
+ Err(ParseError::PartialMatch(123, ".15"))
+ ));
+ }
+
+ #[test]
+ fn test_decimal_i64() {
+ assert_eq!(Ok(123), ParsedNumber::parse_i64("123"));
+ assert_eq!(Ok(-123), ParsedNumber::parse_i64("-123"));
+ assert!(matches!(
+ ParsedNumber::parse_i64("--123"),
+ Err(ParseError::NotNumeric)
+ ));
+ assert_eq!(
+ Ok(i64::MAX),
+ ParsedNumber::parse_i64(&format!("{}", i64::MAX))
+ );
+ assert_eq!(
+ Ok(i64::MIN),
+ ParsedNumber::parse_i64(&format!("{}", i64::MIN))
+ );
+ assert!(matches!(
+ ParsedNumber::parse_i64(&format!("{}", u64::MAX)),
+ Err(ParseError::Overflow)
+ ));
+ assert!(matches!(
+ ParsedNumber::parse_i64(&format!("{}", i64::MAX as u64 + 1)),
+ Err(ParseError::Overflow)
+ ));
+ }
+
+ #[test]
+ fn test_decimal_f64() {
+ assert_eq!(Ok(123.0), ParsedNumber::parse_f64("123"));
+ assert_eq!(Ok(-123.0), ParsedNumber::parse_f64("-123"));
+ assert_eq!(Ok(123.0), ParsedNumber::parse_f64("123."));
+ assert_eq!(Ok(-123.0), ParsedNumber::parse_f64("-123."));
+ assert_eq!(Ok(123.0), ParsedNumber::parse_f64("123.0"));
+ assert_eq!(Ok(-123.0), ParsedNumber::parse_f64("-123.0"));
+ assert_eq!(Ok(123.15), ParsedNumber::parse_f64("123.15"));
+ assert_eq!(Ok(-123.15), ParsedNumber::parse_f64("-123.15"));
+ assert_eq!(Ok(0.15), ParsedNumber::parse_f64(".15"));
+ assert_eq!(Ok(-0.15), ParsedNumber::parse_f64("-.15"));
+ assert_eq!(
+ Ok(0.15),
+ ParsedNumber::parse_f64(".150000000000000000000000000231313")
+ );
+ assert!(matches!(ParsedNumber::parse_f64("1.2.3"),
+ Err(ParseError::PartialMatch(f, ".3")) if f == 1.2));
+ assert_eq!(Ok(f64::INFINITY), ParsedNumber::parse_f64("inf"));
+ assert_eq!(Ok(f64::NEG_INFINITY), ParsedNumber::parse_f64("-inf"));
+ assert!(ParsedNumber::parse_f64("NaN").unwrap().is_nan());
+ assert!(ParsedNumber::parse_f64("NaN").unwrap().is_sign_positive());
+ assert!(ParsedNumber::parse_f64("-NaN").unwrap().is_nan());
+ assert!(ParsedNumber::parse_f64("-NaN").unwrap().is_sign_negative());
+ assert!(matches!(ParsedNumber::parse_f64("-infinity"),
+ Err(ParseError::PartialMatch(f, "inity")) if f == f64::NEG_INFINITY));
+ assert!(ParsedNumber::parse_f64(&format!("{}", u64::MAX)).is_ok());
+ assert!(ParsedNumber::parse_f64(&format!("{}", i64::MIN)).is_ok());
+ }
+
+ #[test]
+ fn test_hexadecimal() {
+ assert_eq!(Ok(0x123), ParsedNumber::parse_u64("0x123"));
+ assert_eq!(Ok(0x123), ParsedNumber::parse_u64("0X123"));
+ assert_eq!(Ok(0xfe), ParsedNumber::parse_u64("0xfE"));
+ assert_eq!(Ok(-0x123), ParsedNumber::parse_i64("-0x123"));
+
+ assert_eq!(Ok(0.5), ParsedNumber::parse_f64("0x.8"));
+ assert_eq!(Ok(0.0625), ParsedNumber::parse_f64("0x.1"));
+ assert_eq!(Ok(15.0078125), ParsedNumber::parse_f64("0xf.02"));
+ }
+
+ #[test]
+ fn test_octal() {
+ assert_eq!(Ok(0), ParsedNumber::parse_u64("0"));
+ assert_eq!(Ok(0o123), ParsedNumber::parse_u64("0123"));
+ assert_eq!(Ok(0o123), ParsedNumber::parse_u64("00123"));
+ assert_eq!(Ok(0), ParsedNumber::parse_u64("00"));
+ assert!(matches!(
+ ParsedNumber::parse_u64("008"),
+ Err(ParseError::PartialMatch(0, "8"))
+ ));
+ assert!(matches!(
+ ParsedNumber::parse_u64("08"),
+ Err(ParseError::PartialMatch(0, "8"))
+ ));
+ assert!(matches!(
+ ParsedNumber::parse_u64("0."),
+ Err(ParseError::PartialMatch(0, "."))
+ ));
+ }
+
+ #[test]
+ fn test_binary() {
+ assert_eq!(Ok(0b1011), ParsedNumber::parse_u64("0b1011"));
+ assert_eq!(Ok(0b1011), ParsedNumber::parse_u64("0B1011"));
+ }
+}
diff --git a/src/uucore/src/lib/features/format/spec.rs b/src/uucore/src/lib/features/format/spec.rs
new file mode 100644
index 0000000000000000000000000000000000000000..543346bf43d3c1f2b8db5dd74c47d2e888e7c656
--- /dev/null
+++ b/src/uucore/src/lib/features/format/spec.rs
@@ -0,0 +1,485 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore (vars) intmax ptrdiff padlen
+
+use crate::quoting_style::{escape_name, QuotingStyle};
+
+use super::{
+ num_format::{
+ self, Case, FloatVariant, ForceDecimal, Formatter, NumberAlignment, PositiveSign, Prefix,
+ UnsignedIntVariant,
+ },
+ parse_escape_only, ArgumentIter, FormatChar, FormatError,
+};
+use std::{io::Write, ops::ControlFlow};
+
+/// A parsed specification for formatting a value
+///
+/// This might require more than one argument to resolve width or precision
+/// values that are given as `*`.
+#[derive(Debug)]
+pub enum Spec {
+ Char {
+ width: Option<CanAsterisk<usize>>,
+ align_left: bool,
+ },
+ String {
+ precision: Option<CanAsterisk<usize>>,
+ width: Option<CanAsterisk<usize>>,
+ align_left: bool,
+ },
+ EscapedString,
+ QuotedString,
+ SignedInt {
+ width: Option<CanAsterisk<usize>>,
+ precision: Option<CanAsterisk<usize>>,
+ positive_sign: PositiveSign,
+ alignment: NumberAlignment,
+ },
+ UnsignedInt {
+ variant: UnsignedIntVariant,
+ width: Option<CanAsterisk<usize>>,
+ precision: Option<CanAsterisk<usize>>,
+ alignment: NumberAlignment,
+ },
+ Float {
+ variant: FloatVariant,
+ case: Case,
+ force_decimal: ForceDecimal,
+ width: Option<CanAsterisk<usize>>,
+ positive_sign: PositiveSign,
+ alignment: NumberAlignment,
+ precision: Option<CanAsterisk<usize>>,
+ },
+}
+
+/// Precision and width specified might use an asterisk to indicate that they are
+/// determined by an argument.
+#[derive(Clone, Copy, Debug)]
+pub enum CanAsterisk<T> {
+ Fixed(T),
+ Asterisk,
+}
+
+/// Size of the expected type (ignored)
+///
+/// We ignore this parameter entirely, but we do parse it.
+/// It could be used in the future if the need arises.
+enum Length {
+ /// signed/unsigned char ("hh")
+ Char,
+ /// signed/unsigned short int ("h")
+ Short,
+ /// signed/unsigned long int ("l")
+ Long,
+ /// signed/unsigned long long int ("ll")
+ LongLong,
+ /// intmax_t ("j")
+ IntMaxT,
+ /// size_t ("z")
+ SizeT,
+ /// ptrdiff_t ("t")
+ PtfDiffT,
+ /// long double ("L")
+ LongDouble,
+}
+
+#[derive(Default, PartialEq, Eq)]
+struct Flags {
+ minus: bool,
+ plus: bool,
+ space: bool,
+ hash: bool,
+ zero: bool,
+}
+
+impl Flags {
+ pub fn parse(rest: &mut &[u8], index: &mut usize) -> Self {
+ let mut flags = Self::default();
+
+ while let Some(x) = rest.get(*index) {
+ match x {
+ b'-' => flags.minus = true,
+ b'+' => flags.plus = true,
+ b' ' => flags.space = true,
+ b'#' => flags.hash = true,
+ b'0' => flags.zero = true,
+ _ => break,
+ }
+ *index += 1;
+ }
+
+ flags
+ }
+
+ /// Whether any of the flags is set to true
+ fn any(&self) -> bool {
+ self != &Self::default()
+ }
+}
+
+impl Spec {
+ pub fn parse<'a>(rest: &mut &'a [u8]) -> Result<Self, &'a [u8]> {
+ // Based on the C++ reference, the spec format looks like:
+ //
+ // %[flags][width][.precision][length]specifier
+ //
+ // However, we have already parsed the '%'.
+ let mut index = 0;
+ let start = *rest;
+
+ let flags = Flags::parse(rest, &mut index);
+
+ let positive_sign = match flags {
+ Flags { plus: true, .. } => PositiveSign::Plus,
+ Flags { space: true, .. } => PositiveSign::Space,
+ _ => PositiveSign::None,
+ };
+
+ let width = eat_asterisk_or_number(rest, &mut index);
+
+ let precision = if let Some(b'.') = rest.get(index) {
+ index += 1;
+ Some(eat_asterisk_or_number(rest, &mut index).unwrap_or(CanAsterisk::Fixed(0)))
+ } else {
+ None
+ };
+
+ // The `0` flag is ignored if `-` is given or a precision is specified.
+ // So the only case for RightZero, is when `-` is not given and the
+ // precision is none.
+ let alignment = if flags.minus {
+ NumberAlignment::Left
+ } else if flags.zero && precision.is_none() {
+ NumberAlignment::RightZero
+ } else {
+ NumberAlignment::RightSpace
+ };
+
+ // We ignore the length. It's not really relevant to printf
+ let _ = Self::parse_length(rest, &mut index);
+
+ let Some(type_spec) = rest.get(index) else {
+ return Err(&start[..index]);
+ };
+ index += 1;
+ *rest = &start[index..];
+
+ Ok(match type_spec {
+ // GNU accepts minus, plus and space even though they are not used
+ b'c' => {
+ if flags.zero || flags.hash || precision.is_some() {
+ return Err(&start[..index]);
+ }
+ Self::Char {
+ width,
+ align_left: flags.minus,
+ }
+ }
+ b's' => {
+ if flags.zero || flags.hash {
+ return Err(&start[..index]);
+ }
+ Self::String {
+ precision,
+ width,
+ align_left: flags.minus,
+ }
+ }
+ b'b' => {
+ if flags.any() || width.is_some() || precision.is_some() {
+ return Err(&start[..index]);
+ }
+ Self::EscapedString
+ }
+ b'q' => {
+ if flags.any() || width.is_some() || precision.is_some() {
+ return Err(&start[..index]);
+ }
+ Self::QuotedString
+ }
+ b'd' | b'i' => {
+ if flags.hash {
+ return Err(&start[..index]);
+ }
+ Self::SignedInt {
+ width,
+ precision,
+ alignment,
+ positive_sign,
+ }
+ }
+ c @ (b'u' | b'o' | b'x' | b'X') => {
+ // Normal unsigned integer cannot have a prefix
+ if *c == b'u' && flags.hash {
+ return Err(&start[..index]);
+ }
+ let prefix = if flags.hash { Prefix::Yes } else { Prefix::No };
+ let variant = match c {
+ b'u' => UnsignedIntVariant::Decimal,
+ b'o' => UnsignedIntVariant::Octal(prefix),
+ b'x' => UnsignedIntVariant::Hexadecimal(Case::Lowercase, prefix),
+ b'X' => UnsignedIntVariant::Hexadecimal(Case::Uppercase, prefix),
+ _ => unreachable!(),
+ };
+ Self::UnsignedInt {
+ variant,
+ precision,
+ width,
+ alignment,
+ }
+ }
+ c @ (b'f' | b'F' | b'e' | b'E' | b'g' | b'G' | b'a' | b'A') => Self::Float {
+ width,
+ precision,
+ variant: match c {
+ b'f' | b'F' => FloatVariant::Decimal,
+ b'e' | b'E' => FloatVariant::Scientific,
+ b'g' | b'G' => FloatVariant::Shortest,
+ b'a' | b'A' => FloatVariant::Hexadecimal,
+ _ => unreachable!(),
+ },
+ force_decimal: if flags.hash {
+ ForceDecimal::Yes
+ } else {
+ ForceDecimal::No
+ },
+ case: if c.is_ascii_uppercase() {
+ Case::Uppercase
+ } else {
+ Case::Lowercase
+ },
+ alignment,
+ positive_sign,
+ },
+ _ => return Err(&start[..index]),
+ })
+ }
+
+ fn parse_length(rest: &mut &[u8], index: &mut usize) -> Option<Length> {
+ // Parse 0..N length options, keep the last one
+ // Even though it is just ignored. We might want to use it later and we
+ // should parse those characters.
+ //
+ // TODO: This needs to be configurable: `seq` accepts only one length
+ // param
+ let mut length = None;
+ loop {
+ let new_length = rest.get(*index).and_then(|c| {
+ Some(match c {
+ b'h' => {
+ if let Some(b'h') = rest.get(*index + 1) {
+ *index += 1;
+ Length::Char
+ } else {
+ Length::Short
+ }
+ }
+ b'l' => {
+ if let Some(b'l') = rest.get(*index + 1) {
+ *index += 1;
+ Length::Long
+ } else {
+ Length::LongLong
+ }
+ }
+ b'j' => Length::IntMaxT,
+ b'z' => Length::SizeT,
+ b't' => Length::PtfDiffT,
+ b'L' => Length::LongDouble,
+ _ => return None,
+ })
+ });
+ if new_length.is_some() {
+ *index += 1;
+ length = new_length;
+ } else {
+ break;
+ }
+ }
+ length
+ }
+
+ pub fn write<'a>(
+ &self,
+ mut writer: impl Write,
+ mut args: impl ArgumentIter<'a>,
+ ) -> Result<(), FormatError> {
+ match self {
+ Self::Char { width, align_left } => {
+ let width = resolve_asterisk(*width, &mut args)?.unwrap_or(0);
+ write_padded(writer, &[args.get_char()], width, *align_left)
+ }
+ Self::String {
+ width,
+ align_left,
+ precision,
+ } => {
+ let width = resolve_asterisk(*width, &mut args)?.unwrap_or(0);
+
+ // GNU does do this truncation on a byte level, see for instance:
+ // printf "%.1s" 🙃
+ // > �
+ // For now, we let printf panic when we truncate within a code point.
+ // TODO: We need to not use Rust's formatting for aligning the output,
+ // so that we can just write bytes to stdout without panicking.
+ let precision = resolve_asterisk(*precision, &mut args)?;
+ let s = args.get_str();
+ let truncated = match precision {
+ Some(p) if p < s.len() => &s[..p],
+ _ => s,
+ };
+ write_padded(writer, truncated.as_bytes(), width, *align_left)
+ }
+ Self::EscapedString => {
+ let s = args.get_str();
+ let mut parsed = Vec::new();
+ for c in parse_escape_only(s.as_bytes()) {
+ match c.write(&mut parsed)? {
+ ControlFlow::Continue(()) => {}
+ ControlFlow::Break(()) => {
+ // TODO: This should break the _entire execution_ of printf
+ break;
+ }
+ };
+ }
+ writer.write_all(&parsed).map_err(FormatError::IoError)
+ }
+ Self::QuotedString => {
+ let s = args.get_str();
+ writer
+ .write_all(
+ escape_name(
+ s.as_ref(),
+ &QuotingStyle::Shell {
+ escape: true,
+ always_quote: false,
+ show_control: false,
+ },
+ )
+ .as_bytes(),
+ )
+ .map_err(FormatError::IoError)
+ }
+ Self::SignedInt {
+ width,
+ precision,
+ positive_sign,
+ alignment,
+ } => {
+ let width = resolve_asterisk(*width, &mut args)?.unwrap_or(0);
+ let precision = resolve_asterisk(*precision, &mut args)?.unwrap_or(0);
+ let i = args.get_i64();
+
+ num_format::SignedInt {
+ width,
+ precision,
+ positive_sign: *positive_sign,
+ alignment: *alignment,
+ }
+ .fmt(writer, i)
+ .map_err(FormatError::IoError)
+ }
+ Self::UnsignedInt {
+ variant,
+ width,
+ precision,
+ alignment,
+ } => {
+ let width = resolve_asterisk(*width, &mut args)?.unwrap_or(0);
+ let precision = resolve_asterisk(*precision, &mut args)?.unwrap_or(0);
+ let i = args.get_u64();
+
+ num_format::UnsignedInt {
+ variant: *variant,
+ precision,
+ width,
+ alignment: *alignment,
+ }
+ .fmt(writer, i)
+ .map_err(FormatError::IoError)
+ }
+ Self::Float {
+ variant,
+ case,
+ force_decimal,
+ width,
+ positive_sign,
+ alignment,
+ precision,
+ } => {
+ let width = resolve_asterisk(*width, &mut args)?.unwrap_or(0);
+ let precision = resolve_asterisk(*precision, &mut args)?.unwrap_or(6);
+ let f = args.get_f64();
+
+ num_format::Float {
+ width,
+ precision,
+ variant: *variant,
+ case: *case,
+ force_decimal: *force_decimal,
+ positive_sign: *positive_sign,
+ alignment: *alignment,
+ }
+ .fmt(writer, f)
+ .map_err(FormatError::IoError)
+ }
+ }
+ }
+}
+
+fn resolve_asterisk<'a>(
+ option: Option<CanAsterisk<usize>>,
+ mut args: impl ArgumentIter<'a>,
+) -> Result<Option<usize>, FormatError> {
+ Ok(match option {
+ None => None,
+ Some(CanAsterisk::Asterisk) => Some(usize::try_from(args.get_u64()).ok().unwrap_or(0)),
+ Some(CanAsterisk::Fixed(w)) => Some(w),
+ })
+}
+
+fn write_padded(
+ mut writer: impl Write,
+ text: &[u8],
+ width: usize,
+ left: bool,
+) -> Result<(), FormatError> {
+ let padlen = width.saturating_sub(text.len());
+ if left {
+ writer.write_all(text)?;
+ write!(writer, "{: <padlen$}", "")
+ } else {
+ write!(writer, "{: >padlen$}", "")?;
+ writer.write_all(text)
+ }
+ .map_err(FormatError::IoError)
+}
+
+fn eat_asterisk_or_number(rest: &mut &[u8], index: &mut usize) -> Option<CanAsterisk<usize>> {
+ if let Some(b'*') = rest.get(*index) {
+ *index += 1;
+ Some(CanAsterisk::Asterisk)
+ } else {
+ eat_number(rest, index).map(CanAsterisk::Fixed)
+ }
+}
+
+fn eat_number(rest: &mut &[u8], index: &mut usize) -> Option<usize> {
+ match rest[*index..].iter().position(|b| !b.is_ascii_digit()) {
+ None | Some(0) => None,
+ Some(i) => {
+ // TODO: This might need to handle errors better
+ // For example in case of overflow.
+ let parsed = std::str::from_utf8(&rest[*index..(*index + i)])
+ .unwrap()
+ .parse()
+ .unwrap();
+ *index += i;
+ Some(parsed)
+ }
+ }
+}
diff --git a/src/uucore/src/lib/features/fs.rs b/src/uucore/src/lib/features/fs.rs
index d5c7cbac1fed6bea816ed73dfd2982fe370b4858..73c61e0a3e423f5fe2511b9474ccc881c485dd29 100644
--- a/src/uucore/src/lib/features/fs.rs
+++ b/src/uucore/src/lib/features/fs.rs
@@ -1,8 +1,5 @@
// This file is part of the uutils coreutils package.
//
-// (c) Joseph Crail <jbcrail@gmail.com>
-// (c) Jian Zeng <anonymousknight96 AT gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
@@ -16,7 +13,6 @@ use libc::{
S_IROTH, S_IRUSR, S_ISGID, S_ISUID, S_ISVTX, S_IWGRP, S_IWOTH, S_IWUSR, S_IXGRP, S_IXOTH,
S_IXUSR,
};
-use std::borrow::Cow;
use std::collections::HashSet;
use std::collections::VecDeque;
use std::env;
@@ -31,6 +27,9 @@ use std::path::{Component, Path, PathBuf, MAIN_SEPARATOR};
#[cfg(target_os = "windows")]
use winapi_util::AsHandleRef;
+/// Used to check if the `mode` has its `perm` bit set.
+///
+/// This macro expands to `mode & perm != 0`.
#[cfg(unix)]
#[macro_export]
macro_rules! has {
@@ -112,9 +111,17 @@ impl FileInformation {
#[cfg(all(
unix,
not(target_vendor = "apple"),
+ not(target_os = "aix"),
not(target_os = "android"),
not(target_os = "freebsd"),
+ not(target_os = "netbsd"),
+ not(target_os = "openbsd"),
+ not(target_os = "illumos"),
+ not(target_os = "solaris"),
not(target_arch = "aarch64"),
+ not(target_arch = "riscv64"),
+ not(target_arch = "loongarch64"),
+ not(target_arch = "sparc64"),
target_pointer_width = "64"
))]
return self.0.st_nlink;
@@ -124,20 +131,36 @@ impl FileInformation {
target_vendor = "apple",
target_os = "android",
target_os = "freebsd",
+ target_os = "netbsd",
+ target_os = "openbsd",
+ target_os = "illumos",
+ target_os = "solaris",
target_arch = "aarch64",
+ target_arch = "riscv64",
+ target_arch = "loongarch64",
+ target_arch = "sparc64",
not(target_pointer_width = "64")
)
))]
return self.0.st_nlink.into();
+ #[cfg(target_os = "aix")]
+ return self.0.st_nlink.try_into().unwrap();
#[cfg(windows)]
return self.0.number_of_links();
}
#[cfg(unix)]
pub fn inode(&self) -> u64 {
- #[cfg(all(not(target_os = "freebsd"), target_pointer_width = "64"))]
+ #[cfg(all(
+ not(any(target_os = "freebsd", target_os = "netbsd")),
+ target_pointer_width = "64"
+ ))]
return self.0.st_ino;
- #[cfg(any(target_os = "freebsd", not(target_pointer_width = "64")))]
+ #[cfg(any(
+ target_os = "freebsd",
+ target_os = "netbsd",
+ not(target_pointer_width = "64")
+ ))]
return self.0.st_ino.into();
}
}
@@ -174,30 +197,6 @@ impl Hash for FileInformation {
}
}
-/// resolve a relative path
-pub fn resolve_relative_path(path: &Path) -> Cow<Path> {
- if path.components().all(|e| e != Component::ParentDir) {
- return path.into();
- }
- let root = Component::RootDir.as_os_str();
- let mut result = env::current_dir().unwrap_or_else(|_| PathBuf::from(root));
- for comp in path.components() {
- match comp {
- Component::ParentDir => {
- if let Ok(p) = result.read_link() {
- result = p;
- }
- result.pop();
- }
- Component::CurDir => (),
- Component::RootDir | Component::Normal(_) | Component::Prefix(_) => {
- result.push(comp.as_os_str());
- }
- }
- }
- result.into()
-}
-
/// Controls how symbolic links should be handled when canonicalizing a path.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum MissingHandling {
@@ -324,6 +323,7 @@ impl<'a> From<Component<'a>> for OwningComponent {
/// * [`ResolveMode::Logical`] makes this function resolve '..' components
/// before symlinks
///
+#[allow(clippy::cognitive_complexity)]
pub fn canonicalize<P: AsRef<Path>>(
original: P,
miss_mode: MissingHandling,
@@ -423,6 +423,7 @@ pub fn canonicalize<P: AsRef<Path>>(
}
#[cfg(not(unix))]
+/// Display the permissions of a file
pub fn display_permissions(metadata: &fs::Metadata, display_file_type: bool) -> String {
let write = if metadata.permissions().readonly() {
'-'
@@ -439,37 +440,58 @@ pub fn display_permissions(metadata: &fs::Metadata, display_file_type: bool) ->
'-'
};
- format!("{0}r{1}xr{1}xr{1}x", file_type, write)
+ format!("{file_type}r{write}xr{write}xr{write}x")
} else {
- format!("r{0}xr{0}xr{0}x", write)
+ format!("r{write}xr{write}xr{write}x")
}
}
#[cfg(unix)]
/// Display the permissions of a file
-/// On non unix like system, just show '----------'
pub fn display_permissions(metadata: &fs::Metadata, display_file_type: bool) -> String {
let mode: mode_t = metadata.mode() as mode_t;
display_permissions_unix(mode, display_file_type)
}
+/// Returns a character representation of the file type based on its mode.
+/// This function is specific to Unix-like systems.
+///
+/// - `mode`: The mode of the file, typically obtained from file metadata.
+///
+/// # Returns
+/// - 'd' for directories
+/// - 'c' for character devices
+/// - 'b' for block devices
+/// - '-' for regular files
+/// - 'p' for FIFOs (named pipes)
+/// - 'l' for symbolic links
+/// - 's' for sockets
+/// - '?' for any other unrecognized file types
+#[cfg(unix)]
+fn get_file_display(mode: mode_t) -> char {
+ match mode & S_IFMT {
+ S_IFDIR => 'd',
+ S_IFCHR => 'c',
+ S_IFBLK => 'b',
+ S_IFREG => '-',
+ S_IFIFO => 'p',
+ S_IFLNK => 'l',
+ S_IFSOCK => 's',
+ // TODO: Other file types
+ _ => '?',
+ }
+}
+
+// The logic below is more readable written this way.
+#[allow(clippy::if_not_else)]
+#[allow(clippy::cognitive_complexity)]
#[cfg(unix)]
/// Display the permissions of a file on a unix like system
pub fn display_permissions_unix(mode: mode_t, display_file_type: bool) -> String {
let mut result;
if display_file_type {
result = String::with_capacity(10);
- result.push(match mode & S_IFMT {
- S_IFDIR => 'd',
- S_IFCHR => 'c',
- S_IFBLK => 'b',
- S_IFREG => '-',
- S_IFIFO => 'p',
- S_IFLNK => 'l',
- S_IFSOCK => 's',
- // TODO: Other file types
- _ => '?',
- });
+ result.push(get_file_display(mode));
} else {
result = String::with_capacity(9);
}
@@ -580,10 +602,203 @@ pub fn make_path_relative_to<P1: AsRef<Path>, P2: AsRef<Path>>(path: P1, to: P2)
components.iter().collect()
}
+/// Checks if there is a symlink loop in the given path.
+///
+/// A symlink loop is a chain of symlinks where the last symlink points back to one of the previous symlinks in the chain.
+///
+/// # Arguments
+///
+/// * `path` - A reference to a `Path` representing the starting path to check for symlink loops.
+///
+/// # Returns
+///
+/// * `bool` - Returns `true` if a symlink loop is detected, `false` otherwise.
+pub fn is_symlink_loop(path: &Path) -> bool {
+ let mut visited_symlinks = HashSet::new();
+ let mut current_path = path.to_path_buf();
+
+ while let (Ok(metadata), Ok(link)) = (
+ current_path.symlink_metadata(),
+ fs::read_link(¤t_path),
+ ) {
+ if !metadata.file_type().is_symlink() {
+ return false;
+ }
+ if !visited_symlinks.insert(current_path.clone()) {
+ return true;
+ }
+ current_path = link;
+ }
+
+ false
+}
+
+#[cfg(not(unix))]
+// Hard link comparison is not supported on non-Unix platforms
+pub fn are_hardlinks_to_same_file(_source: &Path, _target: &Path) -> bool {
+ false
+}
+
+/// Checks if two paths are hard links to the same file.
+///
+/// # Arguments
+///
+/// * `source` - A reference to a `Path` representing the source path.
+/// * `target` - A reference to a `Path` representing the target path.
+///
+/// # Returns
+///
+/// * `bool` - Returns `true` if the paths are hard links to the same file, and `false` otherwise.
+#[cfg(unix)]
+pub fn are_hardlinks_to_same_file(source: &Path, target: &Path) -> bool {
+ let source_metadata = match fs::symlink_metadata(source) {
+ Ok(metadata) => metadata,
+ Err(_) => return false,
+ };
+
+ let target_metadata = match fs::symlink_metadata(target) {
+ Ok(metadata) => metadata,
+ Err(_) => return false,
+ };
+
+ source_metadata.ino() == target_metadata.ino() && source_metadata.dev() == target_metadata.dev()
+}
+
+#[cfg(not(unix))]
+pub fn are_hardlinks_or_one_way_symlink_to_same_file(_source: &Path, _target: &Path) -> bool {
+ false
+}
+
+/// Checks if either two paths are hard links to the same file or if the source path is a symbolic link which when fully resolved points to target path
+///
+/// # Arguments
+///
+/// * `source` - A reference to a `Path` representing the source path.
+/// * `target` - A reference to a `Path` representing the target path.
+///
+/// # Returns
+///
+/// * `bool` - Returns `true` if either of above conditions are true, and `false` otherwise.
+#[cfg(unix)]
+pub fn are_hardlinks_or_one_way_symlink_to_same_file(source: &Path, target: &Path) -> bool {
+ let source_metadata = match fs::metadata(source) {
+ Ok(metadata) => metadata,
+ Err(_) => return false,
+ };
+
+ let target_metadata = match fs::symlink_metadata(target) {
+ Ok(metadata) => metadata,
+ Err(_) => return false,
+ };
+
+ source_metadata.ino() == target_metadata.ino() && source_metadata.dev() == target_metadata.dev()
+}
+
+/// Returns true if the passed `path` ends with a path terminator.
+///
+/// This function examines the last character of the path to determine
+/// if it is a directory separator. It supports both Unix-style (`/`)
+/// and Windows-style (`\`) separators.
+///
+/// # Arguments
+///
+/// * `path` - A reference to the path to be checked.
+#[cfg(unix)]
+pub fn path_ends_with_terminator(path: &Path) -> bool {
+ use std::os::unix::prelude::OsStrExt;
+ path.as_os_str()
+ .as_bytes()
+ .last()
+ .map_or(false, |&byte| byte == b'/' || byte == b'\\')
+}
+
+#[cfg(windows)]
+pub fn path_ends_with_terminator(path: &Path) -> bool {
+ use std::os::windows::prelude::OsStrExt;
+ path.as_os_str()
+ .encode_wide()
+ .last()
+ .map_or(false, |wide| wide == b'/'.into() || wide == b'\\'.into())
+}
+
+pub mod sane_blksize {
+
+ #[cfg(not(target_os = "windows"))]
+ use std::os::unix::fs::MetadataExt;
+ use std::{fs::metadata, path::Path};
+
+ pub const DEFAULT: u64 = 512;
+ pub const MAX: u64 = (u32::MAX / 8 + 1) as u64;
+
+ /// Provides sanity checked blksize value from the provided value.
+ ///
+ /// If the provided value is a invalid values a meaningful adaption
+ /// of that value is done.
+ pub fn sane_blksize(st_blksize: u64) -> u64 {
+ match st_blksize {
+ 0 => DEFAULT,
+ 1..=MAX => st_blksize,
+ _ => DEFAULT,
+ }
+ }
+
+ /// Provides the blksize information from the provided metadata.
+ ///
+ /// If the metadata contain invalid values a meaningful adaption
+ /// of that value is done.
+ pub fn sane_blksize_from_metadata(_metadata: &std::fs::Metadata) -> u64 {
+ #[cfg(not(target_os = "windows"))]
+ {
+ sane_blksize(_metadata.blksize())
+ }
+
+ #[cfg(target_os = "windows")]
+ {
+ DEFAULT
+ }
+ }
+
+ /// Provides the blksize information from given file path's filesystem.
+ ///
+ /// If the metadata can't be fetched or contain invalid values a
+ /// meaningful adaption of that value is done.
+ pub fn sane_blksize_from_path(path: &Path) -> u64 {
+ match metadata(path) {
+ Ok(metadata) => sane_blksize_from_metadata(&metadata),
+ Err(_) => DEFAULT,
+ }
+ }
+}
+
+/// Extracts the filename component from the given `file` path and returns it as an `Option<&str>`.
+///
+/// If the `file` path contains a filename, this function returns `Some(filename)` where `filename` is
+/// the extracted filename as a string slice (`&str`). If the `file` path does not have a filename
+/// component or if the filename is not valid UTF-8, it returns `None`.
+///
+/// # Arguments
+///
+/// * `file`: A reference to a `Path` representing the file path from which to extract the filename.
+///
+/// # Returns
+///
+/// * `Some(filename)`: If a valid filename exists in the `file` path, where `filename` is the
+/// extracted filename as a string slice (`&str`).
+/// * `None`: If the `file` path does not contain a valid filename or if the filename is not valid UTF-8.
+pub fn get_filename(file: &Path) -> Option<&str> {
+ file.file_name().and_then(|filename| filename.to_str())
+}
+
#[cfg(test)]
mod tests {
// Note this useful idiom: importing names from outer (for mod tests) scope.
use super::*;
+ #[cfg(unix)]
+ use std::io::Write;
+ #[cfg(unix)]
+ use std::os::unix;
+ #[cfg(unix)]
+ use tempfile::{tempdir, NamedTempFile};
struct NormalizePathTestCase<'a> {
path: &'a str,
@@ -691,4 +906,128 @@ mod tests {
display_permissions_unix(S_IFCHR | S_ISVTX as mode_t | 0o054, true)
);
}
+
+ #[cfg(unix)]
+ #[test]
+ fn test_is_symlink_loop_no_loop() {
+ let temp_dir = tempdir().unwrap();
+ let file_path = temp_dir.path().join("file.txt");
+ let symlink_path = temp_dir.path().join("symlink");
+
+ fs::write(&file_path, "test content").unwrap();
+ unix::fs::symlink(&file_path, &symlink_path).unwrap();
+
+ assert!(!is_symlink_loop(&symlink_path));
+ }
+
+ #[cfg(unix)]
+ #[test]
+ fn test_is_symlink_loop_direct_loop() {
+ let temp_dir = tempdir().unwrap();
+ let symlink_path = temp_dir.path().join("loop");
+
+ unix::fs::symlink(&symlink_path, &symlink_path).unwrap();
+
+ assert!(is_symlink_loop(&symlink_path));
+ }
+
+ #[cfg(unix)]
+ #[test]
+ fn test_is_symlink_loop_indirect_loop() {
+ let temp_dir = tempdir().unwrap();
+ let symlink1_path = temp_dir.path().join("symlink1");
+ let symlink2_path = temp_dir.path().join("symlink2");
+
+ unix::fs::symlink(&symlink1_path, &symlink2_path).unwrap();
+ unix::fs::symlink(&symlink2_path, &symlink1_path).unwrap();
+
+ assert!(is_symlink_loop(&symlink1_path));
+ }
+
+ #[cfg(unix)]
+ #[test]
+ fn test_are_hardlinks_to_same_file_same_file() {
+ let mut temp_file = NamedTempFile::new().unwrap();
+ writeln!(temp_file, "Test content").unwrap();
+
+ let path1 = temp_file.path();
+ let path2 = temp_file.path();
+
+ assert!(are_hardlinks_to_same_file(path1, path2));
+ }
+
+ #[cfg(unix)]
+ #[test]
+ fn test_are_hardlinks_to_same_file_different_files() {
+ let mut temp_file1 = NamedTempFile::new().unwrap();
+ writeln!(temp_file1, "Test content 1").unwrap();
+
+ let mut temp_file2 = NamedTempFile::new().unwrap();
+ writeln!(temp_file2, "Test content 2").unwrap();
+
+ let path1 = temp_file1.path();
+ let path2 = temp_file2.path();
+
+ assert!(!are_hardlinks_to_same_file(path1, path2));
+ }
+
+ #[cfg(unix)]
+ #[test]
+ fn test_are_hardlinks_to_same_file_hard_link() {
+ let mut temp_file = NamedTempFile::new().unwrap();
+ writeln!(temp_file, "Test content").unwrap();
+ let path1 = temp_file.path();
+
+ let path2 = temp_file.path().with_extension("hardlink");
+ fs::hard_link(path1, &path2).unwrap();
+
+ assert!(are_hardlinks_to_same_file(path1, &path2));
+ }
+
+ #[cfg(unix)]
+ #[test]
+ fn test_get_file_display() {
+ assert_eq!(get_file_display(S_IFDIR | 0o755), 'd');
+ assert_eq!(get_file_display(S_IFCHR | 0o644), 'c');
+ assert_eq!(get_file_display(S_IFBLK | 0o600), 'b');
+ assert_eq!(get_file_display(S_IFREG | 0o777), '-');
+ assert_eq!(get_file_display(S_IFIFO | 0o666), 'p');
+ assert_eq!(get_file_display(S_IFLNK | 0o777), 'l');
+ assert_eq!(get_file_display(S_IFSOCK | 0o600), 's');
+ assert_eq!(get_file_display(0o777), '?');
+ }
+
+ #[test]
+ fn test_path_ends_with_terminator() {
+ // Path ends with a forward slash
+ assert!(path_ends_with_terminator(Path::new("/some/path/")));
+
+ // Path ends with a backslash
+ assert!(path_ends_with_terminator(Path::new("C:\\some\\path\\")));
+
+ // Path does not end with a terminator
+ assert!(!path_ends_with_terminator(Path::new("/some/path")));
+ assert!(!path_ends_with_terminator(Path::new("C:\\some\\path")));
+
+ // Empty path
+ assert!(!path_ends_with_terminator(Path::new("")));
+
+ // Root path
+ assert!(path_ends_with_terminator(Path::new("/")));
+ assert!(path_ends_with_terminator(Path::new("C:\\")));
+ }
+
+ #[test]
+ fn test_sane_blksize() {
+ assert_eq!(512, sane_blksize::sane_blksize(0));
+ assert_eq!(512, sane_blksize::sane_blksize(512));
+ assert_eq!(4096, sane_blksize::sane_blksize(4096));
+ assert_eq!(0x2000_0000, sane_blksize::sane_blksize(0x2000_0000));
+ assert_eq!(512, sane_blksize::sane_blksize(0x2000_0001));
+ }
+ #[test]
+ fn test_get_file_name() {
+ let file_path = PathBuf::from("~/foo.txt");
+ assert!(matches!(get_filename(&file_path), Some("foo.txt")));
+ }
}
diff --git a/src/uucore/src/lib/features/fsext.rs b/src/uucore/src/lib/features/fsext.rs
index fcace586de036414f93f53c299056247165d4e88..eaa672472b686bf312088724fe7b97958fa267bc 100644
--- a/src/uucore/src/lib/features/fsext.rs
+++ b/src/uucore/src/lib/features/fsext.rs
@@ -1,58 +1,47 @@
// This file is part of the uutils coreutils package.
//
-// (c) Jian Zeng <anonymousknight96@gmail.com>
-// (c) Fangxu Hu <framlog@gmail.com>
-// (c) Sylvestre Ledru <sylvestre@debian.org>
-//
-// For the full copyright and license information, please view the LICENSE file
-// that was distributed with this source code.
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//! Set of functions to manage file systems
-// spell-checker:ignore DATETIME subsecond (arch) bitrig ; (fs) cifs smbfs
-
-extern crate time;
-use time::macros::format_description;
-use time::UtcOffset;
-
-pub use crate::*; // import macros from `../../macros.rs`
+// spell-checker:ignore DATETIME getmntinfo subsecond (fs) cifs smbfs
#[cfg(any(target_os = "linux", target_os = "android"))]
const LINUX_MTAB: &str = "/etc/mtab";
#[cfg(any(target_os = "linux", target_os = "android"))]
const LINUX_MOUNTINFO: &str = "/proc/self/mountinfo";
+#[cfg(all(unix, not(any(target_os = "aix", target_os = "redox"))))]
static MOUNT_OPT_BIND: &str = "bind";
#[cfg(windows)]
const MAX_PATH: usize = 266;
-#[cfg(not(unix))]
+#[cfg(windows)]
static EXIT_ERR: i32 = 1;
+#[cfg(any(
+ windows,
+ target_os = "freebsd",
+ target_vendor = "apple",
+ target_os = "netbsd",
+ target_os = "openbsd"
+))]
+use crate::crash;
+#[cfg(windows)]
+use crate::show_warning;
+
#[cfg(windows)]
use std::ffi::OsStr;
#[cfg(windows)]
use std::os::windows::ffi::OsStrExt;
#[cfg(windows)]
-use windows_sys::Win32::Foundation::{ERROR_NO_MORE_FILES, INVALID_HANDLE_VALUE};
-#[cfg(windows)]
-use windows_sys::Win32::Storage::FileSystem::{
- FindFirstVolumeW, FindNextVolumeW, FindVolumeClose, GetDiskFreeSpaceW, GetDriveTypeW,
- GetVolumeInformationW, GetVolumePathNamesForVolumeNameW, QueryDosDeviceW,
+use windows_sys::Win32::{
+ Foundation::{ERROR_NO_MORE_FILES, INVALID_HANDLE_VALUE},
+ Storage::FileSystem::{
+ FindFirstVolumeW, FindNextVolumeW, FindVolumeClose, GetDiskFreeSpaceW, GetDriveTypeW,
+ GetVolumeInformationW, GetVolumePathNamesForVolumeNameW, QueryDosDeviceW,
+ },
+ System::WindowsProgramming::DRIVE_REMOTE,
};
-#[cfg(windows)]
-use windows_sys::Win32::System::WindowsProgramming::DRIVE_REMOTE;
-
-// Warning: the pointer has to be used *immediately* or the Vec
-// it points to will be dropped!
-#[cfg(windows)]
-macro_rules! String2LPWSTR {
- ($str: expr) => {
- OsStr::new(&$str)
- .encode_wide()
- .chain(Some(0))
- .collect::<Vec<u16>>()
- .as_ptr()
- };
-}
#[cfg(windows)]
#[allow(non_snake_case)]
@@ -61,27 +50,27 @@ fn LPWSTR2String(buf: &[u16]) -> String {
String::from_utf16(&buf[..len]).unwrap()
}
+#[cfg(windows)]
+fn to_nul_terminated_wide_string(s: impl AsRef<OsStr>) -> Vec<u16> {
+ s.as_ref()
+ .encode_wide()
+ .chain(Some(0))
+ .collect::<Vec<u16>>()
+}
+
#[cfg(unix)]
use libc::{
mode_t, strerror, S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK,
};
use std::borrow::Cow;
-use std::convert::{AsRef, From};
-#[cfg(any(
- target_vendor = "apple",
- target_os = "freebsd",
- target_os = "netbsd",
- target_os = "openbsd",
- target_os = "linux",
- target_os = "android",
-))]
+#[cfg(unix)]
use std::ffi::CStr;
-#[cfg(not(windows))]
+#[cfg(unix)]
use std::ffi::CString;
use std::io::Error as IOError;
#[cfg(unix)]
use std::mem;
-#[cfg(not(unix))]
+#[cfg(windows)]
use std::path::Path;
use std::time::UNIX_EPOCH;
@@ -94,8 +83,8 @@ use std::time::UNIX_EPOCH;
))]
pub use libc::statfs as StatFs;
#[cfg(any(
+ target_os = "aix",
target_os = "netbsd",
- target_os = "bitrig",
target_os = "dragonfly",
target_os = "illumos",
target_os = "solaris",
@@ -109,106 +98,55 @@ pub use libc::statvfs as StatFs;
target_vendor = "apple",
target_os = "freebsd",
target_os = "openbsd",
- target_os = "redox"
))]
pub use libc::statfs as statfs_fn;
#[cfg(any(
+ target_os = "aix",
target_os = "netbsd",
- target_os = "bitrig",
target_os = "illumos",
target_os = "solaris",
- target_os = "dragonfly"
+ target_os = "dragonfly",
+ target_os = "redox"
))]
pub use libc::statvfs as statfs_fn;
pub trait BirthTime {
- fn pretty_birth(&self) -> String;
- fn birth(&self) -> u64;
+ fn birth(&self) -> Option<(u64, u32)>;
}
use std::fs::Metadata;
impl BirthTime for Metadata {
- fn pretty_birth(&self) -> String {
- self.created()
- .ok()
- .and_then(|t| t.duration_since(UNIX_EPOCH).ok())
- .map(|e| pretty_time(e.as_secs() as i64, i64::from(e.subsec_nanos())))
- .unwrap_or_else(|| "-".to_owned())
- }
-
- fn birth(&self) -> u64 {
+ fn birth(&self) -> Option<(u64, u32)> {
self.created()
.ok()
.and_then(|t| t.duration_since(UNIX_EPOCH).ok())
- .map(|e| e.as_secs())
- .unwrap_or_default()
+ .map(|e| (e.as_secs(), e.subsec_nanos()))
}
}
#[derive(Debug, Clone)]
pub struct MountInfo {
- // it stores `volume_name` in windows platform and `dev_id` in unix platform
+ /// Stores `volume_name` in windows platform and `dev_id` in unix platform
pub dev_id: String,
pub dev_name: String,
pub fs_type: String,
- pub mount_dir: String,
- pub mount_option: String, // we only care "bind" option
pub mount_root: String,
+ pub mount_dir: String,
+ /// We only care whether this field contains "bind"
+ pub mount_option: String,
pub remote: bool,
pub dummy: bool,
}
impl MountInfo {
- fn set_missing_fields(&mut self) {
- #[cfg(unix)]
- {
- use std::os::unix::fs::MetadataExt;
- // We want to keep the dev_id on Windows
- // but set dev_id
- if let Ok(stat) = std::fs::metadata(&self.mount_dir) {
- // Why do we cast this to i32?
- self.dev_id = (stat.dev() as i32).to_string();
- } else {
- self.dev_id = String::new();
- }
- }
- // set MountInfo::dummy
- // spell-checker:disable
- match self.fs_type.as_ref() {
- "autofs" | "proc" | "subfs"
- /* for Linux 2.6/3.x */
- | "debugfs" | "devpts" | "fusectl" | "mqueue" | "rpc_pipefs" | "sysfs"
- /* FreeBSD, Linux 2.4 */
- | "devfs"
- /* for NetBSD 3.0 */
- | "kernfs"
- /* for Irix 6.5 */
- | "ignore" => self.dummy = true,
- _ => self.dummy = self.fs_type == "none"
- && !self.mount_option.contains(MOUNT_OPT_BIND)
- }
- // spell-checker:enable
- // set MountInfo::remote
- #[cfg(windows)]
- {
- self.remote = DRIVE_REMOTE == unsafe { GetDriveTypeW(String2LPWSTR!(self.mount_root)) };
- }
- #[cfg(unix)]
- {
- if self.dev_name.find(':').is_some()
- || (self.dev_name.starts_with("//") && self.fs_type == "smbfs"
- || self.fs_type == "cifs")
- || self.dev_name == "-hosts"
- {
- self.remote = true;
- } else {
- self.remote = false;
- }
- }
- }
-
#[cfg(any(target_os = "linux", target_os = "android"))]
fn new(file_name: &str, raw: &[&str]) -> Option<Self> {
+ let dev_name;
+ let fs_type;
+ let mount_root;
+ let mount_dir;
+ let mount_option;
+
match file_name {
// spell-checker:ignore (word) noatime
// Format: 36 35 98:0 /mnt1 /mnt2 rw,noatime master:1 - ext3 /dev/root rw,errors=continue
@@ -218,36 +156,38 @@ impl MountInfo {
let after_fields = raw[FIELDS_OFFSET..].iter().position(|c| *c == "-").unwrap()
+ FIELDS_OFFSET
+ 1;
- let mut m = Self {
- dev_id: String::new(),
- dev_name: raw[after_fields + 1].to_string(),
- fs_type: raw[after_fields].to_string(),
- mount_root: raw[3].to_string(),
- mount_dir: raw[4].to_string(),
- mount_option: raw[5].to_string(),
- remote: false,
- dummy: false,
- };
- m.set_missing_fields();
- Some(m)
+ dev_name = raw[after_fields + 1].to_string();
+ fs_type = raw[after_fields].to_string();
+ mount_root = raw[3].to_string();
+ mount_dir = raw[4].to_string();
+ mount_option = raw[5].to_string();
}
LINUX_MTAB => {
- let mut m = Self {
- dev_id: String::new(),
- dev_name: raw[0].to_string(),
- fs_type: raw[2].to_string(),
- mount_root: String::new(),
- mount_dir: raw[1].to_string(),
- mount_option: raw[3].to_string(),
- remote: false,
- dummy: false,
- };
- m.set_missing_fields();
- Some(m)
+ dev_name = raw[0].to_string();
+ fs_type = raw[2].to_string();
+ mount_root = String::new();
+ mount_dir = raw[1].to_string();
+ mount_option = raw[3].to_string();
}
- _ => None,
- }
+ _ => return None,
+ };
+
+ let dev_id = mount_dev_id(&mount_dir);
+ let dummy = is_dummy_filesystem(&fs_type, &mount_option);
+ let remote = is_remote_filesystem(&dev_name, &fs_type);
+
+ Some(Self {
+ dev_id,
+ dev_name,
+ fs_type,
+ mount_dir,
+ mount_option,
+ mount_root,
+ remote,
+ dummy,
+ })
}
+
#[cfg(windows)]
fn new(mut volume_name: String) -> Option<Self> {
let mut dev_name_buf = [0u16; MAX_PATH];
@@ -269,8 +209,9 @@ impl MountInfo {
let mut mount_root_buf = [0u16; MAX_PATH];
let success = unsafe {
+ let volume_name = to_nul_terminated_wide_string(&volume_name);
GetVolumePathNamesForVolumeNameW(
- String2LPWSTR!(volume_name),
+ volume_name.as_ptr(),
mount_root_buf.as_mut_ptr(),
mount_root_buf.len() as u32,
ptr::null_mut(),
@@ -284,8 +225,9 @@ impl MountInfo {
let mut fs_type_buf = [0u16; MAX_PATH];
let success = unsafe {
+ let mount_root = to_nul_terminated_wide_string(&mount_root);
GetVolumeInformationW(
- String2LPWSTR!(mount_root),
+ mount_root.as_ptr(),
ptr::null_mut(),
0,
ptr::null_mut(),
@@ -295,23 +237,26 @@ impl MountInfo {
fs_type_buf.len() as u32,
)
};
- let fs_type = if 0 != success {
- Some(LPWSTR2String(&fs_type_buf))
- } else {
+ let fs_type = if 0 == success {
None
+ } else {
+ Some(LPWSTR2String(&fs_type_buf))
};
- let mut mn_info = Self {
+ let remote = DRIVE_REMOTE
+ == unsafe {
+ let mount_root = to_nul_terminated_wide_string(&mount_root);
+ GetDriveTypeW(mount_root.as_ptr())
+ };
+ Some(Self {
dev_id: volume_name,
dev_name,
fs_type: fs_type.unwrap_or_default(),
mount_root,
mount_dir: String::new(),
mount_option: String::new(),
- remote: false,
+ remote,
dummy: false,
- };
- mn_info.set_missing_fields();
- Some(mn_info)
+ })
}
}
@@ -319,37 +264,81 @@ impl MountInfo {
target_os = "freebsd",
target_vendor = "apple",
target_os = "netbsd",
- target_os = "openbsd"
+ target_os = "openbsd",
))]
impl From<StatFs> for MountInfo {
fn from(statfs: StatFs) -> Self {
- let mut info = Self {
- dev_id: String::new(),
- dev_name: unsafe {
- // spell-checker:disable-next-line
- CStr::from_ptr(&statfs.f_mntfromname[0])
- .to_string_lossy()
- .into_owned()
- },
- fs_type: unsafe {
- // spell-checker:disable-next-line
- CStr::from_ptr(&statfs.f_fstypename[0])
- .to_string_lossy()
- .into_owned()
- },
- mount_dir: unsafe {
- // spell-checker:disable-next-line
- CStr::from_ptr(&statfs.f_mntonname[0])
- .to_string_lossy()
- .into_owned()
- },
+ let dev_name = unsafe {
+ // spell-checker:disable-next-line
+ CStr::from_ptr(&statfs.f_mntfromname[0])
+ .to_string_lossy()
+ .into_owned()
+ };
+ let fs_type = unsafe {
+ // spell-checker:disable-next-line
+ CStr::from_ptr(&statfs.f_fstypename[0])
+ .to_string_lossy()
+ .into_owned()
+ };
+ let mount_dir = unsafe {
+ // spell-checker:disable-next-line
+ CStr::from_ptr(&statfs.f_mntonname[0])
+ .to_string_lossy()
+ .into_owned()
+ };
+
+ let dev_id = mount_dev_id(&mount_dir);
+ let dummy = is_dummy_filesystem(&fs_type, "");
+ let remote = is_remote_filesystem(&dev_name, &fs_type);
+
+ Self {
+ dev_id,
+ dev_name,
+ fs_type,
+ mount_dir,
mount_root: String::new(),
mount_option: String::new(),
- remote: false,
- dummy: false,
- };
- info.set_missing_fields();
- info
+ remote,
+ dummy,
+ }
+ }
+}
+
+#[cfg(all(unix, not(any(target_os = "aix", target_os = "redox"))))]
+fn is_dummy_filesystem(fs_type: &str, mount_option: &str) -> bool {
+ // spell-checker:disable
+ match fs_type {
+ "autofs" | "proc" | "subfs"
+ // for Linux 2.6/3.x
+ | "debugfs" | "devpts" | "fusectl" | "mqueue" | "rpc_pipefs" | "sysfs"
+ // FreeBSD, Linux 2.4
+ | "devfs"
+ // for NetBSD 3.0
+ | "kernfs"
+ // for Irix 6.5
+ | "ignore" => true,
+ _ => fs_type == "none"
+ && !mount_option.contains(MOUNT_OPT_BIND)
+ }
+ // spell-checker:enable
+}
+
+#[cfg(all(unix, not(any(target_os = "aix", target_os = "redox"))))]
+fn is_remote_filesystem(dev_name: &str, fs_type: &str) -> bool {
+ dev_name.find(':').is_some()
+ || (dev_name.starts_with("//") && fs_type == "smbfs" || fs_type == "cifs")
+ || dev_name == "-hosts"
+}
+
+#[cfg(all(unix, not(any(target_os = "aix", target_os = "redox"))))]
+fn mount_dev_id(mount_dir: &str) -> String {
+ use std::os::unix::fs::MetadataExt;
+
+ if let Ok(stat) = std::fs::metadata(mount_dir) {
+ // Why do we cast this to i32?
+ (stat.dev() as i32).to_string()
+ } else {
+ String::new()
}
}
@@ -368,16 +357,22 @@ use libc::c_int;
))]
extern "C" {
#[cfg(all(target_vendor = "apple", target_arch = "x86_64"))]
- #[link_name = "getmntinfo$INODE64"] // spell-checker:disable-line
+ #[link_name = "getmntinfo$INODE64"]
fn get_mount_info(mount_buffer_p: *mut *mut StatFs, flags: c_int) -> c_int;
#[cfg(any(
- all(target_os = "freebsd"),
- all(target_os = "netbsd"),
- all(target_os = "openbsd"),
+ target_os = "netbsd",
+ target_os = "openbsd",
all(target_vendor = "apple", target_arch = "aarch64")
))]
- #[link_name = "getmntinfo"] // spell-checker:disable-line
+ #[link_name = "getmntinfo"]
+ fn get_mount_info(mount_buffer_p: *mut *mut StatFs, flags: c_int) -> c_int;
+
+ // Rust on FreeBSD uses 11.x ABI for filesystem metadata syscalls.
+ // Call the right version of the symbol for getmntinfo() result to
+ // match libc StatFS layout.
+ #[cfg(target_os = "freebsd")]
+ #[link_name = "getmntinfo@FBSD_1.0"]
fn get_mount_info(mount_buffer_p: *mut *mut StatFs, flags: c_int) -> c_int;
}
@@ -410,7 +405,7 @@ pub fn read_fs_list() -> Result<Vec<MountInfo>, std::io::Error> {
let reader = BufReader::new(f);
Ok(reader
.lines()
- .filter_map(|line| line.ok())
+ .map_while(Result::ok)
.filter_map(|line| {
let raw_data = line.split_whitespace().collect::<Vec<&str>>();
MountInfo::new(file_name, &raw_data)
@@ -477,7 +472,12 @@ pub fn read_fs_list() -> Result<Vec<MountInfo>, std::io::Error> {
}
Ok(mounts)
}
- #[cfg(any(target_os = "redox", target_os = "illumos", target_os = "solaris"))]
+ #[cfg(any(
+ target_os = "aix",
+ target_os = "redox",
+ target_os = "illumos",
+ target_os = "solaris"
+ ))]
{
// No method to read mounts, yet
Ok(Vec::new())
@@ -499,7 +499,10 @@ impl FsUsage {
#[cfg(unix)]
pub fn new(statvfs: StatFs) -> Self {
{
- #[cfg(all(not(target_os = "freebsd"), target_pointer_width = "64"))]
+ #[cfg(all(
+ not(any(target_os = "freebsd", target_os = "openbsd")),
+ target_pointer_width = "64"
+ ))]
return Self {
blocksize: statvfs.f_bsize as u64, // or `statvfs.f_frsize` ?
blocks: statvfs.f_blocks,
@@ -509,7 +512,10 @@ impl FsUsage {
files: statvfs.f_files,
ffree: statvfs.f_ffree,
};
- #[cfg(all(not(target_os = "freebsd"), not(target_pointer_width = "64")))]
+ #[cfg(all(
+ not(any(target_os = "freebsd", target_os = "openbsd")),
+ not(target_pointer_width = "64")
+ ))]
return Self {
blocksize: statvfs.f_bsize as u64, // or `statvfs.f_frsize` ?
blocks: statvfs.f_blocks.into(),
@@ -532,15 +538,29 @@ impl FsUsage {
files: statvfs.f_files,
ffree: statvfs.f_ffree.try_into().unwrap(),
};
+ #[cfg(target_os = "openbsd")]
+ return Self {
+ blocksize: statvfs.f_bsize.into(),
+ blocks: statvfs.f_blocks,
+ bfree: statvfs.f_bfree,
+ bavail: statvfs.f_bavail.try_into().unwrap(),
+ bavail_top_bit_set: ((std::convert::TryInto::<u64>::try_into(statvfs.f_bavail)
+ .unwrap())
+ & (1u64.rotate_right(1)))
+ != 0,
+ files: statvfs.f_files,
+ ffree: statvfs.f_ffree,
+ };
}
}
- #[cfg(not(unix))]
+ #[cfg(windows)]
pub fn new(path: &Path) -> Self {
let mut root_path = [0u16; MAX_PATH];
let success = unsafe {
+ let path = to_nul_terminated_wide_string(path);
GetVolumePathNamesForVolumeNameW(
//path_utf8.as_ptr(),
- String2LPWSTR!(path.as_os_str()),
+ path.as_ptr(),
root_path.as_mut_ptr(),
root_path.len() as u32,
ptr::null_mut(),
@@ -560,8 +580,9 @@ impl FsUsage {
let mut total_number_of_clusters = 0;
let success = unsafe {
+ let path = to_nul_terminated_wide_string(path);
GetDiskFreeSpaceW(
- String2LPWSTR!(path.as_os_str()),
+ path.as_ptr(),
&mut sectors_per_cluster,
&mut bytes_per_sector,
&mut number_of_free_clusters,
@@ -617,22 +638,42 @@ impl FsMeta for StatFs {
#[cfg(all(
not(target_env = "musl"),
not(target_vendor = "apple"),
+ not(target_os = "aix"),
not(target_os = "android"),
not(target_os = "freebsd"),
+ not(target_os = "netbsd"),
+ not(target_os = "openbsd"),
+ not(target_os = "illumos"),
+ not(target_os = "solaris"),
+ not(target_os = "redox"),
+ not(target_arch = "s390x"),
target_pointer_width = "64"
))]
return self.f_bsize;
#[cfg(all(
not(target_env = "musl"),
not(target_os = "freebsd"),
+ not(target_os = "netbsd"),
+ not(target_os = "redox"),
any(
+ target_arch = "s390x",
target_vendor = "apple",
- target_os = "android",
+ all(target_os = "android", target_pointer_width = "32"),
+ target_os = "openbsd",
not(target_pointer_width = "64")
)
))]
return self.f_bsize.into();
- #[cfg(any(target_env = "musl", target_os = "freebsd"))]
+ #[cfg(any(
+ target_env = "musl",
+ target_os = "aix",
+ target_os = "freebsd",
+ target_os = "netbsd",
+ target_os = "illumos",
+ target_os = "solaris",
+ target_os = "redox",
+ all(target_os = "android", target_pointer_width = "64"),
+ ))]
return self.f_bsize.try_into().unwrap();
}
fn total_blocks(&self) -> u64 {
@@ -648,11 +689,19 @@ impl FsMeta for StatFs {
return self.f_bfree.into();
}
fn avail_blocks(&self) -> u64 {
- #[cfg(all(not(target_os = "freebsd"), target_pointer_width = "64"))]
+ #[cfg(all(
+ not(target_os = "freebsd"),
+ not(target_os = "openbsd"),
+ target_pointer_width = "64"
+ ))]
return self.f_bavail;
- #[cfg(all(not(target_os = "freebsd"), not(target_pointer_width = "64")))]
+ #[cfg(all(
+ not(target_os = "freebsd"),
+ not(target_os = "openbsd"),
+ not(target_pointer_width = "64")
+ ))]
return self.f_bavail.into();
- #[cfg(target_os = "freebsd")]
+ #[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
return self.f_bavail.try_into().unwrap();
}
fn total_file_nodes(&self) -> u64 {
@@ -681,6 +730,7 @@ impl FsMeta for StatFs {
not(target_vendor = "apple"),
not(target_os = "android"),
not(target_os = "freebsd"),
+ not(target_arch = "s390x"),
target_pointer_width = "64"
))]
return self.f_type;
@@ -688,13 +738,17 @@ impl FsMeta for StatFs {
not(target_env = "musl"),
any(
target_vendor = "apple",
- target_os = "android",
+ all(target_os = "android", target_pointer_width = "32"),
target_os = "freebsd",
+ target_arch = "s390x",
not(target_pointer_width = "64")
)
))]
return self.f_type.into();
- #[cfg(target_env = "musl")]
+ #[cfg(any(
+ target_env = "musl",
+ all(target_os = "android", target_pointer_width = "64"),
+ ))]
return self.f_type.try_into().unwrap();
}
#[cfg(not(any(
@@ -811,57 +865,14 @@ where
}
}
-// match strftime "%Y-%m-%d %H:%M:%S.%f %z"
-const PRETTY_DATETIME_FORMAT: &[time::format_description::FormatItem] = format_description!(
- "\
-[year]-[month]-[day padding:zero] \
-[hour]:[minute]:[second].[subsecond digits:9] \
-[offset_hour sign:mandatory][offset_minute]"
-);
-
-pub fn pretty_time(sec: i64, nsec: i64) -> String {
- // sec == seconds since UNIX_EPOCH
- // nsec == nanoseconds since (UNIX_EPOCH + sec)
- let ts_nanos: i128 = (sec * 1_000_000_000 + nsec).into();
-
- // Return the date in UTC
- let tm = match time::OffsetDateTime::from_unix_timestamp_nanos(ts_nanos) {
- Ok(tm) => tm,
- Err(e) => {
- panic!("error: {}", e);
- }
- };
-
- // Get the offset to convert to local time
- // Because of DST (daylight saving), we get the local time back when
- // the date was set
- let local_offset = match UtcOffset::local_offset_at(tm) {
- Ok(lo) => lo,
- Err(e) => {
- panic!("error: {}", e);
- }
- };
-
- // Include the conversion to local time
- let res = tm
- .to_offset(local_offset)
- .format(&PRETTY_DATETIME_FORMAT)
- .unwrap();
- if res.ends_with(" -0000") {
- res.replace(" -0000", " +0000")
- } else {
- res
- }
-}
-
#[cfg(unix)]
pub fn pretty_filetype<'a>(mode: mode_t, size: u64) -> &'a str {
match mode & S_IFMT {
S_IFREG => {
- if size != 0 {
- "regular file"
- } else {
+ if size == 0 {
"regular empty file"
+ } else {
+ "regular file"
}
}
S_IFDIR => "directory",
@@ -888,6 +899,7 @@ pub fn pretty_fstype<'a>(fstype: i64) -> Cow<'a, str> {
0x0187 => "autofs".into(),
0x4246_5331 => "befs".into(),
0x6264_6576 => "bdevfs".into(),
+ 0xCA451A4E => "bcachefs".into(),
0x1BAD_FACE => "bfs".into(),
0xCAFE_4A11 => "bpf_fs".into(),
0x4249_4E4D => "binfmt_misc".into(),
@@ -993,7 +1005,8 @@ pub fn pretty_fstype<'a>(fstype: i64) -> Cow<'a, str> {
0x5846_5342 => "xfs".into(),
0x012F_D16D => "xia".into(),
0x2FC1_2FC1 => "zfs".into(),
- other => format!("UNKNOWN ({:#x})", other).into(),
+ 0xDE => "zfs".into(),
+ other => format!("UNKNOWN ({other:#x})").into(),
}
// spell-checker:enable
}
diff --git a/src/uucore/src/lib/features/fsxattr.rs b/src/uucore/src/lib/features/fsxattr.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3cb00edc0cb894559755a54fbe9408d3a4d93286
--- /dev/null
+++ b/src/uucore/src/lib/features/fsxattr.rs
@@ -0,0 +1,154 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore getxattr
+
+//! Set of functions to manage xattr on files and dirs
+use std::collections::HashMap;
+use std::ffi::OsString;
+use std::path::Path;
+
+/// Copies extended attributes (xattrs) from one file or directory to another.
+///
+/// # Arguments
+///
+/// * `source` - A reference to the source path.
+/// * `dest` - A reference to the destination path.
+///
+/// # Returns
+///
+/// A result indicating success or failure.
+pub fn copy_xattrs<P: AsRef<Path>>(source: P, dest: P) -> std::io::Result<()> {
+ for attr_name in xattr::list(&source)? {
+ if let Some(value) = xattr::get(&source, &attr_name)? {
+ xattr::set(&dest, &attr_name, &value)?;
+ }
+ }
+ Ok(())
+}
+
+/// Retrieves the extended attributes (xattrs) of a given file or directory.
+///
+/// # Arguments
+///
+/// * `source` - A reference to the path of the file or directory.
+///
+/// # Returns
+///
+/// A result containing a HashMap of attributes names and values, or an error.
+pub fn retrieve_xattrs<P: AsRef<Path>>(source: P) -> std::io::Result<HashMap<OsString, Vec<u8>>> {
+ let mut attrs = HashMap::new();
+ for attr_name in xattr::list(&source)? {
+ if let Some(value) = xattr::get(&source, &attr_name)? {
+ attrs.insert(attr_name, value);
+ }
+ }
+ Ok(attrs)
+}
+
+/// Applies extended attributes (xattrs) to a given file or directory.
+///
+/// # Arguments
+///
+/// * `dest` - A reference to the path of the file or directory.
+/// * `xattrs` - A HashMap containing attribute names and their corresponding values.
+///
+/// # Returns
+///
+/// A result indicating success or failure.
+pub fn apply_xattrs<P: AsRef<Path>>(
+ dest: P,
+ xattrs: HashMap<OsString, Vec<u8>>,
+) -> std::io::Result<()> {
+ for (attr, value) in xattrs {
+ xattr::set(&dest, &attr, &value)?;
+ }
+ Ok(())
+}
+
+/// Checks if a file has an Access Control List (ACL) based on its extended attributes.
+///
+/// # Arguments
+///
+/// * `file` - A reference to the path of the file.
+///
+/// # Returns
+///
+/// `true` if the file has extended attributes (indicating an ACL), `false` otherwise.
+pub fn has_acl<P: AsRef<Path>>(file: P) -> bool {
+ // don't use exacl here, it is doing more getxattr call then needed
+ match xattr::list(file) {
+ Ok(acl) => {
+ // if we have extra attributes, we have an acl
+ acl.count() > 0
+ }
+ Err(_) => false,
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use std::fs::File;
+ use tempfile::tempdir;
+
+ #[test]
+ fn test_copy_xattrs() {
+ let temp_dir = tempdir().unwrap();
+ let source_path = temp_dir.path().join("source.txt");
+ let dest_path = temp_dir.path().join("dest.txt");
+
+ File::create(&source_path).unwrap();
+ File::create(&dest_path).unwrap();
+
+ let test_attr = "user.test";
+ let test_value = b"test value";
+ xattr::set(&source_path, test_attr, test_value).unwrap();
+
+ copy_xattrs(&source_path, &dest_path).unwrap();
+
+ let copied_value = xattr::get(&dest_path, test_attr).unwrap().unwrap();
+ assert_eq!(copied_value, test_value);
+ }
+
+ #[test]
+ fn test_apply_and_retrieve_xattrs() {
+ let temp_dir = tempdir().unwrap();
+ let file_path = temp_dir.path().join("test_file.txt");
+
+ File::create(&file_path).unwrap();
+
+ let mut test_xattrs = HashMap::new();
+ let test_attr = "user.test_attr";
+ let test_value = b"test value";
+ test_xattrs.insert(OsString::from(test_attr), test_value.to_vec());
+ apply_xattrs(&file_path, test_xattrs).unwrap();
+
+ let retrieved_xattrs = retrieve_xattrs(&file_path).unwrap();
+ assert!(retrieved_xattrs.contains_key(OsString::from(test_attr).as_os_str()));
+ assert_eq!(
+ retrieved_xattrs
+ .get(OsString::from(test_attr).as_os_str())
+ .unwrap(),
+ test_value
+ );
+ }
+
+ #[test]
+ fn test_file_has_acl() {
+ let temp_dir = tempdir().unwrap();
+ let file_path = temp_dir.path().join("test_file.txt");
+
+ File::create(&file_path).unwrap();
+
+ assert!(!has_acl(&file_path));
+
+ let test_attr = "user.test_acl";
+ let test_value = b"test value";
+ xattr::set(&file_path, test_attr, test_value).unwrap();
+
+ assert!(has_acl(&file_path));
+ }
+}
diff --git a/src/uucore/src/lib/features/lines.rs b/src/uucore/src/lib/features/lines.rs
index a7f4df76d216d54be955eb04735c9658b9406b11..3e3c82b3a5c9c90eade5d5f4dca7b2714cc8160b 100644
--- a/src/uucore/src/lib/features/lines.rs
+++ b/src/uucore/src/lib/features/lines.rs
@@ -1,7 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (vars)
//! Iterate over lines, including the line ending character(s).
//!
diff --git a/src/uucore/src/lib/features/memo.rs b/src/uucore/src/lib/features/memo.rs
deleted file mode 100644
index c61be8acf9841d88fbbe1d8890869e68ca02a7ab..0000000000000000000000000000000000000000
--- a/src/uucore/src/lib/features/memo.rs
+++ /dev/null
@@ -1,175 +0,0 @@
-//! Main entry point for our implementation of printf.
-//!
-//! The [`printf`] and [`sprintf`] closely match the behavior of the
-//! corresponding C functions: the former renders a formatted string
-//! to stdout, the latter renders to a new [`String`] object.
-use crate::display::Quotable;
-use crate::error::{UResult, USimpleError};
-use crate::features::tokenize::sub::SubParser;
-use crate::features::tokenize::token::Token;
-use crate::features::tokenize::unescaped_text::UnescapedText;
-use crate::show_warning;
-use itertools::put_back_n;
-use std::io::{stdout, Cursor, Write};
-use std::iter::Peekable;
-use std::slice::Iter;
-
-/// Memo runner of printf
-/// Takes a format string and arguments
-/// 1. tokenize format string into tokens, consuming
-/// any subst. arguments along the way.
-/// 2. feeds remaining arguments into function
-/// that prints tokens.
-struct Memo {
- tokens: Vec<Token>,
-}
-
-fn warn_excess_args(first_arg: &str) {
- show_warning!(
- "ignoring excess arguments, starting with {}",
- first_arg.quote()
- );
-}
-
-impl Memo {
- fn new<W>(
- writer: &mut W,
- pf_string: &str,
- pf_args_it: &mut Peekable<Iter<String>>,
- ) -> UResult<Self>
- where
- W: Write,
- {
- let mut pm = Self { tokens: Vec::new() };
- let mut it = put_back_n(pf_string.chars());
- let mut has_sub = false;
- loop {
- if let Some(x) = UnescapedText::from_it_core(writer, &mut it, false) {
- pm.tokens.push(x);
- }
- if let Some(x) = SubParser::from_it(writer, &mut it, pf_args_it)? {
- if !has_sub {
- has_sub = true;
- }
- pm.tokens.push(x);
- }
- if let Some(x) = it.next() {
- it.put_back(x);
- } else {
- break;
- }
- }
- if !has_sub {
- let mut drain = false;
- if let Some(first_arg) = pf_args_it.peek() {
- warn_excess_args(first_arg);
- drain = true;
- }
- if drain {
- loop {
- // drain remaining args;
- if pf_args_it.next().is_none() {
- break;
- }
- }
- }
- }
- Ok(pm)
- }
- fn apply<W>(&self, writer: &mut W, pf_args_it: &mut Peekable<Iter<String>>)
- where
- W: Write,
- {
- for tkn in &self.tokens {
- tkn.write(writer, pf_args_it);
- }
- }
- fn run_all<W>(writer: &mut W, pf_string: &str, pf_args: &[String]) -> UResult<()>
- where
- W: Write,
- {
- let mut arg_it = pf_args.iter().peekable();
- let pm = Self::new(writer, pf_string, &mut arg_it)?;
- loop {
- if arg_it.peek().is_none() {
- return Ok(());
- }
- pm.apply(writer, &mut arg_it);
- }
- }
-}
-
-/// Write a formatted string to stdout.
-///
-/// `format_string` contains the template and `args` contains the
-/// arguments to render into the template.
-///
-/// See also [`sprintf`], which creates a new formatted [`String`].
-///
-/// # Examples
-///
-/// ```rust
-/// use uucore::memo::printf;
-///
-/// printf("hello %s", &["world".to_string()]).unwrap();
-/// // prints "hello world"
-/// ```
-pub fn printf(format_string: &str, args: &[String]) -> UResult<()> {
- let mut writer = stdout();
- Memo::run_all(&mut writer, format_string, args)
-}
-
-/// Create a new formatted string.
-///
-/// `format_string` contains the template and `args` contains the
-/// arguments to render into the template.
-///
-/// See also [`printf`], which prints to stdout.
-///
-/// # Examples
-///
-/// ```rust
-/// use uucore::memo::sprintf;
-///
-/// let s = sprintf("hello %s", &["world".to_string()]).unwrap();
-/// assert_eq!(s, "hello world".to_string());
-/// ```
-pub fn sprintf(format_string: &str, args: &[String]) -> UResult<String> {
- let mut writer = Cursor::new(vec![]);
- Memo::run_all(&mut writer, format_string, args)?;
- let buf = writer.into_inner();
- match String::from_utf8(buf) {
- Ok(s) => Ok(s),
- Err(e) => Err(USimpleError::new(
- 1,
- format!("failed to parse formatted string as UTF-8: {}", e),
- )),
- }
-}
-
-#[cfg(test)]
-mod tests {
-
- use crate::memo::sprintf;
-
- #[test]
- fn test_sprintf_smoke() {
- assert_eq!(sprintf("", &[]).unwrap(), "".to_string())
- }
-
- #[test]
- fn test_sprintf_no_args() {
- assert_eq!(
- sprintf("hello world", &[]).unwrap(),
- "hello world".to_string()
- )
- }
-
- #[test]
- fn test_sprintf_string() {
- assert_eq!(
- sprintf("hello %s", &["world".to_string()]).unwrap(),
- "hello world".to_string()
- )
- }
-}
diff --git a/src/uucore/src/lib/features/mode.rs b/src/uucore/src/lib/features/mode.rs
index c274643631d25db62aa0c6cddc185091e81d9bbd..c2da380bf0f0003a1ef599c5586412b9dc773f55 100644
--- a/src/uucore/src/lib/features/mode.rs
+++ b/src/uucore/src/lib/features/mode.rs
@@ -1,7 +1,5 @@
// This file is part of the uutils coreutils package.
//
-// (c) Alex Lyon <arcterus@mail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
@@ -20,7 +18,7 @@ pub fn parse_numeric(fperm: u32, mut mode: &str, considering_dir: bool) -> Resul
u32::from_str_radix(mode, 8).map_err(|e| e.to_string())?
};
if change > 0o7777 {
- Err(format!("mode is too large ({} > 7777", change))
+ Err(format!("mode is too large ({change} > 7777"))
} else {
Ok(match op {
Some('+') => fperm | change,
@@ -42,7 +40,7 @@ pub fn parse_symbolic(
) -> Result<u32, String> {
let (mask, pos) = parse_levels(mode);
if pos == mode.len() {
- return Err(format!("invalid mode ({})", mode));
+ return Err(format!("invalid mode ({mode})"));
}
let respect_umask = pos == 0;
mode = &mode[pos..];
@@ -97,8 +95,7 @@ fn parse_op(mode: &str) -> Result<(char, usize), String> {
match ch {
'+' | '-' | '=' => Ok((ch, 1)),
_ => Err(format!(
- "invalid operator (expected +, -, or =, but found {})",
- ch
+ "invalid operator (expected +, -, or =, but found {ch})"
)),
}
}
@@ -123,6 +120,15 @@ fn parse_change(mode: &str, fperm: u32, considering_dir: bool) -> (u32, usize) {
'o' => srwx = ((fperm << 6) & 0o700) | ((fperm << 3) & 0o070) | (fperm & 0o007),
_ => break,
};
+ if ch == 'u' || ch == 'g' || ch == 'o' {
+ // symbolic modes only allows perms to be a single letter of 'ugo'
+ // therefore this must either be the first char or it is unexpected
+ if pos != 0 {
+ break;
+ }
+ pos = 1;
+ break;
+ }
pos += 1;
}
if pos == 0 {
@@ -131,6 +137,7 @@ fn parse_change(mode: &str, fperm: u32, considering_dir: bool) -> (u32, usize) {
(srwx, pos)
}
+#[allow(clippy::unnecessary_cast)]
pub fn parse_mode(mode: &str) -> Result<mode_t, String> {
#[cfg(all(
not(target_os = "freebsd"),
@@ -141,11 +148,10 @@ pub fn parse_mode(mode: &str) -> Result<mode_t, String> {
#[cfg(any(target_os = "freebsd", target_vendor = "apple", target_os = "android"))]
let fperm = (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH) as u32;
- let arr: &[char] = &['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
- let result = if mode.contains(arr) {
- parse_numeric(fperm, mode, true)
+ let result = if mode.chars().any(|c| c.is_ascii_digit()) {
+ parse_numeric(fperm as u32, mode, true)
} else {
- parse_symbolic(fperm, mode, get_umask(), true)
+ parse_symbolic(fperm as u32, mode, get_umask(), true)
};
result.map(|mode| mode as mode_t)
}
@@ -163,11 +169,17 @@ pub fn get_umask() -> u32 {
#[cfg(all(
not(target_os = "freebsd"),
not(target_vendor = "apple"),
- not(target_os = "android")
+ not(target_os = "android"),
+ not(target_os = "redox")
))]
return mask;
- #[cfg(any(target_os = "freebsd", target_vendor = "apple", target_os = "android"))]
- return mask.into();
+ #[cfg(any(
+ target_os = "freebsd",
+ target_vendor = "apple",
+ target_os = "android",
+ target_os = "redox"
+ ))]
+ return mask as u32;
}
// Iterate 'args' and delete the first occurrence
@@ -201,7 +213,7 @@ mod test {
assert_eq!(super::parse_mode("u+x").unwrap(), 0o766);
assert_eq!(
super::parse_mode("+x").unwrap(),
- if !crate::os::is_wsl_1() { 0o777 } else { 0o776 }
+ if crate::os::is_wsl_1() { 0o776 } else { 0o777 }
);
assert_eq!(super::parse_mode("a-w").unwrap(), 0o444);
assert_eq!(super::parse_mode("g-r").unwrap(), 0o626);
diff --git a/src/uucore/src/lib/features/perms.rs b/src/uucore/src/lib/features/perms.rs
index 07203a31816169fdf5f35c1d4ef50f0dd24d8caa..880620c7ab1de820cd5ba9957fa0d683f322fee2 100644
--- a/src/uucore/src/lib/features/perms.rs
+++ b/src/uucore/src/lib/features/perms.rs
@@ -5,17 +5,14 @@
//! Common functions to manage permissions
+// spell-checker:ignore (jargon) TOCTOU
+
use crate::display::Quotable;
-use crate::error::strip_errno;
-use crate::error::UResult;
-use crate::error::USimpleError;
+use crate::error::{strip_errno, UResult, USimpleError};
pub use crate::features::entries;
-use crate::fs::resolve_relative_path;
use crate::show_error;
-use clap::Arg;
-use clap::ArgMatches;
-use clap::Command;
-use libc::{self, gid_t, uid_t};
+use clap::{Arg, ArgMatches, Command};
+use libc::{gid_t, uid_t};
use walkdir::WalkDir;
use std::io::Error as IOError;
@@ -26,7 +23,7 @@ use std::fs::Metadata;
use std::os::unix::fs::MetadataExt;
use std::os::unix::ffi::OsStrExt;
-use std::path::Path;
+use std::path::{Path, MAIN_SEPARATOR_STR};
/// The various level of verbosity
#[derive(PartialEq, Eq, Clone, Debug)]
@@ -182,6 +179,7 @@ pub enum TraverseSymlinks {
pub struct ChownExecutor {
pub dest_uid: Option<u32>,
pub dest_gid: Option<u32>,
+ pub raw_owner: String, // The owner of the file as input by the user in the command line.
pub traverse_symlinks: TraverseSymlinks,
pub verbosity: Verbosity,
pub filter: IfFrom,
@@ -191,6 +189,75 @@ pub struct ChownExecutor {
pub dereference: bool,
}
+#[cfg(test)]
+pub fn check_root(path: &Path, would_recurse_symlink: bool) -> bool {
+ is_root(path, would_recurse_symlink)
+}
+
+/// In the context of chown and chgrp, check whether we are in a "preserve-root" scenario.
+///
+/// In particular, we want to prohibit further traversal only if:
+/// (--preserve-root and -R present) &&
+/// (path canonicalizes to "/") &&
+/// (
+/// (path is a symlink && would traverse/recurse this symlink) ||
+/// (path is not a symlink)
+/// )
+/// The first clause is checked by the caller, the second and third clause is checked here.
+/// The caller has to evaluate -P/-H/-L into 'would_recurse_symlink'.
+/// Recall that canonicalization resolves both relative paths (e.g. "..") and symlinks.
+fn is_root(path: &Path, would_traverse_symlink: bool) -> bool {
+ // The third clause can be evaluated without any syscalls, so we do that first.
+ // If we would_recurse_symlink, then the clause is true no matter whether the path is a symlink
+ // or not. Otherwise, we only need to check here if the path can syntactically be a symlink:
+ if !would_traverse_symlink {
+ // We cannot check path.is_dir() here, as this would resolve symlinks,
+ // which we need to avoid here.
+ // All directory-ish paths match "*/", except ".", "..", "*/.", and "*/..".
+ let looks_like_dir = match path.as_os_str().to_str() {
+ // If it contains special character, prefer to err on the side of safety, i.e. forbidding the chown operation:
+ None => false,
+ Some(".") | Some("..") => true,
+ Some(path_str) => {
+ (path_str.ends_with(MAIN_SEPARATOR_STR))
+ || (path_str.ends_with(&format!("{}.", MAIN_SEPARATOR_STR)))
+ || (path_str.ends_with(&format!("{}..", MAIN_SEPARATOR_STR)))
+ }
+ };
+ // TODO: Once we reach MSRV 1.74.0, replace this abomination by something simpler, e.g. this:
+ // let path_bytes = path.as_os_str().as_encoded_bytes();
+ // let looks_like_dir = path_bytes == [b'.']
+ // || path_bytes == [b'.', b'.']
+ // || path_bytes.ends_with(&[MAIN_SEPARATOR as u8])
+ // || path_bytes.ends_with(&[MAIN_SEPARATOR as u8, b'.'])
+ // || path_bytes.ends_with(&[MAIN_SEPARATOR as u8, b'.', b'.']);
+ if !looks_like_dir {
+ return false;
+ }
+ }
+
+ // FIXME: TOCTOU bug! canonicalize() runs at a different time than WalkDir's recursion decision.
+ // However, we're forced to make the decision whether to warn about --preserve-root
+ // *before* even attempting to chown the path, let alone doing the stat inside WalkDir.
+ if let Ok(p) = path.canonicalize() {
+ let path_buf = path.to_path_buf();
+ if p.parent().is_none() {
+ if path_buf.as_os_str() == "/" {
+ show_error!("it is dangerous to operate recursively on '/'");
+ } else {
+ show_error!(
+ "it is dangerous to operate recursively on {} (same as '/')",
+ path_buf.quote()
+ );
+ }
+ show_error!("use --no-preserve-root to override this failsafe");
+ return true;
+ }
+ }
+
+ false
+}
+
impl ChownExecutor {
pub fn exec(&self) -> UResult<()> {
let mut ret = 0;
@@ -203,38 +270,29 @@ impl ChownExecutor {
Ok(())
}
+ #[allow(clippy::cognitive_complexity)]
fn traverse<P: AsRef<Path>>(&self, root: P) -> i32 {
let path = root.as_ref();
let meta = match self.obtain_meta(path, self.dereference) {
Some(m) => m,
- _ => return 1,
- };
-
- // Prohibit only if:
- // (--preserve-root and -R present) &&
- // (
- // (argument is not symlink && resolved to be '/') ||
- // (argument is symlink && should follow argument && resolved to be '/')
- // )
- if self.recursive && self.preserve_root {
- let may_exist = if self.dereference {
- path.canonicalize().ok()
- } else {
- let real = resolve_relative_path(path);
- if real.is_dir() {
- Some(real.canonicalize().expect("failed to get real path"))
- } else {
- Some(real.into_owned())
- }
- };
-
- if let Some(p) = may_exist {
- if p.parent().is_none() {
- show_error!("it is dangerous to operate recursively on '/'");
- show_error!("use --no-preserve-root to override this failsafe");
- return 1;
+ _ => {
+ if self.verbosity.level == VerbosityLevel::Verbose {
+ println!(
+ "failed to change ownership of {} to {}",
+ path.quote(),
+ self.raw_owner
+ );
}
+ return 1;
}
+ };
+
+ if self.recursive
+ && self.preserve_root
+ && is_root(path, self.traverse_symlinks != TraverseSymlinks::None)
+ {
+ // Fail-fast, do not attempt to recurse.
+ return 1;
}
let ret = if self.matched(meta.uid(), meta.gid()) {
@@ -260,16 +318,22 @@ impl ChownExecutor {
}
}
} else {
+ self.print_verbose_ownership_retained_as(
+ path,
+ meta.uid(),
+ self.dest_gid.map(|_| meta.gid()),
+ );
0
};
- if !self.recursive {
- ret
- } else {
+ if self.recursive {
ret | self.dive_into(&root)
+ } else {
+ ret
}
}
+ #[allow(clippy::cognitive_complexity)]
fn dive_into<P: AsRef<Path>>(&self, root: P) -> i32 {
let root = root.as_ref();
@@ -319,7 +383,18 @@ impl ChownExecutor {
}
};
+ if self.preserve_root && is_root(path, self.traverse_symlinks == TraverseSymlinks::All)
+ {
+ // Fail-fast, do not recurse further.
+ return 1;
+ }
+
if !self.matched(meta.uid(), meta.gid()) {
+ self.print_verbose_ownership_retained_as(
+ path,
+ meta.uid(),
+ self.dest_gid.map(|_| meta.gid()),
+ );
continue;
}
@@ -381,6 +456,35 @@ impl ChownExecutor {
IfFrom::UserGroup(u, g) => u == uid && g == gid,
}
}
+
+ fn print_verbose_ownership_retained_as(&self, path: &Path, uid: u32, gid: Option<u32>) {
+ if self.verbosity.level == VerbosityLevel::Verbose {
+ match (self.dest_uid, self.dest_gid, gid) {
+ (Some(_), Some(_), Some(gid)) => {
+ println!(
+ "ownership of {} retained as {}:{}",
+ path.quote(),
+ entries::uid2usr(uid).unwrap_or_else(|_| uid.to_string()),
+ entries::gid2grp(gid).unwrap_or_else(|_| gid.to_string()),
+ );
+ }
+ (None, Some(_), Some(gid)) => {
+ println!(
+ "ownership of {} retained as {}",
+ path.quote(),
+ entries::gid2grp(gid).unwrap_or_else(|_| gid.to_string()),
+ );
+ }
+ (_, _, _) => {
+ println!(
+ "ownership of {} retained as {}",
+ path.quote(),
+ entries::uid2usr(uid).unwrap_or_else(|_| uid.to_string()),
+ );
+ }
+ }
+ }
+ }
}
pub mod options {
@@ -412,7 +516,13 @@ pub mod options {
pub const ARG_FILES: &str = "FILE";
}
-type GidUidFilterParser = fn(&ArgMatches) -> UResult<(Option<u32>, Option<u32>, IfFrom)>;
+pub struct GidUidOwnerFilter {
+ pub dest_gid: Option<u32>,
+ pub dest_uid: Option<u32>,
+ pub raw_owner: String,
+ pub filter: IfFrom,
+}
+type GidUidFilterOwnerParser = fn(&ArgMatches) -> UResult<GidUidOwnerFilter>;
/// Base implementation for `chgrp` and `chown`.
///
@@ -421,11 +531,12 @@ type GidUidFilterParser = fn(&ArgMatches) -> UResult<(Option<u32>, Option<u32>,
/// `parse_gid_uid_and_filter` will be called to obtain the target gid and uid, and the filter,
/// from `ArgMatches`.
/// `groups_only` determines whether verbose output will only mention the group.
+#[allow(clippy::cognitive_complexity)]
pub fn chown_base(
mut command: Command,
args: impl crate::Args,
add_arg_if_not_reference: &'static str,
- parse_gid_uid_and_filter: GidUidFilterParser,
+ parse_gid_uid_and_filter: GidUidFilterOwnerParser,
groups_only: bool,
) -> UResult<()> {
let args: Vec<_> = args.collect();
@@ -508,12 +619,18 @@ pub fn chown_base(
} else {
VerbosityLevel::Normal
};
- let (dest_gid, dest_uid, filter) = parse_gid_uid_and_filter(&matches)?;
+ let GidUidOwnerFilter {
+ dest_gid,
+ dest_uid,
+ raw_owner,
+ filter,
+ } = parse_gid_uid_and_filter(&matches)?;
let executor = ChownExecutor {
traverse_symlinks,
dest_gid,
dest_uid,
+ raw_owner,
verbosity: Verbosity {
groups_only,
level: verbosity_level,
@@ -526,3 +643,74 @@ pub fn chown_base(
};
executor.exec()
}
+
+#[cfg(test)]
+mod tests {
+ // Note this useful idiom: importing names from outer (for mod tests) scope.
+ use super::*;
+ #[cfg(unix)]
+ use std::os::unix;
+ use std::path::{Component, PathBuf};
+ #[cfg(unix)]
+ use tempfile::tempdir;
+
+ #[test]
+ fn test_empty_string() {
+ let path = PathBuf::new();
+ assert_eq!(path.to_str(), Some(""));
+ // The main point to test here is that we don't crash.
+ // The result should be 'false', to avoid unnecessary and confusing warnings.
+ assert!(!is_root(&path, false));
+ assert!(!is_root(&path, true));
+ }
+
+ #[allow(clippy::needless_borrow)]
+ #[cfg(unix)]
+ #[test]
+ fn test_literal_root() {
+ let component = Component::RootDir;
+ let path: &Path = component.as_ref();
+ assert_eq!(
+ path.to_str(),
+ Some("/"),
+ "cfg(unix) but using non-unix path delimiters?!"
+ );
+ // Must return true, this is the main scenario that --preserve-root shall prevent.
+ assert!(is_root(&path, false));
+ assert!(is_root(&path, true));
+ }
+
+ #[cfg(unix)]
+ #[test]
+ fn test_symlink_slash() {
+ let temp_dir = tempdir().unwrap();
+ let symlink_path = temp_dir.path().join("symlink");
+ unix::fs::symlink(PathBuf::from("/"), symlink_path).unwrap();
+ let symlink_path_slash = temp_dir.path().join("symlink/");
+ // Must return true, we're about to "accidentally" recurse on "/",
+ // since "symlink/" always counts as an already-entered directory
+ // Output from GNU:
+ // $ chown --preserve-root -RH --dereference $(id -u) slink-to-root/
+ // chown: it is dangerous to operate recursively on 'slink-to-root/' (same as '/')
+ // chown: use --no-preserve-root to override this failsafe
+ // [$? = 1]
+ // $ chown --preserve-root -RH --no-dereference $(id -u) slink-to-root/
+ // chown: it is dangerous to operate recursively on 'slink-to-root/' (same as '/')
+ // chown: use --no-preserve-root to override this failsafe
+ // [$? = 1]
+ assert!(is_root(&symlink_path_slash, false));
+ assert!(is_root(&symlink_path_slash, true));
+ }
+
+ #[cfg(unix)]
+ #[test]
+ fn test_symlink_no_slash() {
+ // This covers both the commandline-argument case and the recursion case.
+ let temp_dir = tempdir().unwrap();
+ let symlink_path = temp_dir.path().join("symlink");
+ unix::fs::symlink(PathBuf::from("/"), &symlink_path).unwrap();
+ // Only return true we're about to "accidentally" recurse on "/".
+ assert!(!is_root(&symlink_path, false));
+ assert!(is_root(&symlink_path, true));
+ }
+}
diff --git a/src/uucore/src/lib/features/pipes.rs b/src/uucore/src/lib/features/pipes.rs
index a76322de8e88ad68861eb223e21180c23a7cf189..17c5b1b3245116fe03b5f4259f29429af2d05f88 100644
--- a/src/uucore/src/lib/features/pipes.rs
+++ b/src/uucore/src/lib/features/pipes.rs
@@ -1,10 +1,13 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
/// Thin pipe-related wrappers around functions from the `nix` crate.
use std::fs::File;
#[cfg(any(target_os = "linux", target_os = "android"))]
use std::io::IoSlice;
#[cfg(any(target_os = "linux", target_os = "android"))]
use std::os::unix::io::AsRawFd;
-use std::os::unix::io::FromRawFd;
#[cfg(any(target_os = "linux", target_os = "android"))]
use nix::fcntl::SpliceFFlags;
@@ -17,8 +20,7 @@ pub use nix::{Error, Result};
/// from the first.
pub fn pipe() -> Result<(File, File)> {
let (read, write) = nix::unistd::pipe()?;
- // SAFETY: The file descriptors do not have other owners.
- unsafe { Ok((File::from_raw_fd(read), File::from_raw_fd(write))) }
+ Ok((File::from(read), File::from(write)))
}
/// Less noisy wrapper around [`nix::fcntl::splice`].
diff --git a/src/uucore/src/lib/features/process.rs b/src/uucore/src/lib/features/process.rs
index 933b1f21ba41c409eb638ba4ed8873fb8b2f8e0d..c7dff1f05ec87a10061ee7d2dd1996ce4d8bdfdb 100644
--- a/src/uucore/src/lib/features/process.rs
+++ b/src/uucore/src/lib/features/process.rs
@@ -1,10 +1,7 @@
// This file is part of the uutils coreutils package.
//
-// (c) Maciej Dziardziel <fiedzia@gmail.com>
-// (c) Jian Zeng <anonymousknight96 AT gmail.com>
-//
-// For the full copyright and license information, please view the LICENSE file
-// that was distributed with this source code.
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (vars) cvar exitstatus
// spell-checker:ignore (sys/unix) WIFSIGNALED
@@ -48,6 +45,9 @@ pub trait ChildExt {
/// send the signal to an unrelated process that recycled the PID.
fn send_signal(&mut self, signal: usize) -> io::Result<()>;
+ /// Send a signal to a process group.
+ fn send_signal_group(&mut self, signal: usize) -> io::Result<()>;
+
/// Wait for a process to finish or return after the specified duration.
/// A `timeout` of zero disables the timeout.
fn wait_or_timeout(&mut self, timeout: Duration) -> io::Result<Option<ExitStatus>>;
@@ -55,10 +55,22 @@ pub trait ChildExt {
impl ChildExt for Child {
fn send_signal(&mut self, signal: usize) -> io::Result<()> {
- if unsafe { libc::kill(self.id() as pid_t, signal as i32) } != 0 {
- Err(io::Error::last_os_error())
+ if unsafe { libc::kill(self.id() as pid_t, signal as i32) } == 0 {
+ Ok(())
} else {
+ Err(io::Error::last_os_error())
+ }
+ }
+
+ fn send_signal_group(&mut self, signal: usize) -> io::Result<()> {
+ // Ignore the signal, so we don't go into a signal loop.
+ if unsafe { libc::signal(signal as i32, libc::SIG_IGN) } != 0 {
+ return Err(io::Error::last_os_error());
+ }
+ if unsafe { libc::kill(0, signal as i32) } == 0 {
Ok(())
+ } else {
+ Err(io::Error::last_os_error())
}
}
diff --git a/src/uucore/src/lib/mods/quoting_style.rs b/src/uucore/src/lib/features/quoting_style.rs
similarity index 89%
rename from src/uucore/src/lib/mods/quoting_style.rs
rename to src/uucore/src/lib/features/quoting_style.rs
index b0715413987cc6fbab6455906d581a6a3f1b1893..b517dbd8db5c93ebedc7e2272be5ec5707a5fdc8 100644
--- a/src/uucore/src/lib/mods/quoting_style.rs
+++ b/src/uucore/src/lib/features/quoting_style.rs
@@ -1,11 +1,17 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::char::from_digit;
use std::ffi::OsStr;
+use std::fmt;
// These are characters with special meaning in the shell (e.g. bash).
// The first const contains characters that only have a special meaning when they appear at the beginning of a name.
const SPECIAL_SHELL_CHARS_START: &[char] = &['~', '#'];
const SPECIAL_SHELL_CHARS: &str = "`$&*()|[]{};\\'\"<>?! ";
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum QuotingStyle {
Shell {
escape: bool,
@@ -20,7 +26,7 @@ pub enum QuotingStyle {
},
}
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Quotes {
None,
Single,
@@ -259,13 +265,13 @@ fn shell_with_escape(name: &str, quotes: Quotes) -> (String, bool) {
pub fn escape_name(name: &OsStr, style: &QuotingStyle) -> String {
match style {
QuotingStyle::Literal { show_control } => {
- if !show_control {
+ if *show_control {
+ name.to_string_lossy().into_owned()
+ } else {
name.to_string_lossy()
.chars()
.flat_map(|c| EscapedChar::new_literal(c).hide_control())
.collect()
- } else {
- name.to_string_lossy().into_owned()
}
}
QuotingStyle::C { quotes } => {
@@ -276,8 +282,8 @@ pub fn escape_name(name: &OsStr, style: &QuotingStyle) -> String {
.collect();
match quotes {
- Quotes::Single => format!("'{}'", escaped_str),
- Quotes::Double => format!("\"{}\"", escaped_str),
+ Quotes::Single => format!("'{escaped_str}'"),
+ Quotes::Double => format!("\"{escaped_str}\""),
Quotes::None => escaped_str,
}
}
@@ -304,14 +310,50 @@ pub fn escape_name(name: &OsStr, style: &QuotingStyle) -> String {
};
match (must_quote | contains_quote_chars, quotes) {
- (true, Quotes::Single) => format!("'{}'", escaped_str),
- (true, Quotes::Double) => format!("\"{}\"", escaped_str),
+ (true, Quotes::Single) => format!("'{escaped_str}'"),
+ (true, Quotes::Double) => format!("\"{escaped_str}\""),
_ => escaped_str,
}
}
}
}
+impl fmt::Display for QuotingStyle {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match *self {
+ Self::Shell {
+ escape,
+ always_quote,
+ show_control,
+ } => {
+ let mut style = "shell".to_string();
+ if escape {
+ style.push_str("-escape");
+ }
+ if always_quote {
+ style.push_str("-always-quote");
+ }
+ if show_control {
+ style.push_str("-show-control");
+ }
+ f.write_str(&style)
+ }
+ Self::C { .. } => f.write_str("C"),
+ Self::Literal { .. } => f.write_str("literal"),
+ }
+ }
+}
+
+impl fmt::Display for Quotes {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match *self {
+ Self::None => f.write_str("None"),
+ Self::Single => f.write_str("Single"),
+ Self::Double => f.write_str("Double"),
+ }
+ }
+}
+
#[cfg(test)]
mod tests {
use crate::quoting_style::{escape_name, Quotes, QuotingStyle};
@@ -728,4 +770,45 @@ mod tests {
],
);
}
+
+ #[test]
+ fn test_quoting_style_display() {
+ let style = QuotingStyle::Shell {
+ escape: true,
+ always_quote: false,
+ show_control: false,
+ };
+ assert_eq!(format!("{}", style), "shell-escape");
+
+ let style = QuotingStyle::Shell {
+ escape: false,
+ always_quote: true,
+ show_control: false,
+ };
+ assert_eq!(format!("{}", style), "shell-always-quote");
+
+ let style = QuotingStyle::Shell {
+ escape: false,
+ always_quote: false,
+ show_control: true,
+ };
+ assert_eq!(format!("{}", style), "shell-show-control");
+
+ let style = QuotingStyle::C {
+ quotes: Quotes::Double,
+ };
+ assert_eq!(format!("{}", style), "C");
+
+ let style = QuotingStyle::Literal {
+ show_control: false,
+ };
+ assert_eq!(format!("{}", style), "literal");
+ }
+
+ #[test]
+ fn test_quotes_display() {
+ assert_eq!(format!("{}", Quotes::None), "None");
+ assert_eq!(format!("{}", Quotes::Single), "Single");
+ assert_eq!(format!("{}", Quotes::Double), "Double");
+ }
}
diff --git a/src/uucore/src/lib/mods/ranges.rs b/src/uucore/src/lib/features/ranges.rs
similarity index 85%
rename from src/uucore/src/lib/mods/ranges.rs
rename to src/uucore/src/lib/features/ranges.rs
index 76a61b9a687bdc4f49b8c4383e85e505de2f8d16..19ba23fb2778b2def9e3dd062dd33b616efc350b 100644
--- a/src/uucore/src/lib/mods/ranges.rs
+++ b/src/uucore/src/lib/features/ranges.rs
@@ -1,7 +1,5 @@
// This file is part of the uutils coreutils package.
//
-// (c) Rolf Morel <rolfmorel@gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
@@ -40,6 +38,8 @@ impl FromStr for Range {
fn parse(s: &str) -> Result<usize, &'static str> {
match s.parse::<usize>() {
Ok(0) => Err("fields and positions are numbered from 1"),
+ // GNU fails when we are at the limit. Match their behavior
+ Ok(n) if n == usize::MAX => Err("byte/character offset is too large"),
Ok(n) => Ok(n),
Err(_) => Err("failed to parse range"),
}
@@ -161,6 +161,7 @@ pub fn contain(ranges: &[Range], n: usize) -> bool {
#[cfg(test)]
mod test {
use super::{complement, Range};
+ use std::str::FromStr;
fn m(a: Vec<Range>, b: &[Range]) {
assert_eq!(Range::merge(a), b);
@@ -231,4 +232,33 @@ mod test {
// With start and end
assert_eq!(complement(&[r(1, 4), r(6, usize::MAX - 1)]), vec![r(5, 5)]);
}
+
+ #[test]
+ fn test_from_str() {
+ assert_eq!(Range::from_str("5"), Ok(Range { low: 5, high: 5 }));
+ assert_eq!(Range::from_str("3-5"), Ok(Range { low: 3, high: 5 }));
+ assert_eq!(
+ Range::from_str("5-3"),
+ Err("high end of range less than low end")
+ );
+ assert_eq!(Range::from_str("-"), Err("invalid range with no endpoint"));
+ assert_eq!(
+ Range::from_str("3-"),
+ Ok(Range {
+ low: 3,
+ high: usize::MAX - 1
+ })
+ );
+ assert_eq!(Range::from_str("-5"), Ok(Range { low: 1, high: 5 }));
+ assert_eq!(
+ Range::from_str("0"),
+ Err("fields and positions are numbered from 1")
+ );
+
+ let max_value = format!("{}", usize::MAX);
+ assert_eq!(
+ Range::from_str(&max_value),
+ Err("byte/character offset is too large")
+ );
+ }
}
diff --git a/src/uucore/src/lib/features/ringbuffer.rs b/src/uucore/src/lib/features/ringbuffer.rs
index 08073fae084536314d45384e116b64dfecb8afc0..d58c8c498b8a52c67ec25b85f78459b1a06d9a42 100644
--- a/src/uucore/src/lib/features/ringbuffer.rs
+++ b/src/uucore/src/lib/features/ringbuffer.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//! A fixed-size ring buffer.
use std::collections::VecDeque;
diff --git a/src/uucore/src/lib/features/signals.rs b/src/uucore/src/lib/features/signals.rs
index 55f9b4b79a925bac6623fc7b3987f7f88dfb47b9..8c9ca61953abdf5645ca4da7300b8cf90e6dbaf2 100644
--- a/src/uucore/src/lib/features/signals.rs
+++ b/src/uucore/src/lib/features/signals.rs
@@ -1,12 +1,16 @@
// This file is part of the uutils coreutils package.
//
-// (c) Maciej Dziardziel <fiedzia@gmail.com>
-//
-// For the full copyright and license information, please view the LICENSE file
-// that was distributed with this source code.
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-// spell-checker:ignore (vars/api) fcntl setrlimit setitimer
-// spell-checker:ignore (vars/signals) ABRT ALRM CHLD SEGV SIGABRT SIGALRM SIGBUS SIGCHLD SIGCONT SIGEMT SIGFPE SIGHUP SIGILL SIGINFO SIGINT SIGIO SIGIOT SIGKILL SIGPIPE SIGPROF SIGPWR SIGQUIT SIGSEGV SIGSTOP SIGSYS SIGTERM SIGTRAP SIGTSTP SIGTHR SIGTTIN SIGTTOU SIGURG SIGUSR SIGVTALRM SIGWINCH SIGXCPU SIGXFSZ STKFLT PWR THR TSTP TTIN TTOU VTALRM XCPU XFSZ
+// spell-checker:ignore (vars/api) fcntl setrlimit setitimer rubout pollable sysconf
+// spell-checker:ignore (vars/signals) ABRT ALRM CHLD SEGV SIGABRT SIGALRM SIGBUS SIGCHLD SIGCONT SIGDANGER SIGEMT SIGFPE SIGHUP SIGILL SIGINFO SIGINT SIGIO SIGIOT SIGKILL SIGMIGRATE SIGMSG SIGPIPE SIGPRE SIGPROF SIGPWR SIGQUIT SIGSEGV SIGSTOP SIGSYS SIGTALRM SIGTERM SIGTRAP SIGTSTP SIGTHR SIGTTIN SIGTTOU SIGURG SIGUSR SIGVIRT SIGVTALRM SIGWINCH SIGXCPU SIGXFSZ STKFLT PWR THR TSTP TTIN TTOU VIRT VTALRM XCPU XFSZ SIGCLD SIGPOLL SIGWAITING SIGAIOCANCEL SIGLWP SIGFREEZE SIGTHAW SIGCANCEL SIGLOST SIGXRES SIGJVM SIGRTMIN SIGRT SIGRTMAX TALRM AIOCANCEL XRES RTMIN RTMAX
+#[cfg(unix)]
+use nix::errno::Errno;
+#[cfg(unix)]
+use nix::sys::signal::{
+ signal, SigHandler::SigDfl, SigHandler::SigIgn, Signal::SIGINT, Signal::SIGPIPE,
+};
pub static DEFAULT_SIGNAL: usize = 15;
@@ -23,7 +27,7 @@ Linux Programmer's Manual
*/
-#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(any(target_os = "linux", target_os = "android", target_os = "redox"))]
pub static ALL_SIGNALS: [&str; 32] = [
"EXIT", "HUP", "INT", "QUIT", "ILL", "TRAP", "ABRT", "BUS", "FPE", "KILL", "USR1", "SEGV",
"USR2", "PIPE", "ALRM", "TERM", "STKFLT", "CHLD", "CONT", "STOP", "TSTP", "TTIN", "TTOU",
@@ -175,6 +179,166 @@ pub static ALL_SIGNALS: [&str; 33] = [
"XCPU", "XFSZ", "VTALRM", "PROF", "WINCH", "INFO", "USR1", "USR2", "THR",
];
+/*
+ The following signals are defined in Solaris and illumos;
+ (the signals for illumos are the same as Solaris, but illumos still has SIGLWP
+ as well as the alias for SIGLWP (SIGAIOCANCEL)):
+
+ SIGHUP 1 hangup
+ SIGINT 2 interrupt (rubout)
+ SIGQUIT 3 quit (ASCII FS)
+ SIGILL 4 illegal instruction (not reset when caught)
+ SIGTRAP 5 trace trap (not reset when caught)
+ SIGIOT 6 IOT instruction
+ SIGABRT 6 used by abort, replace SIGIOT in the future
+ SIGEMT 7 EMT instruction
+ SIGFPE 8 floating point exception
+ SIGKILL 9 kill (cannot be caught or ignored)
+ SIGBUS 10 bus error
+ SIGSEGV 11 segmentation violation
+ SIGSYS 12 bad argument to system call
+ SIGPIPE 13 write on a pipe with no one to read it
+ SIGALRM 14 alarm clock
+ SIGTERM 15 software termination signal from kill
+ SIGUSR1 16 user defined signal 1
+ SIGUSR2 17 user defined signal 2
+ SIGCLD 18 child status change
+ SIGCHLD 18 child status change alias (POSIX)
+ SIGPWR 19 power-fail restart
+ SIGWINCH 20 window size change
+ SIGURG 21 urgent socket condition
+ SIGPOLL 22 pollable event occurred
+ SIGIO SIGPOLL socket I/O possible (SIGPOLL alias)
+ SIGSTOP 23 stop (cannot be caught or ignored)
+ SIGTSTP 24 user stop requested from tty
+ SIGCONT 25 stopped process has been continued
+ SIGTTIN 26 background tty read attempted
+ SIGTTOU 27 background tty write attempted
+ SIGVTALRM 28 virtual timer expired
+ SIGPROF 29 profiling timer expired
+ SIGXCPU 30 exceeded cpu limit
+ SIGXFSZ 31 exceeded file size limit
+ SIGWAITING 32 reserved signal no longer used by threading code
+ SIGAIOCANCEL 33 reserved signal no longer used by threading code (formerly SIGLWP)
+ SIGFREEZE 34 special signal used by CPR
+ SIGTHAW 35 special signal used by CPR
+ SIGCANCEL 36 reserved signal for thread cancellation
+ SIGLOST 37 resource lost (eg, record-lock lost)
+ SIGXRES 38 resource control exceeded
+ SIGJVM1 39 reserved signal for Java Virtual Machine
+ SIGJVM2 40 reserved signal for Java Virtual Machine
+ SIGINFO 41 information request
+ SIGRTMIN ((int)_sysconf(_SC_SIGRT_MIN)) first realtime signal
+ SIGRTMAX ((int)_sysconf(_SC_SIGRT_MAX)) last realtime signal
+*/
+
+#[cfg(target_os = "solaris")]
+const SIGNALS_SIZE: usize = 46;
+
+#[cfg(target_os = "illumos")]
+const SIGNALS_SIZE: usize = 47;
+
+#[cfg(any(target_os = "solaris", target_os = "illumos"))]
+static ALL_SIGNALS: [&str; SIGNALS_SIZE] = [
+ "HUP",
+ "INT",
+ "QUIT",
+ "ILL",
+ "TRAP",
+ "IOT",
+ "ABRT",
+ "EMT",
+ "FPE",
+ "KILL",
+ "BUS",
+ "SEGV",
+ "SYS",
+ "PIPE",
+ "ALRM",
+ "TERM",
+ "USR1",
+ "USR2",
+ "CLD",
+ "CHLD",
+ "PWR",
+ "WINCH",
+ "URG",
+ "POLL",
+ "IO",
+ "STOP",
+ "TSTP",
+ "CONT",
+ "TTIN",
+ "TTOU",
+ "VTALRM",
+ "PROF",
+ "XCPU",
+ "XFSZ",
+ "WAITING",
+ "AIOCANCEL",
+ #[cfg(target_os = "illumos")]
+ "LWP",
+ "FREEZE",
+ "THAW",
+ "CANCEL",
+ "LOST",
+ "XRES",
+ "JVM1",
+ "JVM2",
+ "INFO",
+ "RTMIN",
+ "RTMAX",
+];
+
+/*
+ The following signals are defined in AIX:
+
+ SIGHUP hangup, generated when terminal disconnects
+ SIGINT interrupt, generated from terminal special char
+ SIGQUIT quit, generated from terminal special char
+ SIGILL illegal instruction (not reset when caught)
+ SIGTRAP trace trap (not reset when caught)
+ SIGABRT abort process
+ SIGEMT EMT instruction
+ SIGFPE floating point exception
+ SIGKILL kill (cannot be caught or ignored)
+ SIGBUS bus error (specification exception)
+ SIGSEGV segmentation violation
+ SIGSYS bad argument to system call
+ SIGPIPE write on a pipe with no one to read it
+ SIGALRM alarm clock timeout
+ SIGTERM software termination signal
+ SIGURG urgent condition on I/O channel
+ SIGSTOP stop (cannot be caught or ignored)
+ SIGTSTP interactive stop
+ SIGCONT continue (cannot be caught or ignored)
+ SIGCHLD sent to parent on child stop or exit
+ SIGTTIN background read attempted from control terminal
+ SIGTTOU background write attempted to control terminal
+ SIGIO I/O possible, or completed
+ SIGXCPU cpu time limit exceeded (see setrlimit())
+ SIGXFSZ file size limit exceeded (see setrlimit())
+ SIGMSG input data is in the ring buffer
+ SIGWINCH window size changed
+ SIGPWR power-fail restart
+ SIGUSR1 user defined signal 1
+ SIGUSR2 user defined signal 2
+ SIGPROF profiling time alarm (see setitimer)
+ SIGDANGER system crash imminent; free up some page space
+ SIGVTALRM virtual time alarm (see setitimer)
+ SIGMIGRATE migrate process
+ SIGPRE programming exception
+ SIGVIRT AIX virtual time alarm
+ SIGTALRM per-thread alarm clock
+*/
+#[cfg(target_os = "aix")]
+pub static ALL_SIGNALS: [&str; 37] = [
+ "HUP", "INT", "QUIT", "ILL", "TRAP", "ABRT", "EMT", "FPE", "KILL", "BUS", "SEGV", "SYS",
+ "PIPE", "ALRM", "TERM", "URG", "STOP", "TSTP", "CONT", "CHLD", "TTIN", "TTOU", "IO", "XCPU",
+ "XFSZ", "MSG", "WINCH", "PWR", "USR1", "USR2", "PROF", "DANGER", "VTALRM", "MIGRATE", "PRE",
+ "VIRT", "TALRM",
+];
+
pub fn signal_by_name_or_value(signal_name_or_value: &str) -> Option<usize> {
if let Ok(value) = signal_name_or_value.parse() {
if is_signal(value) {
@@ -196,6 +360,19 @@ pub fn signal_name_by_value(signal_value: usize) -> Option<&'static str> {
ALL_SIGNALS.get(signal_value).copied()
}
+#[cfg(unix)]
+pub fn enable_pipe_errors() -> Result<(), Errno> {
+ // We pass the error as is, the return value would just be Ok(SigDfl), so we can safely ignore it.
+ // SAFETY: this function is safe as long as we do not use a custom SigHandler -- we use the default one.
+ unsafe { signal(SIGPIPE, SigDfl) }.map(|_| ())
+}
+#[cfg(unix)]
+pub fn ignore_interrupts() -> Result<(), Errno> {
+ // We pass the error as is, the return value would just be Ok(SigIgn), so we can safely ignore it.
+ // SAFETY: this function is safe as long as we do not use a custom SigHandler -- we use the default one.
+ unsafe { signal(SIGINT, SigIgn) }.map(|_| ())
+}
+
#[test]
fn signal_by_value() {
assert_eq!(signal_by_name_or_value("0"), Some(0));
@@ -215,7 +392,7 @@ fn signal_by_short_name() {
fn signal_by_long_name() {
for (value, signal) in ALL_SIGNALS.iter().enumerate() {
assert_eq!(
- signal_by_name_or_value(&format!("SIG{}", signal)),
+ signal_by_name_or_value(&format!("SIG{signal}")),
Some(value)
);
}
diff --git a/src/uucore/src/lib/features/sum.rs b/src/uucore/src/lib/features/sum.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4982970232cc7fa3843b249f17e6d359833ff658
--- /dev/null
+++ b/src/uucore/src/lib/features/sum.rs
@@ -0,0 +1,508 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore memmem algo
+
+//! Implementations of digest functions, like md5 and sha1.
+//!
+//! The [`Digest`] trait represents the interface for providing inputs
+//! to these digest functions and accessing the resulting hash. The
+//! [`DigestWriter`] struct provides a wrapper around [`Digest`] that
+//! implements the [`Write`] trait, for use in situations where calling
+//! [`write`] would be useful.
+use std::io::Write;
+
+use hex::encode;
+#[cfg(windows)]
+use memchr::memmem;
+
+pub trait Digest {
+ fn new() -> Self
+ where
+ Self: Sized;
+ fn hash_update(&mut self, input: &[u8]);
+ fn hash_finalize(&mut self, out: &mut [u8]);
+ fn reset(&mut self);
+ fn output_bits(&self) -> usize;
+ fn output_bytes(&self) -> usize {
+ (self.output_bits() + 7) / 8
+ }
+ fn result_str(&mut self) -> String {
+ let mut buf: Vec<u8> = vec![0; self.output_bytes()];
+ self.hash_finalize(&mut buf);
+ encode(buf)
+ }
+}
+
+/// first element of the tuple is the blake2b state
+/// second is the number of output bits
+pub struct Blake2b(blake2b_simd::State, usize);
+
+impl Blake2b {
+ /// Return a new Blake2b instance with a custom output bytes length
+ pub fn with_output_bytes(output_bytes: usize) -> Self {
+ let mut params = blake2b_simd::Params::new();
+ params.hash_length(output_bytes);
+
+ let state = params.to_state();
+ Self(state, output_bytes * 8)
+ }
+}
+
+impl Digest for Blake2b {
+ fn new() -> Self {
+ // by default, Blake2b output is 512 bits long (= 64B)
+ Self::with_output_bytes(64)
+ }
+
+ fn hash_update(&mut self, input: &[u8]) {
+ self.0.update(input);
+ }
+
+ fn hash_finalize(&mut self, out: &mut [u8]) {
+ let hash_result = &self.0.finalize();
+ out.copy_from_slice(hash_result.as_bytes());
+ }
+
+ fn reset(&mut self) {
+ *self = Self::with_output_bytes(self.output_bytes());
+ }
+
+ fn output_bits(&self) -> usize {
+ self.1
+ }
+}
+
+pub struct Blake3(blake3::Hasher);
+impl Digest for Blake3 {
+ fn new() -> Self {
+ Self(blake3::Hasher::new())
+ }
+
+ fn hash_update(&mut self, input: &[u8]) {
+ self.0.update(input);
+ }
+
+ fn hash_finalize(&mut self, out: &mut [u8]) {
+ let hash_result = &self.0.finalize();
+ out.copy_from_slice(hash_result.as_bytes());
+ }
+
+ fn reset(&mut self) {
+ *self = Self::new();
+ }
+
+ fn output_bits(&self) -> usize {
+ 256
+ }
+}
+
+pub struct Sm3(sm3::Sm3);
+impl Digest for Sm3 {
+ fn new() -> Self {
+ Self(<sm3::Sm3 as sm3::Digest>::new())
+ }
+
+ fn hash_update(&mut self, input: &[u8]) {
+ <sm3::Sm3 as sm3::Digest>::update(&mut self.0, input);
+ }
+
+ fn hash_finalize(&mut self, out: &mut [u8]) {
+ out.copy_from_slice(&<sm3::Sm3 as sm3::Digest>::finalize(self.0.clone()));
+ }
+
+ fn reset(&mut self) {
+ *self = Self::new();
+ }
+
+ fn output_bits(&self) -> usize {
+ 256
+ }
+}
+
+// NOTE: CRC_TABLE_LEN *must* be <= 256 as we cast 0..CRC_TABLE_LEN to u8
+const CRC_TABLE_LEN: usize = 256;
+
+pub struct CRC {
+ state: u32,
+ size: usize,
+ crc_table: [u32; CRC_TABLE_LEN],
+}
+impl CRC {
+ fn generate_crc_table() -> [u32; CRC_TABLE_LEN] {
+ let mut table = [0; CRC_TABLE_LEN];
+
+ for (i, elt) in table.iter_mut().enumerate().take(CRC_TABLE_LEN) {
+ *elt = Self::crc_entry(i as u8);
+ }
+
+ table
+ }
+ fn crc_entry(input: u8) -> u32 {
+ let mut crc = (input as u32) << 24;
+
+ let mut i = 0;
+ while i < 8 {
+ let if_condition = crc & 0x8000_0000;
+ let if_body = (crc << 1) ^ 0x04c1_1db7;
+ let else_body = crc << 1;
+
+ // NOTE: i feel like this is easier to understand than emulating an if statement in bitwise
+ // ops
+ let condition_table = [else_body, if_body];
+
+ crc = condition_table[(if_condition != 0) as usize];
+ i += 1;
+ }
+
+ crc
+ }
+
+ fn update(&mut self, input: u8) {
+ self.state = (self.state << 8)
+ ^ self.crc_table[((self.state >> 24) as usize ^ input as usize) & 0xFF];
+ }
+}
+
+impl Digest for CRC {
+ fn new() -> Self {
+ Self {
+ state: 0,
+ size: 0,
+ crc_table: Self::generate_crc_table(),
+ }
+ }
+
+ fn hash_update(&mut self, input: &[u8]) {
+ for &elt in input {
+ self.update(elt);
+ }
+ self.size += input.len();
+ }
+
+ fn hash_finalize(&mut self, out: &mut [u8]) {
+ let mut sz = self.size;
+ while sz != 0 {
+ self.update(sz as u8);
+ sz >>= 8;
+ }
+ self.state = !self.state;
+ out.copy_from_slice(&self.state.to_ne_bytes());
+ }
+
+ fn result_str(&mut self) -> String {
+ let mut _out: Vec<u8> = vec![0; 4];
+ self.hash_finalize(&mut _out);
+ format!("{}", self.state)
+ }
+
+ fn reset(&mut self) {
+ *self = Self::new();
+ }
+
+ fn output_bits(&self) -> usize {
+ 256
+ }
+}
+
+// This can be replaced with usize::div_ceil once it is stabilized.
+// This implementation approach is optimized for when `b` is a constant,
+// particularly a power of two.
+pub fn div_ceil(a: usize, b: usize) -> usize {
+ (a + b - 1) / b
+}
+
+pub struct BSD {
+ state: u16,
+}
+impl Digest for BSD {
+ fn new() -> Self {
+ Self { state: 0 }
+ }
+
+ fn hash_update(&mut self, input: &[u8]) {
+ for &byte in input {
+ self.state = (self.state >> 1) + ((self.state & 1) << 15);
+ self.state = self.state.wrapping_add(u16::from(byte));
+ }
+ }
+
+ fn hash_finalize(&mut self, out: &mut [u8]) {
+ out.copy_from_slice(&self.state.to_ne_bytes());
+ }
+
+ fn result_str(&mut self) -> String {
+ let mut _out: Vec<u8> = vec![0; 2];
+ self.hash_finalize(&mut _out);
+ format!("{}", self.state)
+ }
+
+ fn reset(&mut self) {
+ *self = Self::new();
+ }
+
+ fn output_bits(&self) -> usize {
+ 128
+ }
+}
+
+pub struct SYSV {
+ state: u32,
+}
+impl Digest for SYSV {
+ fn new() -> Self {
+ Self { state: 0 }
+ }
+
+ fn hash_update(&mut self, input: &[u8]) {
+ for &byte in input {
+ self.state = self.state.wrapping_add(u32::from(byte));
+ }
+ }
+
+ fn hash_finalize(&mut self, out: &mut [u8]) {
+ self.state = (self.state & 0xffff) + (self.state >> 16);
+ self.state = (self.state & 0xffff) + (self.state >> 16);
+ out.copy_from_slice(&(self.state as u16).to_ne_bytes());
+ }
+
+ fn result_str(&mut self) -> String {
+ let mut _out: Vec<u8> = vec![0; 2];
+ self.hash_finalize(&mut _out);
+ format!("{}", self.state)
+ }
+
+ fn reset(&mut self) {
+ *self = Self::new();
+ }
+
+ fn output_bits(&self) -> usize {
+ 512
+ }
+}
+
+// Implements the Digest trait for sha2 / sha3 algorithms with fixed output
+macro_rules! impl_digest_common {
+ ($algo_type: ty, $size: expr) => {
+ impl Digest for $algo_type {
+ fn new() -> Self {
+ Self(Default::default())
+ }
+
+ fn hash_update(&mut self, input: &[u8]) {
+ digest::Digest::update(&mut self.0, input);
+ }
+
+ fn hash_finalize(&mut self, out: &mut [u8]) {
+ digest::Digest::finalize_into_reset(&mut self.0, out.into());
+ }
+
+ fn reset(&mut self) {
+ *self = Self::new();
+ }
+
+ fn output_bits(&self) -> usize {
+ $size
+ }
+ }
+ };
+}
+
+// Implements the Digest trait for sha2 / sha3 algorithms with variable output
+macro_rules! impl_digest_shake {
+ ($algo_type: ty) => {
+ impl Digest for $algo_type {
+ fn new() -> Self {
+ Self(Default::default())
+ }
+
+ fn hash_update(&mut self, input: &[u8]) {
+ digest::Update::update(&mut self.0, input);
+ }
+
+ fn hash_finalize(&mut self, out: &mut [u8]) {
+ digest::ExtendableOutputReset::finalize_xof_reset_into(&mut self.0, out);
+ }
+
+ fn reset(&mut self) {
+ *self = Self::new();
+ }
+
+ fn output_bits(&self) -> usize {
+ 0
+ }
+ }
+ };
+}
+
+pub struct Md5(md5::Md5);
+pub struct Sha1(sha1::Sha1);
+pub struct Sha224(sha2::Sha224);
+pub struct Sha256(sha2::Sha256);
+pub struct Sha384(sha2::Sha384);
+pub struct Sha512(sha2::Sha512);
+impl_digest_common!(Md5, 128);
+impl_digest_common!(Sha1, 160);
+impl_digest_common!(Sha224, 224);
+impl_digest_common!(Sha256, 256);
+impl_digest_common!(Sha384, 384);
+impl_digest_common!(Sha512, 512);
+
+pub struct Sha3_224(sha3::Sha3_224);
+pub struct Sha3_256(sha3::Sha3_256);
+pub struct Sha3_384(sha3::Sha3_384);
+pub struct Sha3_512(sha3::Sha3_512);
+impl_digest_common!(Sha3_224, 224);
+impl_digest_common!(Sha3_256, 256);
+impl_digest_common!(Sha3_384, 384);
+impl_digest_common!(Sha3_512, 512);
+
+pub struct Shake128(sha3::Shake128);
+pub struct Shake256(sha3::Shake256);
+impl_digest_shake!(Shake128);
+impl_digest_shake!(Shake256);
+
+/// A struct that writes to a digest.
+///
+/// This struct wraps a [`Digest`] and provides a [`Write`]
+/// implementation that passes input bytes directly to the
+/// [`Digest::hash_update`].
+///
+/// On Windows, if `binary` is `false`, then the [`write`]
+/// implementation replaces instances of "\r\n" with "\n" before passing
+/// the input bytes to the [`digest`].
+pub struct DigestWriter<'a> {
+ digest: &'a mut Box<dyn Digest>,
+
+ /// Whether to write to the digest in binary mode or text mode on Windows.
+ ///
+ /// If this is `false`, then instances of "\r\n" are replaced with
+ /// "\n" before passing input bytes to the [`digest`].
+ #[allow(dead_code)]
+ binary: bool,
+
+ /// Whether the previous
+ #[allow(dead_code)]
+ was_last_character_carriage_return: bool,
+ // TODO These are dead code only on non-Windows operating systems.
+ // It might be better to use a `#[cfg(windows)]` guard here.
+}
+
+impl<'a> DigestWriter<'a> {
+ pub fn new(digest: &'a mut Box<dyn Digest>, binary: bool) -> Self {
+ let was_last_character_carriage_return = false;
+ DigestWriter {
+ digest,
+ binary,
+ was_last_character_carriage_return,
+ }
+ }
+
+ pub fn finalize(&mut self) -> bool {
+ if self.was_last_character_carriage_return {
+ self.digest.hash_update(&[b'\r']);
+ true
+ } else {
+ false
+ }
+ }
+}
+
+impl<'a> Write for DigestWriter<'a> {
+ #[cfg(not(windows))]
+ fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+ self.digest.hash_update(buf);
+ Ok(buf.len())
+ }
+
+ #[cfg(windows)]
+ fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+ if self.binary {
+ self.digest.hash_update(buf);
+ return Ok(buf.len());
+ }
+
+ // The remaining code handles Windows text mode, where we must
+ // replace each occurrence of "\r\n" with "\n".
+ //
+ // First, if the last character written was "\r" and the first
+ // character in the current buffer to write is not "\n", then we
+ // need to write the "\r" that we buffered from the previous
+ // call to `write()`.
+ let n = buf.len();
+ if self.was_last_character_carriage_return && n > 0 && buf[0] != b'\n' {
+ self.digest.hash_update(&[b'\r']);
+ }
+
+ // Next, find all occurrences of "\r\n", inputting the slice
+ // just before the "\n" in the previous instance of "\r\n" and
+ // the beginning of this "\r\n".
+ let mut i_prev = 0;
+ for i in memmem::find_iter(buf, b"\r\n") {
+ self.digest.hash_update(&buf[i_prev..i]);
+ i_prev = i + 1;
+ }
+
+ // Finally, check whether the last character is "\r". If so,
+ // buffer it until we know that the next character is not "\n",
+ // which can only be known on the next call to `write()`.
+ //
+ // This all assumes that `write()` will be called on adjacent
+ // blocks of the input.
+ if n > 0 && buf[n - 1] == b'\r' {
+ self.was_last_character_carriage_return = true;
+ self.digest.hash_update(&buf[i_prev..n - 1]);
+ } else {
+ self.was_last_character_carriage_return = false;
+ self.digest.hash_update(&buf[i_prev..n]);
+ }
+
+ // Even though we dropped a "\r" for each "\r\n" we found, we
+ // still report the number of bytes written as `n`. This is
+ // because the meaning of the returned number is supposed to be
+ // the number of bytes consumed by the writer, so that if the
+ // calling code were calling `write()` in a loop, it would know
+ // where the next contiguous slice of the buffer starts.
+ Ok(n)
+ }
+
+ fn flush(&mut self) -> std::io::Result<()> {
+ Ok(())
+ }
+}
+
+#[cfg(test)]
+mod tests {
+
+ /// Test for replacing a "\r\n" sequence with "\n" when the "\r" is
+ /// at the end of one block and the "\n" is at the beginning of the
+ /// next block, when reading in blocks.
+ #[cfg(windows)]
+ #[test]
+ fn test_crlf_across_blocks() {
+ use std::io::Write;
+
+ use super::Digest;
+ use super::DigestWriter;
+ use super::Md5;
+
+ // Writing "\r" in one call to `write()`, and then "\n" in another.
+ let mut digest = Box::new(Md5::new()) as Box<dyn Digest>;
+ let mut writer_crlf = DigestWriter::new(&mut digest, false);
+ writer_crlf.write_all(&[b'\r']).unwrap();
+ writer_crlf.write_all(&[b'\n']).unwrap();
+ writer_crlf.finalize();
+ let result_crlf = digest.result_str();
+
+ // We expect "\r\n" to be replaced with "\n" in text mode on Windows.
+ let mut digest = Box::new(Md5::new()) as Box<dyn Digest>;
+ let mut writer_lf = DigestWriter::new(&mut digest, false);
+ writer_lf.write_all(&[b'\n']).unwrap();
+ writer_lf.finalize();
+ let result_lf = digest.result_str();
+
+ assert_eq!(result_crlf, result_lf);
+ }
+}
diff --git a/src/uucore/src/lib/features/tokenize/mod.rs b/src/uucore/src/lib/features/tokenize/mod.rs
deleted file mode 100644
index dfe44a0e56b222ef882dfd4eaf1de578fa875dda..0000000000000000000000000000000000000000
--- a/src/uucore/src/lib/features/tokenize/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-#[allow(clippy::module_inception)]
-mod num_format;
-pub mod sub;
-pub mod token;
-pub mod unescaped_text;
diff --git a/src/uucore/src/lib/features/tokenize/num_format/format_field.rs b/src/uucore/src/lib/features/tokenize/num_format/format_field.rs
deleted file mode 100644
index 02998cde5407ec49aa21b7b7cb489f3f05a67a06..0000000000000000000000000000000000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/format_field.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-
-//! Primitives used by Sub Tokenizer
-//! and num_format modules
-#[derive(Clone)]
-pub enum FieldType {
- Strf,
- Floatf,
- CninetyNineHexFloatf,
- Scif,
- Decf,
- Intf,
- Charf,
-}
-
-// #[allow(non_camel_case_types)]
-// pub enum FChar {
-// d,
-// e,
-// E,
-// i,
-// f,
-// F,
-// g,
-// G,
-// u,
-// x,
-// X,
-// o
-// }
-//
-
-// a Sub Tokens' fields are stored
-// as a single object so they can be more simply
-// passed by ref to num_format in a Sub method
-#[derive(Clone)]
-pub struct FormatField<'a> {
- pub min_width: Option<isize>,
- pub second_field: Option<u32>,
- pub field_char: &'a char,
- pub field_type: &'a FieldType,
- pub orig: &'a String,
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatter.rs b/src/uucore/src/lib/features/tokenize/num_format/formatter.rs
deleted file mode 100644
index ed7d5a0f609a7569084e48ac719b42965710ffc6..0000000000000000000000000000000000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatter.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-//! Primitives used by num_format and sub_modules.
-//! never dealt with above (e.g. Sub Tokenizer never uses these)
-
-use crate::{display::Quotable, show_error};
-use itertools::{put_back_n, PutBackN};
-use std::str::Chars;
-
-use super::format_field::FormatField;
-
-// contains the rough ingredients to final
-// output for a number, organized together
-// to allow for easy generalization of output manipulation
-// (e.g. max number of digits after decimal)
-#[derive(Default)]
-pub struct FormatPrimitive {
- pub prefix: Option<String>,
- pub pre_decimal: Option<String>,
- pub post_decimal: Option<String>,
- pub suffix: Option<String>,
-}
-
-#[derive(Clone, PartialEq, Eq)]
-pub enum Base {
- Ten = 10,
- Hex = 16,
- Octal = 8,
-}
-
-// information from the beginning of a numeric argument
-// the precedes the beginning of a numeric value
-pub struct InitialPrefix {
- pub radix_in: Base,
- pub sign: i8,
- pub offset: usize,
-}
-
-pub trait Formatter {
- // return a FormatPrimitive for
- // particular field char(s), given the argument
- // string and prefix information (sign, radix)
- fn get_primitive(
- &self,
- field: &FormatField,
- in_prefix: &InitialPrefix,
- str_in: &str,
- ) -> Option<FormatPrimitive>;
- // return a string from a FormatPrimitive,
- // given information about the field
- fn primitive_to_str(&self, prim: &FormatPrimitive, field: FormatField) -> String;
-}
-pub fn get_it_at(offset: usize, str_in: &str) -> PutBackN<Chars> {
- put_back_n(str_in[offset..].chars())
-}
-
-// TODO: put this somewhere better
-pub fn warn_incomplete_conv(pf_arg: &str) {
- // important: keep println here not print
- show_error!("{}: value not completely converted", pf_arg.maybe_quote());
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/mod.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/mod.rs
deleted file mode 100644
index 3df9f7129bc022c52fa6deeea39347ca93f1f0b2..0000000000000000000000000000000000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/mod.rs
+++ /dev/null
@@ -1,270 +0,0 @@
-// spell-checker:ignore (ToDO) arrnum arr_num mult basenum bufferval refd vals arrfloat conv intermed addl
-
-pub fn arrnum_int_mult(arr_num: &[u8], basenum: u8, base_ten_int_fact: u8) -> Vec<u8> {
- let mut carry: u16 = 0;
- let mut rem: u16;
- let mut new_amount: u16;
- let fact: u16 = u16::from(base_ten_int_fact);
- let base: u16 = u16::from(basenum);
-
- let mut ret_rev: Vec<u8> = Vec::new();
- let mut it = arr_num.iter().rev();
- loop {
- let i = it.next();
- match i {
- Some(u) => {
- new_amount = (u16::from(*u) * fact) + carry;
- rem = new_amount % base;
- carry = (new_amount - rem) / base;
- ret_rev.push(rem as u8);
- }
- None => {
- while carry != 0 {
- rem = carry % base;
- carry = (carry - rem) / base;
- ret_rev.push(rem as u8);
- }
- break;
- }
- }
- }
- let ret: Vec<u8> = ret_rev.into_iter().rev().collect();
- ret
-}
-
-#[allow(dead_code)]
-pub struct Remainder<'a> {
- pub position: usize,
- pub replace: Vec<u8>,
- pub arr_num: &'a Vec<u8>,
-}
-
-#[allow(dead_code)]
-pub struct DivOut<'a> {
- pub quotient: u8,
- pub remainder: Remainder<'a>,
-}
-
-#[allow(dead_code)]
-pub fn arrnum_int_div_step<'a>(
- rem_in: &'a Remainder,
- radix_in: u8,
- base_ten_int_divisor: u8,
- after_decimal: bool,
-) -> DivOut<'a> {
- let mut rem_out = Remainder {
- position: rem_in.position,
- replace: Vec::new(),
- arr_num: rem_in.arr_num,
- };
-
- let mut bufferval: u16 = 0;
- let base: u16 = u16::from(radix_in);
- let divisor: u16 = u16::from(base_ten_int_divisor);
- let mut traversed = 0;
-
- let mut quotient = 0;
- let refd_vals = &rem_in.arr_num[rem_in.position + rem_in.replace.len()..];
- let mut it_replace = rem_in.replace.iter();
- let mut it_f = refd_vals.iter();
- loop {
- let u = match it_replace.next() {
- Some(u_rep) => u16::from(*u_rep),
- None => match it_f.next() {
- Some(u_orig) => u16::from(*u_orig),
- None => {
- if !after_decimal {
- break;
- }
- 0
- }
- },
- };
- traversed += 1;
- bufferval += u;
- if bufferval > divisor {
- while bufferval >= divisor {
- quotient += 1;
- bufferval -= divisor;
- }
- rem_out.replace = if bufferval == 0 {
- Vec::new()
- } else {
- let remainder_as_arrnum = unsigned_to_arrnum(bufferval);
- base_conv_vec(&remainder_as_arrnum, 10, radix_in)
- };
- rem_out.position += 1 + (traversed - rem_out.replace.len());
- break;
- } else {
- bufferval *= base;
- }
- }
- DivOut {
- quotient,
- remainder: rem_out,
- }
-}
-pub fn arrnum_int_add(arrnum: &[u8], basenum: u8, base_ten_int_term: u8) -> Vec<u8> {
- let mut carry: u16 = u16::from(base_ten_int_term);
- let mut rem: u16;
- let mut new_amount: u16;
- let base: u16 = u16::from(basenum);
-
- let mut ret_rev: Vec<u8> = Vec::new();
- let mut it = arrnum.iter().rev();
- loop {
- let i = it.next();
- match i {
- Some(u) => {
- new_amount = u16::from(*u) + carry;
- rem = new_amount % base;
- carry = (new_amount - rem) / base;
- ret_rev.push(rem as u8);
- }
- None => {
- while carry != 0 {
- rem = carry % base;
- carry = (carry - rem) / base;
- ret_rev.push(rem as u8);
- }
- break;
- }
- }
- }
- let ret: Vec<u8> = ret_rev.into_iter().rev().collect();
- ret
-}
-
-pub fn base_conv_vec(src: &[u8], radix_src: u8, radix_dest: u8) -> Vec<u8> {
- let mut result = vec![0];
- for i in src {
- result = arrnum_int_mult(&result, radix_dest, radix_src);
- result = arrnum_int_add(&result, radix_dest, *i);
- }
- result
-}
-
-#[allow(dead_code)]
-pub fn unsigned_to_arrnum(src: u16) -> Vec<u8> {
- let mut result: Vec<u8> = Vec::new();
- let mut src_tmp: u16 = src;
- while src_tmp > 0 {
- result.push((src_tmp % 10) as u8);
- src_tmp /= 10;
- }
- result.reverse();
- result
-}
-
-// temporary needs-improvement-function
-pub fn base_conv_float(src: &[u8], radix_src: u8, _radix_dest: u8) -> f64 {
- // it would require a lot of addl code
- // to implement this for arbitrary string input.
- // until then, the below operates as an outline
- // of how it would work.
- let mut factor: f64 = 1_f64;
- let radix_src_float: f64 = f64::from(radix_src);
- let mut r: f64 = 0_f64;
- for (i, u) in src.iter().enumerate() {
- if i > 15 {
- break;
- }
- factor /= radix_src_float;
- r += factor * f64::from(*u);
- }
- r
-}
-
-pub fn str_to_arrnum(src: &str, radix_def_src: &dyn RadixDef) -> Vec<u8> {
- let mut intermed_in: Vec<u8> = Vec::new();
- for c in src.chars() {
- #[allow(clippy::single_match)]
- match radix_def_src.parse_char(c) {
- Some(u) => {
- intermed_in.push(u);
- }
- None => {} //todo err msg on incorrect
- }
- }
- intermed_in
-}
-
-pub fn arrnum_to_str(src: &[u8], radix_def_dest: &dyn RadixDef) -> String {
- let mut str_out = String::new();
- for u in src.iter() {
- #[allow(clippy::single_match)]
- match radix_def_dest.format_u8(*u) {
- Some(c) => {
- str_out.push(c);
- }
- None => {} //todo
- }
- }
- str_out
-}
-
-pub fn base_conv_str(
- src: &str,
- radix_def_src: &dyn RadixDef,
- radix_def_dest: &dyn RadixDef,
-) -> String {
- let intermed_in: Vec<u8> = str_to_arrnum(src, radix_def_src);
- let intermed_out = base_conv_vec(
- &intermed_in,
- radix_def_src.get_max(),
- radix_def_dest.get_max(),
- );
- arrnum_to_str(&intermed_out, radix_def_dest)
-}
-
-pub trait RadixDef {
- fn get_max(&self) -> u8;
- fn parse_char(&self, x: char) -> Option<u8>;
- fn format_u8(&self, x: u8) -> Option<char>;
-}
-pub struct RadixTen;
-
-const ZERO_ASC: u8 = b'0';
-const UPPER_A_ASC: u8 = b'A';
-const LOWER_A_ASC: u8 = b'a';
-
-impl RadixDef for RadixTen {
- fn get_max(&self) -> u8 {
- 10
- }
- fn parse_char(&self, c: char) -> Option<u8> {
- match c {
- '0'..='9' => Some(c as u8 - ZERO_ASC),
- _ => None,
- }
- }
- fn format_u8(&self, u: u8) -> Option<char> {
- match u {
- 0..=9 => Some((ZERO_ASC + u) as char),
- _ => None,
- }
- }
-}
-pub struct RadixHex;
-impl RadixDef for RadixHex {
- fn get_max(&self) -> u8 {
- 16
- }
- fn parse_char(&self, c: char) -> Option<u8> {
- match c {
- '0'..='9' => Some(c as u8 - ZERO_ASC),
- 'A'..='F' => Some(c as u8 + 10 - UPPER_A_ASC),
- 'a'..='f' => Some(c as u8 + 10 - LOWER_A_ASC),
- _ => None,
- }
- }
- fn format_u8(&self, u: u8) -> Option<char> {
- match u {
- 0..=9 => Some((ZERO_ASC + u) as char),
- 10..=15 => Some((UPPER_A_ASC + (u - 10)) as char),
- _ => None,
- }
- }
-}
-
-mod tests;
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/tests.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/tests.rs
deleted file mode 100644
index 903a3faf142331fb90b6cb3dfc1da6019676e31f..0000000000000000000000000000000000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/tests.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-// spell-checker:ignore (ToDO) arrnum mult
-
-#[cfg(test)]
-use super::*;
-
-#[test]
-fn test_arrnum_int_mult() {
- // (in base 10) 12 * 4 = 48
- let factor: Vec<u8> = vec![1, 2];
- let base_num = 10;
- let base_ten_int_fact: u8 = 4;
- let should_output: Vec<u8> = vec![4, 8];
-
- let product = arrnum_int_mult(&factor, base_num, base_ten_int_fact);
- assert!(product == should_output);
-}
-
-#[test]
-fn test_arrnum_int_non_base_10() {
- // (in base 3)
- // 5 * 4 = 20
- let factor: Vec<u8> = vec![1, 2];
- let base_num = 3;
- let base_ten_int_fact: u8 = 4;
- let should_output: Vec<u8> = vec![2, 0, 2];
-
- let product = arrnum_int_mult(&factor, base_num, base_ten_int_fact);
- assert!(product == should_output);
-}
-
-#[test]
-fn test_arrnum_int_div_short_circuit() {
- // (
- let arrnum: Vec<u8> = vec![5, 5, 5, 5, 0];
- let base_num = 10;
- let base_ten_int_divisor: u8 = 41;
- let remainder_passed_in = Remainder {
- position: 1,
- replace: vec![1, 3],
- arr_num: &arrnum,
- };
-
- // the "replace" should mean the number being divided
- // is 1350, the first time you can get 41 to go into
- // 1350, its at 135, where you can get a quotient of
- // 3 and a remainder of 12;
-
- let quotient_should_be: u8 = 3;
- let remainder_position_should_be: usize = 3;
- let remainder_replace_should_be = vec![1, 2];
-
- let result = arrnum_int_div_step(&remainder_passed_in, base_num, base_ten_int_divisor, false);
- assert!(quotient_should_be == result.quotient);
- assert!(remainder_position_should_be == result.remainder.position);
- assert!(remainder_replace_should_be == result.remainder.replace);
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/cninetyninehexfloatf.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/cninetyninehexfloatf.rs
deleted file mode 100644
index 85396a2aa3802490b6b1cde76364d3356f765a32..0000000000000000000000000000000000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/cninetyninehexfloatf.rs
+++ /dev/null
@@ -1,115 +0,0 @@
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-// spell-checker:ignore (ToDO) arrnum
-
-//! formatter for %a %F C99 Hex-floating-point subs
-use super::super::format_field::FormatField;
-use super::super::formatter::{FormatPrimitive, Formatter, InitialPrefix};
-use super::base_conv;
-use super::base_conv::RadixDef;
-use super::float_common::{primitive_to_str_common, FloatAnalysis};
-
-#[derive(Default)]
-pub struct CninetyNineHexFloatf {
- #[allow(dead_code)]
- as_num: f64,
-}
-impl CninetyNineHexFloatf {
- pub fn new() -> Self {
- Self::default()
- }
-}
-
-impl Formatter for CninetyNineHexFloatf {
- fn get_primitive(
- &self,
- field: &FormatField,
- initial_prefix: &InitialPrefix,
- str_in: &str,
- ) -> Option<FormatPrimitive> {
- let second_field = field.second_field.unwrap_or(6) + 1;
- let analysis = FloatAnalysis::analyze(
- str_in,
- initial_prefix,
- Some(second_field as usize),
- None,
- true,
- );
- let f = get_primitive_hex(
- initial_prefix,
- &str_in[initial_prefix.offset..],
- &analysis,
- second_field as usize,
- *field.field_char == 'A',
- );
- Some(f)
- }
- fn primitive_to_str(&self, prim: &FormatPrimitive, field: FormatField) -> String {
- primitive_to_str_common(prim, &field)
- }
-}
-
-// c99 hex has unique requirements of all floating point subs in pretty much every part of building a primitive, from prefix and suffix to need for base conversion (in all other cases if you don't have decimal you must have decimal, here it's the other way around)
-
-// on the todo list is to have a trait for get_primitive that is implemented by each float formatter and can override a default. when that happens we can take the parts of get_primitive_dec specific to dec and spin them out to their own functions that can be overridden.
-fn get_primitive_hex(
- initial_prefix: &InitialPrefix,
- _str_in: &str,
- _analysis: &FloatAnalysis,
- _last_dec_place: usize,
- capitalized: bool,
-) -> FormatPrimitive {
- let prefix = Some(String::from(if initial_prefix.sign == -1 {
- "-0x"
- } else {
- "0x"
- }));
-
- // TODO actual conversion, make sure to get back mantissa.
- // for hex to hex, it's really just a matter of moving the
- // decimal point and calculating the mantissa by its initial
- // position and its moves, with every position counting for
- // the addition or subtraction of 4 (2**4, because 4 bits in a hex digit)
- // to the exponent.
- // decimal's going to be a little more complicated. correct simulation
- // of glibc will require after-decimal division to a specified precision.
- // the difficult part of this (arrnum_int_div_step) is already implemented.
-
- // the hex float name may be a bit misleading in terms of how to go about the
- // conversion. The best way to do it is to just convert the float number
- // directly to base 2 and then at the end translate back to hex.
- let mantissa = 0;
- let suffix = Some({
- let ind = if capitalized { "P" } else { "p" };
- if mantissa >= 0 {
- format!("{}+{}", ind, mantissa)
- } else {
- format!("{}{}", ind, mantissa)
- }
- });
- FormatPrimitive {
- prefix,
- suffix,
- ..Default::default()
- }
-}
-
-#[allow(dead_code)]
-fn to_hex(src: &str, before_decimal: bool) -> String {
- let radix_ten = base_conv::RadixTen;
- let radix_hex = base_conv::RadixHex;
- if before_decimal {
- base_conv::base_conv_str(src, &radix_ten, &radix_hex)
- } else {
- let as_arrnum_ten = base_conv::str_to_arrnum(src, &radix_ten);
- let s = format!(
- "{}",
- base_conv::base_conv_float(&as_arrnum_ten, radix_ten.get_max(), radix_hex.get_max())
- );
- if s.len() > 2 {
- String::from(&s[2..])
- } else {
- // zero
- s
- }
- }
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/decf.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/decf.rs
deleted file mode 100644
index 2ee53882e5db8900f40cd5532e526561e6fe5c05..0000000000000000000000000000000000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/decf.rs
+++ /dev/null
@@ -1,185 +0,0 @@
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-
-//! formatter for %g %G decimal subs
-use super::super::format_field::FormatField;
-use super::super::formatter::{FormatPrimitive, Formatter, InitialPrefix};
-use super::float_common::{get_primitive_dec, primitive_to_str_common, FloatAnalysis};
-
-const SIGNIFICANT_FIGURES: usize = 6;
-
-// Parse a numeric string as the nearest integer with a given significance.
-// This is a helper function for round().
-// Examples:
-// round_to_significance("456", 1) == 500
-// round_to_significance("456", 2) == 460
-// round_to_significance("456", 9) == 456
-fn round_to_significance(input: &str, significant_figures: usize) -> u32 {
- if significant_figures < input.len() {
- // If the input has too many digits, use a float intermediary
- // to round it before converting to an integer. Otherwise,
- // converting straight to integer will truncate.
- // There might be a cleaner way to do this...
- let digits = &input[..significant_figures + 1];
- let float_representation = digits.parse::<f32>().unwrap();
- (float_representation / 10.0).round() as u32
- } else {
- input.parse::<u32>().unwrap_or(0)
- }
-}
-
-// Removing trailing zeroes, expressing the result as an integer where
-// possible. This is a helper function for round().
-fn truncate(mut format: FormatPrimitive) -> FormatPrimitive {
- if let Some(ref post_dec) = format.post_decimal {
- let trimmed = post_dec.trim_end_matches('0');
-
- if trimmed.is_empty() {
- // If there are no nonzero digits after the decimal point,
- // use integer formatting by clearing post_decimal and suffix.
- format.post_decimal = Some(String::new());
- if format.suffix == Some("e+00".into()) {
- format.suffix = Some(String::new());
- }
- } else if trimmed.len() != post_dec.len() {
- // Otherwise, update the format to remove only the trailing
- // zeroes (e.g. "4.50" becomes "4.5", not "4"). If there were
- // no trailing zeroes, do nothing.
- format.post_decimal = Some(trimmed.to_owned());
- }
- }
- format
-}
-
-// Round a format to six significant figures and remove trailing zeroes.
-fn round(mut format: FormatPrimitive) -> FormatPrimitive {
- let mut significant_digits_remaining = SIGNIFICANT_FIGURES;
-
- // First, take as many significant digits as possible from pre_decimal,
- if format.pre_decimal.is_some() {
- let input = format.pre_decimal.as_ref().unwrap();
- let rounded = round_to_significance(input, significant_digits_remaining);
- let mut rounded_str = rounded.to_string();
- significant_digits_remaining -= rounded_str.len();
-
- // If the pre_decimal has exactly enough significant digits,
- // round the input to the nearest integer. If the first
- // post_decimal digit is 5 or higher, round up by incrementing
- // the pre_decimal number. Otherwise, use the pre_decimal as-is.
- if significant_digits_remaining == 0 {
- if let Some(digits) = &format.post_decimal {
- if digits.chars().next().unwrap_or('0') >= '5' {
- let rounded = rounded + 1;
- rounded_str = rounded.to_string();
- }
- }
- }
- format.pre_decimal = Some(rounded_str);
- }
-
- // If no significant digits remain, or there's no post_decimal to
- // round, return the rounded pre_decimal value with no post_decimal.
- // Otherwise, round the post_decimal to the remaining significance.
- if significant_digits_remaining == 0 {
- format.post_decimal = Some(String::new());
- } else if let Some(input) = format.post_decimal {
- let leading_zeroes = input.len() - input.trim_start_matches('0').len();
- let digits = &input[leading_zeroes..];
-
- // In the post_decimal, leading zeroes are significant. "01.0010"
- // has one significant digit in pre_decimal, and 3 from post_decimal.
- let mut post_decimal_str = String::with_capacity(significant_digits_remaining);
- for _ in 0..leading_zeroes {
- post_decimal_str.push('0');
- }
-
- if leading_zeroes < significant_digits_remaining {
- // After significant leading zeroes, round the remaining digits
- // to any remaining significance.
- let rounded = round_to_significance(digits, significant_digits_remaining);
- post_decimal_str.push_str(&rounded.to_string());
- } else if leading_zeroes == significant_digits_remaining
- && digits.chars().next().unwrap_or('0') >= '5'
- {
- // If necessary, round up the post_decimal ("1.000009" should
- // round to 1.00001, instead of truncating after the last
- // significant leading zero).
- post_decimal_str.pop();
- post_decimal_str.push('1');
- } else {
- // If the rounded post_decimal is entirely zeroes, discard
- // it and use integer formatting instead.
- post_decimal_str = String::new();
- }
-
- format.post_decimal = Some(post_decimal_str);
- }
- truncate(format)
-}
-
-// Given an exponent used in scientific notation, return whether the
-// number is small enough to be expressed as a decimal instead. "Small
-// enough" is based only on the number's magnitude, not the length of
-// any string representation.
-fn should_represent_as_decimal(suffix: &Option<String>) -> bool {
- match suffix {
- Some(exponent) => {
- if exponent.chars().nth(1) == Some('-') {
- exponent < &"e-05".into()
- } else {
- exponent < &"e+06".into()
- }
- }
- None => true,
- }
-}
-
-pub struct Decf;
-
-impl Decf {
- pub fn new() -> Self {
- Self
- }
-}
-impl Formatter for Decf {
- fn get_primitive(
- &self,
- field: &FormatField,
- initial_prefix: &InitialPrefix,
- str_in: &str,
- ) -> Option<FormatPrimitive> {
- let second_field = field.second_field.unwrap_or(6) + 1;
- // default to scif interpretation so as to not truncate input vals
- // (that would be displayed in scif) based on relation to decimal place
- let analysis = FloatAnalysis::analyze(
- str_in,
- initial_prefix,
- Some(second_field as usize + 1),
- None,
- false,
- );
- let mut f_dec = get_primitive_dec(
- initial_prefix,
- &str_in[initial_prefix.offset..],
- &analysis,
- second_field as usize,
- Some(*field.field_char == 'G'),
- );
-
- if should_represent_as_decimal(&f_dec.suffix) {
- // Use decimal formatting instead of scientific notation
- // if the input's magnitude is small.
- f_dec = get_primitive_dec(
- initial_prefix,
- &str_in[initial_prefix.offset..],
- &analysis,
- second_field as usize,
- None,
- );
- }
-
- Some(round(f_dec))
- }
- fn primitive_to_str(&self, prim: &FormatPrimitive, field: FormatField) -> String {
- primitive_to_str_common(prim, &field)
- }
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/float_common.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/float_common.rs
deleted file mode 100644
index aa9e497bd1fb55f90d4c2df2996bf5107decb490..0000000000000000000000000000000000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/float_common.rs
+++ /dev/null
@@ -1,375 +0,0 @@
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-// spell-checker:ignore (ToDO) arrnum
-
-use super::super::format_field::FormatField;
-use super::super::formatter::{
- get_it_at, warn_incomplete_conv, Base, FormatPrimitive, InitialPrefix,
-};
-use super::base_conv;
-use super::base_conv::RadixDef;
-
-// if the memory, copy, and comparison cost of chars
-// becomes an issue, we can always operate in vec<u8> here
-// rather than just at de_hex
-
-pub struct FloatAnalysis {
- pub len_important: usize,
- // none means no decimal point.
- pub decimal_pos: Option<usize>,
- pub follow: Option<char>,
-}
-fn has_enough_digits(
- hex_input: bool,
- hex_output: bool,
- string_position: usize,
- starting_position: usize,
- limit: usize,
-) -> bool {
- // -1s are for rounding
- if hex_output {
- if hex_input {
- (string_position - 1) - starting_position >= limit
- } else {
- false //undecidable without converting
- }
- } else if hex_input {
- (((string_position - 1) - starting_position) * 9) / 8 >= limit
- } else {
- (string_position - 1) - starting_position >= limit
- }
-}
-
-impl FloatAnalysis {
- pub fn analyze(
- str_in: &str,
- initial_prefix: &InitialPrefix,
- max_sd_opt: Option<usize>,
- max_after_dec_opt: Option<usize>,
- hex_output: bool,
- ) -> Self {
- // this fn assumes
- // the input string
- // has no leading spaces or 0s
- let str_it = get_it_at(initial_prefix.offset, str_in);
- let mut ret = Self {
- len_important: 0,
- decimal_pos: None,
- follow: None,
- };
- let hex_input = match initial_prefix.radix_in {
- Base::Hex => true,
- Base::Ten => false,
- Base::Octal => {
- panic!("this should never happen: floats should never receive octal input");
- }
- };
- let mut i = 0;
- let mut pos_before_first_nonzero_after_decimal: Option<usize> = None;
- for c in str_it {
- match c {
- e @ ('0'..='9' | 'A'..='F' | 'a'..='f') => {
- if !hex_input {
- match e {
- '0'..='9' => {}
- _ => {
- warn_incomplete_conv(str_in);
- break;
- }
- }
- }
- if ret.decimal_pos.is_some()
- && pos_before_first_nonzero_after_decimal.is_none()
- && e != '0'
- {
- pos_before_first_nonzero_after_decimal = Some(i - 1);
- }
- if let Some(max_sd) = max_sd_opt {
- if i == max_sd {
- // follow is used in cases of %g
- // where the character right after the last
- // sd is considered is rounded affecting
- // the previous digit in 1/2 of instances
- ret.follow = Some(e);
- } else if ret.decimal_pos.is_some() && i > max_sd {
- break;
- }
- }
- if let Some(max_after_dec) = max_after_dec_opt {
- if let Some(p) = ret.decimal_pos {
- if has_enough_digits(hex_input, hex_output, i, p, max_after_dec) {
- break;
- }
- }
- } else if let Some(max_sd) = max_sd_opt {
- if let Some(p) = pos_before_first_nonzero_after_decimal {
- if has_enough_digits(hex_input, hex_output, i, p, max_sd) {
- break;
- }
- }
- }
- }
- '.' => {
- if ret.decimal_pos.is_none() {
- ret.decimal_pos = Some(i);
- } else {
- warn_incomplete_conv(str_in);
- break;
- }
- }
- _ => {
- warn_incomplete_conv(str_in);
- break;
- }
- };
- i += 1;
- }
- ret.len_important = i;
- ret
- }
-}
-
-fn de_hex(src: &str, before_decimal: bool) -> String {
- let radix_ten = base_conv::RadixTen;
- let radix_hex = base_conv::RadixHex;
- if before_decimal {
- base_conv::base_conv_str(src, &radix_hex, &radix_ten)
- } else {
- let as_arrnum_hex = base_conv::str_to_arrnum(src, &radix_hex);
- let s = format!(
- "{}",
- base_conv::base_conv_float(&as_arrnum_hex, radix_hex.get_max(), radix_ten.get_max())
- );
- if s.len() > 2 {
- String::from(&s[2..])
- } else {
- // zero
- s
- }
- }
-}
-
-// takes a string in,
-// truncates to a position,
-// bumps the last digit up one,
-// and if the digit was nine
-// propagate to the next, etc.
-// If before the decimal and the most
-// significant digit is a 9, it becomes a 1
-fn _round_str_from(in_str: &str, position: usize, before_dec: bool) -> (String, bool) {
- let mut it = in_str[0..position].chars();
- let mut rev = String::new();
- let mut i = position;
- let mut finished_in_dec = false;
- while let Some(c) = it.next_back() {
- i -= 1;
- match c {
- '9' => {
- // If we're before the decimal
- // and on the most significant digit,
- // round 9 to 1, else to 0.
- if before_dec && i == 0 {
- rev.push('1');
- } else {
- rev.push('0');
- }
- }
- e => {
- rev.push(((e as u8) + 1) as char);
- finished_in_dec = true;
- break;
- }
- }
- }
- let mut fwd = String::from(&in_str[0..i]);
- for ch in rev.chars().rev() {
- fwd.push(ch);
- }
- (fwd, finished_in_dec)
-}
-
-fn round_terminal_digit(
- before_dec: String,
- after_dec: String,
- position: usize,
-) -> (String, String, bool) {
- if position < after_dec.len() {
- let digit_at_pos: char;
- {
- digit_at_pos = after_dec[position..=position].chars().next().expect("");
- }
- if let '5'..='9' = digit_at_pos {
- let (new_after_dec, finished_in_dec) = _round_str_from(&after_dec, position, false);
- if finished_in_dec {
- return (before_dec, new_after_dec, false);
- } else {
- let (new_before_dec, _) = _round_str_from(&before_dec, before_dec.len(), true);
- let mut dec_place_chg = false;
- let mut before_dec_chars = new_before_dec.chars();
- if before_dec_chars.next() == Some('1') && before_dec_chars.all(|c| c == '0') {
- // If the first digit is a one and remaining are zeros, we have
- // rounded to a new decimal place, so the decimal place must be updated.
- // Only update decimal place if the before decimal != 0
- dec_place_chg = before_dec != "0";
- }
- return (new_before_dec, new_after_dec, dec_place_chg);
- }
- // TODO
- }
- }
- (before_dec, after_dec, false)
-}
-
-pub fn get_primitive_dec(
- initial_prefix: &InitialPrefix,
- str_in: &str,
- analysis: &FloatAnalysis,
- last_dec_place: usize,
- sci_mode: Option<bool>,
-) -> FormatPrimitive {
- let mut f = FormatPrimitive::default();
-
- // add negative sign section
- if initial_prefix.sign == -1 {
- f.prefix = Some(String::from("-"));
- }
-
- // assign the digits before and after the decimal points
- // to separate slices. If no digits after decimal point,
- // assign 0
- let (mut first_segment_raw, second_segment_raw) = match analysis.decimal_pos {
- Some(pos) => (&str_in[..pos], &str_in[pos + 1..]),
- None => (str_in, "0"),
- };
- if first_segment_raw.is_empty() {
- first_segment_raw = "0";
- }
- // convert to string, de_hexifying if input is in hex // spell-checker:disable-line
- let (first_segment, second_segment) = match initial_prefix.radix_in {
- Base::Hex => (
- de_hex(first_segment_raw, true),
- de_hex(second_segment_raw, false),
- ),
- _ => (
- String::from(first_segment_raw),
- String::from(second_segment_raw),
- ),
- };
- let (pre_dec_unrounded, post_dec_unrounded, mut mantissa) = if sci_mode.is_some() {
- if first_segment.len() > 1 {
- let mut post_dec = String::from(&first_segment[1..]);
- post_dec.push_str(&second_segment);
- (
- String::from(&first_segment[0..1]),
- post_dec,
- first_segment.len() as isize - 1,
- )
- } else {
- match first_segment
- .chars()
- .next()
- .expect("float_common: no chars in first segment.")
- {
- '0' => {
- let it = second_segment.chars().enumerate();
- let mut m: isize = 0;
- let mut pre = String::from("0");
- let mut post = String::from("0");
- for (i, c) in it {
- match c {
- '0' => {}
- _ => {
- m = -((i as isize) + 1);
- pre = String::from(&second_segment[i..=i]);
- post = String::from(&second_segment[i + 1..]);
- break;
- }
- }
- }
- (pre, post, m)
- }
- _ => (first_segment, second_segment, 0),
- }
- }
- } else {
- (first_segment, second_segment, 0)
- };
-
- let (pre_dec_draft, post_dec_draft, dec_place_chg) =
- round_terminal_digit(pre_dec_unrounded, post_dec_unrounded, last_dec_place - 1);
- f.post_decimal = Some(post_dec_draft);
- if let Some(capitalized) = sci_mode {
- let si_ind = if capitalized { 'E' } else { 'e' };
- // Increase the mantissa if we're adding a decimal place
- if dec_place_chg {
- mantissa += 1;
- }
- f.suffix = Some(if mantissa >= 0 {
- format!("{}+{:02}", si_ind, mantissa)
- } else {
- // negative sign is considered in format!s
- // leading zeroes
- format!("{}{:03}", si_ind, mantissa)
- });
- f.pre_decimal = Some(pre_dec_draft);
- } else if dec_place_chg {
- // We've rounded up to a new decimal place so append 0
- f.pre_decimal = Some(pre_dec_draft + "0");
- } else {
- f.pre_decimal = Some(pre_dec_draft);
- }
-
- f
-}
-
-pub fn primitive_to_str_common(prim: &FormatPrimitive, field: &FormatField) -> String {
- let mut final_str = String::new();
- if let Some(ref prefix) = prim.prefix {
- final_str.push_str(prefix);
- }
- match prim.pre_decimal {
- Some(ref pre_decimal) => {
- final_str.push_str(pre_decimal);
- }
- None => {
- panic!(
- "error, format primitives provided to int, will, incidentally under correct \
- behavior, always have a pre_dec value."
- );
- }
- }
- let decimal_places = field.second_field.unwrap_or(6);
- match prim.post_decimal {
- Some(ref post_decimal) => {
- if !post_decimal.is_empty() && decimal_places > 0 {
- final_str.push('.');
- let len_avail = post_decimal.len() as u32;
-
- if decimal_places >= len_avail {
- // println!("dec {}, len avail {}", decimal_places, len_avail);
- final_str.push_str(post_decimal);
-
- if *field.field_char != 'g' && *field.field_char != 'G' {
- let diff = decimal_places - len_avail;
- for _ in 0..diff {
- final_str.push('0');
- }
- }
- } else {
- // println!("printing to only {}", decimal_places);
- final_str.push_str(&post_decimal[0..decimal_places as usize]);
- }
- }
- }
- None => {
- panic!(
- "error, format primitives provided to int, will, incidentally under correct \
- behavior, always have a pre_dec value."
- );
- }
- }
- if let Some(ref suffix) = prim.suffix {
- final_str.push_str(suffix);
- }
-
- final_str
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/floatf.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/floatf.rs
deleted file mode 100644
index e13629af5019cad66f9f3ab06b7249aa7038e5c8..0000000000000000000000000000000000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/floatf.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-// spell-checker:ignore (ToDO) arrnum
-
-//! formatter for %f %F common-notation floating-point subs
-use super::super::format_field::FormatField;
-use super::super::formatter::{FormatPrimitive, Formatter, InitialPrefix};
-use super::float_common::{get_primitive_dec, primitive_to_str_common, FloatAnalysis};
-
-#[derive(Default)]
-pub struct Floatf;
-impl Floatf {
- pub fn new() -> Self {
- Self::default()
- }
-}
-impl Formatter for Floatf {
- fn get_primitive(
- &self,
- field: &FormatField,
- initial_prefix: &InitialPrefix,
- str_in: &str,
- ) -> Option<FormatPrimitive> {
- let second_field = field.second_field.unwrap_or(6) + 1;
- let analysis = FloatAnalysis::analyze(
- str_in,
- initial_prefix,
- None,
- Some(second_field as usize),
- false,
- );
- let f = get_primitive_dec(
- initial_prefix,
- &str_in[initial_prefix.offset..],
- &analysis,
- second_field as usize,
- None,
- );
- Some(f)
- }
- fn primitive_to_str(&self, prim: &FormatPrimitive, field: FormatField) -> String {
- primitive_to_str_common(prim, &field)
- }
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/intf.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/intf.rs
deleted file mode 100644
index 4364fd35181c50bd686238af3db076f91ec6852f..0000000000000000000000000000000000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/intf.rs
+++ /dev/null
@@ -1,281 +0,0 @@
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-// spell-checker:ignore (ToDO) arrnum
-
-//! formatter for unsigned and signed int subs
-//! unsigned int: %X %x (hex u64) %o (octal u64) %u (base ten u64)
-//! signed int: %i %d (both base ten i64)
-use super::super::format_field::FormatField;
-use super::super::formatter::{
- get_it_at, warn_incomplete_conv, Base, FormatPrimitive, Formatter, InitialPrefix,
-};
-use std::i64;
-use std::u64;
-
-#[derive(Default)]
-pub struct Intf {
- _a: u32,
-}
-
-// see the Intf::analyze() function below
-struct IntAnalysis {
- check_past_max: bool,
- past_max: bool,
- is_zero: bool,
- len_digits: u8,
-}
-
-impl Intf {
- pub fn new() -> Self {
- Self::default()
- }
- // take a ref to argument string, and basic information
- // about prefix (offset, radix, sign), and analyze string
- // to gain the IntAnalysis information above
- // check_past_max: true if the number *may* be above max,
- // but we don't know either way. One of several reasons
- // we may have to parse as int.
- // past_max: true if the object is past max, false if not
- // in the future we should probably combine these into an
- // Option<bool>
- // is_zero: true if number is zero, false otherwise
- // len_digits: length of digits used to create the int
- // important, for example, if we run into a non-valid character
- fn analyze(str_in: &str, signed_out: bool, initial_prefix: &InitialPrefix) -> IntAnalysis {
- // the maximum number of digits we could conceivably
- // have before the decimal point without exceeding the
- // max
- let mut str_it = get_it_at(initial_prefix.offset, str_in);
- let max_sd_in = if signed_out {
- match initial_prefix.radix_in {
- Base::Ten => 19,
- Base::Octal => 21,
- Base::Hex => 16,
- }
- } else {
- match initial_prefix.radix_in {
- Base::Ten => 20,
- Base::Octal => 22,
- Base::Hex => 16,
- }
- };
- let mut ret = IntAnalysis {
- check_past_max: false,
- past_max: false,
- is_zero: false,
- len_digits: 0,
- };
-
- // todo turn this to a while let now that we know
- // no special behavior on EOI break
- loop {
- let c_opt = str_it.next();
- if let Some(c) = c_opt {
- match c {
- '0'..='9' | 'a'..='f' | 'A'..='F' => {
- if ret.len_digits == 0 && c == '0' {
- ret.is_zero = true;
- } else if ret.is_zero {
- ret.is_zero = false;
- }
- ret.len_digits += 1;
- if ret.len_digits == max_sd_in {
- if let Some(next_ch) = str_it.next() {
- match next_ch {
- '0'..='9' => {
- ret.past_max = true;
- }
- _ => {
- // force conversion
- // to check if its above max.
- // todo: spin out convert
- // into fn, call it here to try
- // read val, on Ok()
- // save val for reuse later
- // that way on same-base in and out
- // we don't needlessly convert int
- // to str, we can just copy it over.
- ret.check_past_max = true;
- str_it.put_back(next_ch);
- }
- }
- if ret.past_max {
- break;
- }
- } else {
- ret.check_past_max = true;
- }
- }
- }
- _ => {
- warn_incomplete_conv(str_in);
- break;
- }
- }
- } else {
- // breaks on EOL
- break;
- }
- }
- ret
- }
- // get a FormatPrimitive of the maximum value for the field char
- // and given sign
- fn get_max(field_char: char, sign: i8) -> FormatPrimitive {
- let mut fmt_primitive = FormatPrimitive::default();
- fmt_primitive.pre_decimal = Some(String::from(match field_char {
- 'd' | 'i' => match sign {
- 1 => "9223372036854775807",
- _ => {
- fmt_primitive.prefix = Some(String::from("-"));
- "9223372036854775808"
- }
- },
- 'x' | 'X' => "ffffffffffffffff",
- 'o' => "1777777777777777777777",
- /* 'u' | */ _ => "18446744073709551615",
- }));
- fmt_primitive
- }
- // conv_from_segment contract:
- // 1. takes
- // - a string that begins with a non-zero digit, and proceeds
- // with zero or more following digits until the end of the string
- // - a radix to interpret those digits as
- // - a char that communicates:
- // whether to interpret+output the string as an i64 or u64
- // what radix to write the parsed number as.
- // 2. parses it as a rust integral type
- // 3. outputs FormatPrimitive with:
- // - if the string falls within bounds:
- // number parsed and written in the correct radix
- // - if the string falls outside bounds:
- // for i64 output, the int minimum or int max (depending on sign)
- // for u64 output, the u64 max in the output radix
- fn conv_from_segment(
- segment: &str,
- radix_in: Base,
- field_char: char,
- sign: i8,
- ) -> FormatPrimitive {
- match field_char {
- 'i' | 'd' => match i64::from_str_radix(segment, radix_in as u32) {
- Ok(i) => {
- let mut fmt_prim = FormatPrimitive::default();
- if sign == -1 {
- fmt_prim.prefix = Some(String::from("-"));
- }
- fmt_prim.pre_decimal = Some(format!("{}", i));
- fmt_prim
- }
- Err(_) => Self::get_max(field_char, sign),
- },
- _ => match u64::from_str_radix(segment, radix_in as u32) {
- Ok(u) => {
- let mut fmt_prim = FormatPrimitive::default();
- let u_f = if sign == -1 { u64::MAX - (u - 1) } else { u };
- fmt_prim.pre_decimal = Some(match field_char {
- 'X' => format!("{:X}", u_f),
- 'x' => format!("{:x}", u_f),
- 'o' => format!("{:o}", u_f),
- _ => format!("{}", u_f),
- });
- fmt_prim
- }
- Err(_) => Self::get_max(field_char, sign),
- },
- }
- }
-}
-impl Formatter for Intf {
- fn get_primitive(
- &self,
- field: &FormatField,
- initial_prefix: &InitialPrefix,
- str_in: &str,
- ) -> Option<FormatPrimitive> {
- let begin = initial_prefix.offset;
-
- // get information about the string. see Intf::Analyze
- // def above.
- let convert_hints = Self::analyze(
- str_in,
- *field.field_char == 'i' || *field.field_char == 'd',
- initial_prefix,
- );
- // We always will have a format primitive to return
- Some(if convert_hints.len_digits == 0 || convert_hints.is_zero {
- // if non-digit or end is reached before a non-zero digit
- FormatPrimitive {
- pre_decimal: Some(String::from("0")),
- ..Default::default()
- }
- } else if !convert_hints.past_max {
- // if the number is or may be below the bounds limit
- let radix_out = match *field.field_char {
- 'd' | 'i' | 'u' => Base::Ten,
- 'x' | 'X' => Base::Hex,
- /* 'o' | */ _ => Base::Octal,
- };
- let radix_mismatch = !radix_out.eq(&initial_prefix.radix_in);
- let decrease_from_max: bool = initial_prefix.sign == -1 && *field.field_char != 'i';
- let end = begin + convert_hints.len_digits as usize;
-
- // convert to int if any one of these is true:
- // - number of digits in int indicates it may be past max
- // - we're subtracting from the max
- // - we're converting the base
- if convert_hints.check_past_max || decrease_from_max || radix_mismatch {
- // radix of in and out is the same.
- let segment = String::from(&str_in[begin..end]);
- Self::conv_from_segment(
- &segment,
- initial_prefix.radix_in.clone(),
- *field.field_char,
- initial_prefix.sign,
- )
- } else {
- // otherwise just do a straight string copy.
- let mut fmt_prim = FormatPrimitive::default();
-
- // this is here and not earlier because
- // zero doesn't get a sign, and conv_from_segment
- // creates its format primitive separately
- if initial_prefix.sign == -1 && *field.field_char == 'i' {
- fmt_prim.prefix = Some(String::from("-"));
- }
- fmt_prim.pre_decimal = Some(String::from(&str_in[begin..end]));
- fmt_prim
- }
- } else {
- Self::get_max(*field.field_char, initial_prefix.sign)
- })
- }
- fn primitive_to_str(&self, prim: &FormatPrimitive, field: FormatField) -> String {
- let mut final_str: String = String::new();
- if let Some(ref prefix) = prim.prefix {
- final_str.push_str(prefix);
- }
- // integral second fields is zero-padded minimum-width
- // which gets handled before general minimum-width
- match prim.pre_decimal {
- Some(ref pre_decimal) => {
- if let Some(min) = field.second_field {
- let mut i = min;
- let len = pre_decimal.len() as u32;
- while i > len {
- final_str.push('0');
- i -= 1;
- }
- }
- final_str.push_str(pre_decimal);
- }
- None => {
- panic!(
- "error, format primitives provided to int, will, incidentally under \
- correct behavior, always have a pre_dec value."
- );
- }
- }
- final_str
- }
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/mod.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/mod.rs
deleted file mode 100644
index e232300718bc22c4ab52fdbbb00dec73a58fc904..0000000000000000000000000000000000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/mod.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-// spell-checker:ignore (vars) charf cninetyninehexfloatf decf floatf intf scif strf Cninety
-
-mod base_conv;
-pub mod cninetyninehexfloatf;
-pub mod decf;
-mod float_common;
-pub mod floatf;
-pub mod intf;
-pub mod scif;
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/scif.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/scif.rs
deleted file mode 100644
index c5b88b5a7f2999cfef50bc65cd7cf243025757ed..0000000000000000000000000000000000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/scif.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-// spell-checker:ignore (vars) charf cninetyninehexfloatf decf floatf intf scif strf Cninety
-
-//! formatter for %e %E scientific notation subs
-use super::super::format_field::FormatField;
-use super::super::formatter::{FormatPrimitive, Formatter, InitialPrefix};
-use super::float_common::{get_primitive_dec, primitive_to_str_common, FloatAnalysis};
-
-#[derive(Default)]
-pub struct Scif;
-
-impl Scif {
- pub fn new() -> Self {
- Self::default()
- }
-}
-impl Formatter for Scif {
- fn get_primitive(
- &self,
- field: &FormatField,
- initial_prefix: &InitialPrefix,
- str_in: &str,
- ) -> Option<FormatPrimitive> {
- let second_field = field.second_field.unwrap_or(6) + 1;
- let analysis = FloatAnalysis::analyze(
- str_in,
- initial_prefix,
- Some(second_field as usize + 1),
- None,
- false,
- );
- let f = get_primitive_dec(
- initial_prefix,
- &str_in[initial_prefix.offset..],
- &analysis,
- second_field as usize,
- Some(*field.field_char == 'E'),
- );
- Some(f)
- }
- fn primitive_to_str(&self, prim: &FormatPrimitive, field: FormatField) -> String {
- primitive_to_str_common(prim, &field)
- }
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/mod.rs b/src/uucore/src/lib/features/tokenize/num_format/mod.rs
deleted file mode 100644
index d40cf92defff35a134bc9381a13140e9de4e2e3e..0000000000000000000000000000000000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-pub mod format_field;
-mod formatter;
-mod formatters;
-pub mod num_format;
diff --git a/src/uucore/src/lib/features/tokenize/num_format/num_format.rs b/src/uucore/src/lib/features/tokenize/num_format/num_format.rs
deleted file mode 100644
index dd3655200ca528b18f35c87a082cb5372125367b..0000000000000000000000000000000000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/num_format.rs
+++ /dev/null
@@ -1,270 +0,0 @@
-// spell-checker:ignore (vars) charf cninetyninehexfloatf decf floatf intf scif strf Cninety
-
-//! handles creating printed output for numeric substitutions
-
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-
-use std::env;
-use std::vec::Vec;
-
-use crate::display::Quotable;
-use crate::{show_error, show_warning};
-
-use super::format_field::{FieldType, FormatField};
-use super::formatter::{Base, FormatPrimitive, Formatter, InitialPrefix};
-use super::formatters::cninetyninehexfloatf::CninetyNineHexFloatf;
-use super::formatters::decf::Decf;
-use super::formatters::floatf::Floatf;
-use super::formatters::intf::Intf;
-use super::formatters::scif::Scif;
-
-pub fn warn_expected_numeric(pf_arg: &str) {
- // important: keep println here not print
- show_error!("{}: expected a numeric value", pf_arg.maybe_quote());
-}
-
-// when character constant arguments have excess characters
-// issue a warning when POSIXLY_CORRECT is not set
-fn warn_char_constant_ign(remaining_bytes: &[u8]) {
- match env::var("POSIXLY_CORRECT") {
- Ok(_) => {}
- Err(e) => {
- if let env::VarError::NotPresent = e {
- show_warning!(
- "{:?}: character(s) following character \
- constant have been ignored",
- remaining_bytes
- );
- }
- }
- }
-}
-
-// this function looks at the first few
-// characters of an argument and returns a value if we can learn
-// a value from that (e.g. no argument? return 0, char constant? ret value)
-fn get_provided(str_in_opt: Option<&String>) -> Option<u8> {
- const C_S_QUOTE: u8 = 39;
- const C_D_QUOTE: u8 = 34;
- match str_in_opt {
- Some(str_in) => {
- let mut byte_it = str_in.bytes();
- if let Some(ch) = byte_it.next() {
- match ch {
- C_S_QUOTE | C_D_QUOTE => {
- Some(match byte_it.next() {
- Some(second_byte) => {
- let mut ignored: Vec<u8> = Vec::new();
- for cont in byte_it {
- ignored.push(cont);
- }
- if !ignored.is_empty() {
- warn_char_constant_ign(&ignored);
- }
- second_byte
- }
- // no byte after quote
- None => {
- let so_far = (ch as char).to_string();
- warn_expected_numeric(&so_far);
- 0_u8
- }
- })
- }
- // first byte is not quote
- _ => None, // no first byte
- }
- } else {
- Some(0_u8)
- }
- }
- None => Some(0),
- }
-}
-
-// takes a string and returns
-// a sign,
-// a base,
-// and an offset for index after all
-// initial spacing, sign, base prefix, and leading zeroes
-fn get_initial_prefix(str_in: &str, field_type: &FieldType) -> InitialPrefix {
- let mut str_it = str_in.chars();
- let mut ret = InitialPrefix {
- radix_in: Base::Ten,
- sign: 1,
- offset: 0,
- };
- let mut top_char = str_it.next();
- // skip spaces and ensure top_char is the first non-space char
- // (or None if none exists)
- while let Some(' ') = top_char {
- ret.offset += 1;
- top_char = str_it.next();
- }
- // parse sign
- match top_char {
- Some('+') => {
- ret.offset += 1;
- top_char = str_it.next();
- }
- Some('-') => {
- ret.sign = -1;
- ret.offset += 1;
- top_char = str_it.next();
- }
- _ => {}
- }
- // we want to exit with offset being
- // the index of the first non-zero
- // digit before the decimal point or
- // if there is none, the zero before the
- // decimal point, or, if there is none,
- // the decimal point.
-
- // while we are determining the offset
- // we will ensure as a convention
- // the offset is always on the first character
- // that we are yet unsure if it is the
- // final offset. If the zero could be before
- // a decimal point we don't move past the zero.
- let mut is_hex = false;
- if Some('0') == top_char {
- if let Some(base) = str_it.next() {
- // lead zeroes can only exist in
- // octal and hex base
- let mut do_clean_lead_zeroes = false;
- match base {
- 'x' | 'X' => {
- is_hex = true;
- ret.offset += 2;
- ret.radix_in = Base::Hex;
- do_clean_lead_zeroes = true;
- }
- e @ '0'..='9' => {
- ret.offset += 1;
- if let FieldType::Intf = *field_type {
- ret.radix_in = Base::Octal;
- }
- if e == '0' {
- do_clean_lead_zeroes = true;
- }
- }
- _ => {}
- }
- if do_clean_lead_zeroes {
- let mut first = true;
- for ch_zero in str_it {
- // see notes on offset above:
- // this is why the offset for octal and decimal numbers
- // that reach this branch is 1 even though
- // they have already eaten the characters '00'
- // this is also why when hex encounters its
- // first zero it does not move its offset
- // forward because it does not know for sure
- // that it's current offset (of that zero)
- // is not the final offset,
- // whereas at that point octal knows its
- // current offset is not the final offset.
- match ch_zero {
- '0' => {
- if !(is_hex && first) {
- ret.offset += 1;
- }
- }
- // if decimal, keep last zero if one exists
- // (it's possible for last zero to
- // not exist at this branch if we're in hex input)
- '.' => break,
- // other digit, etc.
- _ => {
- if !(is_hex && first) {
- ret.offset += 1;
- }
- break;
- }
- }
- if first {
- first = false;
- }
- }
- }
- }
- }
- ret
-}
-
-// this is the function a Sub's print will delegate to
-// if it is a numeric field, passing the field details
-// and an iterator to the argument
-pub fn num_format(field: &FormatField, in_str_opt: Option<&String>) -> Option<String> {
- let field_char = field.field_char;
-
- // num format mainly operates by further delegating to one of
- // several Formatter structs depending on the field
- // see formatter.rs for more details
-
- // to do switch to static dispatch
- let formatter: Box<dyn Formatter> = match *field.field_type {
- FieldType::Intf => Box::new(Intf::new()),
- FieldType::Floatf => Box::new(Floatf::new()),
- FieldType::CninetyNineHexFloatf => Box::new(CninetyNineHexFloatf::new()),
- FieldType::Scif => Box::new(Scif::new()),
- FieldType::Decf => Box::new(Decf::new()),
- _ => {
- panic!("asked to do num format with non-num field type");
- }
- };
- let prim_opt=
- // if we can get an assumed value from looking at the first
- // few characters, use that value to create the FormatPrimitive
- if let Some(provided_num) = get_provided(in_str_opt) {
- let mut tmp = FormatPrimitive::default();
- match field_char {
- 'u' | 'i' | 'd' => {
- tmp.pre_decimal = Some(
- format!("{}", provided_num));
- },
- 'x' | 'X' => {
- tmp.pre_decimal = Some(
- format!("{:x}", provided_num));
- },
- 'o' => {
- tmp.pre_decimal = Some(
- format!("{:o}", provided_num));
- },
- 'e' | 'E' | 'g' | 'G' => {
- let as_str = format!("{}", provided_num);
- let initial_prefix = get_initial_prefix(
- &as_str,
- field.field_type
- );
- tmp=formatter.get_primitive(field, &initial_prefix, &as_str)
- .expect("err during default provided num");
- },
- _ => {
- tmp.pre_decimal = Some(
- format!("{}", provided_num));
- tmp.post_decimal = Some(String::from("0"));
- }
- }
- Some(tmp)
- } else {
- // otherwise we'll interpret the argument as a number
- // using the appropriate Formatter
- let in_str = in_str_opt.expect(
- "please send the devs this message:
- \n get_provided is failing to ret as Some(0) on no str ");
- // first get information about the beginning of the
- // numeric argument that would be useful for
- // any formatter (int or float)
- let initial_prefix = get_initial_prefix(
- in_str,
- field.field_type
- );
- // then get the FormatPrimitive from the Formatter
- formatter.get_primitive(field, &initial_prefix, in_str)
- };
- // if we have a formatPrimitive, print its results
- // according to the field-char appropriate Formatter
- prim_opt.map(|prim| formatter.primitive_to_str(&prim, field.clone()))
-}
diff --git a/src/uucore/src/lib/features/tokenize/sub.rs b/src/uucore/src/lib/features/tokenize/sub.rs
deleted file mode 100644
index 00fd51efd46881e365679310ae8742264625ac0e..0000000000000000000000000000000000000000
--- a/src/uucore/src/lib/features/tokenize/sub.rs
+++ /dev/null
@@ -1,450 +0,0 @@
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-
-//! Sub is a token that represents a
-//! segment of the format string that is a substitution
-//! it is created by Sub's implementation of the Tokenizer trait
-//! Subs which have numeric field chars make use of the num_format
-//! submodule
-use crate::error::{UError, UResult};
-use itertools::{put_back_n, PutBackN};
-use std::error::Error;
-use std::fmt::Display;
-use std::io::Write;
-use std::iter::Peekable;
-use std::process::exit;
-use std::slice::Iter;
-use std::str::Chars;
-// use std::collections::HashSet;
-
-use super::num_format::format_field::{FieldType, FormatField};
-use super::num_format::num_format;
-use super::token;
-use super::unescaped_text::UnescapedText;
-
-const EXIT_ERR: i32 = 1;
-
-#[derive(Debug)]
-pub enum SubError {
- InvalidSpec(String),
-}
-
-impl Display for SubError {
- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
- match self {
- Self::InvalidSpec(s) => write!(f, "%{}: invalid conversion specification", s),
- }
- }
-}
-
-impl Error for SubError {}
-
-impl UError for SubError {}
-
-fn convert_asterisk_arg_int(asterisk_arg: &str) -> isize {
- // this is a costly way to parse the
- // args used for asterisk values into integers
- // from various bases. Actually doing it correctly
- // (going through the pipeline to intf, but returning
- // the integer instead of writing it to string and then
- // back) is on the refactoring TODO
- let field_type = FieldType::Intf;
- let field_char = 'i';
- let field_info = FormatField {
- min_width: Some(0),
- second_field: Some(0),
- orig: &asterisk_arg.to_string(),
- field_type: &field_type,
- field_char: &field_char,
- };
- num_format::num_format(&field_info, Some(&asterisk_arg.to_string()))
- .unwrap()
- .parse::<isize>()
- .unwrap()
-}
-
-pub enum CanAsterisk<T> {
- Fixed(T),
- Asterisk,
-}
-
-// Sub is a tokenizer which creates tokens
-// for substitution segments of a format string
-pub struct Sub {
- min_width: CanAsterisk<Option<isize>>,
- second_field: CanAsterisk<Option<u32>>,
- field_char: char,
- field_type: FieldType,
- orig: String,
- prefix_char: char,
-}
-impl Sub {
- pub fn new(
- min_width: CanAsterisk<Option<isize>>,
- second_field: CanAsterisk<Option<u32>>,
- field_char: char,
- orig: String,
- prefix_char: char,
- ) -> Self {
- // for more dry printing, field characters are grouped
- // in initialization of token.
- let field_type = match field_char {
- 's' | 'b' => FieldType::Strf,
- 'd' | 'i' | 'u' | 'o' | 'x' | 'X' => FieldType::Intf,
- 'f' | 'F' => FieldType::Floatf,
- 'a' | 'A' => FieldType::CninetyNineHexFloatf,
- 'e' | 'E' => FieldType::Scif,
- 'g' | 'G' => FieldType::Decf,
- 'c' => FieldType::Charf,
- _ => {
- // should be unreachable.
- println!("Invalid field type");
- exit(EXIT_ERR);
- }
- };
- Self {
- min_width,
- second_field,
- field_char,
- field_type,
- orig,
- prefix_char,
- }
- }
-}
-
-#[derive(Default)]
-pub(crate) struct SubParser {
- min_width_tmp: Option<String>,
- min_width_is_asterisk: bool,
- past_decimal: bool,
- second_field_tmp: Option<String>,
- second_field_is_asterisk: bool,
- specifiers_found: bool,
- field_char: Option<char>,
- text_so_far: String,
-}
-
-impl SubParser {
- fn new() -> Self {
- Self::default()
- }
- pub(crate) fn from_it<W>(
- writer: &mut W,
- it: &mut PutBackN<Chars>,
- args: &mut Peekable<Iter<String>>,
- ) -> UResult<Option<token::Token>>
- where
- W: Write,
- {
- let mut parser = Self::new();
- if parser.sub_vals_retrieved(it)? {
- let t = Self::build_token(parser);
- t.write(writer, args);
- Ok(Some(t))
- } else {
- Ok(None)
- }
- }
- fn build_token(parser: Self) -> token::Token {
- // not a self method so as to allow move of sub-parser vals.
- // return new Sub struct as token
- let prefix_char = match &parser.min_width_tmp {
- Some(width) if width.starts_with('0') => '0',
- _ => ' ',
- };
-
- token::Token::Sub(Sub::new(
- if parser.min_width_is_asterisk {
- CanAsterisk::Asterisk
- } else {
- CanAsterisk::Fixed(
- parser
- .min_width_tmp
- .map(|x| x.parse::<isize>().unwrap_or(1)),
- )
- },
- if parser.second_field_is_asterisk {
- CanAsterisk::Asterisk
- } else {
- CanAsterisk::Fixed(parser.second_field_tmp.map(|x| x.parse::<u32>().unwrap()))
- },
- parser.field_char.unwrap(),
- parser.text_so_far,
- prefix_char,
- ))
- }
- fn sub_vals_retrieved(&mut self, it: &mut PutBackN<Chars>) -> UResult<bool> {
- if !Self::successfully_eat_prefix(it, &mut self.text_so_far)? {
- return Ok(false);
- }
- // this fn in particular is much longer than it needs to be
- // .could get a lot
- // of code savings just by cleaning it up. shouldn't use a regex
- // though, as we want to mimic the original behavior of printing
- // the field as interpreted up until the error in the field.
-
- let mut legal_fields = vec![
- // 'a', 'A', //c99 hex float implementation not yet complete
- 'b', 'c', 'd', 'e', 'E', 'f', 'F', 'g', 'G', 'i', 'o', 's', 'u', 'x', 'X',
- ];
- let mut specifiers = vec!['h', 'j', 'l', 'L', 't', 'z'];
- legal_fields.sort_unstable();
- specifiers.sort_unstable();
-
- // divide substitution from %([0-9]+)?(.[0-9+])?([a-zA-Z])
- // into min_width, second_field, field_char
- for ch in it {
- self.text_so_far.push(ch);
- match ch {
- '-' | '*' | '0'..='9' => {
- if !self.past_decimal {
- if self.min_width_is_asterisk || self.specifiers_found {
- return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
- }
- if self.min_width_tmp.is_none() {
- self.min_width_tmp = Some(String::new());
- }
- match self.min_width_tmp.as_mut() {
- Some(x) => {
- if (ch == '-' || ch == '*') && !x.is_empty() {
- return Err(
- SubError::InvalidSpec(self.text_so_far.clone()).into()
- );
- }
- if ch == '*' {
- self.min_width_is_asterisk = true;
- }
- x.push(ch);
- }
- None => {
- panic!("should be unreachable");
- }
- }
- } else {
- // second field should never have a
- // negative value
- if self.second_field_is_asterisk || ch == '-' || self.specifiers_found {
- return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
- }
- if self.second_field_tmp.is_none() {
- self.second_field_tmp = Some(String::new());
- }
- match self.second_field_tmp.as_mut() {
- Some(x) => {
- if ch == '*' && !x.is_empty() {
- return Err(
- SubError::InvalidSpec(self.text_so_far.clone()).into()
- );
- }
- if ch == '*' {
- self.second_field_is_asterisk = true;
- }
- x.push(ch);
- }
- None => {
- panic!("should be unreachable");
- }
- }
- }
- }
- '.' => {
- if !self.past_decimal {
- self.past_decimal = true;
- } else {
- return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
- }
- }
- x if legal_fields.binary_search(&x).is_ok() => {
- self.field_char = Some(ch);
- self.text_so_far.push(ch);
- break;
- }
- x if specifiers.binary_search(&x).is_ok() => {
- if !self.past_decimal {
- self.past_decimal = true;
- }
- if !self.specifiers_found {
- self.specifiers_found = true;
- }
- }
- _ => {
- return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
- }
- }
- }
- if self.field_char.is_none() {
- return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
- }
- let field_char_retrieved = self.field_char.unwrap();
- if self.past_decimal && self.second_field_tmp.is_none() {
- self.second_field_tmp = Some(String::from("0"));
- }
- self.validate_field_params(field_char_retrieved)?;
- // if the dot is provided without a second field
- // printf interprets it as 0.
- if let Some(x) = self.second_field_tmp.as_mut() {
- if x.is_empty() {
- self.min_width_tmp = Some(String::from("0"));
- }
- }
-
- Ok(true)
- }
- fn successfully_eat_prefix(
- it: &mut PutBackN<Chars>,
- text_so_far: &mut String,
- ) -> UResult<bool> {
- // get next two chars,
- // if they're '%%' we're not tokenizing it
- // else put chars back
- let preface = it.next();
- let n_ch = it.next();
- if preface == Some('%') && n_ch != Some('%') {
- match n_ch {
- Some(x) => {
- it.put_back(x);
- Ok(true)
- }
- None => {
- text_so_far.push('%');
- Err(SubError::InvalidSpec(text_so_far.clone()).into())
- }
- }
- } else {
- if let Some(x) = n_ch {
- it.put_back(x);
- };
- if let Some(x) = preface {
- it.put_back(x);
- };
- Ok(false)
- }
- }
- fn validate_field_params(&self, field_char: char) -> UResult<()> {
- // check for illegal combinations here when possible vs
- // on each application so we check less per application
- // to do: move these checks to Sub::new
- if (field_char == 's' && self.min_width_tmp == Some(String::from("0")))
- || (field_char == 'c'
- && (self.min_width_tmp == Some(String::from("0")) || self.past_decimal))
- || (field_char == 'b'
- && (self.min_width_tmp.is_some()
- || self.past_decimal
- || self.second_field_tmp.is_some()))
- {
- // invalid string substitution
- // to do: include information about an invalid
- // string substitution
- return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
- }
- Ok(())
- }
-}
-
-impl Sub {
- pub(crate) fn write<W>(&self, writer: &mut W, pf_args_it: &mut Peekable<Iter<String>>)
- where
- W: Write,
- {
- let field = FormatField {
- min_width: match self.min_width {
- CanAsterisk::Fixed(x) => x,
- CanAsterisk::Asterisk => {
- match pf_args_it.next() {
- // temporary, use intf.rs instead
- Some(x) => Some(convert_asterisk_arg_int(x)),
- None => Some(0),
- }
- }
- },
- second_field: match self.second_field {
- CanAsterisk::Fixed(x) => x,
- CanAsterisk::Asterisk => {
- match pf_args_it.next() {
- // temporary, use intf.rs instead
- Some(x) => {
- let result = convert_asterisk_arg_int(x);
- if result < 0 {
- None
- } else {
- Some(result as u32)
- }
- }
- None => Some(0),
- }
- }
- },
- field_char: &self.field_char,
- field_type: &self.field_type,
- orig: &self.orig,
- };
- let pf_arg = pf_args_it.next();
-
- // minimum width is handled independently of actual
- // field char
- let pre_min_width_opt: Option<String> = match *field.field_type {
- // if %s just return arg
- // if %b use UnescapedText module's unescape-fn
- // if %c return first char of arg
- FieldType::Strf | FieldType::Charf => {
- match pf_arg {
- Some(arg_string) => {
- match *field.field_char {
- 's' => Some(match field.second_field {
- Some(max) => String::from(&arg_string[..max as usize]),
- None => arg_string.clone(),
- }),
- 'b' => {
- let mut a_it = put_back_n(arg_string.chars());
- UnescapedText::from_it_core(writer, &mut a_it, true);
- None
- }
- // for 'c': get iter of string vals,
- // get opt<char> of first val
- // and map it to opt<String>
- /* 'c' | */
- _ => arg_string.chars().next().map(|x| x.to_string()),
- }
- }
- None => None,
- }
- }
- _ => {
- // non string/char fields are delegated to num_format
- num_format::num_format(&field, pf_arg)
- }
- };
- if let Some(pre_min_width) = pre_min_width_opt {
- // if have a string, print it, ensuring minimum width is met.
- write!(
- writer,
- "{}",
- match field.min_width {
- Some(min_width) => {
- let diff: isize = min_width.abs() - pre_min_width.len() as isize;
- if diff > 0 {
- let mut final_str = String::new();
- // definitely more efficient ways
- // to do this.
- let pad_before = min_width > 0;
- if !pad_before {
- final_str.push_str(&pre_min_width);
- }
- for _ in 0..diff {
- final_str.push(self.prefix_char);
- }
- if pad_before {
- final_str.push_str(&pre_min_width);
- }
- final_str
- } else {
- pre_min_width
- }
- }
- None => pre_min_width,
- }
- )
- .ok();
- }
- }
-}
diff --git a/src/uucore/src/lib/features/tokenize/token.rs b/src/uucore/src/lib/features/tokenize/token.rs
deleted file mode 100644
index b522c99a4e057fd1b99139dc01621b48842a549a..0000000000000000000000000000000000000000
--- a/src/uucore/src/lib/features/tokenize/token.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//! Traits and enums dealing with Tokenization of printf Format String
-use std::io::Write;
-use std::iter::Peekable;
-use std::slice::Iter;
-
-use crate::features::tokenize::sub::Sub;
-use crate::features::tokenize::unescaped_text::UnescapedText;
-
-// A token object is an object that can print the expected output
-// of a contiguous segment of the format string, and
-// requires at most 1 argument
-pub enum Token {
- Sub(Sub),
- UnescapedText(UnescapedText),
-}
-
-impl Token {
- pub(crate) fn write<W>(&self, writer: &mut W, args: &mut Peekable<Iter<String>>)
- where
- W: Write,
- {
- match self {
- Self::Sub(sub) => sub.write(writer, args),
- Self::UnescapedText(unescaped_text) => unescaped_text.write(writer),
- }
- }
-}
-
-// A tokenizer object is an object that takes an iterator
-// at a position in a format string, and sees whether
-// it can return a token of a type it knows how to produce
-// if so, return the token, move the iterator past the
-// format string text the token represents, and if an
-// argument is used move the argument iter forward one
-
-// creating token of a format string segment should also cause
-// printing of that token's value. Essentially tokenizing
-// a whole format string will print the format string and consume
-// a number of arguments equal to the number of argument-using tokens
diff --git a/src/uucore/src/lib/features/tokenize/unescaped_text.rs b/src/uucore/src/lib/features/tokenize/unescaped_text.rs
deleted file mode 100644
index 59624f14371c237fd5afdc183f85d256e4c5869d..0000000000000000000000000000000000000000
--- a/src/uucore/src/lib/features/tokenize/unescaped_text.rs
+++ /dev/null
@@ -1,281 +0,0 @@
-//! UnescapedText is a tokenizer impl
-//! for tokenizing character literals,
-//! and escaped character literals (of allowed escapes),
-//! into an unescaped text byte array
-
-// spell-checker:ignore (ToDO) retval hexchars octals printf's bvec vals coreutil addchar eval bytecode bslice
-
-use itertools::PutBackN;
-use std::char::from_u32;
-use std::io::Write;
-use std::process::exit;
-use std::str::Chars;
-
-use super::token;
-
-const EXIT_OK: i32 = 0;
-const EXIT_ERR: i32 = 1;
-
-// by default stdout only flushes
-// to console when a newline is passed.
-macro_rules! write_and_flush {
- ($writer:expr, $($args:tt)+) => ({
- write!($writer, "{}", $($args)+).ok();
- $writer.flush().ok();
- })
-}
-
-fn flush_bytes<W>(writer: &mut W, bslice: &[u8])
-where
- W: Write,
-{
- writer.write_all(bslice).ok();
- writer.flush().ok();
-}
-
-#[derive(Default)]
-pub struct UnescapedText(Vec<u8>);
-impl UnescapedText {
- fn new() -> Self {
- Self::default()
- }
- // take an iterator to the format string
- // consume between min and max chars
- // and return it as a base-X number
- fn base_to_u32(min_chars: u8, max_chars: u8, base: u32, it: &mut PutBackN<Chars>) -> u32 {
- let mut retval: u32 = 0;
- let mut found = 0;
- while found < max_chars {
- // if end of input break
- let nc = it.next();
- match nc {
- Some(digit) => {
- // if end of hexchars break
- match digit.to_digit(base) {
- Some(d) => {
- found += 1;
- retval *= base;
- retval += d;
- }
- None => {
- it.put_back(digit);
- break;
- }
- }
- }
- None => {
- break;
- }
- }
- }
- if found < min_chars {
- // only ever expected for hex
- println!("missing hexadecimal number in escape"); //todo stderr
- exit(EXIT_ERR);
- }
- retval
- }
- // validates against valid
- // IEC 10646 vals - these values
- // are pinned against the more popular
- // printf so as to not disrupt when
- // dropped-in as a replacement.
- fn validate_iec(val: u32, eight_word: bool) {
- let mut preface = 'u';
- let leading_zeros = if eight_word {
- preface = 'U';
- 8
- } else {
- 4
- };
- let err_msg = format!(
- "invalid universal character name {0}{1:02$x}",
- preface, val, leading_zeros
- );
- if (val < 159 && (val != 36 && val != 64 && val != 96)) || (val > 55296 && val < 57343) {
- println!("{}", err_msg); //todo stderr
- exit(EXIT_ERR);
- }
- }
- // pass an iterator that succeeds an '/',
- // and process the remaining character
- // adding the unescaped bytes
- // to the passed byte_vec
- // in subs_mode change octal behavior
- fn handle_escaped<W>(
- writer: &mut W,
- byte_vec: &mut Vec<u8>,
- it: &mut PutBackN<Chars>,
- subs_mode: bool,
- ) where
- W: Write,
- {
- let ch = it.next().unwrap_or('\\');
- match ch {
- '0'..='9' | 'x' => {
- let min_len = 1;
- let mut max_len = 2;
- let mut base = 16;
- let ignore = false;
- match ch {
- 'x' => {}
- e @ '0'..='9' => {
- max_len = 3;
- base = 8;
- // in practice, gnu coreutils printf
- // interprets octals without a
- // leading zero in %b
- // but it only skips leading zeros
- // in %b mode.
- // if we ever want to match gnu coreutil
- // printf's docs instead of its behavior
- // we'd set this to true.
- // if subs_mode && e != '0'
- // { ignore = true; }
- if !subs_mode || e != '0' {
- it.put_back(ch);
- }
- }
- _ => {}
- }
- if !ignore {
- let val = (Self::base_to_u32(min_len, max_len, base, it) % 256) as u8;
- byte_vec.push(val);
- let bvec = [val];
- flush_bytes(writer, &bvec);
- } else {
- byte_vec.push(ch as u8);
- }
- }
- e => {
- // only for hex and octal
- // is byte encoding specified.
- // otherwise, why not leave the door open
- // for other encodings unless it turns out
- // a bottleneck.
- let mut s = String::new();
- let ch = match e {
- '\\' => '\\',
- '"' => '"',
- 'n' => '\n',
- 'r' => '\r',
- 't' => '\t',
- // bell
- 'a' => '\x07',
- // backspace
- 'b' => '\x08',
- // vertical tab
- 'v' => '\x0B',
- // form feed
- 'f' => '\x0C',
- // escape character
- 'e' => '\x1B',
- 'c' => exit(EXIT_OK),
- 'u' | 'U' => {
- let len = match e {
- 'u' => 4,
- /* 'U' | */ _ => 8,
- };
- let val = Self::base_to_u32(len, len, 16, it);
- Self::validate_iec(val, false);
- if let Some(c) = from_u32(val) {
- c
- } else {
- '-'
- }
- }
- _ => {
- s.push('\\');
- ch
- }
- };
- s.push(ch);
- write_and_flush!(writer, &s);
- byte_vec.extend(s.bytes());
- }
- };
- }
-
- // take an iterator to a string,
- // and return a wrapper around a Vec<u8> of unescaped bytes
- // break on encounter of sub symbol ('%[^%]') unless called
- // through %b subst.
- pub fn from_it_core<W>(
- writer: &mut W,
- it: &mut PutBackN<Chars>,
- subs_mode: bool,
- ) -> Option<token::Token>
- where
- W: Write,
- {
- let mut addchar = false;
- let mut new_text = Self::new();
- let mut tmp_str = String::new();
- {
- let new_vec: &mut Vec<u8> = &mut (new_text.0);
- while let Some(ch) = it.next() {
- if !addchar {
- addchar = true;
- }
- match ch {
- x if x != '\\' && x != '%' => {
- // lazy branch eval
- // remember this fn could be called
- // many times in a single exec through %b
- write_and_flush!(writer, ch);
- tmp_str.push(ch);
- }
- '\\' => {
- // the literal may be a literal bytecode
- // and not valid utf-8. Str only supports
- // valid utf-8.
- // if we find the unnecessary drain
- // on non hex or octal escapes is costly
- // then we can make it faster/more complex
- // with as-necessary draining.
- if !tmp_str.is_empty() {
- new_vec.extend(tmp_str.bytes());
- tmp_str = String::new();
- }
- Self::handle_escaped(writer, new_vec, it, subs_mode);
- }
- x if x == '%' && !subs_mode => {
- if let Some(follow) = it.next() {
- if follow == '%' {
- write_and_flush!(writer, ch);
- tmp_str.push(ch);
- } else {
- it.put_back(follow);
- it.put_back(ch);
- break;
- }
- } else {
- it.put_back(ch);
- break;
- }
- }
- _ => {
- write_and_flush!(writer, ch);
- tmp_str.push(ch);
- }
- }
- }
- if !tmp_str.is_empty() {
- new_vec.extend(tmp_str.bytes());
- }
- }
- if addchar {
- Some(token::Token::UnescapedText(new_text))
- } else {
- None
- }
- }
-}
-impl UnescapedText {
- pub(crate) fn write<W>(&self, writer: &mut W)
- where
- W: Write,
- {
- flush_bytes(writer, &self.0[..]);
- }
-}
diff --git a/src/uucore/src/lib/features/update_control.rs b/src/uucore/src/lib/features/update_control.rs
new file mode 100644
index 0000000000000000000000000000000000000000..83700e5512f038ae8675ccd83f930a5eb07c826c
--- /dev/null
+++ b/src/uucore/src/lib/features/update_control.rs
@@ -0,0 +1,138 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! Implement GNU-style update functionality.
+//!
+//! - pre-defined [`clap`-Arguments][1] for inclusion in utilities that
+//! implement updates
+//! - determination of the [update mode][2]
+//!
+//! Update-functionality is implemented by the following utilities:
+//!
+//! - `cp`
+//! - `mv`
+//!
+//!
+//! [1]: arguments
+//! [2]: `determine_update_mode()`
+//!
+//!
+//! # Usage example
+//!
+//! ```
+//! #[macro_use]
+//! extern crate uucore;
+//!
+//! use clap::{Command, Arg, ArgMatches};
+//! use uucore::update_control::{self, UpdateMode};
+//!
+//! fn main() {
+//! let matches = Command::new("command")
+//! .arg(update_control::arguments::update())
+//! .arg(update_control::arguments::update_no_args())
+//! .get_matches_from(vec![
+//! "command", "--update=older"
+//! ]);
+//!
+//! let update_mode = update_control::determine_update_mode(&matches);
+//!
+//! // handle cases
+//! if update_mode == UpdateMode::ReplaceIfOlder {
+//! // do
+//! } else {
+//! unreachable!()
+//! }
+//! }
+//! ```
+use clap::ArgMatches;
+
+// Available update mode
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum UpdateMode {
+ // --update=`all`, ``
+ ReplaceAll,
+ // --update=`none`
+ ReplaceNone,
+ // --update=`older`
+ // -u
+ ReplaceIfOlder,
+}
+
+pub mod arguments {
+ use crate::shortcut_value_parser::ShortcutValueParser;
+ use clap::ArgAction;
+
+ pub static OPT_UPDATE: &str = "update";
+ pub static OPT_UPDATE_NO_ARG: &str = "u";
+
+ // `--update` argument, defaults to `older` if no values are provided
+ pub fn update() -> clap::Arg {
+ clap::Arg::new(OPT_UPDATE)
+ .long("update")
+ .help("move only when the SOURCE file is newer than the destination file or when the destination file is missing")
+ .value_parser(ShortcutValueParser::new(["none", "all", "older"]))
+ .num_args(0..=1)
+ .default_missing_value("older")
+ .require_equals(true)
+ .overrides_with("update")
+ .action(clap::ArgAction::Set)
+ }
+
+ // `-u` argument
+ pub fn update_no_args() -> clap::Arg {
+ clap::Arg::new(OPT_UPDATE_NO_ARG)
+ .short('u')
+ .help("like --update but does not accept an argument")
+ .action(ArgAction::SetTrue)
+ }
+}
+
+/// Determine the "mode" for the update operation to perform, if any.
+///
+/// Parses the backup options and converts them to an instance of
+/// `UpdateMode` for further processing.
+///
+/// Takes [`clap::ArgMatches`] as argument which **must** contain the options
+/// from [`arguments::update()`] or [`arguments::update_no_args()`]. Otherwise
+/// the `ReplaceAll` mode is returned unconditionally.
+///
+/// # Examples
+///
+/// Here's how one would integrate the update mode determination into an
+/// application.
+///
+/// ```
+/// #[macro_use]
+/// extern crate uucore;
+/// use uucore::update_control::{self, UpdateMode};
+/// use clap::{Command, Arg, ArgMatches};
+///
+/// fn main() {
+/// let matches = Command::new("command")
+/// .arg(update_control::arguments::update())
+/// .arg(update_control::arguments::update_no_args())
+/// .get_matches_from(vec![
+/// "command", "--update=all"
+/// ]);
+///
+/// let update_mode = update_control::determine_update_mode(&matches);
+/// assert_eq!(update_mode, UpdateMode::ReplaceAll)
+/// }
+pub fn determine_update_mode(matches: &ArgMatches) -> UpdateMode {
+ if let Some(mode) = matches.get_one::<String>(arguments::OPT_UPDATE) {
+ match mode.as_str() {
+ "all" => UpdateMode::ReplaceAll,
+ "none" => UpdateMode::ReplaceNone,
+ "older" => UpdateMode::ReplaceIfOlder,
+ _ => unreachable!("other args restricted by clap"),
+ }
+ } else if matches.get_flag(arguments::OPT_UPDATE_NO_ARG) {
+ // short form of this option is equivalent to using --update=older
+ UpdateMode::ReplaceIfOlder
+ } else {
+ // no option was present
+ UpdateMode::ReplaceAll
+ }
+}
diff --git a/src/uucore/src/lib/features/utmpx.rs b/src/uucore/src/lib/features/utmpx.rs
index b31aadc2522f46a9684a3854def382d6e1af5c92..e9d1bb28ac8c3b81d6d3f08085d562dce2088c7c 100644
--- a/src/uucore/src/lib/features/utmpx.rs
+++ b/src/uucore/src/lib/features/utmpx.rs
@@ -1,7 +1,5 @@
// This file is part of the uutils coreutils package.
//
-// (c) Jian Zeng <anonymousknight96@gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
//
@@ -42,13 +40,10 @@ use std::ptr;
use std::sync::{Mutex, MutexGuard};
pub use self::ut::*;
-use libc::utmpx;
-// pub use libc::getutxid;
-// pub use libc::getutxline;
-// pub use libc::pututxline;
pub use libc::endutxent;
pub use libc::getutxent;
pub use libc::setutxent;
+use libc::utmpx;
#[cfg(any(target_vendor = "apple", target_os = "linux", target_os = "netbsd"))]
pub use libc::utmpxname;
@@ -59,8 +54,6 @@ pub unsafe extern "C" fn utmpxname(_file: *const libc::c_char) -> libc::c_int {
0
}
-use once_cell::sync::Lazy;
-
use crate::*; // import macros from `../../macros.rs`
// In case the c_char array doesn't end with NULL
@@ -192,15 +185,12 @@ impl Utmpx {
}
/// A.K.A. ut.ut_tv
pub fn login_time(&self) -> time::OffsetDateTime {
- #[cfg(all(not(target_os = "freebsd"), not(target_vendor = "apple")))]
- let ts_nanos: i128 = (self.inner.ut_tv.tv_sec as i64 * 1_000_000_000_i64
- + self.inner.ut_tv.tv_usec as i64 * 1_000_i64)
- .into();
- #[cfg(any(target_os = "freebsd", target_vendor = "apple"))]
- let ts_nanos: i128 = (self.inner.ut_tv.tv_sec * 1_000_000_000_i64
- + self.inner.ut_tv.tv_usec as i64 * 1_000_i64)
+ #[allow(clippy::unnecessary_cast)]
+ let ts_nanos: i128 = (1_000_000_000_i64 * self.inner.ut_tv.tv_sec as i64
+ + 1_000_i64 * self.inner.ut_tv.tv_usec as i64)
.into();
- let local_offset = time::OffsetDateTime::now_local().unwrap().offset();
+ let local_offset =
+ time::OffsetDateTime::now_local().map_or_else(|_| time::UtcOffset::UTC, |v| v.offset());
time::OffsetDateTime::from_unix_timestamp_nanos(ts_nanos)
.unwrap()
.to_offset(local_offset)
@@ -234,7 +224,6 @@ impl Utmpx {
let (hostname, display) = host.split_once(':').unwrap_or((&host, ""));
if !hostname.is_empty() {
- extern crate dns_lookup;
use dns_lookup::{getaddrinfo, AddrInfoHints};
const AI_CANONNAME: i32 = 0x2;
@@ -249,7 +238,7 @@ impl Utmpx {
return Ok(if display.is_empty() {
ai_canonname
} else {
- format!("{}:{}", ai_canonname, display)
+ format!("{ai_canonname}:{display}")
});
}
}
@@ -340,7 +329,9 @@ impl Iterator for UtmpxIter {
fn next(&mut self) -> Option<Self::Item> {
unsafe {
let res = getutxent();
- if !res.is_null() {
+ if res.is_null() {
+ None
+ } else {
// The data behind this pointer will be replaced by the next
// call to getutxent(), so we have to read it now.
// All the strings live inline in the struct as arrays, which
@@ -348,8 +339,6 @@ impl Iterator for UtmpxIter {
Some(Utmpx {
inner: ptr::read(res as *const _),
})
- } else {
- None
}
}
}
diff --git a/src/uucore/src/lib/mods/version_cmp.rs b/src/uucore/src/lib/features/version_cmp.rs
similarity index 94%
rename from src/uucore/src/lib/mods/version_cmp.rs
rename to src/uucore/src/lib/features/version_cmp.rs
index 99b8c8b402cd4ad2f8d649f0c3d58fdddec5acbf..d881a73a18331d4b8eafa62de1c7b0d8c9c371df 100644
--- a/src/uucore/src/lib/mods/version_cmp.rs
+++ b/src/uucore/src/lib/features/version_cmp.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::cmp::Ordering;
/// Compares the non-digit parts of a version.
@@ -106,7 +110,7 @@ pub fn version_cmp(mut a: &str, mut b: &str) -> Ordering {
// 1. Compare leading non-numerical part
// 2. Compare leading numerical part
// 3. Repeat
- loop {
+ while !a.is_empty() || !b.is_empty() {
let a_numerical_start = a.find(|c: char| c.is_ascii_digit()).unwrap_or(a.len());
let b_numerical_start = b.find(|c: char| c.is_ascii_digit()).unwrap_or(b.len());
@@ -139,12 +143,9 @@ pub fn version_cmp(mut a: &str, mut b: &str) -> Ordering {
a = &a[a_numerical_end..];
b = &b[b_numerical_end..];
-
- if a.is_empty() && b.is_empty() {
- // Default to the lexical comparison.
- return str_cmp;
- }
}
+
+ Ordering::Equal
}
#[cfg(test)]
@@ -229,14 +230,14 @@ mod tests {
// Leading zeroes
assert_eq!(
version_cmp("012", "12"),
- Ordering::Less,
- "A single leading zero can make a difference"
+ Ordering::Equal,
+ "A single leading zero does not make a difference"
);
assert_eq!(
version_cmp("000800", "0000800"),
- Ordering::Greater,
- "Leading number of zeroes is used even if both non-zero number of zeros"
+ Ordering::Equal,
+ "Multiple leading zeros do not make a difference"
);
// Numbers and other characters combined
@@ -280,14 +281,8 @@ mod tests {
assert_eq!(
version_cmp("aa10aa0022", "aa010aa022"),
- Ordering::Greater,
- "The leading zeroes of the first number has priority."
- );
-
- assert_eq!(
- version_cmp("aa10aa0022", "aa10aa022"),
- Ordering::Less,
- "The leading zeroes of other numbers than the first are used."
+ Ordering::Equal,
+ "Test multiple numeric values with leading zeros"
);
assert_eq!(
@@ -307,7 +302,7 @@ mod tests {
assert_eq!(
version_cmp("aa2000000000000000000000bb", "aa002000000000000000000000bb"),
- Ordering::Greater,
+ Ordering::Equal,
"Leading zeroes for numbers larger than u64::MAX are \
handled correctly without crashing"
);
diff --git a/src/uucore/src/lib/features/wide.rs b/src/uucore/src/lib/features/wide.rs
index 6b9368f5000319399d0d25de1a64429bb6206eef..68341cd6829e59b7d534496f5b93f6d157750f85 100644
--- a/src/uucore/src/lib/features/wide.rs
+++ b/src/uucore/src/lib/features/wide.rs
@@ -1,7 +1,5 @@
// This file is part of the uutils coreutils package.
//
-// (c) Peter Atashian <retep998@gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
diff --git a/src/uucore/src/lib/lib.rs b/src/uucore/src/lib/lib.rs
index 66f8881d6b91899b3f2bd45173b68615120c5b6c..366c420d90292c2878cb91a203250264727ef1ae 100644
--- a/src/uucore/src/lib/lib.rs
+++ b/src/uucore/src/lib/lib.rs
@@ -1,8 +1,9 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// library ~ (core/bundler file)
-// Copyright (C) ~ Alex Lyon <arcterus@mail.com>
-// Copyright (C) ~ Roy Ivy III <rivy.dev@gmail.com>; MIT license
-
// * feature-gated external crates (re-shared as public internal modules)
#[cfg(feature = "libc")]
pub extern crate libc;
@@ -19,33 +20,47 @@ mod parser; // string parsing modules
pub use uucore_procs::*;
// * cross-platform modules
-pub use crate::mods::backup_control;
pub use crate::mods::display;
pub use crate::mods::error;
+pub use crate::mods::io;
+pub use crate::mods::line_ending;
pub use crate::mods::os;
pub use crate::mods::panic;
-pub use crate::mods::quoting_style;
-pub use crate::mods::ranges;
-pub use crate::mods::version_cmp;
+pub use crate::mods::posix;
// * string parsing modules
pub use crate::parser::parse_glob;
pub use crate::parser::parse_size;
pub use crate::parser::parse_time;
+pub use crate::parser::shortcut_value_parser;
// * feature-gated modules
+#[cfg(feature = "backup-control")]
+pub use crate::features::backup_control;
+#[cfg(feature = "checksum")]
+pub use crate::features::checksum;
+#[cfg(feature = "colors")]
+pub use crate::features::colors;
#[cfg(feature = "encoding")]
pub use crate::features::encoding;
+#[cfg(feature = "format")]
+pub use crate::features::format;
#[cfg(feature = "fs")]
pub use crate::features::fs;
-#[cfg(feature = "fsext")]
-pub use crate::features::fsext;
#[cfg(feature = "lines")]
pub use crate::features::lines;
-#[cfg(feature = "memo")]
-pub use crate::features::memo;
+#[cfg(feature = "quoting-style")]
+pub use crate::features::quoting_style;
+#[cfg(feature = "ranges")]
+pub use crate::features::ranges;
#[cfg(feature = "ringbuffer")]
pub use crate::features::ringbuffer;
+#[cfg(feature = "sum")]
+pub use crate::features::sum;
+#[cfg(feature = "update-control")]
+pub use crate::features::update_control;
+#[cfg(feature = "version-cmp")]
+pub use crate::features::version_cmp;
// * (platform-specific) feature-gated modules
// ** non-windows (i.e. Unix + Fuchsia)
@@ -66,6 +81,7 @@ pub use crate::features::signals;
unix,
not(target_os = "android"),
not(target_os = "fuchsia"),
+ not(target_os = "openbsd"),
not(target_os = "redox"),
not(target_env = "musl"),
feature = "utmpx"
@@ -75,6 +91,12 @@ pub use crate::features::utmpx;
#[cfg(all(windows, feature = "wide"))]
pub use crate::features::wide;
+#[cfg(feature = "fsext")]
+pub use crate::features::fsext;
+
+#[cfg(all(unix, not(target_os = "macos"), feature = "fsxattr"))]
+pub use crate::features::fsxattr;
+
//## core functions
use std::ffi::OsString;
@@ -82,14 +104,24 @@ use std::sync::atomic::Ordering;
use once_cell::sync::Lazy;
+/// Execute utility code for `util`.
+///
+/// This macro expands to a main function that invokes the `uumain` function in `util`
+/// Exits with code returned by `uumain`.
#[macro_export]
macro_rules! bin {
($util:ident) => {
pub fn main() {
use std::io::Write;
- uucore::panic::mute_sigpipe_panic(); // suppress extraneous error output for SIGPIPE failures/panics
- let code = $util::uumain(uucore::args_os()); // execute utility code
- std::io::stdout().flush().expect("could not flush stdout"); // (defensively) flush stdout for utility prior to exit; see <https://github.com/rust-lang/rust/issues/23818>
+ // suppress extraneous error output for SIGPIPE failures/panics
+ uucore::panic::mute_sigpipe_panic();
+ // execute utility code
+ let code = $util::uumain(uucore::args_os());
+ // (defensively) flush stdout for utility prior to exit; see <https://github.com/rust-lang/rust/issues/23818>
+ if let Err(e) = std::io::stdout().flush() {
+ eprintln!("Error flushing stdout: {}", e);
+ }
+
std::process::exit(code);
}
};
@@ -97,10 +129,13 @@ macro_rules! bin {
/// Generate the usage string for clap.
///
-/// This function replaces all occurrences of `{}` with the execution phrase
-/// and returns the resulting `String`. It does **not** support
-/// more advanced formatting features such as `{0}`.
+/// This function does two things. It indents all but the first line to align
+/// the lines because clap adds "Usage: " to the first line. And it replaces
+/// all occurrences of `{}` with the execution phrase and returns the resulting
+/// `String`. It does **not** support more advanced formatting features such
+/// as `{0}`.
pub fn format_usage(s: &str) -> String {
+ let s = s.replace('\n', &format!("\n{}", " ".repeat(7)));
s.replace("{}", crate::execution_phrase())
}
@@ -117,13 +152,11 @@ pub fn set_utility_is_second_arg() {
static ARGV: Lazy<Vec<OsString>> = Lazy::new(|| wild::args_os().collect());
static UTIL_NAME: Lazy<String> = Lazy::new(|| {
- if get_utility_is_second_arg() {
- &ARGV[1]
- } else {
- &ARGV[0]
- }
- .to_string_lossy()
- .into_owned()
+ let base_index = usize::from(get_utility_is_second_arg());
+ let is_man = usize::from(ARGV[base_index].eq("manpage"));
+ let argv_index = base_index + is_man;
+
+ ARGV[argv_index].to_string_lossy().into_owned()
});
/// Derive the utility name.
@@ -271,4 +304,13 @@ mod tests {
test_invalid_utf8_args_lossy(os_str);
test_invalid_utf8_args_ignore(os_str);
}
+
+ #[test]
+ fn test_format_usage() {
+ assert_eq!(format_usage("expr EXPRESSION"), "expr EXPRESSION");
+ assert_eq!(
+ format_usage("expr EXPRESSION\nexpr OPTION"),
+ "expr EXPRESSION\n expr OPTION"
+ );
+ }
}
diff --git a/src/uucore/src/lib/macros.rs b/src/uucore/src/lib/macros.rs
index cc8bdafd8ad37a5cfa7e83ba17a44f42f0dbf6f9..dad56ad13a30fde2124db16ca6f671463be64390 100644
--- a/src/uucore/src/lib/macros.rs
+++ b/src/uucore/src/lib/macros.rs
@@ -1,3 +1,8 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
// TODO fix broken links
#![allow(rustdoc::broken_intra_doc_links)]
//! Macros for the uucore utilities.
@@ -36,8 +41,6 @@ use std::sync::atomic::AtomicBool;
// This file is part of the uutils coreutils package.
//
-// (c) Alex Lyon <arcterus@mail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
@@ -88,6 +91,8 @@ pub static UTILITY_IS_SECOND_ARG: AtomicBool = AtomicBool::new(false);
#[macro_export]
macro_rules! show(
($err:expr) => ({
+ #[allow(unused_imports)]
+ use $crate::error::UError;
let e = $err;
$crate::error::set_exit_code(e.code());
eprintln!("{}: {}", $crate::util_name(), e);
@@ -128,7 +133,7 @@ macro_rules! show(
macro_rules! show_if_err(
($res:expr) => ({
if let Err(e) = $res {
- show!(e);
+ $crate::show!(e);
}
})
);
@@ -178,6 +183,14 @@ macro_rules! show_warning(
})
);
+#[macro_export]
+macro_rules! show_warning_caps(
+ ($($args:tt)+) => ({
+ eprint!("{}: WARNING: ", $crate::util_name());
+ eprintln!($($args)+);
+ })
+);
+
/// Display an error and [`std::process::exit`]
///
/// Displays the provided error message using [`show_error!`], then invokes
diff --git a/src/uucore/src/lib/mods.rs b/src/uucore/src/lib/mods.rs
index 4b6c53f9531c2e7bb26180b51a5485e7abb76dde..29508e31a89989668684f19cc7a8e4e305e0bdaa 100644
--- a/src/uucore/src/lib/mods.rs
+++ b/src/uucore/src/lib/mods.rs
@@ -1,11 +1,13 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// mods ~ cross-platforms modules (core/bundler file)
-pub mod backup_control;
pub mod display;
pub mod error;
+pub mod io;
+pub mod line_ending;
pub mod os;
pub mod panic;
-pub mod ranges;
-pub mod version_cmp;
-// dir and vdir also need access to the quoting_style module
-pub mod quoting_style;
+pub mod posix;
diff --git a/src/uucore/src/lib/mods/display.rs b/src/uucore/src/lib/mods/display.rs
index 95288973a28f6fddcb4fa52814b4840c9637a24f..db92c488727a40d10c841e593e97b04cd87ecd19 100644
--- a/src/uucore/src/lib/mods/display.rs
+++ b/src/uucore/src/lib/mods/display.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
/// Utilities for printing paths, with special attention paid to special
/// characters and invalid unicode.
///
diff --git a/src/uucore/src/lib/mods/error.rs b/src/uucore/src/lib/mods/error.rs
index 5f6f21b77eea76db3edc5f15f85282e89e62e622..5720a6bef969cf1d1a2aeefd896133ee3d07e127 100644
--- a/src/uucore/src/lib/mods/error.rs
+++ b/src/uucore/src/lib/mods/error.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// TODO fix broken links
#![allow(rustdoc::broken_intra_doc_links)]
//! All utils return exit with an exit code. Usually, the following scheme is used:
@@ -52,7 +56,6 @@
// spell-checker:ignore uioerror rustdoc
-use clap;
use std::{
error::Error,
fmt::{Display, Formatter},
@@ -396,7 +399,7 @@ impl Display for UIoError {
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
use std::io::ErrorKind::*;
- let mut message;
+ let message;
let message = if self.inner.raw_os_error().is_some() {
// These are errors that come directly from the OS.
// We want to normalize their messages across systems,
@@ -424,7 +427,6 @@ impl Display for UIoError {
// (https://github.com/rust-lang/rust/issues/86442)
// are stabilized, we should add them to the match statement.
message = strip_errno(&self.inner);
- capitalize(&mut message);
&message
}
}
@@ -435,24 +437,16 @@ impl Display for UIoError {
// a file that was not found.
// There are also errors with entirely custom messages.
message = self.inner.to_string();
- capitalize(&mut message);
&message
};
if let Some(ctx) = &self.context {
- write!(f, "{}: {}", ctx, message)
+ write!(f, "{ctx}: {message}")
} else {
- write!(f, "{}", message)
+ write!(f, "{message}")
}
}
}
-/// Capitalize the first character of an ASCII string.
-fn capitalize(text: &mut str) {
- if let Some(first) = text.get_mut(..1) {
- first.make_ascii_uppercase();
- }
-}
-
/// Strip the trailing " (os error XX)" from io error strings.
pub fn strip_errno(err: &std::io::Error) -> String {
let mut msg = err.to_string();
@@ -522,7 +516,7 @@ impl From<std::io::Error> for Box<dyn UError> {
/// // prints "fix me please!: Permission denied"
/// println!("{}", uio_result.unwrap_err());
/// ```
-#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(unix)]
impl<T> FromIo<UResult<T>> for Result<T, nix::Error> {
fn map_err_context(self, context: impl FnOnce() -> String) -> UResult<T> {
self.map_err(|e| {
@@ -534,7 +528,7 @@ impl<T> FromIo<UResult<T>> for Result<T, nix::Error> {
}
}
-#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(unix)]
impl<T> FromIo<UResult<T>> for nix::Error {
fn map_err_context(self, context: impl FnOnce() -> String) -> UResult<T> {
Err(Box::new(UIoError {
@@ -544,7 +538,7 @@ impl<T> FromIo<UResult<T>> for nix::Error {
}
}
-#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(unix)]
impl From<nix::Error> for UIoError {
fn from(f: nix::Error) -> Self {
Self {
@@ -554,7 +548,7 @@ impl From<nix::Error> for UIoError {
}
}
-#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(unix)]
impl From<nix::Error> for Box<dyn UError> {
fn from(f: nix::Error) -> Self {
let u_error: UIoError = f.into();
@@ -751,7 +745,7 @@ impl Display for ClapErrorWrapper {
#[cfg(test)]
mod tests {
#[test]
- #[cfg(any(target_os = "linux", target_os = "android"))]
+ #[cfg(unix)]
fn test_nix_error_conversion() {
use super::{FromIo, UIoError};
use nix::errno::Errno;
@@ -771,6 +765,6 @@ mod tests {
.map_err_context(|| String::from("test"))
.unwrap_err()
.to_string()
- )
+ );
}
}
diff --git a/src/uucore/src/lib/mods/io.rs b/src/uucore/src/lib/mods/io.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0d2240e9b1c61f68f620e8b8c218808c648339a7
--- /dev/null
+++ b/src/uucore/src/lib/mods/io.rs
@@ -0,0 +1,98 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+/// Encapsulates differences between OSs regarding the access to
+/// file handles / descriptors.
+/// This is useful when dealing with lower level stdin/stdout access.
+///
+/// In detail:
+/// On unix like OSs, file _descriptors_ are used in this context.
+/// On windows OSs, file _handles_ are used.
+///
+/// Even though they are distinct classes, they share common functionality.
+/// Access to this common functionality is provided in `OwnedFileDescriptorOrHandle`.
+
+#[cfg(not(windows))]
+use std::os::fd::{AsFd, OwnedFd};
+#[cfg(windows)]
+use std::os::windows::io::{AsHandle, OwnedHandle};
+use std::{
+ fs::{File, OpenOptions},
+ io,
+ path::Path,
+ process::Stdio,
+};
+
+#[cfg(windows)]
+type NativeType = OwnedHandle;
+#[cfg(not(windows))]
+type NativeType = OwnedFd;
+
+/// abstraction wrapper for native file handle / file descriptor
+pub struct OwnedFileDescriptorOrHandle {
+ fx: NativeType,
+}
+
+impl OwnedFileDescriptorOrHandle {
+ /// create from underlying native type
+ pub fn new(x: NativeType) -> Self {
+ Self { fx: x }
+ }
+
+ /// create by opening a file
+ pub fn open_file(options: &OpenOptions, path: &Path) -> io::Result<Self> {
+ let f = options.open(path)?;
+ Self::from(f)
+ }
+
+ /// conversion from borrowed native type
+ ///
+ /// e.g. `std::io::stdout()`, `std::fs::File`, ...
+ #[cfg(windows)]
+ pub fn from<T: AsHandle>(t: T) -> io::Result<Self> {
+ Ok(Self {
+ fx: t.as_handle().try_clone_to_owned()?,
+ })
+ }
+
+ /// conversion from borrowed native type
+ ///
+ /// e.g. `std::io::stdout()`, `std::fs::File`, ...
+ #[cfg(not(windows))]
+ pub fn from<T: AsFd>(t: T) -> io::Result<Self> {
+ Ok(Self {
+ fx: t.as_fd().try_clone_to_owned()?,
+ })
+ }
+
+ /// instantiates a corresponding `File`
+ pub fn into_file(self) -> File {
+ File::from(self.fx)
+ }
+
+ /// instantiates a corresponding `Stdio`
+ pub fn into_stdio(self) -> Stdio {
+ Stdio::from(self.fx)
+ }
+
+ /// clones self. useful when needing another
+ /// owned reference to same file
+ pub fn try_clone(&self) -> io::Result<Self> {
+ self.fx.try_clone().map(Self::new)
+ }
+
+ /// provides native type to be used with
+ /// OS specific functions without abstraction
+ pub fn as_raw(&self) -> &NativeType {
+ &self.fx
+ }
+}
+
+/// instantiates a corresponding `Stdio`
+impl From<OwnedFileDescriptorOrHandle> for Stdio {
+ fn from(value: OwnedFileDescriptorOrHandle) -> Self {
+ value.into_stdio()
+ }
+}
diff --git a/src/uucore/src/lib/mods/line_ending.rs b/src/uucore/src/lib/mods/line_ending.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6fe608e7d9e5b7d848a55de82c5c4cc365301be9
--- /dev/null
+++ b/src/uucore/src/lib/mods/line_ending.rs
@@ -0,0 +1,53 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+//! Provides consistent newline/zero terminator handling for `-z`/`--zero` flags.
+//!
+//! See the [`LineEnding`] struct for more information.
+use std::fmt::Display;
+
+/// Line ending of either `\n` or `\0`
+///
+/// Used by various utilities that have the option to separate lines by nul
+/// characters instead of `\n`. Usually, this is specified with the `-z` or
+/// `--zero` flag.
+///
+/// The [`Display`] implementation writes the character corresponding to the
+/// variant to the formatter.
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub enum LineEnding {
+ #[default]
+ Newline = b'\n',
+ Nul = 0,
+}
+
+impl Display for LineEnding {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ Self::Newline => writeln!(f),
+ Self::Nul => write!(f, "\0"),
+ }
+ }
+}
+
+impl From<LineEnding> for u8 {
+ fn from(line_ending: LineEnding) -> Self {
+ line_ending as Self
+ }
+}
+
+impl LineEnding {
+ /// Create a [`LineEnding`] from a `-z`/`--zero` flag
+ ///
+ /// If `is_zero_terminated` is true, [`LineEnding::Nul`] is returned,
+ /// otherwise [`LineEnding::Newline`].
+ pub fn from_zero_flag(is_zero_terminated: bool) -> Self {
+ if is_zero_terminated {
+ Self::Nul
+ } else {
+ Self::Newline
+ }
+ }
+}
diff --git a/src/uucore/src/lib/mods/os.rs b/src/uucore/src/lib/mods/os.rs
index dd06f473906531f3e9a04dc444f34906775557c4..55bf844b5338152aaba14fb1fb90c120cb6a8045 100644
--- a/src/uucore/src/lib/mods/os.rs
+++ b/src/uucore/src/lib/mods/os.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
/// Test if the program is running under WSL
// ref: <https://github.com/microsoft/WSL/issues/4555> @@ <https://archive.is/dP0bz>
diff --git a/src/uucore/src/lib/mods/panic.rs b/src/uucore/src/lib/mods/panic.rs
index 5a1e20d8090a5f8f163ef13046c5cfdcf75be73d..f42b29581e986ff9d5ab1f64252f04381612c45f 100644
--- a/src/uucore/src/lib/mods/panic.rs
+++ b/src/uucore/src/lib/mods/panic.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//! Custom panic hooks that allow silencing certain types of errors.
//!
//! Use the [`mute_sigpipe_panic`] function to silence panics caused by
diff --git a/src/uucore/src/lib/mods/posix.rs b/src/uucore/src/lib/mods/posix.rs
new file mode 100644
index 0000000000000000000000000000000000000000..662880f8466233067f09b37dca2f1b4f9dbd7c1c
--- /dev/null
+++ b/src/uucore/src/lib/mods/posix.rs
@@ -0,0 +1,52 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore (vars)
+//! Iterate over lines, including the line ending character(s).
+//!
+//! This module provides the [`posix_version`] function, that returns
+//! Some(usize) if the `_POSIX2_VERSION` environment variable is defined
+//! and has value that can be parsed.
+//! Otherwise returns None, so the calling utility would assume default behavior.
+//!
+//! NOTE: GNU (as of v9.4) recognizes three distinct values for POSIX version:
+//! '199209' for POSIX 1003.2-1992, which would define Obsolete mode
+//! '200112' for POSIX 1003.1-2001, which is the minimum version for Traditional mode
+//! '200809' for POSIX 1003.1-2008, which is the minimum version for Modern mode
+//!
+//! Utilities that rely on this module:
+//! `sort` (TBD)
+//! `tail` (TBD)
+//! `touch` (TBD)
+//! `uniq`
+//!
+use std::env;
+
+pub const OBSOLETE: usize = 199209;
+pub const TRADITIONAL: usize = 200112;
+pub const MODERN: usize = 200809;
+
+pub fn posix_version() -> Option<usize> {
+ env::var("_POSIX2_VERSION")
+ .ok()
+ .and_then(|v| v.parse::<usize>().ok())
+}
+
+#[cfg(test)]
+mod tests {
+ use crate::posix::*;
+
+ #[test]
+ fn test_posix_version() {
+ // default
+ assert_eq!(posix_version(), None);
+ // set specific version
+ env::set_var("_POSIX2_VERSION", OBSOLETE.to_string());
+ assert_eq!(posix_version(), Some(OBSOLETE));
+ env::set_var("_POSIX2_VERSION", TRADITIONAL.to_string());
+ assert_eq!(posix_version(), Some(TRADITIONAL));
+ env::set_var("_POSIX2_VERSION", MODERN.to_string());
+ assert_eq!(posix_version(), Some(MODERN));
+ }
+}
diff --git a/src/uucore/src/lib/parser.rs b/src/uucore/src/lib/parser.rs
index 8eae16bbf28f45939f0385add9ac9ffe499cf1a9..a0de6c0d4ef902cead53cb7ef8039d5edfc794c2 100644
--- a/src/uucore/src/lib/parser.rs
+++ b/src/uucore/src/lib/parser.rs
@@ -1,3 +1,8 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
pub mod parse_glob;
pub mod parse_size;
pub mod parse_time;
+pub mod shortcut_value_parser;
diff --git a/src/uucore/src/lib/parser/parse_glob.rs b/src/uucore/src/lib/parser/parse_glob.rs
index 8605f7450e225528900420547c2cabee807ffccc..100d2edf56192718cfc5ee5b064cd8d5d58db213 100644
--- a/src/uucore/src/lib/parser/parse_glob.rs
+++ b/src/uucore/src/lib/parser/parse_glob.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//! Parsing a glob Pattern from a string.
//!
//! Use the [`from_str`] function to parse a [`Pattern`] from a string.
@@ -10,10 +14,15 @@ fn fix_negation(glob: &str) -> String {
let mut chars = glob.chars().collect::<Vec<_>>();
let mut i = 0;
- while i < chars.len() {
- if chars[i] == '[' && i + 4 <= glob.len() && chars[i + 1] == '^' {
+ // Add 3 to prevent out of bounds in loop
+ while i + 3 < chars.len() {
+ if chars[i] == '[' && chars[i + 1] == '^' {
match chars[i + 3..].iter().position(|x| *x == ']') {
- None => (),
+ None => {
+ // if closing square bracket not found, stop looking for it
+ // again
+ break;
+ }
Some(j) => {
chars[i + 1] = '!';
i += j + 4;
@@ -85,6 +94,11 @@ mod tests {
assert_eq!(fix_negation("[[]] [^a]"), "[[]] [!a]");
assert_eq!(fix_negation("[[] [^a]"), "[[] [!a]");
assert_eq!(fix_negation("[]] [^a]"), "[]] [!a]");
+
+ // test that we don't look for closing square brackets unnecessarily
+ // Verifies issue #5584
+ let chars = "^[".repeat(174571);
+ assert_eq!(fix_negation(chars.as_str()), chars);
}
#[test]
@@ -105,5 +119,8 @@ mod tests {
assert_eq!(fix_negation("[^]"), "[^]");
assert_eq!(fix_negation("[^"), "[^");
assert_eq!(fix_negation("[][^]"), "[][^]");
+
+ // Issue #4479
+ assert_eq!(fix_negation("Ã Ã Ã [^"), "Ã Ã Ã [^");
}
}
diff --git a/src/uucore/src/lib/parser/parse_size.rs b/src/uucore/src/lib/parser/parse_size.rs
index 9b59053f063a0b908452f3cf9b194e2ff8156237..a13a44e85784a2d8b9f741dbda3c4813a46b5b9f 100644
--- a/src/uucore/src/lib/parser/parse_size.rs
+++ b/src/uucore/src/lib/parser/parse_size.rs
@@ -1,12 +1,13 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-// spell-checker:ignore (ToDO) hdsf ghead gtail
+// spell-checker:ignore (ToDO) hdsf ghead gtail ACDBK hexdigit
use std::error::Error;
use std::fmt;
+use std::num::IntErrorKind;
use crate::display::Quotable;
@@ -15,6 +16,8 @@ use crate::display::Quotable;
/// The [`Parser::parse`] function performs the parse.
#[derive(Default)]
pub struct Parser<'parser> {
+ /// Whether to allow empty numeric strings.
+ pub no_empty_numeric: bool,
/// Whether to treat the suffix "B" as meaning "bytes".
pub capital_b_bytes: bool,
/// Whether to treat "b" as a "byte count" instead of "block"
@@ -25,6 +28,12 @@ pub struct Parser<'parser> {
pub default_unit: Option<&'parser str>,
}
+enum NumberSystem {
+ Decimal,
+ Octal,
+ Hexadecimal,
+}
+
impl<'parser> Parser<'parser> {
pub fn with_allow_list(&mut self, allow_list: &'parser [&str]) -> &mut Self {
self.allow_list = Some(allow_list);
@@ -41,10 +50,14 @@ impl<'parser> Parser<'parser> {
self
}
+ pub fn with_allow_empty_numeric(&mut self, value: bool) -> &mut Self {
+ self.no_empty_numeric = value;
+ self
+ }
/// Parse a size string into a number of bytes.
///
/// A size string comprises an integer and an optional unit. The unit
- /// may be K, M, G, T, P, E, Z or Y (powers of 1024), or KB, MB,
+ /// may be K, M, G, T, P, E, Z, Y, R or Q (powers of 1024), or KB, MB,
/// etc. (powers of 1000), or b which is 512.
/// Binary prefixes can be used, too: KiB=K, MiB=M, and so on.
///
@@ -58,35 +71,35 @@ impl<'parser> Parser<'parser> {
/// # Examples
///
/// ```rust
- /// use uucore::parse_size::parse_size;
- /// assert_eq!(Ok(123), parse_size("123"));
- /// assert_eq!(Ok(9 * 1000), parse_size("9kB")); // kB is 1000
- /// assert_eq!(Ok(2 * 1024), parse_size("2K")); // K is 1024
+ /// use uucore::parse_size::Parser;
+ /// let parser = Parser {
+ /// default_unit: Some("M"),
+ /// ..Default::default()
+ /// };
+ /// assert_eq!(Ok(123 * 1024 * 1024), parser.parse("123M")); // M is 1024^2
+ /// assert_eq!(Ok(123 * 1024 * 1024), parser.parse("123")); // default unit set to "M" on parser instance
+ /// assert_eq!(Ok(9 * 1000), parser.parse("9kB")); // kB is 1000
+ /// assert_eq!(Ok(2 * 1024), parser.parse("2K")); // K is 1024
+ /// assert_eq!(Ok(44251 * 1024), parser.parse("0xACDBK")); // 0xACDB is 44251 in decimal
/// ```
- pub fn parse(&self, size: &str) -> Result<u64, ParseSizeError> {
+ pub fn parse(&self, size: &str) -> Result<u128, ParseSizeError> {
if size.is_empty() {
return Err(ParseSizeError::parse_failure(size));
}
- // Get the numeric part of the size argument. For example, if the
- // argument is "123K", then the numeric part is "123".
- let numeric_string: String = size.chars().take_while(|c| c.is_ascii_digit()).collect();
- let number: u64 = if !numeric_string.is_empty() {
- match numeric_string.parse() {
- Ok(n) => n,
- Err(_) => return Err(ParseSizeError::parse_failure(size)),
- }
- } else {
- 1
- };
- // Get the alphabetic units part of the size argument and compute
- // the factor it represents. For example, if the argument is "123K",
- // then the unit part is "K" and the factor is 1024. This may be the
- // empty string, in which case, the factor is 1.
- //
- // The lowercase "b" (used by `od`, `head`, `tail`, etc.) means
- // "block" and the Posix block size is 512. The uppercase "B"
- // means "byte".
+ let number_system = Self::determine_number_system(size);
+
+ // Split the size argument into numeric and unit parts
+ // For example, if the argument is "123K", the numeric part is "123", and
+ // the unit is "K"
+ let numeric_string: String = match number_system {
+ NumberSystem::Hexadecimal => size
+ .chars()
+ .take(2)
+ .chain(size.chars().skip(2).take_while(char::is_ascii_hexdigit))
+ .collect(),
+ _ => size.chars().take_while(char::is_ascii_digit).collect(),
+ };
let mut unit: &str = &size[numeric_string.len()..];
if let Some(default_unit) = self.default_unit {
@@ -115,6 +128,12 @@ impl<'parser> Parser<'parser> {
}
}
+ // Compute the factor the unit represents.
+ // empty string means the factor is 1.
+ //
+ // The lowercase "b" (used by `od`, `head`, `tail`, etc.) means
+ // "block" and the Posix block size is 512. The uppercase "B"
+ // means "byte".
let (base, exponent): (u128, u32) = match unit {
"" => (1, 0),
"B" if self.capital_b_bytes => (1, 0),
@@ -127,6 +146,8 @@ impl<'parser> Parser<'parser> {
"EiB" | "eiB" | "E" | "e" => (1024, 6),
"ZiB" | "ziB" | "Z" | "z" => (1024, 7),
"YiB" | "yiB" | "Y" | "y" => (1024, 8),
+ "RiB" | "riB" | "R" | "r" => (1024, 9),
+ "QiB" | "qiB" | "Q" | "q" => (1024, 10),
"KB" | "kB" => (1000, 1),
"MB" | "mB" => (1000, 2),
"GB" | "gB" => (1000, 3),
@@ -135,45 +156,160 @@ impl<'parser> Parser<'parser> {
"EB" | "eB" => (1000, 6),
"ZB" | "zB" => (1000, 7),
"YB" | "yB" => (1000, 8),
+ "RB" | "rB" => (1000, 9),
+ "QB" | "qB" => (1000, 10),
_ if numeric_string.is_empty() => return Err(ParseSizeError::parse_failure(size)),
_ => return Err(ParseSizeError::invalid_suffix(size)),
};
- let factor = match u64::try_from(base.pow(exponent)) {
- Ok(n) => n,
- Err(_) => return Err(ParseSizeError::size_too_big(size)),
+ let factor = base.pow(exponent);
+
+ // parse string into u128
+ let number: u128 = match number_system {
+ NumberSystem::Decimal => {
+ if numeric_string.is_empty() && !self.no_empty_numeric {
+ 1
+ } else {
+ Self::parse_number(&numeric_string, 10, size)?
+ }
+ }
+ NumberSystem::Octal => {
+ let trimmed_string = numeric_string.trim_start_matches('0');
+ Self::parse_number(trimmed_string, 8, size)?
+ }
+ NumberSystem::Hexadecimal => {
+ let trimmed_string = numeric_string.trim_start_matches("0x");
+ Self::parse_number(trimmed_string, 16, size)?
+ }
};
+
number
.checked_mul(factor)
.ok_or_else(|| ParseSizeError::size_too_big(size))
}
+
+ /// Explicit u128 alias for `parse()`
+ pub fn parse_u128(&self, size: &str) -> Result<u128, ParseSizeError> {
+ self.parse(size)
+ }
+
+ /// Same as `parse()` but tries to return u64
+ pub fn parse_u64(&self, size: &str) -> Result<u64, ParseSizeError> {
+ match self.parse(size) {
+ Ok(num_u128) => {
+ let num_u64 = match u64::try_from(num_u128) {
+ Ok(n) => n,
+ Err(_) => return Err(ParseSizeError::size_too_big(size)),
+ };
+ Ok(num_u64)
+ }
+ Err(e) => Err(e),
+ }
+ }
+
+ /// Same as `parse_u64()`, except returns `u64::MAX` on overflow
+ /// GNU lib/coreutils include similar functionality
+ /// and GNU test suite checks this behavior for some utils (`split` for example)
+ pub fn parse_u64_max(&self, size: &str) -> Result<u64, ParseSizeError> {
+ let result = self.parse_u64(size);
+ match result {
+ Ok(_) => result,
+ Err(error) => {
+ if let ParseSizeError::SizeTooBig(_) = error {
+ Ok(u64::MAX)
+ } else {
+ Err(error)
+ }
+ }
+ }
+ }
+
+ /// Same as `parse_u64_max()`, except for u128, i.e. returns `u128::MAX` on overflow
+ pub fn parse_u128_max(&self, size: &str) -> Result<u128, ParseSizeError> {
+ let result = self.parse_u128(size);
+ match result {
+ Ok(_) => result,
+ Err(error) => {
+ if let ParseSizeError::SizeTooBig(_) = error {
+ Ok(u128::MAX)
+ } else {
+ Err(error)
+ }
+ }
+ }
+ }
+
+ fn determine_number_system(size: &str) -> NumberSystem {
+ if size.len() <= 1 {
+ return NumberSystem::Decimal;
+ }
+
+ if size.starts_with("0x") {
+ return NumberSystem::Hexadecimal;
+ }
+
+ let num_digits: usize = size
+ .chars()
+ .take_while(char::is_ascii_digit)
+ .collect::<String>()
+ .len();
+ let all_zeros = size.chars().all(|c| c == '0');
+ if size.starts_with('0') && num_digits > 1 && !all_zeros {
+ return NumberSystem::Octal;
+ }
+
+ NumberSystem::Decimal
+ }
+
+ fn parse_number(
+ numeric_string: &str,
+ radix: u32,
+ original_size: &str,
+ ) -> Result<u128, ParseSizeError> {
+ u128::from_str_radix(numeric_string, radix).map_err(|e| match e.kind() {
+ IntErrorKind::PosOverflow => ParseSizeError::size_too_big(original_size),
+ _ => ParseSizeError::ParseFailure(original_size.to_string()),
+ })
+ }
}
-/// Parse a size string into a number of bytes.
-///
-/// A size string comprises an integer and an optional unit. The unit
-/// may be K, M, G, T, P, E, Z or Y (powers of 1024), or KB, MB,
-/// etc. (powers of 1000), or b which is 512.
-/// Binary prefixes can be used, too: KiB=K, MiB=M, and so on.
-///
-/// # Errors
-///
-/// Will return `ParseSizeError` if it's not possible to parse this
-/// string into a number, e.g. if the string does not begin with a
-/// numeral, or if the unit is not one of the supported units described
-/// in the preceding section.
+/// Parse a size string into a number of bytes
+/// using Default Parser (no custom settings)
///
/// # Examples
///
/// ```rust
-/// use uucore::parse_size::parse_size;
-/// assert_eq!(Ok(123), parse_size("123"));
-/// assert_eq!(Ok(9 * 1000), parse_size("9kB")); // kB is 1000
-/// assert_eq!(Ok(2 * 1024), parse_size("2K")); // K is 1024
+/// use uucore::parse_size::parse_size_u128;
+/// assert_eq!(Ok(123), parse_size_u128("123"));
+/// assert_eq!(Ok(9 * 1000), parse_size_u128("9kB")); // kB is 1000
+/// assert_eq!(Ok(2 * 1024), parse_size_u128("2K")); // K is 1024
+/// assert_eq!(Ok(44251 * 1024), parse_size_u128("0xACDBK"));
/// ```
-pub fn parse_size(size: &str) -> Result<u64, ParseSizeError> {
+pub fn parse_size_u128(size: &str) -> Result<u128, ParseSizeError> {
Parser::default().parse(size)
}
+/// Same as `parse_size_u128()`, but for u64
+pub fn parse_size_u64(size: &str) -> Result<u64, ParseSizeError> {
+ Parser::default().parse_u64(size)
+}
+
+#[deprecated = "Please use parse_size_u64(size: &str) -> Result<u64, ParseSizeError> OR parse_size_u128(size: &str) -> Result<u128, ParseSizeError> instead."]
+pub fn parse_size(size: &str) -> Result<u64, ParseSizeError> {
+ parse_size_u64(size)
+}
+
+/// Same as `parse_size_u64()`, except returns `u64::MAX` on overflow
+/// GNU lib/coreutils include similar functionality
+/// and GNU test suite checks this behavior for some utils
+pub fn parse_size_u64_max(size: &str) -> Result<u64, ParseSizeError> {
+ Parser::default().parse_u64_max(size)
+}
+
+/// Same as `parse_size_u128()`, except returns `u128::MAX` on overflow
+pub fn parse_size_u128_max(size: &str) -> Result<u128, ParseSizeError> {
+ Parser::default().parse_u128_max(size)
+}
+
#[derive(Debug, PartialEq, Eq)]
pub enum ParseSizeError {
InvalidSuffix(String), // Suffix
@@ -196,7 +332,7 @@ impl fmt::Display for ParseSizeError {
let s = match self {
Self::InvalidSuffix(s) | Self::ParseFailure(s) | Self::SizeTooBig(s) => s,
};
- write!(f, "{}", s)
+ write!(f, "{s}")
}
}
@@ -277,7 +413,7 @@ mod tests {
#[test]
fn all_suffixes() {
- // Units are K,M,G,T,P,E,Z,Y (powers of 1024) or KB,MB,... (powers of 1000).
+ // Units are K,M,G,T,P,E,Z,Y,R,Q (powers of 1024) or KB,MB,... (powers of 1000).
// Binary prefixes can be used, too: KiB=K, MiB=M, and so on.
let suffixes = [
('K', 1u32),
@@ -286,60 +422,95 @@ mod tests {
('T', 4u32),
('P', 5u32),
('E', 6u32),
- // The following will always result ParseSizeError::SizeTooBig as they cannot fit in u64
- // ('Z', 7u32),
- // ('Y', 8u32),
+ ('Z', 7u32),
+ ('Y', 8u32),
+ ('R', 9u32),
+ ('Q', 10u32),
];
for &(c, exp) in &suffixes {
- let s = format!("2{}B", c); // KB
- assert_eq!(Ok((2 * (1000_u128).pow(exp)) as u64), parse_size(&s));
- let s = format!("2{}", c); // K
- assert_eq!(Ok((2 * (1024_u128).pow(exp)) as u64), parse_size(&s));
- let s = format!("2{}iB", c); // KiB
- assert_eq!(Ok((2 * (1024_u128).pow(exp)) as u64), parse_size(&s));
+ let s = format!("2{c}B"); // KB
+ assert_eq!(Ok(2 * (1000_u128).pow(exp)), parse_size_u128(&s));
+ let s = format!("2{c}"); // K
+ assert_eq!(Ok(2 * (1024_u128).pow(exp)), parse_size_u128(&s));
+ let s = format!("2{c}iB"); // KiB
+ assert_eq!(Ok(2 * (1024_u128).pow(exp)), parse_size_u128(&s));
let s = format!("2{}iB", c.to_lowercase()); // kiB
- assert_eq!(Ok((2 * (1024_u128).pow(exp)) as u64), parse_size(&s));
+ assert_eq!(Ok(2 * (1024_u128).pow(exp)), parse_size_u128(&s));
// suffix only
- let s = format!("{}B", c); // KB
- assert_eq!(Ok(((1000_u128).pow(exp)) as u64), parse_size(&s));
- let s = format!("{}", c); // K
- assert_eq!(Ok(((1024_u128).pow(exp)) as u64), parse_size(&s));
- let s = format!("{}iB", c); // KiB
- assert_eq!(Ok(((1024_u128).pow(exp)) as u64), parse_size(&s));
+ let s = format!("{c}B"); // KB
+ assert_eq!(Ok((1000_u128).pow(exp)), parse_size_u128(&s));
+ let s = format!("{c}"); // K
+ assert_eq!(Ok((1024_u128).pow(exp)), parse_size_u128(&s));
+ let s = format!("{c}iB"); // KiB
+ assert_eq!(Ok((1024_u128).pow(exp)), parse_size_u128(&s));
let s = format!("{}iB", c.to_lowercase()); // kiB
- assert_eq!(Ok(((1024_u128).pow(exp)) as u64), parse_size(&s));
+ assert_eq!(Ok((1024_u128).pow(exp)), parse_size_u128(&s));
}
}
#[test]
- #[cfg(not(target_pointer_width = "128"))]
fn overflow_x64() {
- assert!(parse_size("10000000000000000000000").is_err());
- assert!(parse_size("1000000000T").is_err());
- assert!(parse_size("100000P").is_err());
- assert!(parse_size("100E").is_err());
- assert!(parse_size("1Z").is_err());
- assert!(parse_size("1Y").is_err());
+ assert!(parse_size_u64("10000000000000000000000").is_err());
+ assert!(parse_size_u64("1000000000T").is_err());
+ assert!(parse_size_u64("100000P").is_err());
+ assert!(parse_size_u64("100E").is_err());
+ assert!(parse_size_u64("1Z").is_err());
+ assert!(parse_size_u64("1Y").is_err());
+ assert!(parse_size_u64("1R").is_err());
+ assert!(parse_size_u64("1Q").is_err());
assert!(variant_eq(
- &parse_size("1Z").unwrap_err(),
+ &parse_size_u64("1Z").unwrap_err(),
&ParseSizeError::SizeTooBig(String::new())
));
assert_eq!(
ParseSizeError::SizeTooBig("'1Y': Value too large for defined data type".to_string()),
- parse_size("1Y").unwrap_err()
+ parse_size_u64("1Y").unwrap_err()
+ );
+ assert_eq!(
+ ParseSizeError::SizeTooBig("'1R': Value too large for defined data type".to_string()),
+ parse_size_u64("1R").unwrap_err()
+ );
+ assert_eq!(
+ ParseSizeError::SizeTooBig("'1Q': Value too large for defined data type".to_string()),
+ parse_size_u64("1Q").unwrap_err()
+ );
+ }
+
+ #[test]
+ fn overflow_to_max_u64() {
+ assert_eq!(Ok(1_099_511_627_776), parse_size_u64_max("1T"));
+ assert_eq!(Ok(1_125_899_906_842_624), parse_size_u64_max("1P"));
+ assert_eq!(Ok(u64::MAX), parse_size_u64_max("18446744073709551616"));
+ assert_eq!(Ok(u64::MAX), parse_size_u64_max("10000000000000000000000"));
+ assert_eq!(Ok(u64::MAX), parse_size_u64_max("1Y"));
+ assert_eq!(Ok(u64::MAX), parse_size_u64_max("1R"));
+ assert_eq!(Ok(u64::MAX), parse_size_u64_max("1Q"));
+ }
+
+ #[test]
+ fn overflow_to_max_u128() {
+ assert_eq!(
+ Ok(12_379_400_392_853_802_748_991_242_240),
+ parse_size_u128_max("10R")
+ );
+ assert_eq!(
+ Ok(12_676_506_002_282_294_014_967_032_053_760),
+ parse_size_u128_max("10Q")
);
+ assert_eq!(Ok(u128::MAX), parse_size_u128_max("1000000000000R"));
+ assert_eq!(Ok(u128::MAX), parse_size_u128_max("1000000000Q"));
}
#[test]
fn invalid_suffix() {
- let test_strings = ["328hdsf3290", "5mib", "1e2", "1H", "1.2"];
+ let test_strings = ["5mib", "1eb", "1H"];
for &test_string in &test_strings {
assert_eq!(
- parse_size(test_string).unwrap_err(),
+ parse_size_u64(test_string).unwrap_err(),
ParseSizeError::InvalidSuffix(format!("{}", test_string.quote()))
);
}
@@ -350,7 +521,7 @@ mod tests {
let test_strings = ["biB", "-", "+", "", "-1", "∞"];
for &test_string in &test_strings {
assert_eq!(
- parse_size(test_string).unwrap_err(),
+ parse_size_u64(test_string).unwrap_err(),
ParseSizeError::ParseFailure(format!("{}", test_string.quote()))
);
}
@@ -358,57 +529,83 @@ mod tests {
#[test]
fn b_suffix() {
- assert_eq!(Ok(3 * 512), parse_size("3b")); // b is 512
+ assert_eq!(Ok(3 * 512), parse_size_u64("3b")); // b is 512
}
#[test]
fn no_suffix() {
- assert_eq!(Ok(1234), parse_size("1234"));
- assert_eq!(Ok(0), parse_size("0"));
- assert_eq!(Ok(5), parse_size("5"));
- assert_eq!(Ok(999), parse_size("999"));
+ assert_eq!(Ok(1234), parse_size_u64("1234"));
+ assert_eq!(Ok(0), parse_size_u64("0"));
+ assert_eq!(Ok(5), parse_size_u64("5"));
+ assert_eq!(Ok(999), parse_size_u64("999"));
}
#[test]
fn kilobytes_suffix() {
- assert_eq!(Ok(123 * 1000), parse_size("123KB")); // KB is 1000
- assert_eq!(Ok(9 * 1000), parse_size("9kB")); // kB is 1000
- assert_eq!(Ok(2 * 1024), parse_size("2K")); // K is 1024
- assert_eq!(Ok(0), parse_size("0K"));
- assert_eq!(Ok(0), parse_size("0KB"));
- assert_eq!(Ok(1000), parse_size("KB"));
- assert_eq!(Ok(1024), parse_size("K"));
- assert_eq!(Ok(2000), parse_size("2kB"));
- assert_eq!(Ok(4000), parse_size("4KB"));
+ assert_eq!(Ok(123 * 1000), parse_size_u64("123KB")); // KB is 1000
+ assert_eq!(Ok(9 * 1000), parse_size_u64("9kB")); // kB is 1000
+ assert_eq!(Ok(2 * 1024), parse_size_u64("2K")); // K is 1024
+ assert_eq!(Ok(0), parse_size_u64("0K"));
+ assert_eq!(Ok(0), parse_size_u64("0KB"));
+ assert_eq!(Ok(1000), parse_size_u64("KB"));
+ assert_eq!(Ok(1024), parse_size_u64("K"));
+ assert_eq!(Ok(2000), parse_size_u64("2kB"));
+ assert_eq!(Ok(4000), parse_size_u64("4KB"));
}
#[test]
fn megabytes_suffix() {
- assert_eq!(Ok(123 * 1024 * 1024), parse_size("123M"));
- assert_eq!(Ok(123 * 1000 * 1000), parse_size("123MB"));
- assert_eq!(Ok(1024 * 1024), parse_size("M"));
- assert_eq!(Ok(1000 * 1000), parse_size("MB"));
- assert_eq!(Ok(2 * 1_048_576), parse_size("2m"));
- assert_eq!(Ok(4 * 1_048_576), parse_size("4M"));
- assert_eq!(Ok(2_000_000), parse_size("2mB"));
- assert_eq!(Ok(4_000_000), parse_size("4MB"));
+ assert_eq!(Ok(123 * 1024 * 1024), parse_size_u64("123M"));
+ assert_eq!(Ok(123 * 1000 * 1000), parse_size_u64("123MB"));
+ assert_eq!(Ok(1024 * 1024), parse_size_u64("M"));
+ assert_eq!(Ok(1000 * 1000), parse_size_u64("MB"));
+ assert_eq!(Ok(2 * 1_048_576), parse_size_u64("2m"));
+ assert_eq!(Ok(4 * 1_048_576), parse_size_u64("4M"));
+ assert_eq!(Ok(2_000_000), parse_size_u64("2mB"));
+ assert_eq!(Ok(4_000_000), parse_size_u64("4MB"));
}
#[test]
fn gigabytes_suffix() {
- assert_eq!(Ok(1_073_741_824), parse_size("1G"));
- assert_eq!(Ok(2_000_000_000), parse_size("2GB"));
+ assert_eq!(Ok(1_073_741_824), parse_size_u64("1G"));
+ assert_eq!(Ok(2_000_000_000), parse_size_u64("2GB"));
}
#[test]
#[cfg(target_pointer_width = "64")]
fn x64() {
- assert_eq!(Ok(1_099_511_627_776), parse_size("1T"));
- assert_eq!(Ok(1_125_899_906_842_624), parse_size("1P"));
- assert_eq!(Ok(1_152_921_504_606_846_976), parse_size("1E"));
- assert_eq!(Ok(2_000_000_000_000), parse_size("2TB"));
- assert_eq!(Ok(2_000_000_000_000_000), parse_size("2PB"));
- assert_eq!(Ok(2_000_000_000_000_000_000), parse_size("2EB"));
+ assert_eq!(Ok(1_099_511_627_776), parse_size_u64("1T"));
+ assert_eq!(Ok(1_125_899_906_842_624), parse_size_u64("1P"));
+ assert_eq!(Ok(1_152_921_504_606_846_976), parse_size_u64("1E"));
+
+ assert_eq!(Ok(1_180_591_620_717_411_303_424), parse_size_u128("1Z"));
+ assert_eq!(Ok(1_208_925_819_614_629_174_706_176), parse_size_u128("1Y"));
+ assert_eq!(
+ Ok(1_237_940_039_285_380_274_899_124_224),
+ parse_size_u128("1R")
+ );
+ assert_eq!(
+ Ok(1_267_650_600_228_229_401_496_703_205_376),
+ parse_size_u128("1Q")
+ );
+
+ assert_eq!(Ok(2_000_000_000_000), parse_size_u64("2TB"));
+ assert_eq!(Ok(2_000_000_000_000_000), parse_size_u64("2PB"));
+ assert_eq!(Ok(2_000_000_000_000_000_000), parse_size_u64("2EB"));
+
+ assert_eq!(Ok(2_000_000_000_000_000_000_000), parse_size_u128("2ZB"));
+ assert_eq!(
+ Ok(2_000_000_000_000_000_000_000_000),
+ parse_size_u128("2YB")
+ );
+ assert_eq!(
+ Ok(2_000_000_000_000_000_000_000_000_000),
+ parse_size_u128("2RB")
+ );
+ assert_eq!(
+ Ok(2_000_000_000_000_000_000_000_000_000_000),
+ parse_size_u128("2QB")
+ );
}
#[test]
@@ -421,9 +618,9 @@ mod tests {
assert_eq!(Ok(1024), parser.parse("1"));
assert_eq!(Ok(2 * 1024), parser.parse("2"));
- assert_eq!(Ok(1 * 1000 * 1000), parser.parse("1MB"));
- assert_eq!(Ok(1 * 1024 * 1024), parser.parse("1M"));
- assert_eq!(Ok(1 * 1024 * 1024 * 1024), parser.parse("1G"));
+ assert_eq!(Ok(1000 * 1000), parser.parse("1MB"));
+ assert_eq!(Ok(1024 * 1024), parser.parse("1M"));
+ assert_eq!(Ok(1024 * 1024 * 1024), parser.parse("1G"));
assert!(parser.parse("1T").is_err());
assert!(parser.parse("1P").is_err());
@@ -431,16 +628,24 @@ mod tests {
parser
.with_allow_list(&[
- "b", "k", "K", "m", "M", "MB", "g", "G", "t", "T", "P", "E", "Z", "Y",
+ "b", "k", "K", "m", "M", "MB", "g", "G", "t", "T", "P", "E", "Z", "Y", "R", "Q",
])
.with_default_unit("K")
.with_b_byte_count(true);
assert_eq!(Ok(1024), parser.parse("1"));
assert_eq!(Ok(2 * 1024), parser.parse("2"));
- assert_eq!(Ok(1 * 1000 * 1000), parser.parse("1MB"));
- assert_eq!(Ok(1 * 1024 * 1024), parser.parse("1M"));
- assert_eq!(Ok(1 * 1024 * 1024 * 1024), parser.parse("1G"));
+ assert_eq!(Ok(1000 * 1000), parser.parse("1MB"));
+ assert_eq!(Ok(1024 * 1024), parser.parse("1M"));
+ assert_eq!(Ok(1024 * 1024 * 1024), parser.parse("1G"));
+ assert_eq!(
+ Ok(1_237_940_039_285_380_274_899_124_224),
+ parser.parse_u128("1R")
+ );
+ assert_eq!(
+ Ok(1_267_650_600_228_229_401_496_703_205_376),
+ parser.parse_u128("1Q")
+ );
assert_eq!(Ok(1), parser.parse("1b"));
assert_eq!(Ok(1024), parser.parse("1024b"));
@@ -450,4 +655,18 @@ mod tests {
assert!(parser.parse("1B").is_err());
assert!(parser.parse("B").is_err());
}
+
+ #[test]
+ fn parse_octal_size() {
+ assert_eq!(Ok(63), parse_size_u64("077"));
+ assert_eq!(Ok(528), parse_size_u64("01020"));
+ assert_eq!(Ok(668 * 1024), parse_size_u128("01234K"));
+ }
+
+ #[test]
+ fn parse_hex_size() {
+ assert_eq!(Ok(10), parse_size_u64("0xA"));
+ assert_eq!(Ok(94722), parse_size_u64("0x17202"));
+ assert_eq!(Ok(44251 * 1024), parse_size_u128("0xACDBK"));
+ }
}
diff --git a/src/uucore/src/lib/parser/parse_time.rs b/src/uucore/src/lib/parser/parse_time.rs
index e440a3c911fafae24c607f9e77af069ee95da13e..727ee28b1bf543648f191b7d222da488bfedca27 100644
--- a/src/uucore/src/lib/parser/parse_time.rs
+++ b/src/uucore/src/lib/parser/parse_time.rs
@@ -1,7 +1,5 @@
// This file is part of the uutils coreutils package.
//
-// (c) Alex Lyon <arcterus@mail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
@@ -51,7 +49,10 @@ pub fn from_str(string: &str) -> Result<Duration, String> {
if len == 0 {
return Err("empty string".to_owned());
}
- let slice = &string[..len - 1];
+ let slice = match string.get(..len - 1) {
+ Some(s) => s,
+ None => return Err(format!("invalid time interval {}", string.quote())),
+ };
let (numstr, times) = match string.chars().next_back().unwrap() {
's' => (slice, 1),
'm' => (slice, 60),
@@ -112,6 +113,11 @@ mod tests {
assert!(from_str("123X").is_err());
}
+ #[test]
+ fn test_error_multi_bytes_characters() {
+ assert!(from_str("10€").is_err());
+ }
+
#[test]
fn test_error_invalid_magnitude() {
assert!(from_str("12abc3s").is_err());
diff --git a/src/uucore/src/lib/parser/shortcut_value_parser.rs b/src/uucore/src/lib/parser/shortcut_value_parser.rs
new file mode 100644
index 0000000000000000000000000000000000000000..125d53ee2c4fe2b3ed6b6180fc5de7f6845eaa90
--- /dev/null
+++ b/src/uucore/src/lib/parser/shortcut_value_parser.rs
@@ -0,0 +1,195 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore abcdefgh abef
+use clap::{
+ builder::{PossibleValue, TypedValueParser},
+ error::{ContextKind, ContextValue, ErrorKind},
+};
+
+#[derive(Clone)]
+pub struct ShortcutValueParser(Vec<PossibleValue>);
+
+/// `ShortcutValueParser` is similar to clap's `PossibleValuesParser`: it verifies that the value is
+/// from an enumerated set of `PossibleValue`.
+///
+/// Whereas `PossibleValuesParser` only accepts exact matches, `ShortcutValueParser` also accepts
+/// shortcuts as long as they are unambiguous.
+impl ShortcutValueParser {
+ pub fn new(values: impl Into<Self>) -> Self {
+ values.into()
+ }
+
+ fn generate_clap_error(
+ &self,
+ cmd: &clap::Command,
+ arg: Option<&clap::Arg>,
+ value: &str,
+ ) -> clap::Error {
+ let mut err = clap::Error::new(ErrorKind::InvalidValue).with_cmd(cmd);
+
+ if let Some(arg) = arg {
+ err.insert(
+ ContextKind::InvalidArg,
+ ContextValue::String(arg.to_string()),
+ );
+ }
+
+ err.insert(
+ ContextKind::InvalidValue,
+ ContextValue::String(value.to_string()),
+ );
+
+ err.insert(
+ ContextKind::ValidValue,
+ ContextValue::Strings(self.0.iter().map(|x| x.get_name().to_string()).collect()),
+ );
+
+ err
+ }
+}
+
+impl TypedValueParser for ShortcutValueParser {
+ type Value = String;
+
+ fn parse_ref(
+ &self,
+ cmd: &clap::Command,
+ arg: Option<&clap::Arg>,
+ value: &std::ffi::OsStr,
+ ) -> Result<Self::Value, clap::Error> {
+ let value = value
+ .to_str()
+ .ok_or(clap::Error::new(ErrorKind::InvalidUtf8))?;
+
+ let matched_values: Vec<_> = self
+ .0
+ .iter()
+ .filter(|x| x.get_name_and_aliases().any(|name| name.starts_with(value)))
+ .collect();
+
+ match matched_values.len() {
+ 0 => Err(self.generate_clap_error(cmd, arg, value)),
+ 1 => Ok(matched_values[0].get_name().to_string()),
+ _ => {
+ if let Some(direct_match) = matched_values.iter().find(|x| x.get_name() == value) {
+ Ok(direct_match.get_name().to_string())
+ } else {
+ Err(self.generate_clap_error(cmd, arg, value))
+ }
+ }
+ }
+ }
+
+ fn possible_values(&self) -> Option<Box<dyn Iterator<Item = PossibleValue> + '_>> {
+ Some(Box::new(self.0.iter().cloned()))
+ }
+}
+
+impl<I, T> From<I> for ShortcutValueParser
+where
+ I: IntoIterator<Item = T>,
+ T: Into<PossibleValue>,
+{
+ fn from(values: I) -> Self {
+ Self(values.into_iter().map(|t| t.into()).collect())
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use std::ffi::OsStr;
+
+ use clap::{builder::PossibleValue, builder::TypedValueParser, error::ErrorKind, Command};
+
+ use super::ShortcutValueParser;
+
+ #[test]
+ fn test_parse_ref() {
+ let cmd = Command::new("cmd");
+ let parser = ShortcutValueParser::new(["abcd"]);
+ let values = ["a", "ab", "abc", "abcd"];
+
+ for value in values {
+ let result = parser.parse_ref(&cmd, None, OsStr::new(value));
+ assert_eq!("abcd", result.unwrap());
+ }
+ }
+
+ #[test]
+ fn test_parse_ref_with_invalid_value() {
+ let cmd = Command::new("cmd");
+ let parser = ShortcutValueParser::new(["abcd"]);
+ let invalid_values = ["e", "abe", "abcde"];
+
+ for invalid_value in invalid_values {
+ let result = parser.parse_ref(&cmd, None, OsStr::new(invalid_value));
+ assert_eq!(ErrorKind::InvalidValue, result.unwrap_err().kind());
+ }
+ }
+
+ #[test]
+ fn test_parse_ref_with_ambiguous_value() {
+ let cmd = Command::new("cmd");
+ let parser = ShortcutValueParser::new(["abcd", "abef"]);
+ let ambiguous_values = ["a", "ab"];
+
+ for ambiguous_value in ambiguous_values {
+ let result = parser.parse_ref(&cmd, None, OsStr::new(ambiguous_value));
+ assert_eq!(ErrorKind::InvalidValue, result.unwrap_err().kind());
+ }
+
+ let result = parser.parse_ref(&cmd, None, OsStr::new("abc"));
+ assert_eq!("abcd", result.unwrap());
+
+ let result = parser.parse_ref(&cmd, None, OsStr::new("abe"));
+ assert_eq!("abef", result.unwrap());
+ }
+
+ #[test]
+ fn test_parse_ref_with_ambiguous_value_that_is_a_possible_value() {
+ let cmd = Command::new("cmd");
+ let parser = ShortcutValueParser::new(["abcd", "abcdefgh"]);
+ let result = parser.parse_ref(&cmd, None, OsStr::new("abcd"));
+ assert_eq!("abcd", result.unwrap());
+ }
+
+ #[test]
+ #[cfg(unix)]
+ fn test_parse_ref_with_invalid_utf8() {
+ use std::os::unix::prelude::OsStrExt;
+
+ let parser = ShortcutValueParser::new(["abcd"]);
+ let cmd = Command::new("cmd");
+
+ let result = parser.parse_ref(&cmd, None, OsStr::from_bytes(&[0xc3, 0x28]));
+ assert_eq!(ErrorKind::InvalidUtf8, result.unwrap_err().kind());
+ }
+
+ #[test]
+ fn test_ambiguous_word_same_meaning() {
+ let cmd = Command::new("cmd");
+ let parser = ShortcutValueParser::new([
+ PossibleValue::new("atime").alias("access"),
+ "status".into(),
+ ]);
+ // Even though "a" is ambiguous (it might mean "atime" or "access"),
+ // the meaning is uniquely defined, therefore accept it.
+ let atime_values = [
+ // spell-checker:disable-next-line
+ "atime", "atim", "at", "a", "access", "acces", "acce", "acc", "ac",
+ ];
+ // spell-checker:disable-next-line
+ let status_values = ["status", "statu", "stat", "sta", "st", "st"];
+
+ for value in atime_values {
+ let result = parser.parse_ref(&cmd, None, OsStr::new(value));
+ assert_eq!("atime", result.unwrap());
+ }
+ for value in status_values {
+ let result = parser.parse_ref(&cmd, None, OsStr::new(value));
+ assert_eq!("status", result.unwrap());
+ }
+ }
+}
diff --git a/src/uucore_procs/Cargo.toml b/src/uucore_procs/Cargo.toml
index c61d636734305dc6713e11cb072fad8bdc704e5b..71fd205f1c6bd208ae1740ec29a495ce0b4c2386 100644
--- a/src/uucore_procs/Cargo.toml
+++ b/src/uucore_procs/Cargo.toml
@@ -1,6 +1,7 @@
+# spell-checker:ignore uuhelp
[package]
name = "uucore_procs"
-version = "0.0.17"
+version = "0.0.27"
authors = ["Roy Ivy III <rivy.dev@gmail.com>"]
license = "MIT"
description = "uutils ~ 'uucore' proc-macros"
@@ -16,5 +17,6 @@ edition = "2021"
proc-macro = true
[dependencies]
-proc-macro2 = "1.0"
-quote = "1.0"
+proc-macro2 = "1.0.81"
+quote = "1.0.36"
+uuhelp_parser = { path = "../uuhelp_parser", version = "0.0.27" }
diff --git a/src/uucore_procs/src/lib.rs b/src/uucore_procs/src/lib.rs
index 89ac1a74956a39751bbacb286ecc02cd0f1d2d96..dfd8b88f63159bbcf8f9899d2d7c54d9c87f7fb2 100644
--- a/src/uucore_procs/src/lib.rs
+++ b/src/uucore_procs/src/lib.rs
@@ -1,7 +1,10 @@
-// Copyright (C) ~ Roy Ivy III <rivy.dev@gmail.com>; MIT license
-// spell-checker:ignore backticks
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+//
+// spell-checker:ignore backticks uuhelp
-extern crate proc_macro;
use std::{fs::File, io::Read, path::PathBuf};
use proc_macro::{Literal, TokenStream, TokenTree};
@@ -51,7 +54,22 @@ fn render_markdown(s: &str) -> String {
s.replace('`', "")
}
-/// Get the usage from the "Usage" section in the help file.
+/// Get the about text from the help file.
+///
+/// The about text is assumed to be the text between the first markdown
+/// code block and the next header, if any. It may span multiple lines.
+#[proc_macro]
+pub fn help_about(input: TokenStream) -> TokenStream {
+ let input: Vec<TokenTree> = input.into_iter().collect();
+ let filename = get_argument(&input, 0, "filename");
+ let text: String = uuhelp_parser::parse_about(&read_help(&filename));
+ if text.is_empty() {
+ panic!("About text not found! Make sure the markdown format is correct");
+ }
+ TokenTree::Literal(Literal::string(&text)).into()
+}
+
+/// Get the usage from the help file.
///
/// The usage is assumed to be surrounded by markdown code fences. It may span
/// multiple lines. The first word of each line is assumed to be the name of
@@ -61,7 +79,10 @@ fn render_markdown(s: &str) -> String {
pub fn help_usage(input: TokenStream) -> TokenStream {
let input: Vec<TokenTree> = input.into_iter().collect();
let filename = get_argument(&input, 0, "filename");
- let text: String = parse_usage(&parse_help("usage", &filename));
+ let text: String = uuhelp_parser::parse_usage(&read_help(&filename));
+ if text.is_empty() {
+ panic!("Usage text not found! Make sure the markdown format is correct");
+ }
TokenTree::Literal(Literal::string(&text)).into()
}
@@ -94,9 +115,15 @@ pub fn help_section(input: TokenStream) -> TokenStream {
let input: Vec<TokenTree> = input.into_iter().collect();
let section = get_argument(&input, 0, "section");
let filename = get_argument(&input, 1, "filename");
- let text = parse_help(§ion, &filename);
- let rendered = render_markdown(&text);
- TokenTree::Literal(Literal::string(&rendered)).into()
+
+ if let Some(text) = uuhelp_parser::parse_section(§ion, &read_help(&filename)) {
+ let rendered = render_markdown(&text);
+ TokenTree::Literal(Literal::string(&rendered)).into()
+ } else {
+ panic!(
+ "The section '{section}' could not be found in the help file. Maybe it is spelled wrong?"
+ )
+ }
}
/// Get an argument from the input vector of `TokenTree`.
@@ -107,8 +134,8 @@ fn get_argument(input: &[TokenTree], index: usize, name: &str) -> String {
// Multiply by two to ignore the `','` in between the arguments
let string = match &input.get(index * 2) {
Some(TokenTree::Literal(lit)) => lit.to_string(),
- Some(_) => panic!("Argument {} should be a string literal.", index),
- None => panic!("Missing argument at index {} for {}", index, name),
+ Some(_) => panic!("Argument {index} should be a string literal."),
+ None => panic!("Missing argument at index {index} for {name}"),
};
string
@@ -121,13 +148,11 @@ fn get_argument(input: &[TokenTree], index: usize, name: &str) -> String {
.to_string()
}
-/// Read the help file and extract a section
-fn parse_help(section: &str, filename: &str) -> String {
- let section = section.to_lowercase();
- let section = section.trim_matches('"');
+/// Read the help file
+fn read_help(filename: &str) -> String {
let mut content = String::new();
- let mut path = PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap());
+ let mut path = PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap());
path.push(filename);
File::open(path)
@@ -135,127 +160,5 @@ fn parse_help(section: &str, filename: &str) -> String {
.read_to_string(&mut content)
.unwrap();
- parse_help_section(section, &content)
-}
-
-/// Get a single section from content
-///
-/// The section must be a second level section (i.e. start with `##`).
-fn parse_help_section(section: &str, content: &str) -> String {
- fn is_section_header(line: &str, section: &str) -> bool {
- line.strip_prefix("##")
- .map_or(false, |l| l.trim().to_lowercase() == section)
- }
-
- // We cannot distinguish between an empty or non-existing section below,
- // so we do a quick test to check whether the section exists to provide
- // a nice error message.
- if content.lines().all(|l| !is_section_header(l, section)) {
- panic!(
- "The section '{}' could not be found in the help file. Maybe it is spelled wrong?",
- section
- )
- }
-
content
- .lines()
- .skip_while(|&l| !is_section_header(l, section))
- .skip(1)
- .take_while(|l| !l.starts_with("##"))
- .collect::<Vec<_>>()
- .join("\n")
- .trim()
- .to_string()
-}
-
-/// Parses a markdown code block into a usage string
-///
-/// The code fences are removed and the name of the util is replaced
-/// with `{}` so that it can be replaced with the appropriate name
-/// at runtime.
-fn parse_usage(content: &str) -> String {
- content
- .strip_suffix("```")
- .unwrap()
- .lines()
- .skip(1) // Skip the "```" of markdown syntax
- .map(|l| {
- // Replace the util name (assumed to be the first word) with "{}"
- // to be replaced with the runtime value later.
- if let Some((_util, args)) = l.split_once(' ') {
- format!("{{}} {}\n", args)
- } else {
- "{}\n".to_string()
- }
- })
- .collect()
-}
-
-#[cfg(test)]
-mod tests {
- use super::{parse_help_section, parse_usage};
-
- #[test]
- fn section_parsing() {
- let input = "\
- # ls\n\
- ## some section\n\
- This is some section\n\
- \n\
- ## ANOTHER SECTION
- This is the other section\n\
- with multiple lines\n";
-
- assert_eq!(
- parse_help_section("some section", input),
- "This is some section"
- );
- assert_eq!(
- parse_help_section("another section", input),
- "This is the other section\nwith multiple lines"
- );
- }
-
- #[test]
- #[should_panic]
- fn section_parsing_panic() {
- let input = "\
- # ls\n\
- ## some section\n\
- This is some section\n\
- \n\
- ## ANOTHER SECTION
- This is the other section\n\
- with multiple lines\n";
- parse_help_section("non-existent section", input);
- }
-
- #[test]
- fn usage_parsing() {
- let input = "\
- # ls\n\
- ## Usage\n\
- ```\n\
- ls -l\n\
- ```\n\
- ## some section\n\
- This is some section\n\
- \n\
- ## ANOTHER SECTION
- This is the other section\n\
- with multiple lines\n";
-
- assert_eq!(parse_usage(&parse_help_section("usage", input)), "{} -l",);
-
- assert_eq!(
- parse_usage(
- "\
- ```\n\
- util [some] [options]\n\
- ```\
- "
- ),
- "{} [some] [options]"
- );
- }
}
diff --git a/src/uuhelp_parser/Cargo.toml b/src/uuhelp_parser/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..dadcc0456ad6a8b8d7bee1f56e57b334591120d1
--- /dev/null
+++ b/src/uuhelp_parser/Cargo.toml
@@ -0,0 +1,10 @@
+# spell-checker:ignore uuhelp
+[package]
+name = "uuhelp_parser"
+version = "0.0.27"
+edition = "2021"
+license = "MIT"
+description = "A collection of functions to parse the markdown code of help files"
+
+homepage = "https://github.com/uutils/coreutils"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uuhelp_parser"
diff --git a/src/uuhelp_parser/LICENSE b/src/uuhelp_parser/LICENSE
new file mode 120000
index 0000000000000000000000000000000000000000..30cff7403da04711c46979a06f6bf8eb10ee088a
--- /dev/null
+++ b/src/uuhelp_parser/LICENSE
@@ -0,0 +1 @@
+../../LICENSE
\ No newline at end of file
diff --git a/src/uuhelp_parser/src/lib.rs b/src/uuhelp_parser/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8faa4e6ce4d4dd4cac3249badc14c426dcc51221
--- /dev/null
+++ b/src/uuhelp_parser/src/lib.rs
@@ -0,0 +1,236 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! A collection of functions to parse the markdown code of help files.
+//!
+//! The structure of the markdown code is assumed to be:
+//!
+//! # util name
+//!
+//! ```text
+//! usage info
+//! ```
+//!
+//! About text
+//!
+//! ## Section 1
+//!
+//! Some content
+//!
+//! ## Section 2
+//!
+//! Some content
+
+const MARKDOWN_CODE_FENCES: &str = "```";
+
+/// Parses the text between the first markdown code block and the next header, if any,
+/// into an about string.
+pub fn parse_about(content: &str) -> String {
+ content
+ .lines()
+ .skip_while(|l| !l.starts_with(MARKDOWN_CODE_FENCES))
+ .skip(1)
+ .skip_while(|l| !l.starts_with(MARKDOWN_CODE_FENCES))
+ .skip(1)
+ .take_while(|l| !l.starts_with('#'))
+ .collect::<Vec<_>>()
+ .join("\n")
+ .trim()
+ .to_string()
+}
+
+/// Parses the first markdown code block into a usage string
+///
+/// The code fences are removed and the name of the util is replaced
+/// with `{}` so that it can be replaced with the appropriate name
+/// at runtime.
+pub fn parse_usage(content: &str) -> String {
+ content
+ .lines()
+ .skip_while(|l| !l.starts_with(MARKDOWN_CODE_FENCES))
+ .skip(1)
+ .take_while(|l| !l.starts_with(MARKDOWN_CODE_FENCES))
+ .map(|l| {
+ // Replace the util name (assumed to be the first word) with "{}"
+ // to be replaced with the runtime value later.
+ if let Some((_util, args)) = l.split_once(' ') {
+ format!("{{}} {args}\n")
+ } else {
+ "{}\n".to_string()
+ }
+ })
+ .collect::<Vec<_>>()
+ .join("")
+ .trim()
+ .to_string()
+}
+
+/// Get a single section from content
+///
+/// The section must be a second level section (i.e. start with `##`).
+pub fn parse_section(section: &str, content: &str) -> Option<String> {
+ fn is_section_header(line: &str, section: &str) -> bool {
+ line.strip_prefix("##")
+ .map_or(false, |l| l.trim().to_lowercase() == section)
+ }
+
+ let section = §ion.to_lowercase();
+
+ // We cannot distinguish between an empty or non-existing section below,
+ // so we do a quick test to check whether the section exists
+ if content.lines().all(|l| !is_section_header(l, section)) {
+ return None;
+ }
+
+ // Prefix includes space to allow processing of section with level 3-6 headers
+ let section_header_prefix = "## ";
+
+ Some(
+ content
+ .lines()
+ .skip_while(|&l| !is_section_header(l, section))
+ .skip(1)
+ .take_while(|l| !l.starts_with(section_header_prefix))
+ .collect::<Vec<_>>()
+ .join("\n")
+ .trim()
+ .to_string(),
+ )
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_parse_section() {
+ let input = "\
+ # ls\n\
+ ## some section\n\
+ This is some section\n\
+ \n\
+ ## ANOTHER SECTION
+ This is the other section\n\
+ with multiple lines\n";
+
+ assert_eq!(
+ parse_section("some section", input).unwrap(),
+ "This is some section"
+ );
+ assert_eq!(
+ parse_section("SOME SECTION", input).unwrap(),
+ "This is some section"
+ );
+ assert_eq!(
+ parse_section("another section", input).unwrap(),
+ "This is the other section\nwith multiple lines"
+ );
+ }
+
+ #[test]
+ fn test_parse_section_with_sub_headers() {
+ let input = "\
+ # ls\n\
+ ## after section\n\
+ This is some section\n\
+ \n\
+ ### level 3 header\n\
+ \n\
+ Additional text under the section.\n\
+ \n\
+ #### level 4 header\n\
+ \n\
+ Yet another paragraph\n";
+
+ assert_eq!(
+ parse_section("after section", input).unwrap(),
+ "This is some section\n\n\
+ ### level 3 header\n\n\
+ Additional text under the section.\n\n\
+ #### level 4 header\n\n\
+ Yet another paragraph"
+ );
+ }
+
+ #[test]
+ fn test_parse_non_existing_section() {
+ let input = "\
+ # ls\n\
+ ## some section\n\
+ This is some section\n\
+ \n\
+ ## ANOTHER SECTION
+ This is the other section\n\
+ with multiple lines\n";
+
+ assert!(parse_section("non-existing section", input).is_none());
+ }
+
+ #[test]
+ fn test_parse_usage() {
+ let input = "\
+ # ls\n\
+ ```\n\
+ ls -l\n\
+ ```\n\
+ ## some section\n\
+ This is some section\n\
+ \n\
+ ## ANOTHER SECTION
+ This is the other section\n\
+ with multiple lines\n";
+
+ assert_eq!(parse_usage(input), "{} -l");
+ }
+
+ #[test]
+ fn test_parse_multi_line_usage() {
+ let input = "\
+ # ls\n\
+ ```\n\
+ ls -a\n\
+ ls -b\n\
+ ls -c\n\
+ ```\n\
+ ## some section\n\
+ This is some section\n";
+
+ assert_eq!(parse_usage(input), "{} -a\n{} -b\n{} -c");
+ }
+
+ #[test]
+ fn test_parse_about() {
+ let input = "\
+ # ls\n\
+ ```\n\
+ ls -l\n\
+ ```\n\
+ \n\
+ This is the about section\n\
+ \n\
+ ## some section\n\
+ This is some section\n";
+
+ assert_eq!(parse_about(input), "This is the about section");
+ }
+
+ #[test]
+ fn test_parse_multi_line_about() {
+ let input = "\
+ # ls\n\
+ ```\n\
+ ls -l\n\
+ ```\n\
+ \n\
+ about a\n\
+ \n\
+ about b\n\
+ \n\
+ ## some section\n\
+ This is some section\n";
+
+ assert_eq!(parse_about(input), "about a\n\nabout b");
+ }
+}
diff --git a/tests/by-util/test_arch.rs b/tests/by-util/test_arch.rs
index 2945a0937d1e4f2dd976650ae7cfa50b8749b507..daf4e32f52bbcc747223794ff562b8c6d8208d7f 100644
--- a/tests/by-util/test_arch.rs
+++ b/tests/by-util/test_arch.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
#[test]
fn test_arch() {
diff --git a/tests/by-util/test_base32.rs b/tests/by-util/test_base32.rs
index bb51cda57f5a39719dd4d961b91ea14a3f1bdb01..785db388be2a015bc38491ccccf756e829cbe283 100644
--- a/tests/by-util/test_base32.rs
+++ b/tests/by-util/test_base32.rs
@@ -1,12 +1,10 @@
// This file is part of the uutils coreutils package.
//
-// (c) Jian Zeng <anonymousknight96@gmail.com>
-//
-// For the full copyright and license information, please view the LICENSE file
-// that was distributed with this source code.
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//
-use crate::common::util::*;
+use crate::common::util::TestScenario;
#[test]
fn test_encode() {
@@ -24,6 +22,26 @@ fn test_encode() {
.stdout_only("JBSWY3DPFQQFO33SNRSCC===\n"); // spell-checker:disable-line
}
+#[test]
+fn test_encode_repeat_flags_later_wrap_10() {
+ let input = "Hello, World!\n";
+ new_ucmd!()
+ .args(&["-ii", "-w17", "-w10"])
+ .pipe_in(input)
+ .succeeds()
+ .stdout_only("JBSWY3DPFQ\nQFO33SNRSC\nCCQ=\n"); // spell-checker:disable-line
+}
+
+#[test]
+fn test_encode_repeat_flags_later_wrap_17() {
+ let input = "Hello, World!\n";
+ new_ucmd!()
+ .args(&["-ii", "-w10", "-w17"])
+ .pipe_in(input)
+ .succeeds()
+ .stdout_only("JBSWY3DPFQQFO33SN\nRSCCCQ=\n"); // spell-checker:disable-line
+}
+
#[test]
fn test_base32_encode_file() {
new_ucmd!()
@@ -44,6 +62,16 @@ fn test_decode() {
}
}
+#[test]
+fn test_decode_repeat_flags() {
+ let input = "JBSWY3DPFQQFO33SNRSCC===\n"; // spell-checker:disable-line
+ new_ucmd!()
+ .args(&["-didiw80", "--wrap=17", "--wrap", "8"]) // spell-checker:disable-line
+ .pipe_in(input)
+ .succeeds()
+ .stdout_only("Hello, World!");
+}
+
#[test]
fn test_garbage() {
let input = "aGVsbG8sIHdvcmxkIQ==\0"; // spell-checker:disable-line
@@ -86,7 +114,7 @@ fn test_wrap() {
fn test_wrap_no_arg() {
for wrap_param in ["-w", "--wrap"] {
let ts = TestScenario::new(util_name!());
- let expected_stderr = "The argument '--wrap <COLS>' requires a value but none was supplied";
+ let expected_stderr = "a value is required for '--wrap <COLS>' but none was supplied";
ts.ucmd()
.arg(wrap_param)
.fails()
@@ -121,5 +149,5 @@ fn test_base32_file_not_found() {
new_ucmd!()
.arg("a.txt")
.fails()
- .stderr_only("base32: a.txt: No such file or directory");
+ .stderr_only("base32: a.txt: No such file or directory\n");
}
diff --git a/tests/by-util/test_base64.rs b/tests/by-util/test_base64.rs
index a5478f6b7be65bcaa6b3016c9289550566ca803f..403fd7db86a98c915e431a84c2b0344a7c209489 100644
--- a/tests/by-util/test_base64.rs
+++ b/tests/by-util/test_base64.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
#[test]
fn test_encode() {
@@ -16,6 +20,26 @@ fn test_encode() {
.stdout_only("aGVsbG8sIHdvcmxkIQ==\n"); // spell-checker:disable-line
}
+#[test]
+fn test_encode_repeat_flags_later_wrap_10() {
+ let input = "hello, world!";
+ new_ucmd!()
+ .args(&["-ii", "-w15", "-w10"])
+ .pipe_in(input)
+ .succeeds()
+ .stdout_only("aGVsbG8sIH\ndvcmxkIQ==\n"); // spell-checker:disable-line
+}
+
+#[test]
+fn test_encode_repeat_flags_later_wrap_15() {
+ let input = "hello, world!";
+ new_ucmd!()
+ .args(&["-ii", "-w10", "-w15"])
+ .pipe_in(input)
+ .succeeds()
+ .stdout_only("aGVsbG8sIHdvcmx\nkIQ==\n"); // spell-checker:disable-line
+}
+
#[test]
fn test_base64_encode_file() {
new_ucmd!()
@@ -36,6 +60,16 @@ fn test_decode() {
}
}
+#[test]
+fn test_decode_repeat_flags() {
+ let input = "aGVsbG8sIHdvcmxkIQ==\n"; // spell-checker:disable-line
+ new_ucmd!()
+ .args(&["-didiw80", "--wrap=17", "--wrap", "8"]) // spell-checker:disable-line
+ .pipe_in(input)
+ .succeeds()
+ .stdout_only("hello, world!");
+}
+
#[test]
fn test_garbage() {
let input = "aGVsbG8sIHdvcmxkIQ==\0"; // spell-checker:disable-line
@@ -79,7 +113,7 @@ fn test_wrap_no_arg() {
new_ucmd!()
.arg(wrap_param)
.fails()
- .stderr_contains("The argument '--wrap <COLS>' requires a value but none was supplied")
+ .stderr_contains("a value is required for '--wrap <COLS>' but none was supplied")
.no_stdout();
}
}
@@ -110,5 +144,5 @@ fn test_base64_file_not_found() {
new_ucmd!()
.arg("a.txt")
.fails()
- .stderr_only("base64: a.txt: No such file or directory");
+ .stderr_only("base64: a.txt: No such file or directory\n");
}
diff --git a/tests/by-util/test_basename.rs b/tests/by-util/test_basename.rs
index 83b598cd45552e0b34609cba5dfcf88c96a07fc9..23e4a2eb455128d6aa5cb75dc20648e2dd223268 100644
--- a/tests/by-util/test_basename.rs
+++ b/tests/by-util/test_basename.rs
@@ -1,6 +1,10 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (words) reallylongexecutable
-use crate::common::util::*;
+use crate::common::util::TestScenario;
#[cfg(any(unix, target_os = "redox"))]
use std::ffi::OsStr;
@@ -66,7 +70,7 @@ fn test_multiple_param() {
new_ucmd!()
.args(&[multiple_param, path, path])
.succeeds()
- .stdout_only("baz\nbaz\n"); // spell-checker:disable-line
+ .stdout_only("baz\nbaz\n");
}
}
@@ -77,7 +81,7 @@ fn test_suffix_param() {
new_ucmd!()
.args(&[suffix_param, ".exe", path, path])
.succeeds()
- .stdout_only("baz\nbaz\n"); // spell-checker:disable-line
+ .stdout_only("baz\nbaz\n");
}
}
@@ -197,3 +201,67 @@ fn test_simple_format() {
fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
}
+
+#[test]
+fn test_repeated_multiple() {
+ new_ucmd!()
+ .args(&["-aa", "-a", "foo"])
+ .succeeds()
+ .stdout_is("foo\n");
+}
+
+#[test]
+fn test_repeated_multiple_many() {
+ new_ucmd!()
+ .args(&["-aa", "-a", "1/foo", "q/bar", "x/y/baz"])
+ .succeeds()
+ .stdout_is("foo\nbar\nbaz\n");
+}
+
+#[test]
+fn test_repeated_suffix_last() {
+ new_ucmd!()
+ .args(&["-s", ".h", "-s", ".c", "foo.c"])
+ .succeeds()
+ .stdout_is("foo\n");
+}
+
+#[test]
+fn test_repeated_suffix_not_first() {
+ new_ucmd!()
+ .args(&["-s", ".h", "-s", ".c", "foo.h"])
+ .succeeds()
+ .stdout_is("foo.h\n");
+}
+
+#[test]
+fn test_repeated_suffix_multiple() {
+ new_ucmd!()
+ .args(&["-as", ".h", "-a", "-s", ".c", "foo.c", "bar.c", "bar.h"])
+ .succeeds()
+ .stdout_is("foo\nbar\nbar.h\n");
+}
+
+#[test]
+fn test_repeated_zero() {
+ new_ucmd!()
+ .args(&["-zz", "-z", "foo/bar"])
+ .succeeds()
+ .stdout_is("bar\0");
+}
+
+#[test]
+fn test_zero_does_not_imply_multiple() {
+ new_ucmd!()
+ .args(&["-z", "foo.c", "c"])
+ .succeeds()
+ .stdout_is("foo.\0");
+}
+
+#[test]
+fn test_suffix_implies_multiple() {
+ new_ucmd!()
+ .args(&["-s", ".c", "foo.c", "o.c"])
+ .succeeds()
+ .stdout_is("foo\no\n");
+}
diff --git a/tests/by-util/test_basenc.rs b/tests/by-util/test_basenc.rs
index ba9eed1cd868c011bdd1f089a775a74288bc1e50..18f0502a1da7d94fd0dc821a65e7e72b29d67deb 100644
--- a/tests/by-util/test_basenc.rs
+++ b/tests/by-util/test_basenc.rs
@@ -1,4 +1,10 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//spell-checker: ignore (encodings) lsbf msbf
+use crate::common::util::TestScenario;
#[test]
fn test_z85_not_padded() {
@@ -7,10 +13,241 @@ fn test_z85_not_padded() {
.args(&["--z85", "-d"])
.pipe_in("##########")
.fails()
- .stderr_only("basenc: error: invalid input");
+ .stderr_only("basenc: error: invalid input\n");
new_ucmd!()
.args(&["--z85"])
.pipe_in("123")
.fails()
- .stderr_only("basenc: error: invalid input (length must be multiple of 4 characters)");
+ .stderr_only("basenc: error: invalid input (length must be multiple of 4 characters)\n");
+}
+
+#[test]
+fn test_invalid_input() {
+ let error_message = if cfg!(windows) {
+ "basenc: .: Permission denied\n"
+ } else {
+ "basenc: error: invalid input\n"
+ };
+ new_ucmd!()
+ .args(&["--base32", "."])
+ .fails()
+ .stderr_only(error_message);
+}
+
+#[test]
+fn test_base64() {
+ new_ucmd!()
+ .arg("--base64")
+ .pipe_in("to>be?")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("dG8+YmU/\n");
+}
+
+#[test]
+fn test_base64_decode() {
+ new_ucmd!()
+ .args(&["--base64", "-d"])
+ .pipe_in("dG8+YmU/")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("to>be?");
+}
+
+#[test]
+fn test_base64url() {
+ new_ucmd!()
+ .arg("--base64url")
+ .pipe_in("to>be?")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("dG8-YmU_\n");
+}
+
+#[test]
+fn test_base64url_decode() {
+ new_ucmd!()
+ .args(&["--base64url", "-d"])
+ .pipe_in("dG8-YmU_")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("to>be?");
+}
+
+#[test]
+fn test_base32() {
+ new_ucmd!()
+ .arg("--base32")
+ .pipe_in("nice>base?")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("NZUWGZJ6MJQXGZJ7\n"); // spell-checker:disable-line
+}
+
+#[test]
+fn test_base32_decode() {
+ new_ucmd!()
+ .args(&["--base32", "-d"])
+ .pipe_in("NZUWGZJ6MJQXGZJ7") // spell-checker:disable-line
+ .succeeds()
+ .no_stderr()
+ .stdout_only("nice>base?");
+}
+
+#[test]
+fn test_base32hex() {
+ new_ucmd!()
+ .arg("--base32hex")
+ .pipe_in("nice>base?")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("DPKM6P9UC9GN6P9V\n"); // spell-checker:disable-line
+}
+
+#[test]
+fn test_base32hex_decode() {
+ new_ucmd!()
+ .args(&["--base32hex", "-d"])
+ .pipe_in("DPKM6P9UC9GN6P9V") // spell-checker:disable-line
+ .succeeds()
+ .no_stderr()
+ .stdout_only("nice>base?");
+}
+
+#[test]
+fn test_base16() {
+ new_ucmd!()
+ .arg("--base16")
+ .pipe_in("Hello, World!")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("48656C6C6F2C20576F726C6421\n");
+}
+
+#[test]
+fn test_base16_decode() {
+ new_ucmd!()
+ .args(&["--base16", "-d"])
+ .pipe_in("48656C6C6F2C20576F726C6421")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("Hello, World!");
+}
+
+#[test]
+fn test_base2msbf() {
+ new_ucmd!()
+ .arg("--base2msbf")
+ .pipe_in("msbf")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("01101101011100110110001001100110\n");
+}
+
+#[test]
+fn test_base2msbf_decode() {
+ new_ucmd!()
+ .args(&["--base2msbf", "-d"])
+ .pipe_in("01101101011100110110001001100110")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("msbf");
+}
+
+#[test]
+fn test_base2lsbf() {
+ new_ucmd!()
+ .arg("--base2lsbf")
+ .pipe_in("lsbf")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("00110110110011100100011001100110\n");
+}
+
+#[test]
+fn test_base2lsbf_decode() {
+ new_ucmd!()
+ .args(&["--base2lsbf", "-d"])
+ .pipe_in("00110110110011100100011001100110")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("lsbf");
+}
+
+#[test]
+fn test_choose_last_encoding_z85() {
+ new_ucmd!()
+ .args(&[
+ "--base2lsbf",
+ "--base2msbf",
+ "--base16",
+ "--base32hex",
+ "--base64url",
+ "--base32",
+ "--base64",
+ "--z85",
+ ])
+ .pipe_in("Hello, World")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("nm=QNz.92jz/PV8\n");
+}
+
+#[test]
+fn test_choose_last_encoding_base64() {
+ new_ucmd!()
+ .args(&[
+ "--base2msbf",
+ "--base2lsbf",
+ "--base64url",
+ "--base32hex",
+ "--base32",
+ "--base16",
+ "--z85",
+ "--base64",
+ ])
+ .pipe_in("Hello, World!")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("SGVsbG8sIFdvcmxkIQ==\n"); // spell-checker:disable-line
+}
+
+#[test]
+fn test_choose_last_encoding_base2lsbf() {
+ new_ucmd!()
+ .args(&[
+ "--base64url",
+ "--base16",
+ "--base2msbf",
+ "--base32",
+ "--base64",
+ "--z85",
+ "--base32hex",
+ "--base2lsbf",
+ ])
+ .pipe_in("lsbf")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("00110110110011100100011001100110\n");
+}
+
+#[test]
+fn test_base32_decode_repeated() {
+ new_ucmd!()
+ .args(&[
+ "--ignore",
+ "--wrap=80",
+ "--base32hex",
+ "--z85",
+ "--ignore",
+ "--decode",
+ "--z85",
+ "--base32",
+ "-w",
+ "10",
+ ])
+ .pipe_in("NZUWGZJ6MJQXGZJ7") // spell-checker:disable-line
+ .succeeds()
+ .no_stderr()
+ .stdout_only("nice>base?");
}
diff --git a/tests/by-util/test_cat.rs b/tests/by-util/test_cat.rs
index dc45b3605e2efb29af027a2a557a94fc712b1bd0..b11c0ec0ce1bdb1ce2d5aa8651976dfc236012ef 100644
--- a/tests/by-util/test_cat.rs
+++ b/tests/by-util/test_cat.rs
@@ -1,6 +1,12 @@
-// spell-checker:ignore NOFILE
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore NOFILE nonewline
-use crate::common::util::*;
+#[cfg(not(windows))]
+use crate::common::util::vec_of_size;
+use crate::common::util::TestScenario;
#[cfg(any(target_os = "linux", target_os = "android"))]
use rlimit::Resource;
use std::fs::OpenOptions;
@@ -17,7 +23,6 @@ fn test_output_simple() {
#[test]
fn test_no_options() {
- // spell-checker:disable-next-line
for fixture in ["empty.txt", "alpha.txt", "nonewline.txt"] {
// Give fixture through command line file argument
new_ucmd!()
@@ -103,7 +108,7 @@ fn test_closes_file_descriptors() {
"alpha.txt",
"alpha.txt",
])
- .with_limit(Resource::NOFILE, 9, 9)
+ .limit(Resource::NOFILE, 9, 9)
.succeeds();
}
@@ -169,6 +174,7 @@ fn test_piped_to_dev_full() {
s.ucmd()
.set_stdout(dev_full)
.pipe_in_fixture("alpha.txt")
+ .ignore_stdin_write_error()
.fails()
.stderr_contains("No space left on device");
}
@@ -182,19 +188,18 @@ fn test_directory() {
s.ucmd()
.args(&["test_directory"])
.fails()
- .stderr_is("cat: test_directory: Is a directory");
+ .stderr_is("cat: test_directory: Is a directory\n");
}
#[test]
fn test_directory_and_file() {
let s = TestScenario::new(util_name!());
s.fixtures.mkdir("test_directory2");
- // spell-checker:disable-next-line
for fixture in ["empty.txt", "alpha.txt", "nonewline.txt"] {
s.ucmd()
.args(&["test_directory2", fixture])
.fails()
- .stderr_is("cat: test_directory2: Is a directory")
+ .stderr_is("cat: test_directory2: Is a directory\n")
.stdout_is_fixture(fixture);
}
}
@@ -212,12 +217,13 @@ fn test_three_directories_and_file_and_stdin() {
"alpha.txt",
"-",
"file_which_does_not_exist.txt",
- "nonewline.txt", // spell-checker:disable-line
+ "nonewline.txt",
"test_directory3/test_directory5",
"test_directory3/../test_directory3/test_directory5",
"test_directory3",
])
.pipe_in("stdout bytes")
+ .ignore_stdin_write_error()
.fails()
.stderr_is_fixture("three_directories_and_file_and_stdin.stderr.expected")
.stdout_is(
@@ -247,6 +253,28 @@ fn test_output_multi_files_print_all_chars() {
// spell-checker:enable
}
+#[test]
+fn test_output_multi_files_print_all_chars_repeated() {
+ // spell-checker:disable
+ new_ucmd!()
+ .args(&["alpha.txt", "256.txt", "-A", "-n", "-A", "-n"])
+ .succeeds()
+ .stdout_only(
+ " 1\tabcde$\n 2\tfghij$\n 3\tklmno$\n 4\tpqrst$\n \
+ 5\tuvwxyz$\n 6\t^@^A^B^C^D^E^F^G^H^I$\n \
+ 7\t^K^L^M^N^O^P^Q^R^S^T^U^V^W^X^Y^Z^[^\\^]^^^_ \
+ !\"#$%&\'()*+,-./0123456789:;\
+ <=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~^?M-^@M-^AM-^\
+ BM-^CM-^DM-^EM-^FM-^GM-^HM-^IM-^JM-^KM-^LM-^MM-^NM-^OM-^PM-^QM-^RM-^SM-^TM-^UM-^V\
+ M-^WM-^XM-^YM-^ZM-^[M-^\\M-^]M-^^M-^_M- \
+ M-!M-\"M-#M-$M-%M-&M-\'M-(M-)M-*M-+M-,M--M-.M-/M-0M-1M-2M-3M-4M-5M-6M-7M-8M-9M-:\
+ M-;M-<M-=M->M-?M-@M-AM-BM-CM-DM-EM-FM-GM-HM-IM-JM-KM-LM-MM-NM-OM-PM-QM-RM-SM-TM-U\
+ M-VM-WM-XM-YM-ZM-[M-\\M-]M-^M-_M-`M-aM-bM-cM-dM-eM-fM-gM-hM-iM-jM-kM-lM-mM-nM-oM-\
+ pM-qM-rM-sM-tM-uM-vM-wM-xM-yM-zM-{M-|M-}M-~M-^?",
+ );
+ // spell-checker:enable
+}
+
#[test]
fn test_numbered_lines_no_trailing_newline() {
// spell-checker:disable
@@ -262,7 +290,7 @@ fn test_numbered_lines_no_trailing_newline() {
#[test]
fn test_stdin_show_nonprinting() {
- for same_param in ["-v", "--show-nonprinting", "--show-non"] {
+ for same_param in ["-v", "-vv", "--show-nonprinting", "--show-non"] {
new_ucmd!()
.args(&[same_param])
.pipe_in("\t\0\n")
@@ -273,7 +301,7 @@ fn test_stdin_show_nonprinting() {
#[test]
fn test_stdin_show_tabs() {
- for same_param in ["-T", "--show-tabs", "--show-ta"] {
+ for same_param in ["-T", "-TT", "--show-tabs", "--show-ta"] {
new_ucmd!()
.args(&[same_param])
.pipe_in("\t\0\n")
@@ -284,7 +312,7 @@ fn test_stdin_show_tabs() {
#[test]
fn test_stdin_show_ends() {
- for same_param in ["-E", "--show-ends", "--show-e"] {
+ for same_param in ["-E", "-EE", "--show-ends", "--show-e"] {
new_ucmd!()
.args(&[same_param, "-"])
.pipe_in("\t\0\n\t")
@@ -294,7 +322,7 @@ fn test_stdin_show_ends() {
}
#[test]
-fn squeeze_all_files() {
+fn test_squeeze_all_files() {
// empty lines at the end of a file are "squeezed" together with empty lines at the beginning
let (at, mut ucmd) = at_and_ucmd!();
at.write("input1", "a\n\n");
@@ -304,6 +332,17 @@ fn squeeze_all_files() {
.stdout_only("a\n\nb");
}
+#[test]
+fn test_squeeze_all_files_repeated() {
+ // empty lines at the end of a file are "squeezed" together with empty lines at the beginning
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.write("input1", "a\n\n");
+ at.write("input2", "\n\nb");
+ ucmd.args(&["-s", "input1", "input2", "-s"])
+ .succeeds()
+ .stdout_only("a\n\nb");
+}
+
#[test]
fn test_show_ends_crlf() {
new_ucmd!()
@@ -333,6 +372,15 @@ fn test_stdin_nonprinting_and_endofline() {
.stdout_only("\t^@$\n");
}
+#[test]
+fn test_stdin_nonprinting_and_endofline_repeated() {
+ new_ucmd!()
+ .args(&["-ee", "-e"])
+ .pipe_in("\t\0\n")
+ .succeeds()
+ .stdout_only("\t^@$\n");
+}
+
#[test]
fn test_stdin_nonprinting_and_tabs() {
new_ucmd!()
@@ -342,6 +390,15 @@ fn test_stdin_nonprinting_and_tabs() {
.stdout_only("^I^@\n");
}
+#[test]
+fn test_stdin_nonprinting_and_tabs_repeated() {
+ new_ucmd!()
+ .args(&["-tt", "-t"])
+ .pipe_in("\t\0\n")
+ .succeeds()
+ .stdout_only("^I^@\n");
+}
+
#[test]
fn test_stdin_squeeze_blank() {
for same_param in ["-s", "--squeeze-blank", "--squeeze"] {
@@ -356,7 +413,7 @@ fn test_stdin_squeeze_blank() {
#[test]
fn test_stdin_number_non_blank() {
// spell-checker:disable-next-line
- for same_param in ["-b", "--number-nonblank", "--number-non"] {
+ for same_param in ["-b", "-bb", "--number-nonblank", "--number-non"] {
new_ucmd!()
.arg(same_param)
.arg("-")
@@ -378,6 +435,15 @@ fn test_non_blank_overrides_number() {
}
}
+#[test]
+fn test_non_blank_overrides_number_even_when_present() {
+ new_ucmd!()
+ .args(&["-n", "-b", "-n"])
+ .pipe_in("\na\nb\n\n\nc")
+ .succeeds()
+ .stdout_only("\n 1\ta\n 2\tb\n\n\n 3\tc");
+}
+
#[test]
fn test_squeeze_blank_before_numbering() {
for same_param in ["-s", "--squeeze-blank"] {
@@ -497,7 +563,6 @@ fn test_write_to_self_empty() {
let file = OpenOptions::new()
.create_new(true)
- .write(true)
.append(true)
.open(&file_path)
.unwrap();
@@ -513,7 +578,6 @@ fn test_write_to_self() {
let file = OpenOptions::new()
.create_new(true)
- .write(true)
.append(true)
.open(file_path)
.unwrap();
@@ -527,10 +591,33 @@ fn test_write_to_self() {
.arg("second_file")
.fails()
.code_is(2)
- .stderr_only("cat: first_file: input file is output file\ncat: first_file: input file is output file");
+ .stderr_only("cat: first_file: input file is output file\ncat: first_file: input file is output file\n");
assert_eq!(
s.fixtures.read("first_file"),
"first_file_content.second_file_content."
);
}
+
+#[test]
+#[cfg(unix)]
+fn test_error_loop() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.symlink_file("2", "1");
+ at.symlink_file("3", "2");
+ at.symlink_file("1", "3");
+ ucmd.arg("1")
+ .fails()
+ .stderr_is("cat: 1: Too many levels of symbolic links\n");
+}
+
+#[test]
+fn test_u_ignored() {
+ for same_param in ["-u", "-uu"] {
+ new_ucmd!()
+ .arg(same_param)
+ .pipe_in("hello")
+ .succeeds()
+ .stdout_only("hello");
+ }
+}
diff --git a/tests/by-util/test_chcon.rs b/tests/by-util/test_chcon.rs
index bea5462b4ca4c54ae0fc7cbda15d95d93acfe60e..a8dae9aed06d722f6d95412741b25a2a00fcd899 100644
--- a/tests/by-util/test_chcon.rs
+++ b/tests/by-util/test_chcon.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (jargon) xattributes
#![cfg(feature = "feat_selinux")]
@@ -84,6 +88,33 @@ fn valid_context_on_valid_symlink() {
assert_eq!(get_file_context(dir.plus("a.tmp")).unwrap(), a_context);
}
+#[test]
+fn valid_context_on_valid_symlink_override_dereference() {
+ let (dir, mut cmd) = at_and_ucmd!();
+ dir.touch("a.tmp");
+ dir.symlink_file("a.tmp", "la.tmp");
+
+ let a_context = get_file_context(dir.plus("a.tmp")).unwrap();
+ let la_context = get_file_context(dir.plus("la.tmp")).unwrap();
+ let new_a_context = "guest_u:object_r:etc_t:s0:c42";
+ assert_ne!(a_context.as_deref(), Some(new_a_context));
+ assert_ne!(la_context.as_deref(), Some(new_a_context));
+
+ cmd.args(&[
+ "--verbose",
+ "--no-dereference",
+ "--dereference",
+ new_a_context,
+ ])
+ .arg(dir.plus("la.tmp"))
+ .succeeds();
+ assert_eq!(
+ get_file_context(dir.plus("a.tmp")).unwrap().as_deref(),
+ Some(new_a_context)
+ );
+ assert_eq!(get_file_context(dir.plus("la.tmp")).unwrap(), la_context);
+}
+
#[test]
fn valid_context_on_broken_symlink() {
let (dir, mut cmd) = at_and_ucmd!();
@@ -100,6 +131,29 @@ fn valid_context_on_broken_symlink() {
);
}
+#[test]
+fn valid_context_on_broken_symlink_after_deref() {
+ let (dir, mut cmd) = at_and_ucmd!();
+ dir.symlink_file("a.tmp", "la.tmp");
+
+ let la_context = get_file_context(dir.plus("la.tmp")).unwrap();
+ let new_la_context = "guest_u:object_r:etc_t:s0:c42";
+ assert_ne!(la_context.as_deref(), Some(new_la_context));
+
+ cmd.args(&[
+ "--verbose",
+ "--dereference",
+ "--no-dereference",
+ new_la_context,
+ ])
+ .arg(dir.plus("la.tmp"))
+ .succeeds();
+ assert_eq!(
+ get_file_context(dir.plus("la.tmp")).unwrap().as_deref(),
+ Some(new_la_context)
+ );
+}
+
#[test]
fn valid_context_with_prior_xattributes() {
let (dir, mut cmd) = at_and_ucmd!();
@@ -320,6 +374,30 @@ fn user_change() {
);
}
+#[test]
+fn user_change_repeated() {
+ let (dir, mut cmd) = at_and_ucmd!();
+
+ dir.touch("a.tmp");
+ let a_context = get_file_context(dir.plus("a.tmp")).unwrap();
+ let new_a_context = if let Some(a_context) = a_context {
+ let mut components: Vec<_> = a_context.split(':').collect();
+ components[0] = "guest_u";
+ components.join(":")
+ } else {
+ set_file_context(dir.plus("a.tmp"), "unconfined_u:object_r:user_tmp_t:s0").unwrap();
+ String::from("guest_u:object_r:user_tmp_t:s0")
+ };
+
+ cmd.args(&["--verbose", "--user=wrong", "--user=guest_u"])
+ .arg(dir.plus("a.tmp"))
+ .succeeds();
+ assert_eq!(
+ get_file_context(dir.plus("a.tmp")).unwrap(),
+ Some(new_a_context)
+ );
+}
+
#[test]
fn role_change() {
let (dir, mut cmd) = at_and_ucmd!();
@@ -417,6 +495,99 @@ fn valid_reference() {
);
}
+#[test]
+fn valid_reference_repeat_flags() {
+ let (dir, mut cmd) = at_and_ucmd!();
+
+ dir.touch("a.tmp");
+ let new_a_context = "guest_u:object_r:etc_t:s0:c42";
+ set_file_context(dir.plus("a.tmp"), new_a_context).unwrap();
+
+ dir.touch("b.tmp");
+ let b_context = get_file_context(dir.plus("b.tmp")).unwrap();
+ assert_ne!(b_context.as_deref(), Some(new_a_context));
+
+ cmd.arg("--verbose")
+ .arg("-vvRRHHLLPP") // spell-checker:disable-line
+ .arg("--no-preserve-root")
+ .arg("--no-preserve-root")
+ .arg("--preserve-root")
+ .arg("--preserve-root")
+ .arg("--dereference")
+ .arg("--dereference")
+ .arg("--no-dereference")
+ .arg("--no-dereference")
+ .arg(format!("--reference={}", dir.plus_as_string("a.tmp")))
+ .arg(dir.plus("b.tmp"))
+ .succeeds();
+ assert_eq!(
+ get_file_context(dir.plus("b.tmp")).unwrap().as_deref(),
+ Some(new_a_context)
+ );
+}
+
+#[test]
+fn valid_reference_repeated_reference() {
+ let (dir, mut cmd) = at_and_ucmd!();
+
+ dir.touch("a.tmp");
+ let new_a_context = "guest_u:object_r:etc_t:s0:c42";
+ set_file_context(dir.plus("a.tmp"), new_a_context).unwrap();
+
+ dir.touch("wrong.tmp");
+ let new_wrong_context = "guest_u:object_r:etc_t:s42:c0";
+ set_file_context(dir.plus("wrong.tmp"), new_wrong_context).unwrap();
+
+ dir.touch("b.tmp");
+ let b_context = get_file_context(dir.plus("b.tmp")).unwrap();
+ assert_ne!(b_context.as_deref(), Some(new_a_context));
+
+ cmd.arg("--verbose")
+ .arg(format!("--reference={}", dir.plus_as_string("wrong.tmp")))
+ .arg(format!("--reference={}", dir.plus_as_string("a.tmp")))
+ .arg(dir.plus("b.tmp"))
+ .succeeds();
+ assert_eq!(
+ get_file_context(dir.plus("b.tmp")).unwrap().as_deref(),
+ Some(new_a_context)
+ );
+ assert_eq!(
+ get_file_context(dir.plus("wrong.tmp")).unwrap().as_deref(),
+ Some(new_wrong_context)
+ );
+}
+
+#[test]
+fn valid_reference_multi() {
+ let (dir, mut cmd) = at_and_ucmd!();
+
+ dir.touch("a.tmp");
+ let new_a_context = "guest_u:object_r:etc_t:s0:c42";
+ set_file_context(dir.plus("a.tmp"), new_a_context).unwrap();
+
+ dir.touch("b1.tmp");
+ let b1_context = get_file_context(dir.plus("b1.tmp")).unwrap();
+ assert_ne!(b1_context.as_deref(), Some(new_a_context));
+
+ dir.touch("b2.tmp");
+ let b2_context = get_file_context(dir.plus("b2.tmp")).unwrap();
+ assert_ne!(b2_context.as_deref(), Some(new_a_context));
+
+ cmd.arg("--verbose")
+ .arg(format!("--reference={}", dir.plus_as_string("a.tmp")))
+ .arg(dir.plus("b1.tmp"))
+ .arg(dir.plus("b2.tmp"))
+ .succeeds();
+ assert_eq!(
+ get_file_context(dir.plus("b1.tmp")).unwrap().as_deref(),
+ Some(new_a_context)
+ );
+ assert_eq!(
+ get_file_context(dir.plus("b2.tmp")).unwrap().as_deref(),
+ Some(new_a_context)
+ );
+}
+
fn get_file_context(path: impl AsRef<Path>) -> Result<Option<String>, selinux::errors::Error> {
let path = path.as_ref();
match selinux::SecurityContext::of_path(path, false, false) {
diff --git a/tests/by-util/test_chgrp.rs b/tests/by-util/test_chgrp.rs
index 1aa01d435cb727221e46cfe5df8abc49dcaad420..eca5ba0edff2a5cb099bf8d4590be5537098fa70 100644
--- a/tests/by-util/test_chgrp.rs
+++ b/tests/by-util/test_chgrp.rs
@@ -1,7 +1,11 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (words) nosuchgroup groupname
-use crate::common::util::*;
-use rust_users::*;
+use crate::common::util::TestScenario;
+use uucore::process::getegid;
#[test]
fn test_invalid_option() {
@@ -48,12 +52,12 @@ fn test_invalid_group() {
.arg("__nosuchgroup__")
.arg("/")
.fails()
- .stderr_is("chgrp: invalid group: '__nosuchgroup__'");
+ .stderr_is("chgrp: invalid group: '__nosuchgroup__'\n");
}
#[test]
fn test_1() {
- if get_effective_gid() != 0 {
+ if getegid() != 0 {
new_ucmd!().arg("bin").arg(DIR).fails().stderr_contains(
// linux fails with "Operation not permitted (os error 1)"
// because of insufficient permissions,
@@ -66,7 +70,7 @@ fn test_1() {
#[test]
fn test_fail_silently() {
- if get_effective_gid() != 0 {
+ if getegid() != 0 {
for opt in ["-f", "--silent", "--quiet", "--sil", "--qui"] {
new_ucmd!()
.arg(opt)
@@ -81,18 +85,29 @@ fn test_fail_silently() {
#[test]
fn test_preserve_root() {
// It's weird that on OS X, `realpath /etc/..` returns '/private'
+ new_ucmd!()
+ .arg("--preserve-root")
+ .arg("-R")
+ .arg("bin")
+ .arg("/")
+ .fails()
+ .stderr_is("chgrp: it is dangerous to operate recursively on '/'\nchgrp: use --no-preserve-root to override this failsafe\n");
for d in [
- "/",
"/////dev///../../../../",
"../../../../../../../../../../../../../../",
"./../../../../../../../../../../../../../../",
] {
+ let expected_error = format!(
+ "chgrp: it is dangerous to operate recursively on '{}' (same as '/')\nchgrp: use --no-preserve-root to override this failsafe\n",
+ d,
+ );
new_ucmd!()
.arg("--preserve-root")
.arg("-R")
- .arg("bin").arg(d)
+ .arg("bin")
+ .arg(d)
.fails()
- .stderr_is("chgrp: it is dangerous to operate recursively on '/'\nchgrp: use --no-preserve-root to override this failsafe");
+ .stderr_is(expected_error);
}
}
@@ -101,26 +116,31 @@ fn test_preserve_root_symlink() {
let file = "test_chgrp_symlink2root";
for d in [
"/",
+ "//",
+ "///",
"////dev//../../../../",
"..//../../..//../..//../../../../../../../../",
".//../../../../../../..//../../../../../../../",
] {
let (at, mut ucmd) = at_and_ucmd!();
at.symlink_file(d, file);
+ let expected_error =
+ "chgrp: it is dangerous to operate recursively on 'test_chgrp_symlink2root' (same as '/')\nchgrp: use --no-preserve-root to override this failsafe\n";
ucmd.arg("--preserve-root")
.arg("-HR")
- .arg("bin").arg(file)
+ .arg("bin")
+ .arg(file)
.fails()
- .stderr_is("chgrp: it is dangerous to operate recursively on '/'\nchgrp: use --no-preserve-root to override this failsafe");
+ .stderr_is(expected_error);
}
let (at, mut ucmd) = at_and_ucmd!();
at.symlink_file("///dev", file);
ucmd.arg("--preserve-root")
.arg("-HR")
- .arg("bin").arg(format!(".//{}/..//..//../../", file))
+ .arg("bin").arg(format!(".//{file}/..//..//../../"))
.fails()
- .stderr_is("chgrp: it is dangerous to operate recursively on '/'\nchgrp: use --no-preserve-root to override this failsafe");
+ .stderr_is("chgrp: it is dangerous to operate recursively on './/test_chgrp_symlink2root/..//..//../../' (same as '/')\nchgrp: use --no-preserve-root to override this failsafe\n");
let (at, mut ucmd) = at_and_ucmd!();
at.symlink_file("/", "__root__");
@@ -128,7 +148,47 @@ fn test_preserve_root_symlink() {
.arg("-R")
.arg("bin").arg("__root__/.")
.fails()
- .stderr_is("chgrp: it is dangerous to operate recursively on '/'\nchgrp: use --no-preserve-root to override this failsafe");
+ .stderr_is("chgrp: it is dangerous to operate recursively on '__root__/.' (same as '/')\nchgrp: use --no-preserve-root to override this failsafe\n");
+}
+
+#[test]
+fn test_preserve_root_symlink_cwd_root() {
+ new_ucmd!()
+ .current_dir("/")
+ .arg("--preserve-root")
+ .arg("-R")
+ .arg("bin").arg(".")
+ .fails()
+ .stderr_is("chgrp: it is dangerous to operate recursively on '.' (same as '/')\nchgrp: use --no-preserve-root to override this failsafe\n");
+ new_ucmd!()
+ .current_dir("/")
+ .arg("--preserve-root")
+ .arg("-R")
+ .arg("bin").arg("/.")
+ .fails()
+ .stderr_is("chgrp: it is dangerous to operate recursively on '/.' (same as '/')\nchgrp: use --no-preserve-root to override this failsafe\n");
+ new_ucmd!()
+ .current_dir("/")
+ .arg("--preserve-root")
+ .arg("-R")
+ .arg("bin").arg("..")
+ .fails()
+ .stderr_is("chgrp: it is dangerous to operate recursively on '..' (same as '/')\nchgrp: use --no-preserve-root to override this failsafe\n");
+ new_ucmd!()
+ .current_dir("/")
+ .arg("--preserve-root")
+ .arg("-R")
+ .arg("bin").arg("/..")
+ .fails()
+ .stderr_is("chgrp: it is dangerous to operate recursively on '/..' (same as '/')\nchgrp: use --no-preserve-root to override this failsafe\n");
+ new_ucmd!()
+ .current_dir("/")
+ .arg("--preserve-root")
+ .arg("-R")
+ .arg("bin")
+ .arg("...")
+ .fails()
+ .stderr_is("chgrp: cannot access '...': No such file or directory\n");
}
#[test]
@@ -137,13 +197,13 @@ fn test_reference() {
// skip for root or MS-WSL
// * MS-WSL is bugged (as of 2019-12-25), allowing non-root accounts su-level privileges for `chgrp`
// * for MS-WSL, succeeds and stdout == 'group of /etc retained as root'
- if !(get_effective_gid() == 0 || uucore::os::is_wsl_1()) {
+ if !(getegid() == 0 || uucore::os::is_wsl_1()) {
new_ucmd!()
.arg("-v")
.arg("--reference=/etc/passwd")
.arg("/etc")
.fails()
- .stderr_is("chgrp: changing group of '/etc': Operation not permitted (os error 1)\nfailed to change group of '/etc' from root to root");
+ .stderr_is("chgrp: changing group of '/etc': Operation not permitted (os error 1)\nfailed to change group of '/etc' from root to root\n");
}
}
@@ -196,14 +256,14 @@ fn test_missing_files() {
.arg("groupname")
.fails()
.stderr_contains(
- "error: The following required arguments were not provided:\n <FILE>...\n",
+ "error: the following required arguments were not provided:\n <FILE>...\n",
);
}
#[test]
#[cfg(target_os = "linux")]
fn test_big_p() {
- if get_effective_gid() != 0 {
+ if getegid() != 0 {
new_ucmd!()
.arg("-RP")
.arg("bin")
@@ -218,7 +278,7 @@ fn test_big_p() {
#[test]
#[cfg(any(target_os = "linux", target_os = "android"))]
fn test_big_h() {
- if get_effective_gid() != 0 {
+ if getegid() != 0 {
assert!(
new_ucmd!()
.arg("-RH")
@@ -270,7 +330,7 @@ fn test_permission_denied() {
.arg(group.as_raw().to_string())
.arg("dir")
.fails()
- .stderr_only("chgrp: cannot access 'dir': Permission denied");
+ .stderr_only("chgrp: cannot access 'dir': Permission denied\n");
}
}
@@ -289,7 +349,7 @@ fn test_subdir_permission_denied() {
.arg(group.as_raw().to_string())
.arg("dir")
.fails()
- .stderr_only("chgrp: cannot access 'dir/subdir': Permission denied");
+ .stderr_only("chgrp: cannot access 'dir/subdir': Permission denied\n");
}
}
diff --git a/tests/by-util/test_chmod.rs b/tests/by-util/test_chmod.rs
index fd296ba89147f9a2a7bd7cb1ed538af454d56784..32bb7a966416faf4c36a1a6d79457b2e21bfde18 100644
--- a/tests/by-util/test_chmod.rs
+++ b/tests/by-util/test_chmod.rs
@@ -1,23 +1,20 @@
-use crate::common::util::*;
-use once_cell::sync::Lazy;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::{AtPath, TestScenario, UCommand};
use std::fs::{metadata, set_permissions, OpenOptions, Permissions};
use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
-use std::sync::Mutex;
-
-extern crate libc;
-use uucore::mode::strip_minus_from_mode;
-extern crate chmod;
-use self::libc::umask;
static TEST_FILE: &str = "file";
static REFERENCE_FILE: &str = "reference";
static REFERENCE_PERMS: u32 = 0o247;
-static UMASK_MUTEX: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(()));
struct TestCase {
args: Vec<&'static str>,
before: u32,
after: u32,
+ umask: Option<libc::mode_t>,
}
fn make_file(file: &str, mode: u32) {
@@ -44,19 +41,19 @@ fn run_single_test(test: &TestCase, at: &AtPath, mut ucmd: UCommand) {
for arg in &test.args {
ucmd.arg(arg);
+ if let Some(umask) = test.umask {
+ ucmd.umask(umask);
+ }
}
let r = ucmd.run();
if !r.succeeded() {
println!("{}", r.stderr_str());
- panic!("{:?}: failed", ucmd.raw);
+ panic!("{ucmd}: failed");
}
let perms = at.metadata(TEST_FILE).permissions().mode();
if perms != test.after {
- panic!(
- "{:?}: expected: {:o} got: {:o}",
- ucmd.raw, test.after, perms
- );
+ panic!("{}: expected: {:o} got: {:o}", ucmd, test.after, perms);
}
}
@@ -75,46 +72,55 @@ fn test_chmod_octal() {
args: vec!["0700", TEST_FILE],
before: 0o100000,
after: 0o100700,
+ umask: None,
},
TestCase {
args: vec!["0070", TEST_FILE],
before: 0o100000,
after: 0o100070,
+ umask: None,
},
TestCase {
args: vec!["0007", TEST_FILE],
before: 0o100000,
after: 0o100007,
+ umask: None,
},
TestCase {
args: vec!["-0700", TEST_FILE],
before: 0o100700,
after: 0o100000,
+ umask: None,
},
TestCase {
args: vec!["-0070", TEST_FILE],
before: 0o100060,
after: 0o100000,
+ umask: None,
},
TestCase {
args: vec!["-0007", TEST_FILE],
before: 0o100001,
after: 0o100000,
+ umask: None,
},
TestCase {
args: vec!["+0100", TEST_FILE],
before: 0o100600,
after: 0o100700,
+ umask: None,
},
TestCase {
args: vec!["+0020", TEST_FILE],
before: 0o100050,
after: 0o100070,
+ umask: None,
},
TestCase {
args: vec!["+0004", TEST_FILE],
before: 0o100003,
after: 0o100007,
+ umask: None,
},
];
run_tests(tests);
@@ -124,86 +130,94 @@ fn test_chmod_octal() {
#[allow(clippy::unreadable_literal)]
// spell-checker:disable-next-line
fn test_chmod_ugoa() {
- let _guard = UMASK_MUTEX.lock();
-
- let last = unsafe { umask(0) };
let tests = vec![
TestCase {
args: vec!["u=rwx", TEST_FILE],
before: 0o100000,
after: 0o100700,
+ umask: Some(0),
},
TestCase {
args: vec!["g=rwx", TEST_FILE],
before: 0o100000,
after: 0o100070,
+ umask: Some(0),
},
TestCase {
args: vec!["o=rwx", TEST_FILE],
before: 0o100000,
after: 0o100007,
+ umask: Some(0),
},
TestCase {
args: vec!["a=rwx", TEST_FILE],
before: 0o100000,
after: 0o100777,
+ umask: Some(0),
},
TestCase {
args: vec!["-r", TEST_FILE],
before: 0o100777,
after: 0o100333,
+ umask: Some(0),
},
TestCase {
args: vec!["-w", TEST_FILE],
before: 0o100777,
after: 0o100555,
+ umask: Some(0),
},
TestCase {
args: vec!["-x", TEST_FILE],
before: 0o100777,
after: 0o100666,
+ umask: Some(0),
},
];
run_tests(tests);
- unsafe {
- umask(0o022);
- }
let tests = vec![
TestCase {
args: vec!["u=rwx", TEST_FILE],
before: 0o100000,
after: 0o100700,
+ umask: Some(0o022),
},
TestCase {
args: vec!["g=rwx", TEST_FILE],
before: 0o100000,
after: 0o100070,
+ umask: Some(0o022),
},
TestCase {
args: vec!["o=rwx", TEST_FILE],
before: 0o100000,
after: 0o100007,
+ umask: Some(0o022),
},
TestCase {
args: vec!["a=rwx", TEST_FILE],
before: 0o100000,
after: 0o100777,
+ umask: Some(0o022),
},
TestCase {
args: vec!["+rw", TEST_FILE],
before: 0o100000,
after: 0o100644,
+ umask: Some(0o022),
},
TestCase {
args: vec!["=rwx", TEST_FILE],
before: 0o100000,
after: 0o100755,
+ umask: Some(0o022),
},
TestCase {
args: vec!["-x", TEST_FILE],
before: 0o100777,
after: 0o100666,
+ umask: Some(0o022),
},
];
run_tests(tests);
@@ -216,15 +230,11 @@ fn test_chmod_ugoa() {
.fails()
.code_is(1)
// spell-checker:disable-next-line
- .stderr_is("chmod: file: new permissions are r-xrwxrwx, not r-xr-xr-x");
+ .stderr_is("chmod: file: new permissions are r-xrwxrwx, not r-xr-xr-x\n");
assert_eq!(
metadata(at.plus("file")).unwrap().permissions().mode(),
0o100577
);
-
- unsafe {
- umask(last);
- }
}
#[test]
@@ -235,26 +245,31 @@ fn test_chmod_ugo_copy() {
args: vec!["u=g", TEST_FILE],
before: 0o100070,
after: 0o100770,
+ umask: None,
},
TestCase {
args: vec!["g=o", TEST_FILE],
before: 0o100005,
after: 0o100055,
+ umask: None,
},
TestCase {
args: vec!["o=u", TEST_FILE],
before: 0o100200,
after: 0o100202,
+ umask: None,
},
TestCase {
args: vec!["u-g", TEST_FILE],
before: 0o100710,
after: 0o100610,
+ umask: None,
},
TestCase {
args: vec!["u+g", TEST_FILE],
before: 0o100250,
after: 0o100750,
+ umask: None,
},
];
run_tests(tests);
@@ -263,33 +278,30 @@ fn test_chmod_ugo_copy() {
#[test]
#[allow(clippy::unreadable_literal)]
fn test_chmod_many_options() {
- let _guard = UMASK_MUTEX.lock();
-
- let original_umask = unsafe { umask(0) };
let tests = vec![TestCase {
args: vec!["-r,a+w", TEST_FILE],
before: 0o100444,
after: 0o100222,
+ umask: Some(0),
}];
run_tests(tests);
- unsafe {
- umask(original_umask);
- }
}
#[test]
#[allow(clippy::unreadable_literal)]
fn test_chmod_reference_file() {
- let tests = vec![
+ let tests = [
TestCase {
args: vec!["--reference", REFERENCE_FILE, TEST_FILE],
before: 0o100070,
after: 0o100247,
+ umask: None,
},
TestCase {
args: vec!["a-w", "--reference", REFERENCE_FILE, TEST_FILE],
before: 0o100070,
after: 0o100247,
+ umask: None,
},
];
let (at, ucmd) = at_and_ucmd!();
@@ -314,20 +326,22 @@ fn test_permission_denied() {
.arg("o=r")
.arg("d")
.fails()
- .stderr_is("chmod: 'd/no-x/y': Permission denied");
+ .stderr_is("chmod: 'd/no-x/y': Permission denied\n");
}
#[test]
#[allow(clippy::unreadable_literal)]
fn test_chmod_recursive() {
- let _guard = UMASK_MUTEX.lock();
-
- let original_umask = unsafe { umask(0) };
let (at, mut ucmd) = at_and_ucmd!();
at.mkdir("a");
at.mkdir("a/b");
at.mkdir("a/b/c");
at.mkdir("z");
+
+ // create expected permissions by removing read bits and write bits to the current perms
+ let a_perms_expected = (at.metadata("a").permissions().mode() & !0o444) | 0o222;
+ let z_perms_expected = (at.metadata("z").permissions().mode() & !0o444) | 0o222;
+
make_file(&at.plus_as_string("a/a"), 0o100444);
make_file(&at.plus_as_string("a/b/b"), 0o100444);
make_file(&at.plus_as_string("a/b/c/c"), 0o100444);
@@ -340,20 +354,17 @@ fn test_chmod_recursive() {
.arg("-r,a+w")
.arg("a")
.arg("z")
+ .umask(0)
.fails()
- .stderr_is("chmod: Permission denied");
+ .stderr_is("chmod: Permission denied\n");
assert_eq!(at.metadata("z/y").permissions().mode(), 0o100444);
assert_eq!(at.metadata("a/a").permissions().mode(), 0o100444);
assert_eq!(at.metadata("a/b/b").permissions().mode(), 0o100444);
assert_eq!(at.metadata("a/b/c/c").permissions().mode(), 0o100444);
println!("mode {:o}", at.metadata("a").permissions().mode());
- assert_eq!(at.metadata("a").permissions().mode(), 0o40333);
- assert_eq!(at.metadata("z").permissions().mode(), 0o40333);
-
- unsafe {
- umask(original_umask);
- }
+ assert_eq!(at.metadata("a").permissions().mode(), a_perms_expected);
+ assert_eq!(at.metadata("z").permissions().mode(), z_perms_expected);
}
#[test]
@@ -414,10 +425,9 @@ fn test_chmod_symlink_non_existing_file() {
let non_existing = "test_chmod_symlink_non_existing_file";
let test_symlink = "test_chmod_symlink_non_existing_file_symlink";
let expected_stdout = &format!(
- "failed to change mode of '{}' from 0000 (---------) to 0000 (---------)",
- test_symlink
+ "failed to change mode of '{test_symlink}' from 0000 (---------) to 1500 (r-x-----T)"
);
- let expected_stderr = &format!("cannot operate on dangling symlink '{}'", test_symlink);
+ let expected_stderr = &format!("cannot operate on dangling symlink '{test_symlink}'");
at.symlink_file(non_existing, test_symlink);
@@ -443,6 +453,17 @@ fn test_chmod_symlink_non_existing_file() {
.code_is(1)
.no_stderr()
.stdout_contains(expected_stdout);
+
+ // this should only include the dangling symlink message
+ // NOT the failure to change mode
+ scene
+ .ucmd()
+ .arg("755")
+ .arg(test_symlink)
+ .run()
+ .code_is(1)
+ .no_stdout()
+ .stderr_contains(expected_stderr);
}
#[test]
@@ -455,10 +476,7 @@ fn test_chmod_symlink_non_existing_file_recursive() {
let test_directory = "test_chmod_symlink_non_existing_file_directory";
at.mkdir(test_directory);
- at.symlink_file(
- non_existing,
- &format!("{}/{}", test_directory, test_symlink),
- );
+ at.symlink_file(non_existing, &format!("{test_directory}/{test_symlink}"));
// this should succeed
scene
@@ -472,8 +490,7 @@ fn test_chmod_symlink_non_existing_file_recursive() {
let expected_stdout = &format!(
// spell-checker:disable-next-line
- "mode of '{}' retained as 0755 (rwxr-xr-x)",
- test_directory
+ "mode of '{test_directory}' retained as 0755 (rwxr-xr-x)"
);
// '-v': this should succeed without stderr
@@ -500,35 +517,6 @@ fn test_chmod_symlink_non_existing_file_recursive() {
.no_stderr();
}
-#[test]
-fn test_chmod_strip_minus_from_mode() {
- let tests = vec![
- // ( before, after )
- ("chmod -v -xw -R FILE", "chmod -v xw -R FILE"),
- ("chmod g=rwx FILE -c", "chmod g=rwx FILE -c"),
- (
- "chmod -c -R -w,o+w FILE --preserve-root",
- "chmod -c -R w,o+w FILE --preserve-root",
- ),
- ("chmod -c -R +w FILE ", "chmod -c -R +w FILE "),
- ("chmod a=r,=xX FILE", "chmod a=r,=xX FILE"),
- (
- "chmod -v --reference REF_FILE -R FILE",
- "chmod -v --reference REF_FILE -R FILE",
- ),
- ("chmod -Rvc -w-x FILE", "chmod -Rvc w-x FILE"),
- ("chmod 755 -v FILE", "chmod 755 -v FILE"),
- ("chmod -v +0004 FILE -R", "chmod -v +0004 FILE -R"),
- ("chmod -v -0007 FILE -R", "chmod -v 0007 FILE -R"),
- ];
-
- for test in tests {
- let mut args: Vec<String> = test.0.split(' ').map(|v| v.to_string()).collect();
- let _mode_had_minus_prefix = strip_minus_from_mode(&mut args);
- assert_eq!(test.1, args.join(" "));
- }
-}
-
#[test]
fn test_chmod_keep_setgid() {
for (from, arg, to) in [
@@ -567,15 +555,186 @@ fn test_invalid_arg() {
}
#[test]
+#[cfg(not(target_os = "android"))]
fn test_mode_after_dash_dash() {
let (at, ucmd) = at_and_ucmd!();
run_single_test(
&TestCase {
args: vec!["--", "-r", TEST_FILE],
- before: 0o100777,
- after: 0o100333,
+ before: 0o100_777,
+ after: 0o100_333,
+ umask: None,
},
&at,
ucmd,
);
}
+
+#[test]
+fn test_chmod_file_after_non_existing_file() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.touch(TEST_FILE);
+ at.touch("file2");
+ set_permissions(at.plus(TEST_FILE), Permissions::from_mode(0o664)).unwrap();
+ set_permissions(at.plus("file2"), Permissions::from_mode(0o664)).unwrap();
+ scene
+ .ucmd()
+ .arg("u+x")
+ .arg("does-not-exist")
+ .arg(TEST_FILE)
+ .fails()
+ .stderr_contains("chmod: cannot access 'does-not-exist': No such file or directory")
+ .code_is(1);
+
+ assert_eq!(at.metadata(TEST_FILE).permissions().mode(), 0o100_764);
+
+ scene
+ .ucmd()
+ .arg("u+x")
+ .arg("--q")
+ .arg("does-not-exist")
+ .arg("file2")
+ .fails()
+ .no_stderr()
+ .code_is(1);
+ assert_eq!(at.metadata("file2").permissions().mode(), 0o100_764);
+}
+
+#[test]
+fn test_chmod_file_symlink_after_non_existing_file() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let existing = "file";
+ let test_existing_symlink = "file_symlink";
+
+ let non_existing = "test_chmod_symlink_non_existing_file";
+ let test_dangling_symlink = "test_chmod_symlink_non_existing_file_symlink";
+ let expected_stdout = &format!(
+ "failed to change mode of '{test_dangling_symlink}' from 0000 (---------) to 1500 (r-x-----T)"
+ );
+ let expected_stderr = &format!("cannot operate on dangling symlink '{test_dangling_symlink}'");
+
+ at.touch(existing);
+ set_permissions(at.plus(existing), Permissions::from_mode(0o664)).unwrap();
+ at.symlink_file(non_existing, test_dangling_symlink);
+ at.symlink_file(existing, test_existing_symlink);
+
+ // this cannot succeed since the symbolic link dangles
+ // but the metadata for the existing target should change
+ scene
+ .ucmd()
+ .arg("u+x")
+ .arg("-v")
+ .arg(test_dangling_symlink)
+ .arg(test_existing_symlink)
+ .fails()
+ .code_is(1)
+ .stdout_contains(expected_stdout)
+ .stderr_contains(expected_stderr);
+ assert_eq!(
+ at.metadata(test_existing_symlink).permissions().mode(),
+ 0o100_764
+ );
+}
+
+#[test]
+fn test_quiet_n_verbose_used_multiple_times() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.touch("file");
+ scene
+ .ucmd()
+ .arg("u+x")
+ .arg("--verbose")
+ .arg("--verbose")
+ .arg("file")
+ .succeeds();
+ scene
+ .ucmd()
+ .arg("u+x")
+ .arg("--quiet")
+ .arg("--quiet")
+ .arg("file")
+ .succeeds();
+}
+
+#[test]
+fn test_changes_from_identical_reference() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.touch("file");
+ scene
+ .ucmd()
+ .arg("-c")
+ .arg("--reference=file")
+ .arg("file")
+ .succeeds()
+ .no_stdout();
+}
+
+#[test]
+fn test_gnu_invalid_mode() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.touch("file");
+ scene.ucmd().arg("u+gr").arg("file").fails();
+}
+
+#[test]
+#[cfg(not(target_os = "android"))]
+fn test_gnu_options() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.touch("file");
+ scene.ucmd().arg("-w").arg("file").succeeds();
+ scene.ucmd().arg("file").arg("-w").succeeds();
+ scene.ucmd().arg("-w").arg("--").arg("file").succeeds();
+}
+
+#[test]
+fn test_gnu_repeating_options() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.touch("file");
+ scene.ucmd().arg("-w").arg("-w").arg("file").succeeds();
+ scene
+ .ucmd()
+ .arg("-w")
+ .arg("-w")
+ .arg("-w")
+ .arg("file")
+ .succeeds();
+}
+
+#[test]
+fn test_gnu_special_filenames() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let perms_before = Permissions::from_mode(0o100_640);
+ let perms_after = Permissions::from_mode(0o100_440);
+
+ make_file(&at.plus_as_string("--"), perms_before.mode());
+ scene.ucmd().arg("-w").arg("--").arg("--").succeeds();
+ assert_eq!(at.metadata("--").permissions(), perms_after);
+ set_permissions(at.plus("--"), perms_before.clone()).unwrap();
+ scene.ucmd().arg("--").arg("-w").arg("--").succeeds();
+ assert_eq!(at.metadata("--").permissions(), perms_after);
+ at.remove("--");
+
+ make_file(&at.plus_as_string("-w"), perms_before.mode());
+ scene.ucmd().arg("-w").arg("--").arg("-w").succeeds();
+ assert_eq!(at.metadata("-w").permissions(), perms_after);
+ set_permissions(at.plus("-w"), perms_before).unwrap();
+ scene.ucmd().arg("--").arg("-w").arg("-w").succeeds();
+ assert_eq!(at.metadata("-w").permissions(), perms_after);
+}
+
+#[test]
+fn test_gnu_special_options() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.touch("file");
+ scene.ucmd().arg("--").arg("--").arg("file").succeeds();
+ scene.ucmd().arg("--").arg("--").fails();
+}
diff --git a/tests/by-util/test_chown.rs b/tests/by-util/test_chown.rs
index 716e7f48f7e70c7ce18ad2ad0a5ab5a5397e8f1c..f893d2611a3816bf4b5db7c9032a9d7f71eb3cde 100644
--- a/tests/by-util/test_chown.rs
+++ b/tests/by-util/test_chown.rs
@@ -1,10 +1,12 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (words) agroupthatdoesntexist auserthatdoesntexist cuuser groupname notexisting passgrp
-use crate::common::util::*;
+use crate::common::util::{is_ci, run_ucmd_as_root, CmdResult, TestScenario};
#[cfg(any(target_os = "linux", target_os = "android"))]
-use rust_users::get_effective_uid;
-
-extern crate chown;
+use uucore::process::geteuid;
// Apparently some CI environments have configuration issues, e.g. with 'whoami' and 'id'.
// If we are running inside the CI and "needle" is in "stderr" skipping this test is
@@ -36,7 +38,7 @@ fn skipping_test_is_okay(result: &CmdResult, needle: &str) -> bool {
#[cfg(test)]
mod test_passgrp {
- use super::chown::entries::{gid2grp, grp2gid, uid2usr, usr2uid};
+ use chown::entries::{gid2grp, grp2gid, uid2usr, usr2uid};
#[test]
fn test_usr2uid() {
@@ -138,7 +140,7 @@ fn test_chown_only_owner_colon() {
scene
.ucmd()
- .arg(format!("{}:", user_name))
+ .arg(format!("{user_name}:"))
.arg("--verbose")
.arg(file1)
.succeeds()
@@ -146,7 +148,7 @@ fn test_chown_only_owner_colon() {
scene
.ucmd()
- .arg(format!("{}.", user_name))
+ .arg(format!("{user_name}."))
.arg("--verbose")
.arg(file1)
.succeeds()
@@ -244,7 +246,7 @@ fn test_chown_owner_group() {
let result = scene
.ucmd()
- .arg(format!("{}:{}", user_name, group_name))
+ .arg(format!("{user_name}:{group_name}"))
.arg("--verbose")
.arg(file1)
.run();
@@ -309,7 +311,7 @@ fn test_chown_various_input() {
let result = scene
.ucmd()
- .arg(format!("{}:{}", user_name, group_name))
+ .arg(format!("{user_name}:{group_name}"))
.arg("--verbose")
.arg(file1)
.run();
@@ -321,7 +323,7 @@ fn test_chown_various_input() {
// check that username.groupname is understood
let result = scene
.ucmd()
- .arg(format!("{}.{}", user_name, group_name))
+ .arg(format!("{user_name}.{group_name}"))
.arg("--verbose")
.arg(file1)
.run();
@@ -365,7 +367,7 @@ fn test_chown_only_group() {
let result = scene
.ucmd()
- .arg(format!(":{}", user_name))
+ .arg(format!(":{user_name}"))
.arg("--verbose")
.arg(file1)
.run();
@@ -396,7 +398,7 @@ fn test_chown_only_user_id() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
- let result = scene.cmd_keepenv("id").arg("-u").run();
+ let result = scene.cmd("id").arg("-u").run();
if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
return;
}
@@ -430,7 +432,7 @@ fn test_chown_fail_id() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
- let result = scene.cmd_keepenv("id").arg("-u").run();
+ let result = scene.cmd("id").arg("-u").run();
if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
return;
}
@@ -442,14 +444,14 @@ fn test_chown_fail_id() {
scene
.ucmd()
- .arg(format!("{}:", user_id))
+ .arg(format!("{user_id}:"))
.arg(file1)
.fails()
.stderr_contains("invalid spec");
scene
.ucmd()
- .arg(format!("{}.", user_id))
+ .arg(format!("{user_id}."))
.arg(file1)
.fails()
.stderr_contains("invalid spec");
@@ -469,7 +471,7 @@ fn test_chown_fail_id() {
#[test]
fn test_chown_only_user_id_nonexistent_user() {
let ts = TestScenario::new(util_name!());
- let at = ts.fixtures.clone();
+ let at = &ts.fixtures;
at.touch("f");
if let Ok(result) = run_ucmd_as_root(&ts, &["12345", "f"]) {
result.success().no_stdout().no_stderr();
@@ -487,7 +489,7 @@ fn test_chown_only_group_id() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
- let result = scene.cmd_keepenv("id").arg("-g").run();
+ let result = scene.cmd("id").arg("-g").run();
if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
return;
}
@@ -499,7 +501,7 @@ fn test_chown_only_group_id() {
let result = scene
.ucmd()
- .arg(format!(":{}", group_id))
+ .arg(format!(":{group_id}"))
.arg("--verbose")
.arg(file1)
.run();
@@ -535,7 +537,7 @@ fn test_chown_only_group_id() {
#[test]
fn test_chown_only_group_id_nonexistent_group() {
let ts = TestScenario::new(util_name!());
- let at = ts.fixtures.clone();
+ let at = &ts.fixtures;
at.touch("f");
if let Ok(result) = run_ucmd_as_root(&ts, &[":12345", "f"]) {
result.success().no_stdout().no_stderr();
@@ -551,14 +553,14 @@ fn test_chown_owner_group_id() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
- let result = scene.cmd_keepenv("id").arg("-u").run();
+ let result = scene.cmd("id").arg("-u").run();
if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
return;
}
let user_id = String::from(result.stdout_str().trim());
assert!(!user_id.is_empty());
- let result = scene.cmd_keepenv("id").arg("-g").run();
+ let result = scene.cmd("id").arg("-g").run();
if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
return;
}
@@ -570,7 +572,7 @@ fn test_chown_owner_group_id() {
let result = scene
.ucmd()
- .arg(format!("{}:{}", user_id, group_id))
+ .arg(format!("{user_id}:{group_id}"))
.arg("--verbose")
.arg(file1)
.run();
@@ -583,7 +585,7 @@ fn test_chown_owner_group_id() {
let result = scene
.ucmd()
- .arg(format!("{}.{}", user_id, group_id))
+ .arg(format!("{user_id}.{group_id}"))
.arg("--verbose")
.arg(file1)
.run();
@@ -612,14 +614,14 @@ fn test_chown_owner_group_mix() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
- let result = scene.cmd_keepenv("id").arg("-u").run();
+ let result = scene.cmd("id").arg("-u").run();
if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
return;
}
let user_id = String::from(result.stdout_str().trim());
assert!(!user_id.is_empty());
- let result = scene.cmd_keepenv("id").arg("-gn").run();
+ let result = scene.cmd("id").arg("-gn").run();
if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
return;
}
@@ -631,7 +633,7 @@ fn test_chown_owner_group_mix() {
let result = scene
.ucmd()
- .arg(format!("{}:{}", user_id, group_name))
+ .arg(format!("{user_id}:{group_name}"))
.arg("--verbose")
.arg(file1)
.run();
@@ -662,10 +664,10 @@ fn test_chown_recursive() {
at.mkdir_all("a/b/c");
at.mkdir("z");
- at.touch(&at.plus_as_string("a/a"));
- at.touch(&at.plus_as_string("a/b/b"));
- at.touch(&at.plus_as_string("a/b/c/c"));
- at.touch(&at.plus_as_string("z/y"));
+ at.touch(at.plus_as_string("a/a"));
+ at.touch(at.plus_as_string("a/b/b"));
+ at.touch(at.plus_as_string("a/b/c/c"));
+ at.touch(at.plus_as_string("z/y"));
let result = scene
.ucmd()
@@ -703,7 +705,7 @@ fn test_root_preserve() {
#[cfg(any(target_os = "linux", target_os = "android"))]
#[test]
fn test_big_p() {
- if get_effective_uid() != 0 {
+ if geteuid() != 0 {
new_ucmd!()
.arg("-RP")
.arg("bin")
@@ -732,15 +734,107 @@ fn test_chown_file_notexisting() {
let user_name = String::from(result.stdout_str().trim());
assert!(!user_name.is_empty());
- let _result = scene
+ scene
.ucmd()
- .arg(user_name)
+ .arg(&user_name)
.arg("--verbose")
.arg("not_existing")
- .fails();
-
- // TODO: uncomment once "failed to change ownership of '{}' to {}" added to stdout
- // result.stderr_contains("retained as");
+ .fails()
+ .stdout_contains(format!(
+ "failed to change ownership of 'not_existing' to {user_name}"
+ ));
// TODO: uncomment once message changed from "cannot dereference" to "cannot access"
// result.stderr_contains("cannot access 'not_existing': No such file or directory");
}
+
+#[test]
+fn test_chown_no_change_to_user() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ let result = scene.cmd("whoami").run();
+ if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
+ return;
+ }
+ let user_name = String::from(result.stdout_str().trim());
+ assert!(!user_name.is_empty());
+
+ for (i, from) in ["42", ":42", "42:42"].iter().enumerate() {
+ let file = i.to_string();
+ at.touch(&file);
+ scene
+ .ucmd()
+ .arg("-v")
+ .arg(format!("--from={from}"))
+ .arg("43")
+ .arg(&file)
+ .succeeds()
+ .stdout_only(format!("ownership of '{file}' retained as {user_name}\n"));
+ }
+}
+
+#[test]
+fn test_chown_no_change_to_group() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ let result = scene.cmd("whoami").run();
+ if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
+ return;
+ }
+ let user_name = String::from(result.stdout_str().trim());
+ assert!(!user_name.is_empty());
+ let result = scene.cmd("id").arg("-ng").run();
+ if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
+ return;
+ }
+ let group_name = String::from(result.stdout_str().trim());
+ assert!(!group_name.is_empty());
+
+ for (i, from) in ["42", ":42", "42:42"].iter().enumerate() {
+ let file = i.to_string();
+ at.touch(&file);
+ scene
+ .ucmd()
+ .arg("-v")
+ .arg(format!("--from={from}"))
+ .arg(":43")
+ .arg(&file)
+ .succeeds()
+ .stdout_only(format!("ownership of '{file}' retained as {group_name}\n"));
+ }
+}
+
+#[test]
+fn test_chown_no_change_to_user_group() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ let result = scene.cmd("whoami").run();
+ if skipping_test_is_okay(&result, "whoami: cannot find name for user ID") {
+ return;
+ }
+ let user_name = String::from(result.stdout_str().trim());
+ assert!(!user_name.is_empty());
+ let result = scene.cmd("id").arg("-ng").run();
+ if skipping_test_is_okay(&result, "id: cannot find name for group ID") {
+ return;
+ }
+ let group_name = String::from(result.stdout_str().trim());
+ assert!(!group_name.is_empty());
+
+ for (i, from) in ["42", ":42", "42:42"].iter().enumerate() {
+ let file = i.to_string();
+ at.touch(&file);
+ scene
+ .ucmd()
+ .arg("-v")
+ .arg(format!("--from={from}"))
+ .arg("43:43")
+ .arg(&file)
+ .succeeds()
+ .stdout_only(format!(
+ "ownership of '{file}' retained as {user_name}:{group_name}\n"
+ ));
+ }
+}
diff --git a/tests/by-util/test_chroot.rs b/tests/by-util/test_chroot.rs
index b53ca4e5bc2af0ed10b06a5a163a4644fbd9a823..bf6b2ce16f10be28c3e53515b9db519d4fac2840 100644
--- a/tests/by-util/test_chroot.rs
+++ b/tests/by-util/test_chroot.rs
@@ -1,6 +1,12 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (words) araba newroot userspec chdir pwd's isroot
-use crate::common::util::*;
+#[cfg(not(target_os = "android"))]
+use crate::common::util::is_ci;
+use crate::common::util::{run_ucmd_as_root, TestScenario};
#[test]
fn test_invalid_arg() {
@@ -15,7 +21,7 @@ fn test_missing_operand() {
assert!(result
.stderr_str()
- .starts_with("error: The following required arguments were not provided"));
+ .starts_with("error: the following required arguments were not provided"));
assert!(result.stderr_str().contains("<newroot>"));
}
@@ -39,11 +45,11 @@ fn test_enter_chroot_fails() {
fn test_no_such_directory() {
let (at, mut ucmd) = at_and_ucmd!();
- at.touch(&at.plus_as_string("a"));
+ at.touch(at.plus_as_string("a"));
ucmd.arg("a")
.fails()
- .stderr_is("chroot: cannot change root directory to 'a': no such directory")
+ .stderr_is("chroot: cannot change root directory to 'a': no such directory\n")
.code_is(125);
}
@@ -94,7 +100,7 @@ fn test_preference_of_userspec() {
.arg("fake")
.arg("-G")
.arg("ABC,DEF")
- .arg(format!("--userspec={}:{}", username, group_name))
+ .arg(format!("--userspec={username}:{group_name}"))
.fails();
result.code_is(125);
@@ -113,15 +119,12 @@ fn test_default_shell() {
at.mkdir(dir);
let shell = std::env::var("SHELL").unwrap_or_else(|_| "/bin/sh".to_string());
- let expected = format!(
- "chroot: failed to run command '{}': No such file or directory",
- shell
- );
+ let expected = format!("chroot: failed to run command '{shell}': No such file or directory");
if let Ok(result) = run_ucmd_as_root(&ts, &[dir]) {
result.stderr_contains(expected);
} else {
- print!("TEST SKIPPED");
+ print!("Test skipped; requires root user");
}
}
@@ -162,7 +165,7 @@ fn test_chroot_skip_chdir_not_root() {
#[test]
fn test_chroot_skip_chdir() {
let ts = TestScenario::new(util_name!());
- let at = ts.fixtures.clone();
+ let at = &ts.fixtures;
let dirs = ["/", "/.", "/..", "isroot"];
at.symlink_file("/", "isroot");
for dir in dirs {
diff --git a/tests/by-util/test_cksum.rs b/tests/by-util/test_cksum.rs
index 523715126a618657f0be7b7f111b278f2fd780db..04a05124c411ee909439a5280f56b1af93a36f45 100644
--- a/tests/by-util/test_cksum.rs
+++ b/tests/by-util/test_cksum.rs
@@ -1,6 +1,14 @@
-// spell-checker:ignore (words) asdf
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore (words) asdf algo algos
-use crate::common::util::*;
+use crate::common::util::TestScenario;
+
+const ALGOS: [&str; 11] = [
+ "sysv", "bsd", "crc", "md5", "sha1", "sha224", "sha256", "sha384", "sha512", "blake2b", "sm3",
+];
#[test]
fn test_invalid_arg() {
@@ -12,7 +20,7 @@ fn test_single_file() {
new_ucmd!()
.arg("lorem_ipsum.txt")
.succeeds()
- .stdout_is_fixture("single_file.expected");
+ .stdout_is_fixture("crc_single_file.expected");
}
#[test]
@@ -21,7 +29,7 @@ fn test_multiple_files() {
.arg("lorem_ipsum.txt")
.arg("alice_in_wonderland.txt")
.succeeds()
- .stdout_is_fixture("multiple_files.expected");
+ .stdout_is_fixture("crc_multiple_files.expected");
}
#[test]
@@ -29,11 +37,11 @@ fn test_stdin() {
new_ucmd!()
.pipe_in_fixture("lorem_ipsum.txt")
.succeeds()
- .stdout_is_fixture("stdin.expected");
+ .stdout_is_fixture("crc_stdin.expected");
}
#[test]
-fn test_empty() {
+fn test_empty_file() {
let (at, mut ucmd) = at_and_ucmd!();
at.touch("a");
@@ -62,25 +70,45 @@ fn test_arg_overrides_stdin() {
}
#[test]
-fn test_invalid_file() {
- let ts = TestScenario::new(util_name!());
- let at = ts.fixtures.clone();
-
- let folder_name = "asdf";
+fn test_nonexisting_file() {
+ let file_name = "asdf";
- // First check when file doesn't exist
- ts.ucmd()
- .arg(folder_name)
+ new_ucmd!()
+ .arg(file_name)
.fails()
.no_stdout()
- .stderr_contains("cksum: asdf: No such file or directory");
+ .stderr_contains(format!("cksum: {file_name}: No such file or directory"));
+}
- // Then check when the file is of an invalid type
- at.mkdir(folder_name);
- ts.ucmd()
- .arg(folder_name)
- .succeeds()
- .stdout_only("4294967295 0 asdf\n");
+#[test]
+fn test_nonexisting_file_out() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.write(
+ "f",
+ "MD5 (nonexistent) = e5773576fc75ff0f8eba14f61587ae28\n",
+ );
+
+ ucmd.arg("-c")
+ .arg("f")
+ .fails()
+ .stdout_contains("nonexistent: FAILED open or read")
+ .stderr_contains("cksum: nonexistent: No such file or directory");
+}
+
+#[test]
+fn test_one_nonexisting_file() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ at.touch("abc.txt");
+ at.touch("xyz.txt");
+
+ ucmd.arg("abc.txt")
+ .arg("asdf.txt")
+ .arg("xyz.txt")
+ .fails()
+ .stdout_contains_line("4294967295 0 xyz.txt")
+ .stderr_contains("asdf.txt: No such file or directory")
+ .stdout_contains_line("4294967295 0 abc.txt");
}
// Make sure crc is correct for files larger than 32 bytes
@@ -114,3 +142,1062 @@ fn test_stdin_larger_than_128_bytes() {
assert_eq!(cksum, 945_881_979);
assert_eq!(bytes_cnt, 2058);
}
+
+#[test]
+fn test_repeated_flags() {
+ new_ucmd!()
+ .arg("-a")
+ .arg("sha1")
+ .arg("--algo=sha256")
+ .arg("-a=md5")
+ .arg("lorem_ipsum.txt")
+ .succeeds()
+ .stdout_is_fixture("md5_single_file.expected");
+}
+
+#[test]
+fn test_tag_after_untagged() {
+ new_ucmd!()
+ .arg("--untagged")
+ .arg("--tag")
+ .arg("-a=md5")
+ .arg("lorem_ipsum.txt")
+ .succeeds()
+ .stdout_is_fixture("md5_single_file.expected");
+}
+
+#[test]
+fn test_algorithm_single_file() {
+ for algo in ALGOS {
+ for option in ["-a", "--algorithm"] {
+ new_ucmd!()
+ .arg(format!("{option}={algo}"))
+ .arg("lorem_ipsum.txt")
+ .succeeds()
+ .stdout_is_fixture(format!("{algo}_single_file.expected"));
+ }
+ }
+}
+
+#[test]
+fn test_algorithm_multiple_files() {
+ for algo in ALGOS {
+ for option in ["-a", "--algorithm"] {
+ new_ucmd!()
+ .arg(format!("{option}={algo}"))
+ .arg("lorem_ipsum.txt")
+ .arg("alice_in_wonderland.txt")
+ .succeeds()
+ .stdout_is_fixture(format!("{algo}_multiple_files.expected"));
+ }
+ }
+}
+
+#[test]
+fn test_algorithm_stdin() {
+ for algo in ALGOS {
+ for option in ["-a", "--algorithm"] {
+ new_ucmd!()
+ .arg(format!("{option}={algo}"))
+ .pipe_in_fixture("lorem_ipsum.txt")
+ .succeeds()
+ .stdout_is_fixture(format!("{algo}_stdin.expected"));
+ }
+ }
+}
+
+#[test]
+fn test_untagged_single_file() {
+ new_ucmd!()
+ .arg("--untagged")
+ .arg("lorem_ipsum.txt")
+ .succeeds()
+ .stdout_is_fixture("untagged/crc_single_file.expected");
+}
+
+#[test]
+fn test_untagged_multiple_files() {
+ new_ucmd!()
+ .arg("--untagged")
+ .arg("lorem_ipsum.txt")
+ .arg("alice_in_wonderland.txt")
+ .succeeds()
+ .stdout_is_fixture("untagged/crc_multiple_files.expected");
+}
+
+#[test]
+fn test_untagged_stdin() {
+ new_ucmd!()
+ .arg("--untagged")
+ .pipe_in_fixture("lorem_ipsum.txt")
+ .succeeds()
+ .stdout_is_fixture("untagged/crc_stdin.expected");
+}
+
+#[test]
+fn test_untagged_algorithm_single_file() {
+ for algo in ALGOS {
+ new_ucmd!()
+ .arg("--untagged")
+ .arg(format!("--algorithm={algo}"))
+ .arg("lorem_ipsum.txt")
+ .succeeds()
+ .stdout_is_fixture(format!("untagged/{algo}_single_file.expected"));
+ }
+}
+
+#[test]
+fn test_tag_short() {
+ new_ucmd!()
+ .arg("-t")
+ .arg("--untagged")
+ .arg("--algorithm=md5")
+ .arg("lorem_ipsum.txt")
+ .succeeds()
+ .stdout_is("cd724690f7dc61775dfac400a71f2caa lorem_ipsum.txt\n");
+}
+
+#[test]
+fn test_untagged_algorithm_after_tag() {
+ new_ucmd!()
+ .arg("--tag")
+ .arg("--untagged")
+ .arg("--algorithm=md5")
+ .arg("lorem_ipsum.txt")
+ .succeeds()
+ .stdout_is_fixture("untagged/md5_single_file.expected");
+}
+
+#[test]
+fn test_untagged_algorithm_multiple_files() {
+ for algo in ALGOS {
+ new_ucmd!()
+ .arg("--untagged")
+ .arg(format!("--algorithm={algo}"))
+ .arg("lorem_ipsum.txt")
+ .arg("alice_in_wonderland.txt")
+ .succeeds()
+ .stdout_is_fixture(format!("untagged/{algo}_multiple_files.expected"));
+ }
+}
+
+#[test]
+fn test_untagged_algorithm_stdin() {
+ for algo in ALGOS {
+ new_ucmd!()
+ .arg("--untagged")
+ .arg(format!("--algorithm={algo}"))
+ .pipe_in_fixture("lorem_ipsum.txt")
+ .succeeds()
+ .stdout_is_fixture(format!("untagged/{algo}_stdin.expected"));
+ }
+}
+
+#[test]
+fn test_check_algo() {
+ new_ucmd!()
+ .arg("-a=bsd")
+ .arg("--check")
+ .arg("lorem_ipsum.txt")
+ .fails()
+ .no_stdout()
+ .stderr_contains("cksum: --check is not supported with --algorithm={bsd,sysv,crc}")
+ .code_is(1);
+ new_ucmd!()
+ .arg("-a=sysv")
+ .arg("--check")
+ .arg("lorem_ipsum.txt")
+ .fails()
+ .no_stdout()
+ .stderr_contains("cksum: --check is not supported with --algorithm={bsd,sysv,crc}")
+ .code_is(1);
+ new_ucmd!()
+ .arg("-a=crc")
+ .arg("--check")
+ .arg("lorem_ipsum.txt")
+ .fails()
+ .no_stdout()
+ .stderr_contains("cksum: --check is not supported with --algorithm={bsd,sysv,crc}")
+ .code_is(1);
+}
+
+#[test]
+fn test_length_with_wrong_algorithm() {
+ new_ucmd!()
+ .arg("--length=16")
+ .arg("--algorithm=md5")
+ .arg("lorem_ipsum.txt")
+ .fails()
+ .no_stdout()
+ .stderr_contains("cksum: --length is only supported with --algorithm=blake2b")
+ .code_is(1);
+
+ new_ucmd!()
+ .arg("--length=16")
+ .arg("--algorithm=md5")
+ .arg("-c")
+ .arg("foo.sums")
+ .fails()
+ .no_stdout()
+ .stderr_contains("cksum: --length is only supported with --algorithm=blake2b")
+ .code_is(1);
+}
+
+#[test]
+fn test_length_not_supported() {
+ new_ucmd!()
+ .arg("--length=15")
+ .arg("lorem_ipsum.txt")
+ .fails()
+ .no_stdout()
+ .stderr_contains("--length is only supported with --algorithm=blake2b")
+ .code_is(1);
+}
+
+#[test]
+fn test_length() {
+ new_ucmd!()
+ .arg("--length=16")
+ .arg("--algorithm=blake2b")
+ .arg("lorem_ipsum.txt")
+ .arg("alice_in_wonderland.txt")
+ .succeeds()
+ .stdout_contains(
+ "BLAKE2b-16 (lorem_ipsum.txt) = 7e2f\nBLAKE2b-16 (alice_in_wonderland.txt) = a546",
+ );
+}
+
+#[test]
+fn test_length_greater_than_512() {
+ new_ucmd!()
+ .arg("--length=1024")
+ .arg("--algorithm=blake2b")
+ .arg("lorem_ipsum.txt")
+ .arg("alice_in_wonderland.txt")
+ .fails()
+ .no_stdout()
+ .stderr_is_fixture("length_larger_than_512.expected");
+}
+
+#[test]
+fn test_length_is_zero() {
+ new_ucmd!()
+ .arg("--length=0")
+ .arg("--algorithm=blake2b")
+ .arg("lorem_ipsum.txt")
+ .arg("alice_in_wonderland.txt")
+ .succeeds()
+ .no_stderr()
+ .stdout_is_fixture("length_is_zero.expected");
+}
+
+#[test]
+fn test_length_repeated() {
+ new_ucmd!()
+ .arg("--length=10")
+ .arg("--length=123456")
+ .arg("--length=0")
+ .arg("--algorithm=blake2b")
+ .arg("lorem_ipsum.txt")
+ .arg("alice_in_wonderland.txt")
+ .succeeds()
+ .no_stderr()
+ .stdout_is_fixture("length_is_zero.expected");
+}
+
+#[test]
+fn test_raw_single_file() {
+ for algo in ALGOS {
+ new_ucmd!()
+ .arg("--raw")
+ .arg("lorem_ipsum.txt")
+ .arg(format!("--algorithm={algo}"))
+ .succeeds()
+ .no_stderr()
+ .stdout_is_fixture_bytes(format!("raw/{algo}_single_file.expected"));
+ }
+}
+#[test]
+fn test_raw_multiple_files() {
+ new_ucmd!()
+ .arg("--raw")
+ .arg("lorem_ipsum.txt")
+ .arg("alice_in_wonderland.txt")
+ .fails()
+ .no_stdout()
+ .stderr_contains("cksum: the --raw option is not supported with multiple files")
+ .code_is(1);
+}
+
+#[test]
+fn test_base64_raw_conflicts() {
+ new_ucmd!()
+ .arg("--base64")
+ .arg("--raw")
+ .arg("lorem_ipsum.txt")
+ .fails()
+ .no_stdout()
+ .stderr_contains("--base64")
+ .stderr_contains("cannot be used with")
+ .stderr_contains("--raw");
+}
+
+#[test]
+fn test_base64_single_file() {
+ for algo in ALGOS {
+ new_ucmd!()
+ .arg("--base64")
+ .arg("lorem_ipsum.txt")
+ .arg(format!("--algorithm={algo}"))
+ .succeeds()
+ .no_stderr()
+ .stdout_is_fixture_bytes(format!("base64/{algo}_single_file.expected"));
+ }
+}
+#[test]
+fn test_base64_multiple_files() {
+ new_ucmd!()
+ .arg("--base64")
+ .arg("--algorithm=md5")
+ .arg("lorem_ipsum.txt")
+ .arg("alice_in_wonderland.txt")
+ .succeeds()
+ .no_stderr()
+ .stdout_is_fixture_bytes("base64/md5_multiple_files.expected");
+}
+
+#[test]
+fn test_fail_on_folder() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let folder_name = "a_folder";
+ at.mkdir(folder_name);
+
+ ucmd.arg(folder_name)
+ .fails()
+ .no_stdout()
+ .stderr_contains(format!("cksum: {folder_name}: Is a directory"));
+}
+
+#[test]
+fn test_all_algorithms_fail_on_folder() {
+ let scene = TestScenario::new(util_name!());
+
+ let at = &scene.fixtures;
+
+ let folder_name = "a_folder";
+ at.mkdir(folder_name);
+
+ for algo in ALGOS {
+ scene
+ .ucmd()
+ .arg(format!("--algorithm={algo}"))
+ .arg(folder_name)
+ .fails()
+ .no_stdout()
+ .stderr_contains(format!("cksum: {folder_name}: Is a directory"));
+ }
+}
+
+#[cfg(unix)]
+#[test]
+fn test_check_error_incorrect_format() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.write("checksum", "e5773576fc75ff0f8eba14f61587ae28 README.md");
+
+ scene
+ .ucmd()
+ .arg("-c")
+ .arg("checksum")
+ .fails()
+ .stderr_contains("no properly formatted checksum lines found");
+}
+
+#[cfg(unix)]
+#[test]
+fn test_dev_null() {
+ let scene = TestScenario::new(util_name!());
+
+ scene
+ .ucmd()
+ .arg("--tag")
+ .arg("--untagged")
+ .arg("--algorithm=md5")
+ .arg("/dev/null")
+ .succeeds()
+ .stdout_contains("d41d8cd98f00b204e9800998ecf8427e ");
+}
+
+#[cfg(unix)]
+#[test]
+fn test_blake2b_512() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+
+ scene
+ .ucmd()
+ .arg("-a")
+ .arg("blake2b")
+ .arg("-l512")
+ .arg("f")
+ .succeeds()
+ .stdout_contains("BLAKE2b (f) = 786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce");
+
+ // test also the read
+ at.write("checksum", "BLAKE2b (f) = 786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce");
+ scene
+ .ucmd()
+ .arg("--check")
+ .arg("checksum")
+ .succeeds()
+ .stdout_contains("f: OK");
+
+ scene
+ .ucmd()
+ .arg("--status")
+ .arg("--check")
+ .arg("checksum")
+ .succeeds()
+ .no_output();
+}
+
+#[test]
+fn test_reset_binary() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+
+ scene
+ .ucmd()
+ .arg("--binary") // should disappear because of the following option
+ .arg("--tag")
+ .arg("--untagged")
+ .arg("--algorithm=md5")
+ .arg(at.subdir.join("f"))
+ .succeeds()
+ .stdout_contains("d41d8cd98f00b204e9800998ecf8427e ");
+}
+
+#[ignore = "issue #6375"]
+#[test]
+fn test_reset_binary_but_set() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+
+ scene
+ .ucmd()
+ .arg("--binary")
+ .arg("--tag")
+ .arg("--untagged")
+ .arg("--binary")
+ .arg("--algorithm=md5")
+ .arg(at.subdir.join("f"))
+ .succeeds()
+ .stdout_contains("d41d8cd98f00b204e9800998ecf8427e *"); // currently, asterisk=false. It should be true
+}
+
+#[test]
+fn test_text_tag() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+
+ scene
+ .ucmd()
+ .arg("--text") // should disappear because of the following option
+ .arg("--tag")
+ .arg(at.subdir.join("f"))
+ .succeeds()
+ .stdout_contains("4294967295 0 ");
+}
+
+#[test]
+fn test_binary_file() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+
+ scene
+ .ucmd()
+ .arg("--untagged")
+ .arg("-b")
+ .arg("--algorithm=md5")
+ .arg(at.subdir.join("f"))
+ .succeeds()
+ .stdout_contains("d41d8cd98f00b204e9800998ecf8427e *");
+
+ scene
+ .ucmd()
+ .arg("--tag")
+ .arg("--untagged")
+ .arg("--binary")
+ .arg("--algorithm=md5")
+ .arg(at.subdir.join("f"))
+ .succeeds()
+ .stdout_contains("d41d8cd98f00b204e9800998ecf8427e *");
+
+ scene
+ .ucmd()
+ .arg("--tag")
+ .arg("--untagged")
+ .arg("--binary")
+ .arg("--algorithm=md5")
+ .arg("raw/blake2b_single_file.expected")
+ .succeeds()
+ .stdout_contains("7e297c07ed8e053600092f91bdd1dad7 *");
+
+ new_ucmd!()
+ .arg("--tag")
+ .arg("--untagged")
+ .arg("--binary")
+ .arg("--algorithm=md5")
+ .arg("lorem_ipsum.txt")
+ .succeeds()
+ .stdout_is("cd724690f7dc61775dfac400a71f2caa *lorem_ipsum.txt\n");
+
+ new_ucmd!()
+ .arg("--untagged")
+ .arg("--binary")
+ .arg("--algorithm=md5")
+ .arg("lorem_ipsum.txt")
+ .succeeds()
+ .stdout_is("cd724690f7dc61775dfac400a71f2caa *lorem_ipsum.txt\n");
+
+ new_ucmd!()
+ .arg("--binary")
+ .arg("--untagged")
+ .arg("--algorithm=md5")
+ .arg("lorem_ipsum.txt")
+ .succeeds()
+ .stdout_is("cd724690f7dc61775dfac400a71f2caa *lorem_ipsum.txt\n");
+
+ new_ucmd!()
+ .arg("-a")
+ .arg("md5")
+ .arg("--binary")
+ .arg("--untagged")
+ .arg("lorem_ipsum.txt")
+ .succeeds()
+ .stdout_is("cd724690f7dc61775dfac400a71f2caa *lorem_ipsum.txt\n");
+
+ new_ucmd!()
+ .arg("-a")
+ .arg("md5")
+ .arg("--binary")
+ .arg("--tag")
+ .arg("--untagged")
+ .arg("lorem_ipsum.txt")
+ .succeeds()
+ .stdout_is("cd724690f7dc61775dfac400a71f2caa lorem_ipsum.txt\n");
+}
+
+#[test]
+fn test_folder_and_file() {
+ let scene = TestScenario::new(util_name!());
+
+ let at = &scene.fixtures;
+
+ let folder_name = "a_folder";
+ at.mkdir(folder_name);
+
+ scene
+ .ucmd()
+ .arg(folder_name)
+ .arg("lorem_ipsum.txt")
+ .fails()
+ .stderr_contains(format!("cksum: {folder_name}: Is a directory"))
+ .stdout_is_fixture("crc_single_file.expected");
+}
+
+#[test]
+fn test_conflicting_options() {
+ let scene = TestScenario::new(util_name!());
+
+ let at = &scene.fixtures;
+
+ at.touch("f");
+
+ scene
+ .ucmd()
+ .arg("--binary")
+ .arg("--check")
+ .arg("f")
+ .fails()
+ .no_stdout()
+ .stderr_contains(
+ "cksum: the --binary and --text options are meaningless when verifying checksums",
+ )
+ .code_is(1);
+}
+
+#[test]
+fn test_check_algo_err() {
+ let scene = TestScenario::new(util_name!());
+
+ let at = &scene.fixtures;
+
+ at.touch("f");
+
+ scene
+ .ucmd()
+ .arg("-a")
+ .arg("sm3")
+ .arg("--check")
+ .arg("f")
+ .fails()
+ .no_stdout()
+ .stderr_contains("cksum: f: no properly formatted checksum lines found")
+ .code_is(1);
+}
+
+#[test]
+fn test_check_pipe() {
+ let scene = TestScenario::new(util_name!());
+
+ let at = &scene.fixtures;
+
+ at.touch("f");
+
+ scene
+ .ucmd()
+ .arg("--check")
+ .arg("-")
+ .pipe_in("f")
+ .fails()
+ .no_stdout()
+ .stderr_contains("cksum: 'standard input': no properly formatted checksum lines found")
+ .code_is(1);
+}
+
+#[test]
+fn test_cksum_check_empty_line() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+ at.write("CHECKSUM", "\
+ SHA384 (f) = 38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b\n\
+ BLAKE2b (f) = 786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce\n\
+ BLAKE2b-384 (f) = b32811423377f52d7862286ee1a72ee540524380fda1724a6f25d7978c6fd3244a6caf0498812673c5e05ef583825100\n\
+ SM3 (f) = 1ab21d8355cfa17f8e61194831e81a8f22bec8c728fefb747ed035eb5082aa2b\n\n");
+ scene
+ .ucmd()
+ .arg("--check")
+ .arg("CHECKSUM")
+ .succeeds()
+ .stdout_contains("f: OK\nf: OK\nf: OK\nf: OK\n")
+ .stderr_does_not_contain("line is improperly formatted");
+}
+
+#[test]
+fn test_cksum_check_space() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+ at.write("CHECKSUM", "\
+ SHA384 (f) = 38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b\n\
+ BLAKE2b (f) = 786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce\n\
+ BLAKE2b-384 (f) = b32811423377f52d7862286ee1a72ee540524380fda1724a6f25d7978c6fd3244a6caf0498812673c5e05ef583825100\n\
+ SM3 (f) = 1ab21d8355cfa17f8e61194831e81a8f22bec8c728fefb747ed035eb5082aa2b\n \n");
+ scene
+ .ucmd()
+ .arg("--check")
+ .arg("CHECKSUM")
+ .succeeds()
+ .stdout_contains("f: OK\nf: OK\nf: OK\nf: OK\n")
+ .stderr_contains("line is improperly formatted");
+}
+
+#[test]
+fn test_cksum_check_leading_info() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+ at.write("CHECKSUM", "\
+ \\SHA384 (f) = 38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b\n\
+ \\BLAKE2b (f) = 786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce\n\
+ \\BLAKE2b-384 (f) = b32811423377f52d7862286ee1a72ee540524380fda1724a6f25d7978c6fd3244a6caf0498812673c5e05ef583825100\n\
+ \\SM3 (f) = 1ab21d8355cfa17f8e61194831e81a8f22bec8c728fefb747ed035eb5082aa2b\n");
+ scene
+ .ucmd()
+ .arg("--check")
+ .arg("CHECKSUM")
+ .succeeds()
+ .stdout_contains("f: OK\nf: OK\nf: OK\nf: OK\n");
+}
+
+#[test]
+fn test_cksum_check() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+ at.write("CHECKSUM", "\
+ SHA384 (f) = 38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b\n\
+ BLAKE2b (f) = 786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce\n\
+ BLAKE2b-384 (f) = b32811423377f52d7862286ee1a72ee540524380fda1724a6f25d7978c6fd3244a6caf0498812673c5e05ef583825100\n\
+ SM3 (f) = 1ab21d8355cfa17f8e61194831e81a8f22bec8c728fefb747ed035eb5082aa2b\n");
+ scene
+ .ucmd()
+ .arg("--check")
+ .arg("CHECKSUM")
+ .succeeds()
+ .stdout_contains("f: OK\nf: OK\nf: OK\nf: OK\n")
+ .stderr_does_not_contain("line is improperly formatted");
+ scene
+ .ucmd()
+ .arg("--check")
+ .arg("--strict")
+ .arg("CHECKSUM")
+ .succeeds()
+ .stdout_contains("f: OK\nf: OK\nf: OK\nf: OK\n")
+ .stderr_does_not_contain("line is improperly formatted");
+ // inject invalid content
+ at.append("CHECKSUM", "incorrect data");
+ scene
+ .ucmd()
+ .arg("--check")
+ .arg("CHECKSUM")
+ .succeeds()
+ .stdout_contains("f: OK\nf: OK\nf: OK\nf: OK\n")
+ .stderr_contains("line is improperly formatted");
+ scene
+ .ucmd()
+ .arg("--check")
+ .arg("--strict")
+ .arg("CHECKSUM")
+ .fails()
+ .stdout_contains("f: OK\nf: OK\nf: OK\nf: OK\n")
+ .stderr_contains("line is improperly formatted");
+}
+
+#[test]
+fn test_cksum_check_case() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+ at.write(
+ "CHECKSUM",
+ "Sha1 (f) = da39a3ee5e6b4b0d3255bfef95601890afd80709\n",
+ );
+ scene.ucmd().arg("--check").arg("CHECKSUM").fails();
+}
+
+#[test]
+fn test_cksum_check_invalid() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let commands = [vec!["-a", "sha384"]];
+ at.touch("f");
+ at.touch("CHECKSUM");
+ for command in &commands {
+ let result = scene.ucmd().args(command).arg("f").succeeds();
+ at.append("CHECKSUM", result.stdout_str());
+ }
+ // inject invalid content
+ at.append("CHECKSUM", "again incorrect data\naze\n");
+ scene
+ .ucmd()
+ .arg("--check")
+ .arg("--strict")
+ .arg("CHECKSUM")
+ .fails()
+ .stdout_contains("f: OK\n")
+ .stderr_contains("2 lines");
+
+ // without strict, it passes
+ scene
+ .ucmd()
+ .arg("--check")
+ .arg("CHECKSUM")
+ .succeeds()
+ .stdout_contains("f: OK\n")
+ .stderr_contains("2 lines");
+}
+
+#[test]
+fn test_cksum_check_failed() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let commands = [vec!["-a", "sha384"]];
+ at.touch("f");
+ at.touch("CHECKSUM");
+ for command in &commands {
+ let result = scene.ucmd().args(command).arg("f").succeeds();
+ at.append("CHECKSUM", result.stdout_str());
+ }
+ // inject invalid content
+ at.append("CHECKSUM", "again incorrect data\naze\nSM3 (input) = 7cfb120d4fabea2a904948538a438fdb57c725157cb40b5aee8d937b8351477e\n");
+
+ let result = scene
+ .ucmd()
+ .arg("--check")
+ .arg("--strict")
+ .arg("CHECKSUM")
+ .fails();
+
+ assert!(result
+ .stderr_str()
+ .contains("input: No such file or directory"));
+ assert!(result
+ .stderr_str()
+ .contains("2 lines are improperly formatted\n"));
+ assert!(result
+ .stderr_str()
+ .contains("1 listed file could not be read\n"));
+ assert!(result.stdout_str().contains("f: OK\n"));
+
+ // without strict
+ let result = scene.ucmd().arg("--check").arg("CHECKSUM").fails();
+
+ assert!(result
+ .stderr_str()
+ .contains("input: No such file or directory"));
+ assert!(result
+ .stderr_str()
+ .contains("2 lines are improperly formatted\n"));
+ assert!(result
+ .stderr_str()
+ .contains("1 listed file could not be read\n"));
+ assert!(result.stdout_str().contains("f: OK\n"));
+
+ // tests with two files
+ at.touch("CHECKSUM2");
+ at.write("f2", "42");
+ for command in &commands {
+ let result = scene.ucmd().args(command).arg("f2").succeeds();
+ at.append("CHECKSUM2", result.stdout_str());
+ }
+ // inject invalid content
+ at.append("CHECKSUM2", "again incorrect data\naze\nSM3 (input2) = 7cfb120d4fabea2a904948538a438fdb57c725157cb40b5aee8d937b8351477e\n");
+ at.append("CHECKSUM2", "again incorrect data\naze\nSM3 (input2) = 7cfb120d4fabea2a904948538a438fdb57c725157cb40b5aee8d937b8351477e\n");
+
+ let result = scene
+ .ucmd()
+ .arg("--check")
+ .arg("CHECKSUM")
+ .arg("CHECKSUM2")
+ .fails();
+ println!("result.stderr_str() {}", result.stderr_str());
+ println!("result.stdout_str() {}", result.stdout_str());
+ assert!(result
+ .stderr_str()
+ .contains("input2: No such file or directory"));
+ assert!(result
+ .stderr_str()
+ .contains("4 lines are improperly formatted\n"));
+ assert!(result
+ .stderr_str()
+ .contains("2 listed files could not be read\n"));
+ assert!(result.stdout_str().contains("f: OK\n"));
+ assert!(result.stdout_str().contains("2: OK\n"));
+}
+
+#[test]
+fn test_check_md5_format() {
+ let scene = TestScenario::new(util_name!());
+
+ let at = &scene.fixtures;
+ at.touch("empty");
+ at.write("f", "d41d8cd98f00b204e9800998ecf8427e *empty\n");
+
+ scene
+ .ucmd()
+ .arg("-a")
+ .arg("md5")
+ .arg("--check")
+ .arg("f")
+ .succeeds()
+ .stdout_contains("empty: OK");
+
+ // with a second file
+ at.write("not-empty", "42");
+ at.write("f2", "a1d0c6e83f027327d8461063f4ac58a6 *not-empty\n");
+
+ scene
+ .ucmd()
+ .arg("-a")
+ .arg("md5")
+ .arg("--check")
+ .arg("f")
+ .arg("f2")
+ .succeeds()
+ .stdout_contains("empty: OK")
+ .stdout_contains("not-empty: OK");
+}
+
+// Manage the mixed behavior
+// cksum --check -a sm3 CHECKSUMS
+// when CHECKSUM contains among other lines:
+// SHA384 (input) = f392fd0ae43879ced890c665a1d47179116b5eddf6fb5b49f4982746418afdcbd54ba5eedcd422af3592f57f666da285
+#[test]
+fn test_cksum_mixed() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let commands = [
+ vec!["-a", "sha384"],
+ vec!["-a", "blake2b"],
+ vec!["-a", "blake2b", "-l", "384"],
+ vec!["-a", "sm3"],
+ ];
+ at.touch("f");
+ at.touch("CHECKSUM");
+ for command in &commands {
+ let result = scene.ucmd().args(command).arg("f").succeeds();
+ at.append("CHECKSUM", result.stdout_str());
+ }
+ println!("Content of CHECKSUM:\n{}", at.read("CHECKSUM"));
+ let result = scene
+ .ucmd()
+ .arg("--check")
+ .arg("-a")
+ .arg("sm3")
+ .arg("CHECKSUM")
+ .succeeds();
+
+ println!("result.stderr_str() {}", result.stderr_str());
+ println!("result.stdout_str() {}", result.stdout_str());
+ assert!(result.stdout_str().contains("f: OK"));
+ assert!(result
+ .stderr_str()
+ .contains("3 lines are improperly formatted"));
+}
+
+#[test]
+fn test_cksum_garbage() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ // Incorrect data at the start
+ at.write(
+ "check-file",
+ "garbage MD5 (README.md) = e5773576fc75ff0f8eba14f61587ae28",
+ );
+ scene
+ .ucmd()
+ .arg("--check")
+ .arg("check-file")
+ .fails()
+ .stderr_contains("check-file: no properly formatted checksum lines found");
+
+ // Incorrect data at the end
+ at.write(
+ "check-file",
+ "MD5 (README.md) = e5773576fc75ff0f8eba14f61587ae28 garbage",
+ );
+ scene
+ .ucmd()
+ .arg("--check")
+ .arg("check-file")
+ .fails()
+ .stderr_contains("check-file: no properly formatted checksum lines found");
+}
+
+#[ignore = "Should fail on bits"]
+#[test]
+fn test_md5_bits() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.write(
+ "f",
+ "MD5-65536 (README.md) = e5773576fc75ff0f8eba14f61587ae28\n",
+ );
+
+ ucmd.arg("-c")
+ .arg("f")
+ .fails()
+ .stderr_contains("f: no properly formatted checksum lines found");
+}
+
+#[test]
+fn test_blake2b_bits() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.write(
+ "f",
+ "BLAKE2b-257 (README.md) = f9a984b70cf9a7549920864860fd1131c9fb6c0552def0b6dcce1d87b4ec4c5d\n"
+ );
+
+ ucmd.arg("-c")
+ .arg("f")
+ .fails()
+ .stderr_contains("f: no properly formatted checksum lines found");
+}
+
+#[test]
+fn test_bsd_case() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.write("f", "bSD (README.md) = 0000\n");
+
+ scene
+ .ucmd()
+ .arg("-c")
+ .arg("f")
+ .fails()
+ .stderr_contains("f: no properly formatted checksum lines found");
+ at.write("f", "BsD (README.md) = 0000\n");
+
+ scene
+ .ucmd()
+ .arg("-c")
+ .arg("f")
+ .fails()
+ .stderr_contains("f: no properly formatted checksum lines found");
+}
+
+#[ignore = "Different output"]
+#[test]
+fn test_blake2d_tested_with_sha1() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.write(
+ "f",
+ "BLAKE2b (f) = 786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce\n"
+ );
+
+ ucmd.arg("-a")
+ .arg("sha1")
+ .arg("-c")
+ .arg("f")
+ .fails()
+ .stderr_contains("f: no properly formatted checksum lines found");
+}
+
+#[test]
+fn test_unknown_sha() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.write("f", "SHA4 (README.md) = 00000000\n");
+
+ ucmd.arg("-c")
+ .arg("f")
+ .fails()
+ .stderr_contains("f: no properly formatted checksum lines found");
+}
+
+#[test]
+fn test_check_directory_error() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ at.mkdir("d");
+ at.write(
+ "f",
+ "BLAKE2b (d) = 786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce\n"
+ );
+ #[cfg(not(windows))]
+ let err_msg = "cksum: d: Is a directory\n";
+ #[cfg(windows)]
+ let err_msg = "cksum: d: Permission denied\n";
+ ucmd.arg("--check")
+ .arg(at.subdir.join("f"))
+ .fails()
+ .stderr_contains(err_msg);
+}
diff --git a/tests/by-util/test_comm.rs b/tests/by-util/test_comm.rs
index 9fc175c7fab21e0daa0fb76990bc433ff5ddca89..2dc385ef3f2565e96fde3bea42403a35a855d23c 100644
--- a/tests/by-util/test_comm.rs
+++ b/tests/by-util/test_comm.rs
@@ -1,6 +1,10 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (words) defaultcheck nocheck
-use crate::common::util::*;
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
@@ -55,6 +59,38 @@ fn empty_empty() {
.stdout_only_fixture("emptyempty.expected"); // spell-checker:disable-line
}
+#[test]
+fn total() {
+ new_ucmd!()
+ .args(&["--total", "a", "b"])
+ .succeeds()
+ .stdout_is_fixture("ab_total.expected");
+}
+
+#[test]
+fn total_with_suppressed_regular_output() {
+ new_ucmd!()
+ .args(&["--total", "-123", "a", "b"])
+ .succeeds()
+ .stdout_is_fixture("ab_total_suppressed_regular_output.expected");
+}
+
+#[test]
+fn repeated_flags() {
+ new_ucmd!()
+ .args(&["--total", "-123123", "--total", "a", "b"])
+ .succeeds()
+ .stdout_is_fixture("ab_total_suppressed_regular_output.expected");
+}
+
+#[test]
+fn total_with_output_delimiter() {
+ new_ucmd!()
+ .args(&["--total", "--output-delimiter=word", "a", "b"])
+ .succeeds()
+ .stdout_is_fixture("ab_total_delimiter_word.expected");
+}
+
#[test]
fn output_delimiter() {
new_ucmd!()
@@ -63,6 +99,69 @@ fn output_delimiter() {
.stdout_only_fixture("ab_delimiter_word.expected");
}
+#[test]
+fn output_delimiter_hyphen_one() {
+ new_ucmd!()
+ .args(&["--output-delimiter", "-1", "a", "b"])
+ .succeeds()
+ .stdout_only_fixture("ab_delimiter_hyphen_one.expected");
+}
+
+#[test]
+fn output_delimiter_hyphen_help() {
+ new_ucmd!()
+ .args(&["--output-delimiter", "--help", "a", "b"])
+ .succeeds()
+ .stdout_only_fixture("ab_delimiter_hyphen_help.expected");
+}
+
+#[test]
+fn output_delimiter_multiple_identical() {
+ new_ucmd!()
+ .args(&[
+ "--output-delimiter=word",
+ "--output-delimiter=word",
+ "a",
+ "b",
+ ])
+ .succeeds()
+ .stdout_only_fixture("ab_delimiter_word.expected");
+}
+
+#[test]
+fn output_delimiter_multiple_different() {
+ new_ucmd!()
+ .args(&[
+ "--output-delimiter=word",
+ "--output-delimiter=other",
+ "a",
+ "b",
+ ])
+ .fails()
+ .no_stdout()
+ .stderr_contains("multiple")
+ .stderr_contains("output")
+ .stderr_contains("delimiters");
+}
+
+#[test]
+#[ignore = "This is too weird; deviate intentionally."]
+fn output_delimiter_multiple_different_prevents_help() {
+ new_ucmd!()
+ .args(&[
+ "--output-delimiter=word",
+ "--output-delimiter=other",
+ "--help",
+ "a",
+ "b",
+ ])
+ .fails()
+ .no_stdout()
+ .stderr_contains("multiple")
+ .stderr_contains("output")
+ .stderr_contains("delimiters");
+}
+
#[test]
fn output_delimiter_nul() {
new_ucmd!()
@@ -71,19 +170,33 @@ fn output_delimiter_nul() {
.stdout_only_fixture("ab_delimiter_nul.expected");
}
-// even though (info) documentation suggests this is an option
-// in latest GNU Coreutils comm, it actually is not.
-// this test is essentially an alarm in case some well-intending
-// developer implements it.
-//marked as unimplemented as error message not set yet.
-#[cfg_attr(not(feature = "test_unimplemented"), ignore)]
#[test]
fn zero_terminated() {
for param in ["-z", "--zero-terminated"] {
new_ucmd!()
- .args(&[param, "a", "b"])
- .fails()
- .stderr_only("error to be defined");
+ .args(&[param, "a_nul", "b_nul"])
+ .succeeds()
+ .stdout_only_fixture("ab_nul.expected");
+ }
+}
+
+#[test]
+fn zero_terminated_provided_multiple_times() {
+ for param in ["-z", "--zero-terminated"] {
+ new_ucmd!()
+ .args(&[param, param, param, "a_nul", "b_nul"])
+ .succeeds()
+ .stdout_only_fixture("ab_nul.expected");
+ }
+}
+
+#[test]
+fn zero_terminated_with_total() {
+ for param in ["-z", "--zero-terminated"] {
+ new_ucmd!()
+ .args(&[param, "--total", "a_nul", "b_nul"])
+ .succeeds()
+ .stdout_only_fixture("ab_nul_total.expected");
}
}
@@ -162,16 +275,14 @@ fn unintuitive_default_behavior_1() {
.stdout_only_fixture("defaultcheck_unintuitive.expected");
}
-#[ignore] //bug? should help be stdout if not called via -h|--help?
#[test]
fn no_arguments() {
- new_ucmd!().fails().no_stdout().no_stderr();
+ new_ucmd!().fails().no_stdout();
}
-#[ignore] //bug? should help be stdout if not called via -h|--help?
#[test]
fn one_argument() {
- new_ucmd!().arg("a").fails().no_stdout().no_stderr();
+ new_ucmd!().arg("a").fails().no_stdout();
}
#[test]
@@ -179,5 +290,5 @@ fn test_no_such_file() {
new_ucmd!()
.args(&["bogus_file_1", "bogus_file_2"])
.fails()
- .stderr_only("comm: bogus_file_1: No such file or directory");
+ .stderr_only("comm: bogus_file_1: No such file or directory\n");
}
diff --git a/tests/by-util/test_cp.rs b/tests/by-util/test_cp.rs
index ee15887db7a282ecf603c1d86b20c6036836da93..3b4ec74f7751b4d157302c9485f35588604f2502 100644
--- a/tests/by-util/test_cp.rs
+++ b/tests/by-util/test_cp.rs
@@ -1,30 +1,40 @@
-// spell-checker:ignore (flags) reflink (fs) tmpfs (linux) rlimit Rlim NOFILE clob btrfs ROOTDIR USERDIR procfs outfile
-
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore (flags) reflink (fs) tmpfs (linux) rlimit Rlim NOFILE clob btrfs neve ROOTDIR USERDIR procfs outfile uufs xattrs
+// spell-checker:ignore bdfl hlsl IRWXO IRWXG
+use crate::common::util::TestScenario;
#[cfg(not(windows))]
use std::fs::set_permissions;
#[cfg(not(windows))]
use std::os::unix::fs;
-#[cfg(all(unix, not(target_os = "freebsd")))]
+#[cfg(unix)]
use std::os::unix::fs::MetadataExt;
-#[cfg(all(unix, not(target_os = "freebsd")))]
+#[cfg(unix)]
use std::os::unix::fs::PermissionsExt;
#[cfg(windows)]
use std::os::windows::fs::symlink_file;
#[cfg(not(windows))]
use std::path::Path;
+#[cfg(target_os = "linux")]
+use std::path::PathBuf;
#[cfg(any(target_os = "linux", target_os = "android"))]
use filetime::FileTime;
-#[cfg(any(target_os = "linux", target_os = "android"))]
-use rlimit::Resource;
+#[cfg(target_os = "linux")]
+use std::ffi::OsString;
#[cfg(any(target_os = "linux", target_os = "android"))]
use std::fs as std_fs;
use std::thread::sleep;
use std::time::Duration;
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(feature = "truncate")]
+use crate::common::util::PATH;
+
static TEST_EXISTING_FILE: &str = "existing_file.txt";
static TEST_HELLO_WORLD_SOURCE: &str = "hello_world.txt";
static TEST_HELLO_WORLD_SOURCE_SYMLINK: &str = "hello_world.txt.link";
@@ -46,6 +56,11 @@ static TEST_MOUNT_MOUNTPOINT: &str = "mount";
static TEST_MOUNT_OTHER_FILESYSTEM_FILE: &str = "mount/DO_NOT_copy_me.txt";
#[cfg(unix)]
static TEST_NONEXISTENT_FILE: &str = "nonexistent_file.txt";
+#[cfg(all(
+ unix,
+ not(any(target_os = "android", target_os = "macos", target_os = "openbsd"))
+))]
+use crate::common::util::compare_xattrs;
/// Assert that mode, ownership, and permissions of two metadata objects match.
#[cfg(all(not(windows), not(target_os = "freebsd")))]
@@ -91,7 +106,7 @@ fn test_cp_existing_target() {
assert_eq!(at.read(TEST_EXISTING_FILE), "Hello, World!\n");
// No backup should have been created
- assert!(!at.file_exists(&format!("{}~", TEST_EXISTING_FILE)));
+ assert!(!at.file_exists(format!("{TEST_EXISTING_FILE}~")));
}
#[test]
@@ -101,10 +116,26 @@ fn test_cp_duplicate_files() {
.arg(TEST_HELLO_WORLD_SOURCE)
.arg(TEST_COPY_TO_FOLDER)
.succeeds()
- .stderr_contains("specified more than once");
+ .stderr_contains(format!(
+ "source file '{TEST_HELLO_WORLD_SOURCE}' specified more than once"
+ ));
assert_eq!(at.read(TEST_COPY_TO_FOLDER_FILE), "Hello, World!\n");
}
+#[test]
+fn test_cp_same_file() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let file = "a";
+
+ at.touch(file);
+
+ ucmd.arg(file)
+ .arg(file)
+ .fails()
+ .code_is(1)
+ .stderr_contains(format!("'{file}' and '{file}' are the same file"));
+}
+
#[test]
fn test_cp_multiple_files_target_is_file() {
new_ucmd!()
@@ -121,7 +152,9 @@ fn test_cp_directory_not_recursive() {
.arg(TEST_COPY_TO_FOLDER)
.arg(TEST_HELLO_WORLD_DEST)
.fails()
- .stderr_contains("omitting directory");
+ .stderr_is(format!(
+ "cp: -r not specified; omitting directory '{TEST_COPY_TO_FOLDER}'\n"
+ ));
}
#[test]
@@ -150,6 +183,20 @@ fn test_cp_recurse() {
assert_eq!(at.read(TEST_COPY_TO_FOLDER_NEW_FILE), "Hello, World!\n");
}
+#[test]
+#[cfg(not(target_os = "macos"))]
+fn test_cp_recurse_several() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.arg("-r")
+ .arg("-r")
+ .arg(TEST_COPY_FROM_FOLDER)
+ .arg(TEST_COPY_TO_FOLDER_NEW)
+ .succeeds();
+
+ // Check the content of the destination file that was copied.
+ assert_eq!(at.read(TEST_COPY_TO_FOLDER_NEW_FILE), "Hello, World!\n");
+}
+
#[test]
fn test_cp_with_dirs_t() {
let (at, mut ucmd) = at_and_ucmd!();
@@ -204,6 +251,22 @@ fn test_cp_arg_no_target_directory() {
.stderr_contains("cannot overwrite directory");
}
+#[test]
+fn test_cp_arg_no_target_directory_with_recursive() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ at.mkdir("dir");
+ at.mkdir("dir2");
+ at.touch("dir/a");
+ at.touch("dir/b");
+
+ ucmd.arg("-rT").arg("dir").arg("dir2").succeeds();
+
+ assert!(at.plus("dir2").join("a").exists());
+ assert!(at.plus("dir2").join("b").exists());
+ assert!(!at.plus("dir2").join("dir").exists());
+}
+
#[test]
fn test_cp_target_directory_is_file() {
new_ucmd!()
@@ -211,19 +274,205 @@ fn test_cp_target_directory_is_file() {
.arg(TEST_HOW_ARE_YOU_SOURCE)
.arg(TEST_HELLO_WORLD_SOURCE)
.fails()
- .stderr_contains(format!("'{}' is not a directory", TEST_HOW_ARE_YOU_SOURCE));
+ .stderr_contains(format!("'{TEST_HOW_ARE_YOU_SOURCE}' is not a directory"));
}
#[test]
-fn test_cp_arg_update_interactive() {
+fn test_cp_arg_update_interactive_error() {
new_ucmd!()
.arg(TEST_HELLO_WORLD_SOURCE)
.arg(TEST_HOW_ARE_YOU_SOURCE)
.arg("-i")
- .arg("--update")
+ .fails()
+ .no_stdout();
+}
+
+#[test]
+fn test_cp_arg_update_none() {
+ for argument in ["--update=none", "--update=non", "--update=n"] {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ ucmd.arg(TEST_HELLO_WORLD_SOURCE)
+ .arg(TEST_HOW_ARE_YOU_SOURCE)
+ .arg(argument)
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+
+ assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "How are you?\n");
+ }
+}
+
+#[test]
+fn test_cp_arg_update_all() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ ucmd.arg(TEST_HELLO_WORLD_SOURCE)
+ .arg(TEST_HOW_ARE_YOU_SOURCE)
+ .arg("--update=all")
.succeeds()
- .no_stdout()
- .no_stderr();
+ .no_stderr()
+ .no_stdout();
+
+ assert_eq!(
+ at.read(TEST_HOW_ARE_YOU_SOURCE),
+ at.read(TEST_HELLO_WORLD_SOURCE)
+ );
+}
+
+#[test]
+fn test_cp_arg_update_older_dest_not_older_than_src() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let old = "test_cp_arg_update_dest_not_older_file1";
+ let new = "test_cp_arg_update_dest_not_older_file2";
+ let old_content = "old content\n";
+ let new_content = "new content\n";
+
+ at.write(old, old_content);
+ at.write(new, new_content);
+
+ ucmd.arg(old)
+ .arg(new)
+ .arg("--update=older")
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+
+ assert_eq!(at.read(new), "new content\n");
+}
+
+#[test]
+fn test_cp_arg_update_older_dest_older_than_src() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let old = "test_cp_arg_update_dest_older_file1";
+ let new = "test_cp_arg_update_dest_older_file2";
+ let old_content = "old content\n";
+ let new_content = "new content\n";
+
+ at.write(old, old_content);
+
+ sleep(Duration::from_secs(1));
+
+ at.write(new, new_content);
+
+ ucmd.arg(new)
+ .arg(old)
+ .arg("--update=older")
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+
+ assert_eq!(at.read(old), "new content\n");
+}
+
+#[test]
+fn test_cp_arg_update_short_no_overwrite() {
+ // same as --update=older
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let old = "test_cp_arg_update_short_no_overwrite_file1";
+ let new = "test_cp_arg_update_short_no_overwrite_file2";
+ let old_content = "old content\n";
+ let new_content = "new content\n";
+
+ at.write(old, old_content);
+
+ sleep(Duration::from_secs(1));
+
+ at.write(new, new_content);
+
+ ucmd.arg(old)
+ .arg(new)
+ .arg("-u")
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+
+ assert_eq!(at.read(new), "new content\n");
+}
+
+#[test]
+fn test_cp_arg_update_short_overwrite() {
+ // same as --update=older
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let old = "test_cp_arg_update_short_overwrite_file1";
+ let new = "test_cp_arg_update_short_overwrite_file2";
+ let old_content = "old content\n";
+ let new_content = "new content\n";
+
+ at.write(old, old_content);
+
+ sleep(Duration::from_secs(1));
+
+ at.write(new, new_content);
+
+ ucmd.arg(new)
+ .arg(old)
+ .arg("-u")
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+
+ assert_eq!(at.read(old), "new content\n");
+}
+
+#[test]
+fn test_cp_arg_update_none_then_all() {
+ // take last if multiple update args are supplied,
+ // update=all wins in this case
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let old = "test_cp_arg_update_none_then_all_file1";
+ let new = "test_cp_arg_update_none_then_all_file2";
+ let old_content = "old content\n";
+ let new_content = "new content\n";
+
+ at.write(old, old_content);
+
+ sleep(Duration::from_secs(1));
+
+ at.write(new, new_content);
+
+ ucmd.arg(old)
+ .arg(new)
+ .arg("--update=none")
+ .arg("--update=all")
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+
+ assert_eq!(at.read(new), "old content\n");
+}
+
+#[test]
+fn test_cp_arg_update_all_then_none() {
+ // take last if multiple update args are supplied,
+ // update=none wins in this case
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let old = "test_cp_arg_update_all_then_none_file1";
+ let new = "test_cp_arg_update_all_then_none_file2";
+ let old_content = "old content\n";
+ let new_content = "new content\n";
+
+ at.write(old, old_content);
+
+ sleep(Duration::from_secs(1));
+
+ at.write(new, new_content);
+
+ ucmd.arg(old)
+ .arg(new)
+ .arg("--update=all")
+ .arg("--update=none")
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+
+ assert_eq!(at.read(new), "new content\n");
}
#[test]
@@ -233,9 +482,81 @@ fn test_cp_arg_interactive() {
at.touch("b");
ucmd.args(&["-i", "a", "b"])
.pipe_in("N\n")
+ .fails()
+ .no_stdout()
+ .stderr_is("cp: overwrite 'b'? ");
+}
+
+#[test]
+#[cfg(not(any(target_os = "android", target_os = "freebsd")))]
+fn test_cp_arg_interactive_update_overwrite_newer() {
+ // -u -i won't show the prompt to validate the override or not
+ // Therefore, the error code will be 0
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.touch("a");
+ at.touch("b");
+ ucmd.args(&["-i", "-u", "a", "b"])
+ .pipe_in("")
.succeeds()
+ .no_stdout();
+ // Make extra sure that closing stdin behaves identically to piping-in nothing.
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.touch("a");
+ at.touch("b");
+ ucmd.args(&["-i", "-u", "a", "b"]).succeeds().no_stdout();
+}
+
+#[test]
+#[cfg(not(any(target_os = "android", target_os = "freebsd")))]
+fn test_cp_arg_interactive_update_overwrite_older() {
+ // -u -i *WILL* show the prompt to validate the override.
+ // Therefore, the error code depends on the prompt response.
+ // Option N
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.touch("b");
+ std::thread::sleep(Duration::from_secs(1));
+ at.touch("a");
+ ucmd.args(&["-i", "-u", "a", "b"])
+ .pipe_in("N\n")
+ .fails()
+ .code_is(1)
.no_stdout()
.stderr_is("cp: overwrite 'b'? ");
+
+ // Option Y
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.touch("b");
+ std::thread::sleep(Duration::from_secs(1));
+ at.touch("a");
+ ucmd.args(&["-i", "-u", "a", "b"])
+ .pipe_in("Y\n")
+ .succeeds()
+ .no_stdout();
+}
+
+#[test]
+#[cfg(not(target_os = "android"))]
+fn test_cp_arg_interactive_verbose() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.touch("a");
+ at.touch("b");
+ ucmd.args(&["-vi", "a", "b"])
+ .pipe_in("N\n")
+ .fails()
+ .stderr_is("cp: overwrite 'b'? ")
+ .no_stdout();
+}
+
+#[test]
+#[cfg(not(target_os = "android"))]
+fn test_cp_arg_interactive_verbose_clobber() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.touch("a");
+ at.touch("b");
+ ucmd.args(&["-vin", "a", "b"])
+ .fails()
+ .stderr_is("cp: not replacing 'b'\n")
+ .no_stdout();
}
#[test]
@@ -252,6 +573,41 @@ fn test_cp_arg_link() {
assert_eq!(at.metadata(TEST_HELLO_WORLD_SOURCE).st_nlink(), 2);
}
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_arg_link_with_dest_hardlink_to_source() {
+ use std::os::linux::fs::MetadataExt;
+
+ let (at, mut ucmd) = at_and_ucmd!();
+ let file = "file";
+ let hardlink = "hardlink";
+
+ at.touch(file);
+ at.hard_link(file, hardlink);
+
+ ucmd.args(&["--link", file, hardlink]).succeeds();
+
+ assert_eq!(at.metadata(file).st_nlink(), 2);
+ assert!(at.file_exists(file));
+ assert!(at.file_exists(hardlink));
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_arg_link_with_same_file() {
+ use std::os::linux::fs::MetadataExt;
+
+ let (at, mut ucmd) = at_and_ucmd!();
+ let file = "file";
+
+ at.touch(file);
+
+ ucmd.args(&["--link", file, file]).succeeds();
+
+ assert_eq!(at.metadata(file).st_nlink(), 1);
+ assert!(at.file_exists(file));
+}
+
#[test]
fn test_cp_arg_symlink() {
let (at, mut ucmd) = at_and_ucmd!();
@@ -269,7 +625,8 @@ fn test_cp_arg_no_clobber() {
ucmd.arg(TEST_HELLO_WORLD_SOURCE)
.arg(TEST_HOW_ARE_YOU_SOURCE)
.arg("--no-clobber")
- .succeeds();
+ .fails()
+ .stderr_contains("not replacing");
assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "How are you?\n");
}
@@ -280,7 +637,7 @@ fn test_cp_arg_no_clobber_inferred_arg() {
ucmd.arg(TEST_HELLO_WORLD_SOURCE)
.arg(TEST_HOW_ARE_YOU_SOURCE)
.arg("--no-clob")
- .succeeds();
+ .fails();
assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "How are you?\n");
}
@@ -307,7 +664,7 @@ fn test_cp_arg_no_clobber_twice() {
.arg("--no-clobber")
.arg("source.txt")
.arg("dest.txt")
- .succeeds();
+ .fails();
assert_eq!(at.read("source.txt"), "some-content");
// Should be empty as the "no-clobber" should keep
@@ -374,11 +731,51 @@ fn test_cp_arg_backup() {
assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "Hello, World!\n");
assert_eq!(
- at.read(&format!("{}~", TEST_HOW_ARE_YOU_SOURCE)),
+ at.read(&format!("{TEST_HOW_ARE_YOU_SOURCE}~")),
"How are you?\n"
);
}
+#[test]
+fn test_cp_arg_backup_with_dest_a_symlink() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let source = "source";
+ let source_content = "content";
+ let symlink = "symlink";
+ let original = "original";
+ let backup = "symlink~";
+
+ at.write(source, source_content);
+ at.write(original, "original");
+ at.symlink_file(original, symlink);
+
+ ucmd.arg("-b").arg(source).arg(symlink).succeeds();
+
+ assert!(!at.symlink_exists(symlink));
+ assert_eq!(source_content, at.read(symlink));
+ assert!(at.symlink_exists(backup));
+ assert_eq!(original, at.resolve_link(backup));
+}
+
+#[test]
+fn test_cp_arg_backup_with_dest_a_symlink_to_source() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let source = "source";
+ let source_content = "content";
+ let symlink = "symlink";
+ let backup = "symlink~";
+
+ at.write(source, source_content);
+ at.symlink_file(source, symlink);
+
+ ucmd.arg("-b").arg(source).arg(symlink).succeeds();
+
+ assert!(!at.symlink_exists(symlink));
+ assert_eq!(source_content, at.read(symlink));
+ assert!(at.symlink_exists(backup));
+ assert_eq!(source, at.resolve_link(backup));
+}
+
#[test]
fn test_cp_arg_backup_with_other_args() {
let (at, mut ucmd) = at_and_ucmd!();
@@ -390,7 +787,7 @@ fn test_cp_arg_backup_with_other_args() {
assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "Hello, World!\n");
assert_eq!(
- at.read(&format!("{}~", TEST_HOW_ARE_YOU_SOURCE)),
+ at.read(&format!("{TEST_HOW_ARE_YOU_SOURCE}~")),
"How are you?\n"
);
}
@@ -406,7 +803,7 @@ fn test_cp_arg_backup_arg_first() {
assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "Hello, World!\n");
assert_eq!(
- at.read(&format!("{}~", TEST_HOW_ARE_YOU_SOURCE)),
+ at.read(&format!("{TEST_HOW_ARE_YOU_SOURCE}~")),
"How are you?\n"
);
}
@@ -424,7 +821,7 @@ fn test_cp_arg_suffix() {
assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "Hello, World!\n");
assert_eq!(
- at.read(&format!("{}.bak", TEST_HOW_ARE_YOU_SOURCE)),
+ at.read(&format!("{TEST_HOW_ARE_YOU_SOURCE}.bak")),
"How are you?\n"
);
}
@@ -442,7 +839,7 @@ fn test_cp_arg_suffix_hyphen_value() {
assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "Hello, World!\n");
assert_eq!(
- at.read(&format!("{}-v", TEST_HOW_ARE_YOU_SOURCE)),
+ at.read(&format!("{TEST_HOW_ARE_YOU_SOURCE}-v")),
"How are you?\n"
);
}
@@ -461,7 +858,7 @@ fn test_cp_custom_backup_suffix_via_env() {
assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "Hello, World!\n");
assert_eq!(
- at.read(&format!("{}{}", TEST_HOW_ARE_YOU_SOURCE, suffix)),
+ at.read(&format!("{TEST_HOW_ARE_YOU_SOURCE}{suffix}")),
"How are you?\n"
);
}
@@ -478,7 +875,7 @@ fn test_cp_backup_numbered_with_t() {
assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "Hello, World!\n");
assert_eq!(
- at.read(&format!("{}.~1~", TEST_HOW_ARE_YOU_SOURCE)),
+ at.read(&format!("{TEST_HOW_ARE_YOU_SOURCE}.~1~")),
"How are you?\n"
);
}
@@ -495,7 +892,7 @@ fn test_cp_backup_numbered() {
assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "Hello, World!\n");
assert_eq!(
- at.read(&format!("{}.~1~", TEST_HOW_ARE_YOU_SOURCE)),
+ at.read(&format!("{TEST_HOW_ARE_YOU_SOURCE}.~1~")),
"How are you?\n"
);
}
@@ -512,7 +909,7 @@ fn test_cp_backup_existing() {
assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "Hello, World!\n");
assert_eq!(
- at.read(&format!("{}~", TEST_HOW_ARE_YOU_SOURCE)),
+ at.read(&format!("{TEST_HOW_ARE_YOU_SOURCE}~")),
"How are you?\n"
);
}
@@ -529,7 +926,7 @@ fn test_cp_backup_nil() {
assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "Hello, World!\n");
assert_eq!(
- at.read(&format!("{}~", TEST_HOW_ARE_YOU_SOURCE)),
+ at.read(&format!("{TEST_HOW_ARE_YOU_SOURCE}~")),
"How are you?\n"
);
}
@@ -537,7 +934,7 @@ fn test_cp_backup_nil() {
#[test]
fn test_cp_numbered_if_existing_backup_existing() {
let (at, mut ucmd) = at_and_ucmd!();
- let existing_backup = &format!("{}.~1~", TEST_HOW_ARE_YOU_SOURCE);
+ let existing_backup = &format!("{TEST_HOW_ARE_YOU_SOURCE}.~1~");
at.touch(existing_backup);
ucmd.arg("--backup=existing")
@@ -549,7 +946,7 @@ fn test_cp_numbered_if_existing_backup_existing() {
assert!(at.file_exists(TEST_HOW_ARE_YOU_SOURCE));
assert!(at.file_exists(existing_backup));
assert_eq!(
- at.read(&format!("{}.~2~", TEST_HOW_ARE_YOU_SOURCE)),
+ at.read(&format!("{TEST_HOW_ARE_YOU_SOURCE}.~2~")),
"How are you?\n"
);
}
@@ -557,7 +954,7 @@ fn test_cp_numbered_if_existing_backup_existing() {
#[test]
fn test_cp_numbered_if_existing_backup_nil() {
let (at, mut ucmd) = at_and_ucmd!();
- let existing_backup = &format!("{}.~1~", TEST_HOW_ARE_YOU_SOURCE);
+ let existing_backup = &format!("{TEST_HOW_ARE_YOU_SOURCE}.~1~");
at.touch(existing_backup);
ucmd.arg("--backup=nil")
@@ -569,7 +966,7 @@ fn test_cp_numbered_if_existing_backup_nil() {
assert!(at.file_exists(TEST_HOW_ARE_YOU_SOURCE));
assert!(at.file_exists(existing_backup));
assert_eq!(
- at.read(&format!("{}.~2~", TEST_HOW_ARE_YOU_SOURCE)),
+ at.read(&format!("{TEST_HOW_ARE_YOU_SOURCE}.~2~")),
"How are you?\n"
);
}
@@ -586,7 +983,7 @@ fn test_cp_backup_simple() {
assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "Hello, World!\n");
assert_eq!(
- at.read(&format!("{}~", TEST_HOW_ARE_YOU_SOURCE)),
+ at.read(&format!("{TEST_HOW_ARE_YOU_SOURCE}~")),
"How are you?\n"
);
}
@@ -594,15 +991,14 @@ fn test_cp_backup_simple() {
#[test]
fn test_cp_backup_simple_protect_source() {
let (at, mut ucmd) = at_and_ucmd!();
- let source = format!("{}~", TEST_HELLO_WORLD_SOURCE);
+ let source = format!("{TEST_HELLO_WORLD_SOURCE}~");
at.touch(&source);
ucmd.arg("--backup=simple")
.arg(&source)
.arg(TEST_HELLO_WORLD_SOURCE)
.fails()
.stderr_only(format!(
- "cp: backing up '{}' might destroy source; '{}' not copied",
- TEST_HELLO_WORLD_SOURCE, source,
+ "cp: backing up '{TEST_HELLO_WORLD_SOURCE}' might destroy source; '{source}' not copied\n",
));
assert_eq!(at.read(TEST_HELLO_WORLD_SOURCE), "Hello, World!\n");
@@ -621,7 +1017,7 @@ fn test_cp_backup_never() {
assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "Hello, World!\n");
assert_eq!(
- at.read(&format!("{}~", TEST_HOW_ARE_YOU_SOURCE)),
+ at.read(&format!("{TEST_HOW_ARE_YOU_SOURCE}~")),
"How are you?\n"
);
}
@@ -637,7 +1033,7 @@ fn test_cp_backup_none() {
.no_stderr();
assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "Hello, World!\n");
- assert!(!at.file_exists(&format!("{}~", TEST_HOW_ARE_YOU_SOURCE)));
+ assert!(!at.file_exists(format!("{TEST_HOW_ARE_YOU_SOURCE}~")));
}
#[test]
@@ -651,7 +1047,7 @@ fn test_cp_backup_off() {
.no_stderr();
assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "Hello, World!\n");
- assert!(!at.file_exists(&format!("{}~", TEST_HOW_ARE_YOU_SOURCE)));
+ assert!(!at.file_exists(format!("{TEST_HOW_ARE_YOU_SOURCE}~")));
}
#[test]
@@ -701,7 +1097,7 @@ fn test_cp_deref() {
.join(TEST_HELLO_WORLD_SOURCE_SYMLINK);
// unlike -P/--no-deref, we expect a file, not a link
assert!(at.file_exists(
- &path_to_new_symlink
+ path_to_new_symlink
.clone()
.into_os_string()
.into_string()
@@ -801,7 +1197,7 @@ fn test_cp_strip_trailing_slashes() {
//using --strip-trailing-slashes option
ucmd.arg("--strip-trailing-slashes")
- .arg(format!("{}/", TEST_HELLO_WORLD_SOURCE))
+ .arg(format!("{TEST_HELLO_WORLD_SOURCE}/"))
.arg(TEST_HELLO_WORLD_DEST)
.succeeds();
@@ -820,8 +1216,7 @@ fn test_cp_parents() {
assert_eq!(
at.read(&format!(
- "{}/{}",
- TEST_COPY_TO_FOLDER, TEST_COPY_FROM_FOLDER_FILE
+ "{TEST_COPY_TO_FOLDER}/{TEST_COPY_FROM_FOLDER_FILE}"
)),
"Hello, World!\n"
);
@@ -839,16 +1234,12 @@ fn test_cp_parents_multiple_files() {
assert_eq!(
at.read(&format!(
- "{}/{}",
- TEST_COPY_TO_FOLDER, TEST_COPY_FROM_FOLDER_FILE
+ "{TEST_COPY_TO_FOLDER}/{TEST_COPY_FROM_FOLDER_FILE}"
)),
"Hello, World!\n"
);
assert_eq!(
- at.read(&format!(
- "{}/{}",
- TEST_COPY_TO_FOLDER, TEST_HOW_ARE_YOU_SOURCE
- )),
+ at.read(&format!("{TEST_COPY_TO_FOLDER}/{TEST_HOW_ARE_YOU_SOURCE}")),
"How are you?\n"
);
}
@@ -864,30 +1255,112 @@ fn test_cp_parents_dest_not_directory() {
}
#[test]
-#[cfg(unix)]
-fn test_cp_writable_special_file_permissions() {
- new_ucmd!().arg("/dev/null").arg("/dev/zero").succeeds();
-}
-
-#[test]
-#[cfg(unix)]
-fn test_cp_issue_1665() {
+fn test_cp_parents_with_permissions_copy_file() {
let (at, mut ucmd) = at_and_ucmd!();
- ucmd.arg("/dev/null").arg("foo").succeeds();
- assert!(at.file_exists("foo"));
- assert_eq!(at.read("foo"), "");
-}
-#[test]
-fn test_cp_preserve_no_args() {
- let (at, mut ucmd) = at_and_ucmd!();
- let src_file = "a";
- let dst_file = "b";
+ let dir = "dir";
+ let file = "p1/p2/file";
+
+ at.mkdir(dir);
+ at.mkdir_all("p1/p2");
+ at.touch(file);
- // Prepare the source file
- at.touch(src_file);
#[cfg(unix)]
- at.set_mode(src_file, 0o0500);
+ {
+ let p1_mode = 0o0777;
+ let p2_mode = 0o0711;
+ let file_mode = 0o0702;
+
+ at.set_mode("p1", p1_mode);
+ at.set_mode("p1/p2", p2_mode);
+ at.set_mode(file, file_mode);
+ }
+
+ ucmd.arg("-p")
+ .arg("--parents")
+ .arg(file)
+ .arg(dir)
+ .succeeds();
+
+ #[cfg(all(unix, not(target_os = "freebsd")))]
+ {
+ let p1_metadata = at.metadata("p1");
+ let p2_metadata = at.metadata("p1/p2");
+ let file_metadata = at.metadata(file);
+
+ assert_metadata_eq!(p1_metadata, at.metadata("dir/p1"));
+ assert_metadata_eq!(p2_metadata, at.metadata("dir/p1/p2"));
+ assert_metadata_eq!(file_metadata, at.metadata("dir/p1/p2/file"));
+ }
+}
+
+#[test]
+fn test_cp_parents_with_permissions_copy_dir() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let dir1 = "dir";
+ let dir2 = "p1/p2";
+ let file = "p1/p2/file";
+
+ at.mkdir(dir1);
+ at.mkdir_all(dir2);
+ at.touch(file);
+
+ #[cfg(unix)]
+ {
+ let p1_mode = 0o0777;
+ let p2_mode = 0o0711;
+ let file_mode = 0o0702;
+
+ at.set_mode("p1", p1_mode);
+ at.set_mode("p1/p2", p2_mode);
+ at.set_mode(file, file_mode);
+ }
+
+ ucmd.arg("-p")
+ .arg("--parents")
+ .arg("-r")
+ .arg(dir2)
+ .arg(dir1)
+ .succeeds();
+
+ #[cfg(all(unix, not(target_os = "freebsd")))]
+ {
+ let p1_metadata = at.metadata("p1");
+ let p2_metadata = at.metadata("p1/p2");
+ let file_metadata = at.metadata(file);
+
+ assert_metadata_eq!(p1_metadata, at.metadata("dir/p1"));
+ assert_metadata_eq!(p2_metadata, at.metadata("dir/p1/p2"));
+ assert_metadata_eq!(file_metadata, at.metadata("dir/p1/p2/file"));
+ }
+}
+
+#[test]
+#[cfg(unix)]
+fn test_cp_writable_special_file_permissions() {
+ new_ucmd!().arg("/dev/null").arg("/dev/zero").succeeds();
+}
+
+#[test]
+#[cfg(unix)]
+fn test_cp_issue_1665() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.arg("/dev/null").arg("foo").succeeds();
+ assert!(at.file_exists("foo"));
+ assert_eq!(at.read("foo"), "");
+}
+
+#[test]
+fn test_cp_preserve_no_args() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let src_file = "a";
+ let dst_file = "b";
+
+ // Prepare the source file
+ at.touch(src_file);
+ #[cfg(unix)]
+ at.set_mode(src_file, 0o0500);
// Copy
ucmd.arg(src_file)
@@ -906,7 +1379,7 @@ fn test_cp_preserve_no_args() {
}
#[test]
-fn test_cp_preserve_all() {
+fn test_cp_preserve_no_args_before_opts() {
let (at, mut ucmd) = at_and_ucmd!();
let src_file = "a";
let dst_file = "b";
@@ -916,11 +1389,10 @@ fn test_cp_preserve_all() {
#[cfg(unix)]
at.set_mode(src_file, 0o0500);
- // TODO: create a destination that does not allow copying of xattr and context
// Copy
- ucmd.arg(src_file)
+ ucmd.arg("--preserve")
+ .arg(src_file)
.arg(dst_file)
- .arg("--preserve=all")
.succeeds();
#[cfg(all(unix, not(target_os = "freebsd")))]
@@ -933,6 +1405,33 @@ fn test_cp_preserve_all() {
}
}
+#[test]
+fn test_cp_preserve_all() {
+ for argument in ["--preserve=all", "--preserve=al"] {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let src_file = "a";
+ let dst_file = "b";
+
+ // Prepare the source file
+ at.touch(src_file);
+ #[cfg(unix)]
+ at.set_mode(src_file, 0o0500);
+
+ // TODO: create a destination that does not allow copying of xattr and context
+ // Copy
+ ucmd.arg(src_file).arg(dst_file).arg(argument).succeeds();
+
+ #[cfg(all(unix, not(target_os = "freebsd")))]
+ {
+ // Assert that the mode, ownership, and timestamps are preserved
+ // NOTICE: the ownership is not modified on the src file, because that requires root permissions
+ let metadata_src = at.metadata(src_file);
+ let metadata_dst = at.metadata(dst_file);
+ assert_metadata_eq!(metadata_src, metadata_dst);
+ }
+ }
+}
+
#[test]
#[cfg(all(unix, not(target_os = "android")))]
fn test_cp_preserve_xattr() {
@@ -978,7 +1477,37 @@ fn test_cp_preserve_all_context_fails_on_non_selinux() {
}
#[test]
-#[cfg(any(target_os = "android"))]
+fn test_cp_preserve_link_parses() {
+ // TODO: Also check whether --preserve=link did the right thing!
+ for argument in [
+ "--preserve=links",
+ "--preserve=link",
+ "--preserve=li",
+ "--preserve=l",
+ ] {
+ new_ucmd!()
+ .arg(argument)
+ .arg(TEST_COPY_FROM_FOLDER_FILE)
+ .arg(TEST_HELLO_WORLD_DEST)
+ .succeeds()
+ .no_output();
+ }
+}
+
+#[test]
+fn test_cp_preserve_invalid_rejected() {
+ new_ucmd!()
+ .arg("--preserve=invalid-value")
+ .arg(TEST_COPY_FROM_FOLDER_FILE)
+ .arg(TEST_HELLO_WORLD_DEST)
+ .fails()
+ .code_is(1)
+ .no_stdout();
+}
+
+#[test]
+#[cfg(target_os = "android")]
+#[ignore = "disabled until fixed"] // FIXME: the test looks to .succeed on android
fn test_cp_preserve_xattr_fails_on_android() {
// Because of the SELinux extended attributes used on Android, trying to copy extended
// attributes has to fail in this case, since we specify `--preserve=xattr` and this puts it
@@ -990,6 +1519,225 @@ fn test_cp_preserve_xattr_fails_on_android() {
.fails();
}
+#[test]
+// android platform will causing stderr = cp: Permission denied (os error 13)
+#[cfg(not(target_os = "android"))]
+fn test_cp_preserve_links_case_1() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ at.touch("a");
+ at.hard_link("a", "b");
+ at.mkdir("c");
+
+ ucmd.arg("-d").arg("a").arg("b").arg("c").succeeds();
+
+ assert!(at.dir_exists("c"));
+ assert!(at.plus("c").join("a").exists());
+ assert!(at.plus("c").join("b").exists());
+
+ #[cfg(unix)]
+ {
+ let metadata_a = std::fs::metadata(at.subdir.join("c").join("a")).unwrap();
+ let metadata_b = std::fs::metadata(at.subdir.join("c").join("b")).unwrap();
+
+ assert_eq!(metadata_a.ino(), metadata_b.ino());
+ }
+}
+
+#[test]
+// android platform will causing stderr = cp: Permission denied (os error 13)
+#[cfg(not(target_os = "android"))]
+fn test_cp_preserve_links_case_2() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ at.touch("a");
+ at.symlink_file("a", "b");
+ at.mkdir("c");
+
+ ucmd.arg("--preserve=links")
+ .arg("-R")
+ .arg("-H")
+ .arg("a")
+ .arg("b")
+ .arg("c")
+ .succeeds();
+
+ assert!(at.dir_exists("c"));
+ assert!(at.plus("c").join("a").exists());
+ assert!(at.plus("c").join("b").exists());
+
+ #[cfg(unix)]
+ {
+ let metadata_a = std::fs::metadata(at.subdir.join("c").join("a")).unwrap();
+ let metadata_b = std::fs::metadata(at.subdir.join("c").join("b")).unwrap();
+
+ assert_eq!(metadata_a.ino(), metadata_b.ino());
+ }
+}
+
+#[test]
+// android platform will causing stderr = cp: Permission denied (os error 13)
+#[cfg(not(target_os = "android"))]
+fn test_cp_preserve_links_case_3() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ at.mkdir("d");
+ at.touch("d/a");
+ at.symlink_file("d/a", "d/b");
+
+ ucmd.arg("--preserve=links")
+ .arg("-R")
+ .arg("-L")
+ .arg("d")
+ .arg("c")
+ .succeeds();
+
+ assert!(at.dir_exists("c"));
+ assert!(at.plus("c").join("a").exists());
+ assert!(at.plus("c").join("b").exists());
+
+ #[cfg(unix)]
+ {
+ let metadata_a = std::fs::metadata(at.subdir.join("c").join("a")).unwrap();
+ let metadata_b = std::fs::metadata(at.subdir.join("c").join("b")).unwrap();
+
+ assert_eq!(metadata_a.ino(), metadata_b.ino());
+ }
+}
+
+#[test]
+// android platform will causing stderr = cp: Permission denied (os error 13)
+#[cfg(not(target_os = "android"))]
+fn test_cp_preserve_links_case_4() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ at.mkdir("d");
+ at.touch("d/a");
+ at.hard_link("d/a", "d/b");
+
+ ucmd.arg("--preserve=links")
+ .arg("-R")
+ .arg("-L")
+ .arg("d")
+ .arg("c")
+ .succeeds();
+
+ assert!(at.dir_exists("c"));
+ assert!(at.plus("c").join("a").exists());
+ assert!(at.plus("c").join("b").exists());
+
+ #[cfg(unix)]
+ {
+ let metadata_a = std::fs::metadata(at.subdir.join("c").join("a")).unwrap();
+ let metadata_b = std::fs::metadata(at.subdir.join("c").join("b")).unwrap();
+
+ assert_eq!(metadata_a.ino(), metadata_b.ino());
+ }
+}
+
+#[test]
+// android platform will causing stderr = cp: Permission denied (os error 13)
+#[cfg(not(target_os = "android"))]
+fn test_cp_preserve_links_case_5() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ at.mkdir("d");
+ at.touch("d/a");
+ at.hard_link("d/a", "d/b");
+
+ ucmd.arg("-dR")
+ .arg("--no-preserve=links")
+ .arg("d")
+ .arg("c")
+ .succeeds();
+
+ assert!(at.dir_exists("c"));
+ assert!(at.plus("c").join("a").exists());
+ assert!(at.plus("c").join("b").exists());
+
+ #[cfg(unix)]
+ {
+ let metadata_a = std::fs::metadata(at.subdir.join("c").join("a")).unwrap();
+ let metadata_b = std::fs::metadata(at.subdir.join("c").join("b")).unwrap();
+
+ assert_ne!(metadata_a.ino(), metadata_b.ino());
+ }
+}
+
+#[test]
+// android platform will causing stderr = cp: Permission denied (os error 13)
+#[cfg(not(target_os = "android"))]
+fn test_cp_preserve_links_case_6() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ at.touch("a");
+ at.hard_link("a", "b");
+ at.mkdir("c");
+
+ ucmd.arg("-d").arg("a").arg("b").arg("c").succeeds();
+
+ assert!(at.dir_exists("c"));
+ assert!(at.plus("c").join("a").exists());
+ assert!(at.plus("c").join("b").exists());
+
+ #[cfg(unix)]
+ {
+ let metadata_a = std::fs::metadata(at.subdir.join("c").join("a")).unwrap();
+ let metadata_b = std::fs::metadata(at.subdir.join("c").join("b")).unwrap();
+
+ assert_eq!(metadata_a.ino(), metadata_b.ino());
+ }
+}
+
+#[test]
+// android platform will causing stderr = cp: Permission denied (os error 13)
+#[cfg(not(target_os = "android"))]
+fn test_cp_preserve_links_case_7() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ at.mkdir("src");
+ at.touch("src/f");
+ at.hard_link("src/f", "src/g");
+
+ at.mkdir("dest");
+ at.touch("dest/g");
+
+ ucmd.arg("-n")
+ .arg("--preserve=links")
+ .arg("src/f")
+ .arg("src/g")
+ .arg("dest")
+ .fails()
+ .stderr_contains("not replacing");
+
+ assert!(at.dir_exists("dest"));
+ assert!(at.plus("dest").join("f").exists());
+ assert!(at.plus("dest").join("g").exists());
+}
+
+#[test]
+#[cfg(unix)]
+fn test_cp_no_preserve_mode() {
+ use uucore::fs as uufs;
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ at.touch("a");
+ at.set_mode("a", 0o731);
+
+ ucmd.arg("-a")
+ .arg("--no-preserve=mode")
+ .arg("a")
+ .arg("b")
+ .umask(0o077)
+ .succeeds();
+
+ assert!(at.file_exists("b"));
+
+ let metadata_b = std::fs::metadata(at.subdir.join("b")).unwrap();
+ let permission_b = uufs::display_permissions(&metadata_b, false);
+ assert_eq!(permission_b, "rw-------".to_string());
+}
+
#[test]
// For now, disable the test on Windows. Symlinks aren't well support on Windows.
// It works on Unix for now and it works locally when run from a powershell
@@ -1068,7 +1816,7 @@ fn test_cp_deref_folder_to_folder() {
.join(TEST_COPY_TO_FOLDER_NEW)
.join(TEST_HELLO_WORLD_SOURCE_SYMLINK);
assert!(at.file_exists(
- &path_to_new_symlink
+ path_to_new_symlink
.clone()
.into_os_string()
.into_string()
@@ -1186,7 +1934,7 @@ fn test_cp_no_deref_folder_to_folder() {
#[cfg(target_os = "linux")]
fn test_cp_archive() {
let (at, mut ucmd) = at_and_ucmd!();
- let ts = time::OffsetDateTime::now_local().unwrap();
+ let ts = time::OffsetDateTime::now_utc();
let previous = FileTime::from_unix_time(ts.unix_timestamp() - 3600, ts.nanosecond());
// set the file creation/modification an hour ago
filetime::set_file_times(
@@ -1231,8 +1979,8 @@ fn test_cp_archive_recursive() {
let file_2 = at.subdir.join(TEST_COPY_TO_FOLDER).join("2");
let file_2_link = at.subdir.join(TEST_COPY_TO_FOLDER).join("2.link");
- at.touch(&file_1.to_string_lossy());
- at.touch(&file_2.to_string_lossy());
+ at.touch(file_1);
+ at.touch(file_2);
at.symlink_file("1", &file_1_link.to_string_lossy());
at.symlink_file("2", &file_2_link.to_string_lossy());
@@ -1258,18 +2006,8 @@ fn test_cp_archive_recursive() {
.run();
println!("ls dest {}", result.stdout_str());
- assert!(at.file_exists(
- &at.subdir
- .join(TEST_COPY_TO_FOLDER_NEW)
- .join("1")
- .to_string_lossy()
- ));
- assert!(at.file_exists(
- &at.subdir
- .join(TEST_COPY_TO_FOLDER_NEW)
- .join("2")
- .to_string_lossy()
- ));
+ assert!(at.file_exists(at.subdir.join(TEST_COPY_TO_FOLDER_NEW).join("1")));
+ assert!(at.file_exists(at.subdir.join(TEST_COPY_TO_FOLDER_NEW).join("2")));
assert!(at.is_symlink(
&at.subdir
@@ -1289,7 +2027,7 @@ fn test_cp_archive_recursive() {
#[cfg(any(target_os = "linux", target_os = "android"))]
fn test_cp_preserve_timestamps() {
let (at, mut ucmd) = at_and_ucmd!();
- let ts = time::OffsetDateTime::now_local().unwrap();
+ let ts = time::OffsetDateTime::now_utc();
let previous = FileTime::from_unix_time(ts.unix_timestamp() - 3600, ts.nanosecond());
// set the file creation/modification an hour ago
filetime::set_file_times(
@@ -1322,7 +2060,7 @@ fn test_cp_preserve_timestamps() {
#[cfg(any(target_os = "linux", target_os = "android"))]
fn test_cp_no_preserve_timestamps() {
let (at, mut ucmd) = at_and_ucmd!();
- let ts = time::OffsetDateTime::now_local().unwrap();
+ let ts = time::OffsetDateTime::now_utc();
let previous = FileTime::from_unix_time(ts.unix_timestamp() - 3600, ts.nanosecond());
// set the file creation/modification an hour ago
filetime::set_file_times(
@@ -1350,7 +2088,7 @@ fn test_cp_no_preserve_timestamps() {
let result = scene2.cmd("ls").arg("-al").arg(at.subdir).run();
println!("ls dest {}", result.stdout_str());
- println!("creation {:?} / {:?}", creation, creation2);
+ println!("creation {creation:?} / {creation2:?}");
assert_ne!(creation, creation2);
let res = creation.elapsed().unwrap() - creation2.elapsed().unwrap();
@@ -1379,13 +2117,13 @@ fn test_cp_one_file_system() {
use walkdir::WalkDir;
let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
// Test must be run as root (or with `sudo -E`)
if scene.cmd("whoami").run().stdout_str() != "root\n" {
return;
}
- let at = scene.fixtures.clone();
let at_src = AtPath::new(&at.plus(TEST_MOUNT_COPY_FROM_FOLDER));
let at_dst = AtPath::new(&at.plus(TEST_COPY_TO_FOLDER_NEW));
@@ -1488,14 +2226,16 @@ fn test_cp_reflink_none() {
#[test]
#[cfg(any(target_os = "linux", target_os = "android", target_os = "macos"))]
fn test_cp_reflink_never() {
- let (at, mut ucmd) = at_and_ucmd!();
- ucmd.arg("--reflink=never")
- .arg(TEST_HELLO_WORLD_SOURCE)
- .arg(TEST_EXISTING_FILE)
- .succeeds();
+ for argument in ["--reflink=never", "--reflink=neve", "--reflink=n"] {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.arg(argument)
+ .arg(TEST_HELLO_WORLD_SOURCE)
+ .arg(TEST_EXISTING_FILE)
+ .succeeds();
- // Check the content of the destination file
- assert_eq!(at.read(TEST_EXISTING_FILE), "Hello, World!\n");
+ // Check the content of the destination file
+ assert_eq!(at.read(TEST_EXISTING_FILE), "Hello, World!\n");
+ }
}
#[test]
@@ -1507,7 +2247,7 @@ fn test_cp_reflink_bad() {
.arg(TEST_HELLO_WORLD_SOURCE)
.arg(TEST_EXISTING_FILE)
.fails()
- .stderr_contains("error: 'bad' isn't a valid value for '--reflink[=<WHEN>]'");
+ .stderr_contains("error: invalid value 'bad' for '--reflink[=<WHEN>]'");
}
#[test]
@@ -1524,13 +2264,14 @@ fn test_cp_reflink_insufficient_permission() {
.arg("unreadable")
.arg(TEST_EXISTING_FILE)
.fails()
- .stderr_only("cp: 'unreadable' -> 'existing_file.txt': Permission denied (os error 13)");
+ .stderr_only("cp: 'unreadable' -> 'existing_file.txt': Permission denied (os error 13)\n");
}
-#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(target_os = "linux")]
#[test]
fn test_closes_file_descriptors() {
use procfs::process::Process;
+ use rlimit::Resource;
let me = Process::myself().unwrap();
// The test suite runs in parallel, we have pipe, sockets
@@ -1540,7 +2281,6 @@ fn test_closes_file_descriptors() {
let limit_fd: u64 = number_file_already_opened + 9;
// For debugging purposes:
- #[cfg(not(target_os = "android"))]
for f in me.fd().unwrap() {
let fd = f.unwrap();
println!("{:?} {:?}", fd, fd.mode());
@@ -1551,7 +2291,7 @@ fn test_closes_file_descriptors() {
.arg("--reflink=auto")
.arg("dir_with_10_files/")
.arg("dir_with_10_files_new/")
- .with_limit(Resource::NOFILE, limit_fd, limit_fd)
+ .limit(Resource::NOFILE, limit_fd, limit_fd)
.succeeds();
}
@@ -1578,19 +2318,21 @@ fn test_cp_sparse_never_empty() {
#[cfg(any(target_os = "linux", target_os = "android"))]
#[test]
fn test_cp_sparse_always_empty() {
- let (at, mut ucmd) = at_and_ucmd!();
+ for argument in ["--sparse=always", "--sparse=alway", "--sparse=al"] {
+ let (at, mut ucmd) = at_and_ucmd!();
- const BUFFER_SIZE: usize = 4096 * 4;
- let buf: [u8; BUFFER_SIZE] = [0; BUFFER_SIZE];
+ const BUFFER_SIZE: usize = 4096 * 4;
+ let buf: [u8; BUFFER_SIZE] = [0; BUFFER_SIZE];
- at.make_file("src_file1");
- at.write_bytes("src_file1", &buf);
+ at.make_file("src_file1");
+ at.write_bytes("src_file1", &buf);
- ucmd.args(&["--sparse=always", "src_file1", "dst_file_sparse"])
- .succeeds();
+ ucmd.args(&[argument, "src_file1", "dst_file_sparse"])
+ .succeeds();
- assert_eq!(at.read_bytes("dst_file_sparse"), buf);
- assert_eq!(at.metadata("dst_file_sparse").blocks(), 0);
+ assert_eq!(at.read_bytes("dst_file_sparse"), buf);
+ assert_eq!(at.metadata("dst_file_sparse").blocks(), 0);
+ }
}
#[cfg(any(target_os = "linux", target_os = "android"))]
@@ -1673,12 +2415,12 @@ fn test_cp_reflink_always_override() {
const USERDIR: &str = "dir/";
const MOUNTPOINT: &str = "mountpoint/";
- let src1_path: &str = &vec![MOUNTPOINT, USERDIR, "src1"].concat();
- let src2_path: &str = &vec![MOUNTPOINT, USERDIR, "src2"].concat();
- let dst_path: &str = &vec![MOUNTPOINT, USERDIR, "dst"].concat();
+ let src1_path: &str = &[MOUNTPOINT, USERDIR, "src1"].concat();
+ let src2_path: &str = &[MOUNTPOINT, USERDIR, "src2"].concat();
+ let dst_path: &str = &[MOUNTPOINT, USERDIR, "dst"].concat();
scene.fixtures.mkdir(ROOTDIR);
- scene.fixtures.mkdir(&vec![ROOTDIR, USERDIR].concat());
+ scene.fixtures.mkdir([ROOTDIR, USERDIR].concat());
// Setup:
// Because neither `mkfs.btrfs` not btrfs `mount` options allow us to have a mountpoint owned
@@ -1698,7 +2440,8 @@ fn test_cp_reflink_always_override() {
.succeeds();
if !scene
- .cmd_keepenv("env")
+ .cmd("env")
+ .env("PATH", PATH)
.args(&["mkfs.btrfs", "--rootdir", ROOTDIR, DISK])
.run()
.succeeded()
@@ -1710,7 +2453,8 @@ fn test_cp_reflink_always_override() {
scene.fixtures.mkdir(MOUNTPOINT);
let mount = scene
- .cmd_keepenv("sudo")
+ .cmd("sudo")
+ .env("PATH", PATH)
.args(&["-E", "--non-interactive", "mount", DISK, MOUNTPOINT])
.run();
@@ -1736,7 +2480,8 @@ fn test_cp_reflink_always_override() {
.succeeds();
scene
- .cmd_keepenv("sudo")
+ .cmd("sudo")
+ .env("PATH", PATH)
.args(&["-E", "--non-interactive", "umount", MOUNTPOINT])
.succeeds();
}
@@ -1783,25 +2528,29 @@ fn test_copy_symlink_force() {
}
#[test]
-#[cfg(all(unix, not(target_os = "freebsd")))]
+#[cfg(unix)]
fn test_no_preserve_mode() {
use std::os::unix::prelude::MetadataExt;
- use uucore::mode::get_umask;
-
- const PERMS_ALL: u32 = 0o7777;
+ const PERMS_ALL: u32 = if cfg!(target_os = "freebsd") {
+ // Only the superuser can set the sticky bit on a file.
+ 0o6777
+ } else {
+ 0o7777
+ };
let (at, mut ucmd) = at_and_ucmd!();
at.touch("file");
set_permissions(at.plus("file"), PermissionsExt::from_mode(PERMS_ALL)).unwrap();
+ let umask: u16 = 0o022;
ucmd.arg("file")
.arg("dest")
+ .umask(umask as libc::mode_t)
.succeeds()
.no_stderr()
.no_stdout();
- let umask = get_umask();
// remove sticky bit, setuid and setgid bit; apply umask
- let expected_perms = PERMS_ALL & !0o7000 & !umask;
+ let expected_perms = PERMS_ALL & !0o7000 & !umask as u32;
assert_eq!(
at.plus("dest").metadata().unwrap().mode() & 0o7777,
expected_perms
@@ -1809,11 +2558,16 @@ fn test_no_preserve_mode() {
}
#[test]
-#[cfg(all(unix, not(target_os = "freebsd")))]
+#[cfg(unix)]
fn test_preserve_mode() {
use std::os::unix::prelude::MetadataExt;
- const PERMS_ALL: u32 = 0o7777;
+ const PERMS_ALL: u32 = if cfg!(target_os = "freebsd") {
+ // Only the superuser can set the sticky bit on a file.
+ 0o6777
+ } else {
+ 0o7777
+ };
let (at, mut ucmd) = at_and_ucmd!();
at.touch("file");
@@ -1851,10 +2605,8 @@ fn test_copy_through_just_created_symlink() {
at.mkdir("b");
at.mkdir("c");
at.relative_symlink_file("../t", "a/1");
- at.touch("b/1");
at.write("b/1", "hello");
if create_t {
- at.touch("t");
at.write("t", "world");
}
ucmd.arg("--no-dereference")
@@ -1863,9 +2615,9 @@ fn test_copy_through_just_created_symlink() {
.arg("c")
.fails()
.stderr_only(if cfg!(not(target_os = "windows")) {
- "cp: will not copy 'b/1' through just-created symlink 'c/1'"
+ "cp: will not copy 'b/1' through just-created symlink 'c/1'\n"
} else {
- "cp: will not copy 'b/1' through just-created symlink 'c\\1'"
+ "cp: will not copy 'b/1' through just-created symlink 'c\\1'\n"
});
if create_t {
assert_eq!(at.read("a/1"), "world");
@@ -1881,7 +2633,18 @@ fn test_copy_through_dangling_symlink() {
ucmd.arg("file")
.arg("target")
.fails()
- .stderr_only("cp: not writing through dangling symlink 'target'");
+ .stderr_only("cp: not writing through dangling symlink 'target'\n");
+}
+
+#[test]
+fn test_copy_through_dangling_symlink_posixly_correct() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.touch("file");
+ at.symlink_file("nonexistent", "target");
+ ucmd.arg("file")
+ .arg("target")
+ .env("POSIXLY_CORRECT", "1")
+ .succeeds();
}
#[test]
@@ -1896,10 +2659,66 @@ fn test_copy_through_dangling_symlink_no_dereference() {
.no_stdout();
}
-/// Test for copying a dangling symbolic link and its permissions.
-#[cfg(not(target_os = "freebsd"))] // FIXME: fix this test for FreeBSD
#[test]
-fn test_copy_through_dangling_symlink_no_dereference_permissions() {
+fn test_cp_symlink_overwrite_detection() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+
+ at.mkdir("good");
+ at.mkdir("tmp");
+ at.write("README", "file1");
+ at.write("good/README", "file2");
+
+ at.symlink_file("tmp/foo", "tmp/README");
+ at.touch("tmp/foo");
+
+ ts.ucmd()
+ .arg("README")
+ .arg("good/README")
+ .arg("tmp")
+ .fails()
+ .stderr_only(if cfg!(target_os = "windows") {
+ "cp: will not copy 'good/README' through just-created symlink 'tmp\\README'\n"
+ } else if cfg!(target_os = "macos") {
+ "cp: will not overwrite just-created 'tmp/README' with 'good/README'\n"
+ } else {
+ "cp: will not copy 'good/README' through just-created symlink 'tmp/README'\n"
+ });
+ let contents = at.read("tmp/foo");
+ // None of the files seem to be copied in macos
+ if cfg!(not(target_os = "macos")) {
+ assert_eq!(contents, "file1");
+ }
+}
+
+#[test]
+fn test_cp_dangling_symlink_inside_directory() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+
+ at.mkdir("good");
+ at.mkdir("tmp");
+ at.write("README", "file1");
+ at.write("good/README", "file2");
+
+ at.symlink_file("foo", "tmp/README");
+
+ ts.ucmd()
+ .arg("README")
+ .arg("good/README")
+ .arg("tmp")
+ .fails()
+ .stderr_only( if cfg!(target_os="windows") {
+ "cp: not writing through dangling symlink 'tmp\\README'\ncp: not writing through dangling symlink 'tmp\\README'\n"
+ } else {
+ "cp: not writing through dangling symlink 'tmp/README'\ncp: not writing through dangling symlink 'tmp/README'\n"
+ } );
+}
+
+/// Test for copying a dangling symbolic link and its permissions.
+#[cfg(not(target_os = "freebsd"))] // FIXME: fix this test for FreeBSD
+#[test]
+fn test_copy_through_dangling_symlink_no_dereference_permissions() {
let (at, mut ucmd) = at_and_ucmd!();
// target name link name
at.symlink_file("no-such-file", "dangle");
@@ -1933,7 +2752,7 @@ fn test_copy_through_dangling_symlink_no_dereference_2() {
at.symlink_file("nonexistent", "target");
ucmd.args(&["-P", "file", "target"])
.fails()
- .stderr_only("cp: not writing through dangling symlink 'target'");
+ .stderr_only("cp: not writing through dangling symlink 'target'\n");
}
/// Test that copy through a dangling symbolic link fails, even with --force.
@@ -1945,7 +2764,7 @@ fn test_copy_through_dangling_symlink_force() {
at.symlink_file("no-such-file", "dest");
ucmd.args(&["--force", "src", "dest"])
.fails()
- .stderr_only("cp: not writing through dangling symlink 'dest'");
+ .stderr_only("cp: not writing through dangling symlink 'dest'\n");
assert!(!at.file_exists("dest"));
}
@@ -1958,7 +2777,7 @@ fn test_cp_archive_on_nonexistent_file() {
.arg(TEST_EXISTING_FILE)
.fails()
.stderr_only(
- "cp: cannot stat 'nonexistent_file.txt': No such file or directory (os error 2)",
+ "cp: cannot stat 'nonexistent_file.txt': No such file or directory (os error 2)\n",
);
}
@@ -1996,12 +2815,8 @@ fn test_dir_recursive_copy() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
- at.mkdir("parent1");
- at.mkdir("parent2");
- at.mkdir("parent1/child");
- at.mkdir("parent2/child1");
- at.mkdir("parent2/child1/child2");
- at.mkdir("parent2/child1/child2/child3");
+ at.mkdir_all("parent1/child");
+ at.mkdir_all("parent2/child1/child2/child3");
// case-1: copy parent1 -> parent1: should fail
scene
@@ -2043,7 +2858,7 @@ fn test_cp_dir_vs_file() {
.arg(TEST_COPY_FROM_FOLDER)
.arg(TEST_EXISTING_FILE)
.fails()
- .stderr_only("cp: cannot overwrite non-directory with directory");
+ .stderr_only("cp: cannot overwrite non-directory with directory\n");
}
#[test]
@@ -2077,7 +2892,6 @@ fn test_copy_no_dereference_1() {
let (at, mut ucmd) = at_and_ucmd!();
at.mkdir("a");
at.mkdir("b");
- at.touch("a/foo");
at.write("a/foo", "bar");
at.relative_symlink_file("../a/foo", "b/foo");
ucmd.args(&["-P", "a/foo", "b"]).fails();
@@ -2090,10 +2904,8 @@ fn test_abuse_existing() {
at.mkdir("b");
at.mkdir("c");
at.relative_symlink_file("../t", "a/1");
- at.touch("b/1");
at.write("b/1", "hello");
at.relative_symlink_file("../t", "c/1");
- at.touch("t");
at.write("t", "i");
ucmd.args(&["-dR", "a/1", "b/1", "c"])
.fails()
@@ -2205,7 +3017,6 @@ fn test_cp_copy_symlink_contents_recursive() {
let (at, mut ucmd) = at_and_ucmd!();
at.mkdir("src-dir");
at.mkdir("dest-dir");
- at.touch("f");
at.write("f", "f");
at.relative_symlink_file("f", "slink");
at.relative_symlink_file("no-file", &path_concat!("src-dir", "slink"));
@@ -2223,7 +3034,6 @@ fn test_cp_copy_symlink_contents_recursive() {
fn test_cp_mode_symlink() {
for from in ["file", "slink", "slink2"] {
let (at, mut ucmd) = at_and_ucmd!();
- at.touch("file");
at.write("file", "f");
at.relative_symlink_file("file", "slink");
at.relative_symlink_file("slink", "slink2");
@@ -2239,7 +3049,6 @@ fn test_cp_mode_symlink() {
fn test_cp_mode_hardlink() {
for from in ["file", "slink", "slink2"] {
let (at, mut ucmd) = at_and_ucmd!();
- at.touch("file");
at.write("file", "f");
at.relative_symlink_file("file", "slink");
at.relative_symlink_file("slink", "slink2");
@@ -2257,7 +3066,6 @@ fn test_cp_mode_hardlink() {
#[test]
fn test_cp_mode_hardlink_no_dereference() {
let (at, mut ucmd) = at_and_ucmd!();
- at.touch("file");
at.write("file", "f");
at.relative_symlink_file("file", "slink");
at.relative_symlink_file("slink", "slink2");
@@ -2266,6 +3074,40 @@ fn test_cp_mode_hardlink_no_dereference() {
assert_eq!(at.read_symlink("z"), "slink");
}
+#[cfg(not(any(windows, target_os = "android")))]
+#[test]
+fn test_remove_destination_with_destination_being_a_hardlink_to_source() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let file = "file";
+ let hardlink = "hardlink";
+
+ at.touch(file);
+ at.hard_link(file, hardlink);
+
+ ucmd.args(&["--remove-destination", file, hardlink])
+ .succeeds();
+
+ assert_eq!("", at.resolve_link(hardlink));
+ assert!(at.file_exists(file));
+ assert!(at.file_exists(hardlink));
+}
+
+#[test]
+fn test_remove_destination_with_destination_being_a_symlink_to_source() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let file = "file";
+ let symlink = "symlink";
+
+ at.touch(file);
+ at.symlink_file(file, symlink);
+
+ ucmd.args(&["--remove-destination", file, symlink])
+ .succeeds();
+ assert!(!at.symlink_exists(symlink));
+ assert!(at.file_exists(file));
+ assert!(at.file_exists(symlink));
+}
+
#[test]
fn test_remove_destination_symbolic_link_loop() {
let (at, mut ucmd) = at_and_ucmd!();
@@ -2279,15 +3121,29 @@ fn test_remove_destination_symbolic_link_loop() {
assert!(at.file_exists("loop"));
}
+#[test]
+#[cfg(not(windows))]
+fn test_cp_symbolic_link_loop() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.symlink_file("loop", "loop");
+ at.plus("loop");
+ at.touch("f");
+ ucmd.args(&["-f", "f", "loop"])
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert!(at.file_exists("loop"));
+}
+
/// Test that copying a directory to itself is disallowed.
#[test]
fn test_copy_directory_to_itself_disallowed() {
let (at, mut ucmd) = at_and_ucmd!();
at.mkdir("d");
#[cfg(not(windows))]
- let expected = "cp: cannot copy a directory, 'd', into itself, 'd/d'";
+ let expected = "cp: cannot copy a directory, 'd', into itself, 'd/d'\n";
#[cfg(windows)]
- let expected = "cp: cannot copy a directory, 'd', into itself, 'd\\d'";
+ let expected = "cp: cannot copy a directory, 'd', into itself, 'd\\d'\n";
ucmd.args(&["-R", "d", "d"]).fails().stderr_only(expected);
}
@@ -2299,9 +3155,9 @@ fn test_copy_nested_directory_to_itself_disallowed() {
at.mkdir("a/b");
at.mkdir("a/b/c");
#[cfg(not(windows))]
- let expected = "cp: cannot copy a directory, 'a/b', into itself, 'a/b/c/b'";
+ let expected = "cp: cannot copy a directory, 'a/b', into itself, 'a/b/c/b'\n";
#[cfg(windows)]
- let expected = "cp: cannot copy a directory, 'a/b', into itself, 'a/b/c\\b'";
+ let expected = "cp: cannot copy a directory, 'a/b', into itself, 'a/b/c\\b'\n";
ucmd.args(&["-R", "a/b", "a/b/c"])
.fails()
.stderr_only(expected);
@@ -2361,7 +3217,7 @@ fn test_copy_dir_preserve_permissions_inaccessible_file() {
ucmd.args(&["-p", "-R", "d1", "d2"])
.fails()
.code_is(1)
- .stderr_only("cp: cannot open 'd1/f' for reading: Permission denied");
+ .stderr_only("cp: cannot open 'd1/f' for reading: permission denied\n");
assert!(at.dir_exists("d2"));
assert!(!at.file_exists("d2/f"));
@@ -2378,7 +3234,7 @@ fn test_same_file_backup() {
at.touch("f");
ucmd.args(&["--backup", "f", "f"])
.fails()
- .stderr_only("cp: 'f' and 'f' are the same file");
+ .stderr_only("cp: 'f' and 'f' are the same file\n");
assert!(!at.file_exists("f~"));
}
@@ -2390,12 +3246,12 @@ fn test_same_file_force() {
at.touch("f");
ucmd.args(&["--force", "f", "f"])
.fails()
- .stderr_only("cp: 'f' and 'f' are the same file");
+ .stderr_only("cp: 'f' and 'f' are the same file\n");
assert!(!at.file_exists("f~"));
}
/// Test that copying file to itself with forced backup succeeds.
-#[cfg(all(not(windows)))]
+#[cfg(not(windows))]
#[test]
fn test_same_file_force_backup() {
let (at, mut ucmd) = at_and_ucmd!();
@@ -2527,14 +3383,2279 @@ fn test_symbolic_link_file() {
#[test]
fn test_src_base_dot() {
let ts = TestScenario::new(util_name!());
- let at = ts.fixtures.clone();
+ let at = &ts.fixtures;
at.mkdir("x");
at.mkdir("y");
- let mut ucmd = UCommand::new(ts.bin_path, &Some(ts.util_name), at.plus("y"), true);
-
- ucmd.args(&["--verbose", "-r", "../x/.", "."])
+ ts.ucmd()
+ .current_dir(at.plus("y"))
+ .args(&["--verbose", "-r", "../x/.", "."])
.succeeds()
.no_stderr()
.no_stdout();
assert!(!at.dir_exists("y/x"));
}
+
+#[cfg(target_os = "linux")]
+fn non_utf8_name(suffix: &str) -> OsString {
+ use std::os::unix::ffi::OsStringExt;
+ let mut name = OsString::from_vec(vec![0xff, 0xff]);
+ name.push(suffix);
+ name
+}
+
+#[cfg(target_os = "linux")]
+#[test]
+fn test_non_utf8_src() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let src = non_utf8_name("src");
+ std::fs::File::create(at.plus(&src)).unwrap();
+ ucmd.args(&[src, "dest".into()])
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+ assert!(at.file_exists("dest"));
+}
+
+#[cfg(target_os = "linux")]
+#[test]
+fn test_non_utf8_dest() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let dest = non_utf8_name("dest");
+ ucmd.args(&[TEST_HELLO_WORLD_SOURCE.as_ref(), &*dest])
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+ assert!(at.file_exists(dest));
+}
+
+#[cfg(target_os = "linux")]
+#[test]
+fn test_non_utf8_target() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let dest = non_utf8_name("dest");
+ at.mkdir(&dest);
+ ucmd.args(&["-t".as_ref(), &*dest, TEST_HELLO_WORLD_SOURCE.as_ref()])
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+ let mut copied_file = PathBuf::from(dest);
+ copied_file.push(TEST_HELLO_WORLD_SOURCE);
+ assert!(at.file_exists(copied_file));
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_cp_archive_on_directory_ending_dot() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.mkdir("dir1");
+ at.mkdir("dir2");
+ at.touch("dir1/file");
+ ucmd.args(&["-a", "dir1/.", "dir2"]).succeeds();
+ assert!(at.file_exists("dir2/file"));
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))]
+fn test_cp_debug_default() {
+ #[cfg(target_os = "macos")]
+ let expected = "copy offload: unknown, reflink: unsupported, sparse detection: unsupported";
+ #[cfg(target_os = "linux")]
+ let expected = "copy offload: unknown, reflink: unsupported, sparse detection: no";
+ #[cfg(windows)]
+ let expected = "copy offload: unsupported, reflink: unsupported, sparse detection: unsupported";
+
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.touch("a");
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains(expected);
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))]
+fn test_cp_debug_multiple_default() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ let dir = "dir";
+ at.touch("a");
+ at.touch("b");
+ at.mkdir(dir);
+
+ let result = ts
+ .ucmd()
+ .arg("--debug")
+ .arg("a")
+ .arg("b")
+ .arg(dir)
+ .succeeds();
+
+ #[cfg(target_os = "macos")]
+ let expected = "copy offload: unknown, reflink: unsupported, sparse detection: unsupported";
+ #[cfg(target_os = "linux")]
+ let expected = "copy offload: unknown, reflink: unsupported, sparse detection: no";
+ #[cfg(windows)]
+ let expected = "copy offload: unsupported, reflink: unsupported, sparse detection: unsupported";
+
+ // two files, two occurrences
+ assert_eq!(result.stdout_str().matches(expected).count(), 2);
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_debug_sparse_reflink() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.touch("a");
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--sparse=always")
+ .arg("--reflink=never")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: avoided, reflink: no, sparse detection: zeros");
+}
+
+#[test]
+fn test_cp_debug_no_update() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.touch("a");
+ at.touch("b");
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--update=none")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("skipped 'b'");
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_debug_sparse_always() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.touch("a");
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--sparse=always")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: avoided, reflink: unsupported, sparse detection: zeros");
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_debug_sparse_never() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.touch("a");
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--sparse=never")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: avoided, reflink: no, sparse detection: no");
+}
+
+#[test]
+fn test_cp_debug_sparse_auto() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.touch("a");
+
+ #[cfg(not(any(target_os = "linux", target_os = "macos")))]
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--sparse=auto")
+ .arg("a")
+ .arg("b")
+ .succeeds();
+
+ #[cfg(any(target_os = "linux", target_os = "macos"))]
+ {
+ #[cfg(target_os = "macos")]
+ let expected = "copy offload: unknown, reflink: unsupported, sparse detection: unsupported";
+ #[cfg(target_os = "linux")]
+ let expected = "copy offload: unknown, reflink: unsupported, sparse detection: no";
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--sparse=auto")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains(expected);
+ }
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "macos"))]
+fn test_cp_debug_reflink_auto() {
+ #[cfg(target_os = "macos")]
+ let expected = "copy offload: unknown, reflink: unsupported, sparse detection: unsupported";
+ #[cfg(target_os = "linux")]
+ let expected = "copy offload: unknown, reflink: unsupported, sparse detection: no";
+
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.touch("a");
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--reflink=auto")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains(expected);
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_debug_sparse_always_reflink_auto() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.touch("a");
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--sparse=always")
+ .arg("--reflink=auto")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: avoided, reflink: unsupported, sparse detection: zeros");
+}
+
+#[test]
+fn test_cp_only_source_no_target() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.touch("a");
+ ts.ucmd()
+ .arg("a")
+ .fails()
+ .stderr_contains("missing destination file operand after \"a\"");
+}
+
+#[test]
+fn test_cp_dest_no_permissions() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+
+ at.touch("valid.txt");
+ at.touch("invalid_perms.txt");
+ at.set_readonly("invalid_perms.txt");
+
+ ts.ucmd()
+ .args(&["valid.txt", "invalid_perms.txt"])
+ .fails()
+ .stderr_contains("invalid_perms.txt")
+ .stderr_contains("denied");
+}
+
+#[test]
+#[cfg(all(unix, not(target_os = "freebsd")))]
+fn test_cp_attributes_only() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let a = "file_a";
+ let b = "file_b";
+ let mode_a = 0o0500;
+ let mode_b = 0o0777;
+
+ at.write(a, "a");
+ at.write(b, "b");
+ at.set_mode(a, mode_a);
+ at.set_mode(b, mode_b);
+
+ let mode_a = at.metadata(a).mode();
+ let mode_b = at.metadata(b).mode();
+
+ // --attributes-only doesn't do anything without other attribute preservation flags
+ ucmd.arg("--attributes-only")
+ .arg(a)
+ .arg(b)
+ .succeeds()
+ .no_output();
+
+ assert_eq!("a", at.read(a));
+ assert_eq!("b", at.read(b));
+ assert_eq!(mode_a, at.metadata(a).mode());
+ assert_eq!(mode_b, at.metadata(b).mode());
+}
+
+#[test]
+fn test_cp_seen_file() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+
+ at.mkdir("a");
+ at.mkdir("b");
+ at.mkdir("c");
+ at.write("a/f", "a");
+ at.write("b/f", "b");
+
+ let result = ts.ucmd().arg("a/f").arg("b/f").arg("c").fails();
+ #[cfg(not(unix))]
+ assert!(result
+ .stderr_str()
+ .contains("will not overwrite just-created 'c\\f' with 'b/f'"));
+ #[cfg(unix)]
+ assert!(result
+ .stderr_str()
+ .contains("will not overwrite just-created 'c/f' with 'b/f'"));
+
+ assert!(at.plus("c").join("f").exists());
+
+ ts.ucmd()
+ .arg("--backup=numbered")
+ .arg("a/f")
+ .arg("b/f")
+ .arg("c")
+ .succeeds();
+ assert!(at.plus("c").join("f").exists());
+ assert!(at.plus("c").join("f.~1~").exists());
+}
+
+#[test]
+fn test_cp_path_ends_with_terminator() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.mkdir("a");
+ ts.ucmd().arg("-r").arg("-T").arg("a").arg("e/").succeeds();
+}
+
+#[test]
+fn test_cp_no_such() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.touch("b");
+ ts.ucmd()
+ .arg("b")
+ .arg("no-such/")
+ .fails()
+ .stderr_is("cp: 'no-such/' is not a directory\n");
+}
+
+#[cfg(all(
+ unix,
+ not(any(target_os = "android", target_os = "macos", target_os = "openbsd"))
+))]
+#[test]
+fn test_acl_preserve() {
+ use std::process::Command;
+
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let path1 = "a";
+ let path2 = "b";
+ let file = "a/file";
+ let file_target = "b/file";
+ at.mkdir(path1);
+ at.mkdir(path2);
+ at.touch(file);
+
+ let path = at.plus_as_string(file);
+ // calling the command directly. xattr requires some dev packages to be installed
+ // and it adds a complex dependency just for a test
+ match Command::new("setfacl")
+ .args(["-m", "group::rwx", path1])
+ .status()
+ .map(|status| status.code())
+ {
+ Ok(Some(0)) => {}
+ Ok(_) => {
+ println!("test skipped: setfacl failed");
+ return;
+ }
+ Err(e) => {
+ println!("test skipped: setfacl failed with {}", e);
+ return;
+ }
+ }
+
+ scene.ucmd().args(&["-p", &path, path2]).succeeds();
+
+ assert!(compare_xattrs(&file, &file_target));
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_never_with_hole() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.write("a", "hello");
+ let f = std::fs::OpenOptions::new()
+ .write(true)
+ .open(at.plus("a"))
+ .unwrap();
+ f.set_len(10000).unwrap();
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--reflink=never")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: avoided, reflink: no, sparse detection: SEEK_HOLE");
+
+ let src_file_metadata = std::fs::metadata(at.plus("a")).unwrap();
+ let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
+ assert_eq!(src_file_metadata.blocks(), dst_file_metadata.blocks());
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_never_empty_file_with_hole() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.touch("a");
+ let f = std::fs::OpenOptions::new()
+ .write(true)
+ .open(at.plus("a"))
+ .unwrap();
+ f.set_len(10000).unwrap();
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--reflink=never")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: unknown, reflink: no, sparse detection: SEEK_HOLE");
+
+ let src_file_metadata = std::fs::metadata(at.plus("a")).unwrap();
+ let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
+ assert_eq!(src_file_metadata.blocks(), dst_file_metadata.blocks());
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_default_with_hole() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.touch("a");
+ let f = std::fs::OpenOptions::new()
+ .write(true)
+ .open(at.plus("a"))
+ .unwrap();
+ f.set_len(10000).unwrap();
+
+ at.append_bytes("a", "hello".as_bytes());
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: yes, reflink: unsupported, sparse detection: SEEK_HOLE");
+
+ let src_file_metadata = std::fs::metadata(at.plus("a")).unwrap();
+ let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
+ assert_eq!(src_file_metadata.blocks(), dst_file_metadata.blocks());
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_default_less_than_512_bytes() {
+ let ts = TestScenario::new(util_name!());
+
+ let at = &ts.fixtures;
+ at.write_bytes("a", "hello".as_bytes());
+ let f = std::fs::OpenOptions::new()
+ .write(true)
+ .open(at.plus("a"))
+ .unwrap();
+ f.set_len(400).unwrap();
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--reflink=auto")
+ .arg("--sparse=auto")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: yes, reflink: unsupported, sparse detection: no");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_default_without_hole() {
+ let ts = TestScenario::new(util_name!());
+
+ let at = &ts.fixtures;
+ at.write_bytes("a", "hello".as_bytes());
+
+ let filler_bytes = [0_u8; 10000];
+
+ at.append_bytes("a", &filler_bytes);
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: yes, reflink: unsupported, sparse detection: no");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_default_empty_file_with_hole() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.touch("a");
+ let f = std::fs::OpenOptions::new()
+ .write(true)
+ .open(at.plus("a"))
+ .unwrap();
+ f.set_len(10000).unwrap();
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains(
+ "copy offload: unknown, reflink: unsupported, sparse detection: SEEK_HOLE",
+ );
+
+ let src_file_metadata = std::fs::metadata(at.plus("a")).unwrap();
+ let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
+ assert_eq!(src_file_metadata.blocks(), dst_file_metadata.blocks());
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_never_sparse_always_with_hole() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.write("a", "hello");
+ let f = std::fs::OpenOptions::new()
+ .write(true)
+ .open(at.plus("a"))
+ .unwrap();
+ f.set_len(10000).unwrap();
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--reflink=never")
+ .arg("--sparse=always")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: avoided, reflink: no, sparse detection: SEEK_HOLE + zeros");
+
+ let src_file_metadata = std::fs::metadata(at.plus("a")).unwrap();
+ let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
+ assert_eq!(src_file_metadata.blocks(), dst_file_metadata.blocks());
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_never_sparse_always_without_hole() {
+ let ts = TestScenario::new(util_name!());
+ let empty_bytes = [0_u8; 10000];
+ let at = &ts.fixtures;
+ at.write("a", "hello");
+ at.append_bytes("a", &empty_bytes);
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--reflink=never")
+ .arg("--sparse=always")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: avoided, reflink: no, sparse detection: zeros");
+
+ let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
+ assert_eq!(
+ dst_file_metadata.blocks(),
+ dst_file_metadata.blksize() / 512
+ );
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_never_sparse_always_empty_file_with_hole() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.touch("a");
+ let f = std::fs::OpenOptions::new()
+ .write(true)
+ .open(at.plus("a"))
+ .unwrap();
+ f.set_len(10000).unwrap();
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--reflink=never")
+ .arg("--sparse=always")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: unknown, reflink: no, sparse detection: SEEK_HOLE");
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_default_virtual_file() {
+ // This file has existed at least since 2008, so we assume that it is present on "all" Linux kernels.
+ // https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-profiling
+
+ use std::os::unix::prelude::MetadataExt;
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ ts.ucmd().arg("/sys/kernel/profiling").arg("b").succeeds();
+
+ let dest_size = std::fs::metadata(at.plus("b"))
+ .expect("Metadata of copied file cannot be read")
+ .size();
+ assert!(dest_size > 0);
+}
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_auto_sparse_always_non_sparse_file_with_long_zero_sequence() {
+ let ts = TestScenario::new(util_name!());
+
+ let buf: Vec<u8> = vec![0; 4096 * 4];
+ let at = &ts.fixtures;
+ at.touch("a");
+ at.append_bytes("a", &buf);
+ at.append_bytes("a", "hello".as_bytes());
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--sparse=always")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: avoided, reflink: unsupported, sparse detection: zeros");
+
+ let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
+ assert_eq!(
+ dst_file_metadata.blocks(),
+ dst_file_metadata.blksize() / 512
+ );
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_debug_sparse_never_empty_sparse_file() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.touch("a");
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--sparse=never")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: avoided, reflink: no, sparse detection: no");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_never_sparse_always_non_sparse_file_with_long_zero_sequence() {
+ let ts = TestScenario::new(util_name!());
+
+ let buf: Vec<u8> = vec![0; 4096 * 4];
+ let at = &ts.fixtures;
+ at.touch("a");
+ at.append_bytes("a", &buf);
+ at.append_bytes("a", "hello".as_bytes());
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--reflink=never")
+ .arg("--sparse=always")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: avoided, reflink: no, sparse detection: zeros");
+
+ let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
+ assert_eq!(
+ dst_file_metadata.blocks(),
+ dst_file_metadata.blksize() / 512
+ );
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_debug_sparse_always_sparse_virtual_file() {
+ // This file has existed at least since 2008, so we assume that it is present on "all" Linux kernels.
+ // https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-profiling
+ let ts = TestScenario::new(util_name!());
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--sparse=always")
+ .arg("/sys/kernel/profiling")
+ .arg("b")
+ .succeeds()
+ .stdout_contains(
+ "copy offload: avoided, reflink: unsupported, sparse detection: SEEK_HOLE + zeros",
+ );
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_never_less_than_512_bytes() {
+ let ts = TestScenario::new(util_name!());
+
+ let at = &ts.fixtures;
+ at.write_bytes("a", "hello".as_bytes());
+ let f = std::fs::OpenOptions::new()
+ .write(true)
+ .open(at.plus("a"))
+ .unwrap();
+ f.set_len(400).unwrap();
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--reflink=never")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: avoided, reflink: no, sparse detection: no");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_never_sparse_never_empty_file_with_hole() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.touch("a");
+ let f = std::fs::OpenOptions::new()
+ .write(true)
+ .open(at.plus("a"))
+ .unwrap();
+ f.set_len(10000).unwrap();
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--reflink=never")
+ .arg("--sparse=never")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: unknown, reflink: no, sparse detection: SEEK_HOLE");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_never_file_with_hole() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.touch("a");
+ let f = std::fs::OpenOptions::new()
+ .write(true)
+ .open(at.plus("a"))
+ .unwrap();
+ f.set_len(10000).unwrap();
+ at.append_bytes("a", "hello".as_bytes());
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--reflink=never")
+ .arg("--sparse=never")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: avoided, reflink: no, sparse detection: SEEK_HOLE");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_sparse_never_less_than_512_bytes() {
+ let ts = TestScenario::new(util_name!());
+
+ let at = &ts.fixtures;
+ at.write_bytes("a", "hello".as_bytes());
+ let f = std::fs::OpenOptions::new()
+ .write(true)
+ .open(at.plus("a"))
+ .unwrap();
+ f.set_len(400).unwrap();
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--reflink=auto")
+ .arg("--sparse=never")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: avoided, reflink: no, sparse detection: no");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_sparse_never_without_hole() {
+ let ts = TestScenario::new(util_name!());
+
+ let at = &ts.fixtures;
+ at.write_bytes("a", "hello".as_bytes());
+
+ let filler_bytes = [0_u8; 10000];
+
+ at.append_bytes("a", &filler_bytes);
+
+ ts.ucmd()
+ .arg("--reflink=auto")
+ .arg("--sparse=never")
+ .arg("--debug")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: avoided, reflink: no, sparse detection: no");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_sparse_never_empty_file_with_hole() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.touch("a");
+ let f = std::fs::OpenOptions::new()
+ .write(true)
+ .open(at.plus("a"))
+ .unwrap();
+ f.set_len(10000).unwrap();
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--reflink=auto")
+ .arg("--sparse=never")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: unknown, reflink: no, sparse detection: SEEK_HOLE");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_sparse_never_file_with_hole() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.touch("a");
+ let f = std::fs::OpenOptions::new()
+ .write(true)
+ .open(at.plus("a"))
+ .unwrap();
+ f.set_len(10000).unwrap();
+ at.append_bytes("a", "hello".as_bytes());
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--reflink=auto")
+ .arg("--sparse=never")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: avoided, reflink: no, sparse detection: SEEK_HOLE");
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_debug_default_sparse_virtual_file() {
+ // This file has existed at least since 2008, so we assume that it is present on "all" Linux kernels.
+ // https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-profiling
+ let ts = TestScenario::new(util_name!());
+ ts.ucmd()
+ .arg("--debug")
+ .arg("/sys/kernel/profiling")
+ .arg("b")
+ .succeeds()
+ .stdout_contains(
+ "copy offload: unsupported, reflink: unsupported, sparse detection: SEEK_HOLE",
+ );
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_debug_sparse_never_zero_sized_virtual_file() {
+ let ts = TestScenario::new(util_name!());
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--sparse=never")
+ .arg("/proc/version")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: avoided, reflink: no, sparse detection: no");
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_debug_default_zero_sized_virtual_file() {
+ let ts = TestScenario::new(util_name!());
+ ts.ucmd()
+ .arg("--debug")
+ .arg("/proc/version")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: unsupported, reflink: unsupported, sparse detection: no");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_never_without_hole() {
+ let ts = TestScenario::new(util_name!());
+ let filler_bytes = [0_u8; 1000];
+ let at = &ts.fixtures;
+ at.write("a", "hello");
+ at.append_bytes("a", &filler_bytes);
+
+ ts.ucmd()
+ .arg("--debug")
+ .arg("--reflink=never")
+ .arg("a")
+ .arg("b")
+ .succeeds()
+ .stdout_contains("copy offload: avoided, reflink: no, sparse detection: no");
+}
+
+#[test]
+fn test_cp_force_remove_destination_attributes_only_with_symlink() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.write("file1", "1");
+ at.write("file2", "2");
+ at.symlink_file("file1", "sym1");
+
+ scene
+ .ucmd()
+ .args(&[
+ "-a",
+ "--remove-destination",
+ "--attributes-only",
+ "sym1",
+ "file2",
+ ])
+ .succeeds();
+
+ assert!(
+ at.symlink_exists("file2"),
+ "file2 is not a symbolic link as expected"
+ );
+
+ assert_eq!(
+ at.read("file1"),
+ at.read("file2"),
+ "Contents of file1 and file2 do not match"
+ );
+}
+
+#[test]
+fn test_cp_no_dereference_attributes_only_with_symlink() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.write("file1", "1");
+ at.write("file2", "2");
+ at.write("file2.exp", "2");
+ at.symlink_file("file1", "sym1");
+
+ let result = scene
+ .ucmd()
+ .args(&["--no-dereference", "--attributes-only", "sym1", "file2"])
+ .fails();
+
+ assert_eq!(result.code(), 1, "cp command did not fail");
+
+ assert_eq!(
+ at.read("file2"),
+ at.read("file2.exp"),
+ "file2 content does not match expected"
+ );
+}
+#[cfg(all(unix, not(target_os = "android")))]
+#[cfg(test)]
+/// contains the test for cp when the source and destination points to the same file
+mod same_file {
+
+ use crate::common::util::TestScenario;
+
+ const FILE_NAME: &str = "foo";
+ const SYMLINK_NAME: &str = "symlink";
+ const CONTENTS: &str = "abcd";
+
+ // the following tests tries to copy a file to the symlink of the same file with
+ // various options
+ #[test]
+ fn test_same_file_from_file_to_symlink() {
+ for option in ["-d", "-f", "-df"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ scene
+ .ucmd()
+ .args(&[option, FILE_NAME, SYMLINK_NAME])
+ .fails()
+ .stderr_contains("'foo' and 'symlink' are the same file");
+ assert!(at.symlink_exists(SYMLINK_NAME));
+ assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+ assert!(at.file_exists(FILE_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_file_to_symlink_with_rem_option() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ scene
+ .ucmd()
+ .args(&["--rem", FILE_NAME, SYMLINK_NAME])
+ .succeeds();
+ assert!(at.file_exists(SYMLINK_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ assert!(at.file_exists(FILE_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+
+ #[test]
+ fn test_same_file_from_file_to_symlink_with_backup_option() {
+ for option in ["-b", "-bd", "-bf", "-bdf"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let backup = "symlink~";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ scene
+ .ucmd()
+ .args(&[option, FILE_NAME, SYMLINK_NAME])
+ .succeeds();
+ assert!(at.symlink_exists(backup));
+ assert_eq!(FILE_NAME, at.resolve_link(backup));
+ assert!(at.file_exists(SYMLINK_NAME));
+ assert_eq!(at.read(SYMLINK_NAME), CONTENTS,);
+ assert!(at.file_exists(FILE_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_file_to_symlink_with_link_option() {
+ for option in ["-l", "-dl"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ scene
+ .ucmd()
+ .args(&[option, FILE_NAME, SYMLINK_NAME])
+ .fails()
+ .stderr_contains("cp: cannot create hard link 'symlink' to 'foo'");
+ assert!(at.symlink_exists(SYMLINK_NAME));
+ assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+ assert!(at.file_exists(FILE_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_file_to_symlink_with_options_link_and_force() {
+ for option in ["-fl", "-dfl"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ scene
+ .ucmd()
+ .args(&[option, FILE_NAME, SYMLINK_NAME])
+ .succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.file_exists(SYMLINK_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_file_to_symlink_with_options_backup_and_link() {
+ for option in ["-bl", "-bdl", "-bfl", "-bdfl"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let backup = "symlink~";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ scene
+ .ucmd()
+ .args(&[option, FILE_NAME, SYMLINK_NAME])
+ .succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.file_exists(SYMLINK_NAME));
+ assert!(at.symlink_exists(backup));
+ assert_eq!(FILE_NAME, at.resolve_link(backup));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_file_to_symlink_with_options_symlink() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ scene
+ .ucmd()
+ .args(&["-s", FILE_NAME, SYMLINK_NAME])
+ .fails()
+ .stderr_contains("cp: cannot create symlink 'symlink' to 'foo'");
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.symlink_exists(SYMLINK_NAME));
+ assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+
+ #[test]
+ fn test_same_file_from_file_to_symlink_with_options_symlink_and_force() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ scene
+ .ucmd()
+ .args(&["-sf", FILE_NAME, SYMLINK_NAME])
+ .succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.symlink_exists(SYMLINK_NAME));
+ assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ // the following tests tries to copy a symlink to the file that symlink points to with
+ // various options
+ #[test]
+ fn test_same_file_from_symlink_to_file() {
+ for option in ["-d", "-f", "-df", "--rem"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ scene
+ .ucmd()
+ .args(&[option, SYMLINK_NAME, FILE_NAME])
+ .fails()
+ .stderr_contains("'symlink' and 'foo' are the same file");
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.symlink_exists(SYMLINK_NAME));
+ assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_symlink_to_file_with_option_backup() {
+ for option in ["-b", "-bf"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ scene
+ .ucmd()
+ .args(&[option, SYMLINK_NAME, FILE_NAME])
+ .fails()
+ .stderr_contains("'symlink' and 'foo' are the same file");
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.symlink_exists(SYMLINK_NAME));
+ assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+ #[test]
+ fn test_same_file_from_symlink_to_file_with_option_backup_without_deref() {
+ for option in ["-bd", "-bdf"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let backup = "foo~";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ scene
+ .ucmd()
+ .args(&[option, SYMLINK_NAME, FILE_NAME])
+ .succeeds();
+ assert!(at.file_exists(backup));
+ assert!(at.symlink_exists(FILE_NAME));
+ // this doesn't makes sense but this is how gnu does it
+ assert_eq!(FILE_NAME, at.resolve_link(FILE_NAME));
+ assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+ assert_eq!(at.read(backup), CONTENTS,);
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_symlink_to_file_with_options_link() {
+ for option in ["-l", "-dl", "-fl", "-bl", "-bfl"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ scene
+ .ucmd()
+ .args(&[option, SYMLINK_NAME, FILE_NAME])
+ .succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.symlink_exists(SYMLINK_NAME));
+ assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_symlink_to_file_with_option_symlink() {
+ for option in ["-s", "-sf"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ scene
+ .ucmd()
+ .args(&[option, SYMLINK_NAME, FILE_NAME])
+ .fails()
+ .stderr_contains("'symlink' and 'foo' are the same file");
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.symlink_exists(SYMLINK_NAME));
+ assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+
+ // the following tests tries to copy a file to the same file with various options
+ #[test]
+ fn test_same_file_from_file_to_file() {
+ for option in ["-d", "-f", "-df", "--rem"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.write(FILE_NAME, CONTENTS);
+ scene
+ .ucmd()
+ .args(&[option, FILE_NAME, FILE_NAME])
+ .fails()
+ .stderr_contains("'foo' and 'foo' are the same file");
+ assert!(at.file_exists(FILE_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+ #[test]
+ fn test_same_file_from_file_to_file_with_backup() {
+ for option in ["-b", "-bd"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.write(FILE_NAME, CONTENTS);
+ scene
+ .ucmd()
+ .args(&[option, FILE_NAME, FILE_NAME])
+ .fails()
+ .stderr_contains("'foo' and 'foo' are the same file");
+ assert!(at.file_exists(FILE_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_file_to_file_with_options_backup_and_no_deref() {
+ for option in ["-bf", "-bdf"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let backup = "foo~";
+ at.write(FILE_NAME, CONTENTS);
+ scene
+ .ucmd()
+ .args(&[option, FILE_NAME, FILE_NAME])
+ .succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.file_exists(backup));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ assert_eq!(at.read(backup), CONTENTS,);
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_file_to_file_with_options_link() {
+ for option in ["-l", "-dl", "-fl", "-dfl", "-bl", "-bdl"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let backup = "foo~";
+ at.write(FILE_NAME, CONTENTS);
+ scene
+ .ucmd()
+ .args(&[option, FILE_NAME, FILE_NAME])
+ .succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert!(!at.file_exists(backup));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_file_to_file_with_options_link_and_backup_and_force() {
+ for option in ["-bfl", "-bdfl"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let backup = "foo~";
+ at.write(FILE_NAME, CONTENTS);
+ scene
+ .ucmd()
+ .args(&[option, FILE_NAME, FILE_NAME])
+ .succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.file_exists(backup));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ assert_eq!(at.read(backup), CONTENTS,);
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_file_to_file_with_options_symlink() {
+ for option in ["-s", "-sf"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.write(FILE_NAME, CONTENTS);
+ scene
+ .ucmd()
+ .args(&[option, FILE_NAME, FILE_NAME])
+ .fails()
+ .stderr_contains("'foo' and 'foo' are the same file");
+ assert!(at.file_exists(FILE_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+
+ // the following tests tries to copy a symlink that points to a file to a symlink
+ // that points to the same file with various options
+ #[test]
+ fn test_same_file_from_symlink_to_symlink_with_option_no_deref() {
+ for option in ["-d", "-df"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let symlink1 = "sl1";
+ let symlink2 = "sl2";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, symlink1);
+ at.symlink_file(FILE_NAME, symlink2);
+ scene.ucmd().args(&[option, symlink1, symlink2]).succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ assert_eq!(FILE_NAME, at.resolve_link(symlink1));
+ assert_eq!(FILE_NAME, at.resolve_link(symlink2));
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_symlink_to_symlink_with_option_force() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let symlink1 = "sl1";
+ let symlink2 = "sl2";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, symlink1);
+ at.symlink_file(FILE_NAME, symlink2);
+ scene
+ .ucmd()
+ .args(&["-f", symlink1, symlink2])
+ .fails()
+ .stderr_contains("'sl1' and 'sl2' are the same file");
+ assert!(at.file_exists(FILE_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ assert_eq!(FILE_NAME, at.resolve_link(symlink1));
+ assert_eq!(FILE_NAME, at.resolve_link(symlink2));
+ }
+
+ #[test]
+ fn test_same_file_from_symlink_to_symlink_with_option_rem() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let symlink1 = "sl1";
+ let symlink2 = "sl2";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, symlink1);
+ at.symlink_file(FILE_NAME, symlink2);
+ scene.ucmd().args(&["--rem", symlink1, symlink2]).succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ assert_eq!(FILE_NAME, at.resolve_link(symlink1));
+ assert!(at.file_exists(symlink2));
+ assert_eq!(at.read(symlink2), CONTENTS,);
+ }
+
+ #[test]
+ fn test_same_file_from_symlink_to_symlink_with_option_backup() {
+ for option in ["-b", "-bf"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let symlink1 = "sl1";
+ let symlink2 = "sl2";
+ let backup = "sl2~";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, symlink1);
+ at.symlink_file(FILE_NAME, symlink2);
+ scene.ucmd().args(&[option, symlink1, symlink2]).succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ assert_eq!(FILE_NAME, at.resolve_link(symlink1));
+ assert!(at.file_exists(symlink2));
+ assert_eq!(at.read(symlink2), CONTENTS,);
+ assert_eq!(FILE_NAME, at.resolve_link(backup));
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_symlink_to_symlink_with_option_backup_and_no_deref() {
+ for option in ["-bd", "-bdf"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let symlink1 = "sl1";
+ let symlink2 = "sl2";
+ let backup = "sl2~";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, symlink1);
+ at.symlink_file(FILE_NAME, symlink2);
+ scene.ucmd().args(&[option, symlink1, symlink2]).succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ assert_eq!(FILE_NAME, at.resolve_link(symlink1));
+ assert_eq!(FILE_NAME, at.resolve_link(symlink2));
+ assert_eq!(FILE_NAME, at.resolve_link(backup));
+ }
+ }
+ #[test]
+ fn test_same_file_from_symlink_to_symlink_with_option_link() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let symlink1 = "sl1";
+ let symlink2 = "sl2";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, symlink1);
+ at.symlink_file(FILE_NAME, symlink2);
+ scene
+ .ucmd()
+ .args(&["-l", symlink1, symlink2])
+ .fails()
+ .stderr_contains("cannot create hard link 'sl2' to 'sl1'");
+ assert!(at.file_exists(FILE_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ assert_eq!(FILE_NAME, at.resolve_link(symlink1));
+ assert_eq!(FILE_NAME, at.resolve_link(symlink2));
+ }
+
+ #[test]
+ fn test_same_file_from_symlink_to_symlink_with_option_force_link() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let symlink1 = "sl1";
+ let symlink2 = "sl2";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, symlink1);
+ at.symlink_file(FILE_NAME, symlink2);
+ scene.ucmd().args(&["-fl", symlink1, symlink2]).succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ assert_eq!(FILE_NAME, at.resolve_link(symlink1));
+ assert!(at.file_exists(symlink2));
+ assert_eq!(at.read(symlink2), CONTENTS,);
+ }
+
+ #[test]
+ fn test_same_file_from_symlink_to_symlink_with_option_backup_and_link() {
+ for option in ["-bl", "-bfl"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let symlink1 = "sl1";
+ let symlink2 = "sl2";
+ let backup = "sl2~";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, symlink1);
+ at.symlink_file(FILE_NAME, symlink2);
+ scene.ucmd().args(&[option, symlink1, symlink2]).succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ assert_eq!(FILE_NAME, at.resolve_link(symlink1));
+ assert!(at.file_exists(symlink2));
+ assert_eq!(at.read(symlink2), CONTENTS,);
+ assert_eq!(FILE_NAME, at.resolve_link(backup));
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_symlink_to_symlink_with_option_symlink() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let symlink1 = "sl1";
+ let symlink2 = "sl2";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, symlink1);
+ at.symlink_file(FILE_NAME, symlink2);
+ scene
+ .ucmd()
+ .args(&["-s", symlink1, symlink2])
+ .fails()
+ .stderr_contains("cannot create symlink 'sl2' to 'sl1'");
+ assert!(at.file_exists(FILE_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ assert_eq!(FILE_NAME, at.resolve_link(symlink1));
+ assert_eq!(FILE_NAME, at.resolve_link(symlink2));
+ }
+
+ #[test]
+ fn test_same_file_from_symlink_to_symlink_with_option_symlink_and_force() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let symlink1 = "sl1";
+ let symlink2 = "sl2";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, symlink1);
+ at.symlink_file(FILE_NAME, symlink2);
+ scene.ucmd().args(&["-sf", symlink1, symlink2]).succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ assert_eq!(FILE_NAME, at.resolve_link(symlink1));
+ assert_eq!(symlink1, at.resolve_link(symlink2));
+ }
+
+ // the following tests tries to copy file to a hardlink of the same file with
+ // various options
+ #[test]
+ fn test_same_file_from_file_to_hardlink() {
+ for option in ["-d", "-f", "-df"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let hardlink = "hardlink";
+ at.write(FILE_NAME, CONTENTS);
+ at.hard_link(FILE_NAME, hardlink);
+
+ scene
+ .ucmd()
+ .args(&[option, FILE_NAME, hardlink])
+ .fails()
+ .stderr_contains("'foo' and 'hardlink' are the same file");
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.file_exists(hardlink));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_file_to_hardlink_with_option_rem() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let hardlink = "hardlink";
+ at.write(FILE_NAME, CONTENTS);
+ at.hard_link(FILE_NAME, hardlink);
+ scene
+ .ucmd()
+ .args(&["--rem", FILE_NAME, hardlink])
+ .succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.file_exists(hardlink));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+
+ #[test]
+ fn test_same_file_from_file_to_hardlink_with_option_backup() {
+ for option in ["-b", "-bd", "-bf", "-bdf"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let hardlink = "hardlink";
+ let backup = "hardlink~";
+ at.write(FILE_NAME, CONTENTS);
+ at.hard_link(FILE_NAME, hardlink);
+ scene.ucmd().args(&[option, FILE_NAME, hardlink]).succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.file_exists(hardlink));
+ assert!(at.file_exists(backup));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_file_to_hardlink_with_option_link() {
+ for option in ["-l", "-dl", "-fl", "-dfl", "-bl", "-bdl", "-bfl", "-bdfl"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let hardlink = "hardlink";
+ at.write(FILE_NAME, CONTENTS);
+ at.hard_link(FILE_NAME, hardlink);
+ scene.ucmd().args(&[option, FILE_NAME, hardlink]).succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.file_exists(hardlink));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_file_to_hardlink_with_option_symlink() {
+ for option in ["-s", "-sf"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let hardlink = "hardlink";
+ at.write(FILE_NAME, CONTENTS);
+ at.hard_link(FILE_NAME, hardlink);
+ scene
+ .ucmd()
+ .args(&[option, FILE_NAME, hardlink])
+ .fails()
+ .stderr_contains("'foo' and 'hardlink' are the same file");
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.file_exists(hardlink));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+
+ // the following tests tries to copy symlink to a hardlink of the same symlink with
+ // various options
+ #[test]
+ fn test_same_file_from_hard_link_of_symlink_to_symlink() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let hardlink_to_symlink = "hlsl";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+ scene
+ .ucmd()
+ .args(&[hardlink_to_symlink, SYMLINK_NAME])
+ .fails()
+ .stderr_contains("cp: 'hlsl' and 'symlink' are the same file");
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.symlink_exists(SYMLINK_NAME));
+ assert!(at.symlink_exists(hardlink_to_symlink));
+ assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+ assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+
+ #[test]
+ fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_force() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let hardlink_to_symlink = "hlsl";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+ scene
+ .ucmd()
+ .args(&["-f", hardlink_to_symlink, SYMLINK_NAME])
+ .fails()
+ .stderr_contains("cp: 'hlsl' and 'symlink' are the same file");
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.symlink_exists(SYMLINK_NAME));
+ assert!(at.symlink_exists(hardlink_to_symlink));
+ assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+ assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+
+ #[test]
+ fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_no_deref() {
+ for option in ["-d", "-df"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let hardlink_to_symlink = "hlsl";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+ scene
+ .ucmd()
+ .args(&[option, hardlink_to_symlink, SYMLINK_NAME])
+ .succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.symlink_exists(SYMLINK_NAME));
+ assert!(at.symlink_exists(hardlink_to_symlink));
+ assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+ assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_rem() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let hardlink_to_symlink = "hlsl";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+ scene
+ .ucmd()
+ .args(&["--rem", hardlink_to_symlink, SYMLINK_NAME])
+ .succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.file_exists(SYMLINK_NAME));
+ assert!(!at.symlink_exists(SYMLINK_NAME));
+ assert!(at.symlink_exists(hardlink_to_symlink));
+ assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ assert_eq!(at.read(SYMLINK_NAME), CONTENTS,);
+ }
+
+ #[test]
+ fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_backup() {
+ for option in ["-b", "-bf"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let backup = "symlink~";
+ let hardlink_to_symlink = "hlsl";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+ scene
+ .ucmd()
+ .args(&[option, hardlink_to_symlink, SYMLINK_NAME])
+ .succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.file_exists(SYMLINK_NAME));
+ assert!(!at.symlink_exists(SYMLINK_NAME));
+ assert!(at.symlink_exists(hardlink_to_symlink));
+ assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+ assert!(at.symlink_exists(backup));
+ assert_eq!(FILE_NAME, at.resolve_link(backup));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ assert_eq!(at.read(SYMLINK_NAME), CONTENTS,);
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_backup_and_no_deref() {
+ for option in ["-bd", "-bdf"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let backup = "symlink~";
+ let hardlink_to_symlink = "hlsl";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+ scene
+ .ucmd()
+ .args(&[option, hardlink_to_symlink, SYMLINK_NAME])
+ .succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.symlink_exists(SYMLINK_NAME));
+ assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+ assert!(at.symlink_exists(hardlink_to_symlink));
+ assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+ assert!(at.symlink_exists(backup));
+ assert_eq!(FILE_NAME, at.resolve_link(backup));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_link() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let hardlink_to_symlink = "hlsl";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+ scene
+ .ucmd()
+ .args(&["-l", hardlink_to_symlink, SYMLINK_NAME])
+ .fails()
+ .stderr_contains("cannot create hard link 'symlink' to 'hlsl'");
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.symlink_exists(SYMLINK_NAME));
+ assert!(at.symlink_exists(hardlink_to_symlink));
+ assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+ assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+
+ #[test]
+ fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_link_and_no_deref() {
+ for option in ["-dl", "-dfl"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let hardlink_to_symlink = "hlsl";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+ scene
+ .ucmd()
+ .args(&[option, hardlink_to_symlink, SYMLINK_NAME])
+ .succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.symlink_exists(SYMLINK_NAME));
+ assert!(at.symlink_exists(hardlink_to_symlink));
+ assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+ assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_link_and_force() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let hardlink_to_symlink = "hlsl";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+ scene
+ .ucmd()
+ .args(&["-fl", hardlink_to_symlink, SYMLINK_NAME])
+ .succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.file_exists(SYMLINK_NAME));
+ assert!(!at.symlink_exists(SYMLINK_NAME));
+ assert!(at.symlink_exists(hardlink_to_symlink));
+ assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+
+ #[test]
+ fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_link_and_backup() {
+ for option in ["-bl", "-bfl"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let backup = "symlink~";
+ let hardlink_to_symlink = "hlsl";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+ scene
+ .ucmd()
+ .args(&[option, hardlink_to_symlink, SYMLINK_NAME])
+ .succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.file_exists(SYMLINK_NAME));
+ assert!(!at.symlink_exists(SYMLINK_NAME));
+ assert!(at.symlink_exists(hardlink_to_symlink));
+ assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+ assert!(at.symlink_exists(backup));
+ assert_eq!(FILE_NAME, at.resolve_link(backup));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_hard_link_of_symlink_to_symlink_with_options_backup_link_no_deref() {
+ for option in ["-bdl", "-bdfl"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let hardlink_to_symlink = "hlsl";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+ scene
+ .ucmd()
+ .args(&[option, hardlink_to_symlink, SYMLINK_NAME])
+ .succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.symlink_exists(SYMLINK_NAME));
+ assert!(at.symlink_exists(hardlink_to_symlink));
+ assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+ assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+ }
+
+ #[test]
+ fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_symlink() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let hardlink_to_symlink = "hlsl";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+ scene
+ .ucmd()
+ .args(&["-s", hardlink_to_symlink, SYMLINK_NAME])
+ .fails()
+ .stderr_contains("cannot create symlink 'symlink' to 'hlsl'");
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.symlink_exists(SYMLINK_NAME));
+ assert!(at.symlink_exists(hardlink_to_symlink));
+ assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+ assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+
+ #[test]
+ fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_symlink_and_force() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let hardlink_to_symlink = "hlsl";
+ at.write(FILE_NAME, CONTENTS);
+ at.symlink_file(FILE_NAME, SYMLINK_NAME);
+ at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+ scene
+ .ucmd()
+ .args(&["-sf", hardlink_to_symlink, SYMLINK_NAME])
+ .succeeds();
+ assert!(at.file_exists(FILE_NAME));
+ assert!(at.symlink_exists(SYMLINK_NAME));
+ assert!(at.symlink_exists(hardlink_to_symlink));
+ assert_eq!(hardlink_to_symlink, at.resolve_link(SYMLINK_NAME));
+ assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+ assert_eq!(at.read(FILE_NAME), CONTENTS,);
+ }
+}
+
+// the following tests are for how the cp should behave when the source is a symlink
+// and link option is given
+#[cfg(all(unix, not(target_os = "android")))]
+mod link_deref {
+
+ use crate::common::util::{AtPath, TestScenario};
+ use std::os::unix::fs::MetadataExt;
+
+ const FILE: &str = "file";
+ const FILE_LINK: &str = "file_link";
+ const DIR: &str = "dir";
+ const DIR_LINK: &str = "dir_link";
+ const DANG_LINK: &str = "dang_link";
+ const DST: &str = "dst";
+
+ fn setup_link_deref_tests(source: &str, at: &AtPath) {
+ match source {
+ FILE_LINK => {
+ at.touch(FILE);
+ at.symlink_file(FILE, FILE_LINK);
+ }
+ DIR_LINK => {
+ at.mkdir(DIR);
+ at.symlink_dir(DIR, DIR_LINK);
+ }
+ DANG_LINK => at.symlink_file("nowhere", DANG_LINK),
+ _ => {}
+ }
+ }
+
+ // cp --link shouldn't deref source if -P is given
+ #[test]
+ fn test_cp_symlink_as_source_with_link_and_no_deref() {
+ for src in [FILE_LINK, DIR_LINK, DANG_LINK] {
+ for r in [false, true] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ setup_link_deref_tests(src, at);
+ let mut args = vec!["--link", "-P", src, DST];
+ if r {
+ args.push("-R");
+ };
+ scene.ucmd().args(&args).succeeds().no_stderr();
+ at.is_symlink(DST);
+ let src_ino = at.symlink_metadata(src).ino();
+ let dest_ino = at.symlink_metadata(DST).ino();
+ assert_eq!(src_ino, dest_ino);
+ }
+ }
+ }
+
+ // Dereferencing should fail for dangling symlink.
+ #[test]
+ fn test_cp_dang_link_as_source_with_link() {
+ for option in ["", "-L", "-H"] {
+ for r in [false, true] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ setup_link_deref_tests(DANG_LINK, at);
+ let mut args = vec!["--link", DANG_LINK, DST];
+ if r {
+ args.push("-R");
+ };
+ if !option.is_empty() {
+ args.push(option);
+ }
+ scene
+ .ucmd()
+ .args(&args)
+ .fails()
+ .stderr_contains("No such file or directory");
+ }
+ }
+ }
+
+ // Dereferencing should fail for the 'dir_link' without -R.
+ #[test]
+ fn test_cp_dir_link_as_source_with_link() {
+ for option in ["", "-L", "-H"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ setup_link_deref_tests(DIR_LINK, at);
+ let mut args = vec!["--link", DIR_LINK, DST];
+ if !option.is_empty() {
+ args.push(option);
+ }
+ scene
+ .ucmd()
+ .args(&args)
+ .fails()
+ .stderr_contains("cp: -r not specified; omitting directory");
+ }
+ }
+
+ // cp --link -R 'dir_link' should create a new directory.
+ #[test]
+ fn test_cp_dir_link_as_source_with_link_and_r() {
+ for option in ["", "-L", "-H"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ setup_link_deref_tests(DIR_LINK, at);
+ let mut args = vec!["--link", "-R", DIR_LINK, DST];
+ if !option.is_empty() {
+ args.push(option);
+ }
+ scene.ucmd().args(&args).succeeds();
+ at.dir_exists(DST);
+ }
+ }
+
+ //cp --link 'file_link' should create a hard link to the target.
+ #[test]
+ fn test_cp_file_link_as_source_with_link() {
+ for option in ["", "-L", "-H"] {
+ for r in [false, true] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ setup_link_deref_tests(FILE_LINK, at);
+ let mut args = vec!["--link", "-R", FILE_LINK, DST];
+ if !option.is_empty() {
+ args.push(option);
+ }
+ if r {
+ args.push("-R");
+ }
+ scene.ucmd().args(&args).succeeds();
+ at.file_exists(DST);
+ let src_ino = at.symlink_metadata(FILE).ino();
+ let dest_ino = at.symlink_metadata(DST).ino();
+ assert_eq!(src_ino, dest_ino);
+ }
+ }
+ }
+}
+
+// The cp command might create directories with excessively permissive permissions temporarily,
+// which could be problematic if we aim to preserve ownership or mode. For example, when
+// copying a directory, the destination directory could temporarily be setgid on some filesystems.
+// This temporary setgid status could grant access to other users who share the same group
+// ownership as the newly created directory.To mitigate this issue, when creating a directory we
+// disable these excessive permissions.
+#[test]
+#[cfg(unix)]
+fn test_dir_perm_race_with_preserve_mode_and_ownership() {
+ const SRC_DIR: &str = "src";
+ const DEST_DIR: &str = "dest";
+ const FIFO: &str = "src/fifo";
+ for attr in ["mode", "ownership"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.mkdir(SRC_DIR);
+ at.mkdir(DEST_DIR);
+ at.set_mode(SRC_DIR, 0o775);
+ at.set_mode(DEST_DIR, 0o2775);
+ at.mkfifo(FIFO);
+ let child = scene
+ .ucmd()
+ .args(&[
+ format!("--preserve={}", attr).as_str(),
+ "-R",
+ "--copy-contents",
+ "--parents",
+ SRC_DIR,
+ DEST_DIR,
+ ])
+ // make sure permissions weren't disabled because of umask.
+ .umask(0)
+ .run_no_wait();
+ // while cp wait for fifo we could check the dirs created by cp
+ let timeout = Duration::from_secs(10);
+ let start_time = std::time::Instant::now();
+ // wait for cp to create dirs
+ loop {
+ if start_time.elapsed() >= timeout {
+ panic!("timed out: cp took too long to create destination directory")
+ }
+ if at.dir_exists(&format!("{}/{}", DEST_DIR, SRC_DIR)) {
+ break;
+ }
+ std::thread::sleep(Duration::from_millis(100));
+ }
+ let mode = at.metadata(&format!("{}/{}", DEST_DIR, SRC_DIR)).mode();
+ #[allow(clippy::unnecessary_cast)]
+ let mask = if attr == "mode" {
+ libc::S_IWGRP | libc::S_IWOTH
+ } else {
+ libc::S_IRWXG | libc::S_IRWXO
+ } as u32;
+ assert_eq!(
+ (mode & mask),
+ 0,
+ "unwanted permissions are present - {}",
+ attr
+ );
+ at.write(FIFO, "done");
+ child.wait().unwrap().succeeded();
+ }
+}
+
+#[test]
+// when -d and -a are overridden with --preserve or --no-preserve make sure that it only
+// overrides attributes not other flags like -r or --no_deref implied in -a and -d.
+fn test_preserve_attrs_overriding_1() {
+ const FILE: &str = "file";
+ const SYMLINK: &str = "symlink";
+ const DEST: &str = "dest";
+ for f in ["-d", "-a"] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.make_file(FILE);
+ at.symlink_file(FILE, SYMLINK);
+ scene
+ .ucmd()
+ .args(&[f, "--no-preserve=all", SYMLINK, DEST])
+ .succeeds();
+ at.symlink_exists(DEST);
+ }
+}
+
+#[test]
+#[cfg(all(unix, not(target_os = "android")))]
+fn test_preserve_attrs_overriding_2() {
+ const FILE1: &str = "file1";
+ const FILE2: &str = "file2";
+ const FOLDER: &str = "folder";
+ const DEST: &str = "dest";
+ for mut args in [
+ // All of the following to args should tell cp to preserve mode and
+ // timestamp, but not the link.
+ vec!["-r", "--preserve=mode,link,timestamp", "--no-preserve=link"],
+ vec![
+ "-r",
+ "--preserve=mode",
+ "--preserve=link",
+ "--preserve=timestamp",
+ "--no-preserve=link",
+ ],
+ vec![
+ "-r",
+ "--preserve=mode,link",
+ "--no-preserve=link",
+ "--preserve=timestamp",
+ ],
+ vec!["-a", "--no-preserve=link"],
+ vec!["-r", "--preserve", "--no-preserve=link"],
+ ] {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.mkdir(FOLDER);
+ at.make_file(&format!("{}/{}", FOLDER, FILE1));
+ at.set_mode(&format!("{}/{}", FOLDER, FILE1), 0o775);
+ at.hard_link(
+ &format!("{}/{}", FOLDER, FILE1),
+ &format!("{}/{}", FOLDER, FILE2),
+ );
+ args.append(&mut vec![FOLDER, DEST]);
+ let src_file1_metadata = at.metadata(&format!("{}/{}", FOLDER, FILE1));
+ scene.ucmd().args(&args).succeeds();
+ at.dir_exists(DEST);
+ let dest_file1_metadata = at.metadata(&format!("{}/{}", DEST, FILE1));
+ let dest_file2_metadata = at.metadata(&format!("{}/{}", DEST, FILE2));
+ assert_eq!(
+ src_file1_metadata.modified().unwrap(),
+ dest_file1_metadata.modified().unwrap()
+ );
+ assert_eq!(src_file1_metadata.mode(), dest_file1_metadata.mode());
+ assert_ne!(dest_file1_metadata.ino(), dest_file2_metadata.ino());
+ }
+}
+
+/// Test the behavior of preserving permissions when copying through a symlink
+#[test]
+#[cfg(unix)]
+fn test_cp_symlink_permissions() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.touch("a");
+ at.set_mode("a", 0o700);
+ at.symlink_file("a", "symlink");
+ at.mkdir("dest");
+ scene
+ .ucmd()
+ .args(&["--preserve", "symlink", "dest"])
+ .succeeds();
+ let dest_dir_metadata = at.metadata("dest/symlink");
+ let src_dir_metadata = at.metadata("a");
+ assert_eq!(
+ src_dir_metadata.permissions().mode(),
+ dest_dir_metadata.permissions().mode()
+ );
+}
+
+/// Test the behavior of preserving permissions of parents when copying through a symlink
+#[test]
+#[cfg(unix)]
+fn test_cp_parents_symlink_permissions_file() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.mkdir("a");
+ at.touch("a/file");
+ at.set_mode("a", 0o700);
+ at.symlink_dir("a", "symlink");
+ at.mkdir("dest");
+ scene
+ .ucmd()
+ .args(&["--parents", "-a", "symlink/file", "dest"])
+ .succeeds();
+ let dest_dir_metadata = at.metadata("dest/symlink");
+ let src_dir_metadata = at.metadata("a");
+ assert_eq!(
+ src_dir_metadata.permissions().mode(),
+ dest_dir_metadata.permissions().mode()
+ );
+}
+
+/// Test the behavior of preserving permissions of parents when copying through
+/// a symlink when source is a dir.
+#[test]
+#[cfg(unix)]
+fn test_cp_parents_symlink_permissions_dir() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.mkdir_all("a/b");
+ at.set_mode("a", 0o755); // Set mode for the actual directory
+ at.symlink_dir("a", "symlink");
+ at.mkdir("dest");
+ scene
+ .ucmd()
+ .args(&["--parents", "-a", "symlink/b", "dest"])
+ .succeeds();
+ let dest_dir_metadata = at.metadata("dest/symlink");
+ let src_dir_metadata = at.metadata("a");
+ assert_eq!(
+ src_dir_metadata.permissions().mode(),
+ dest_dir_metadata.permissions().mode()
+ );
+}
+
+/// Test the behavior of copying a file to a destination with parents using absolute paths.
+#[cfg(unix)]
+#[test]
+fn test_cp_parents_absolute_path() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.mkdir_all("a/b");
+ at.touch("a/b/f");
+ at.mkdir("dest");
+ let src = format!("{}/a/b/f", at.root_dir_resolved());
+ scene
+ .ucmd()
+ .args(&["--parents", src.as_str(), "dest"])
+ .succeeds();
+ let res = format!("dest{}/a/b/f", at.root_dir_resolved());
+ at.file_exists(res);
+}
diff --git a/tests/by-util/test_csplit.rs b/tests/by-util/test_csplit.rs
index d44b4aca57ec423d05d6284a83c108b4540ef3fc..03b8c92fc0951069ec351c7d46dc9f894dbfce0c 100644
--- a/tests/by-util/test_csplit.rs
+++ b/tests/by-util/test_csplit.rs
@@ -1,10 +1,14 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
use glob::glob;
/// Returns a string of numbers with the given range, each on a new line.
/// The upper bound is not included.
fn generate(from: u32, to: u32) -> String {
- (from..to).fold(String::new(), |acc, v| format!("{}{}\n", acc, v))
+ (from..to).fold(String::new(), |acc, v| format!("{acc}{v}\n"))
}
#[test]
@@ -213,7 +217,7 @@ fn test_up_to_match_repeat_over() {
ucmd.args(&["numbers50.txt", "/9$/", "{50}"])
.fails()
.stdout_is("16\n29\n30\n30\n30\n6\n")
- .stderr_is("csplit: '/9$/': match not found on repetition 5");
+ .stderr_is("csplit: '/9$/': match not found on repetition 5\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("there should be splits created")
@@ -224,7 +228,7 @@ fn test_up_to_match_repeat_over() {
ucmd.args(&["numbers50.txt", "/9$/", "{50}", "-k"])
.fails()
.stdout_is("16\n29\n30\n30\n30\n6\n")
- .stderr_is("csplit: '/9$/': match not found on repetition 5");
+ .stderr_is("csplit: '/9$/': match not found on repetition 5\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("there should be splits created")
@@ -370,7 +374,7 @@ fn test_option_keep() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["-k", "numbers50.txt", "/20/", "/nope/"])
.fails()
- .stderr_is("csplit: '/nope/': match not found")
+ .stderr_is("csplit: '/nope/': match not found\n")
.stdout_is("48\n93\n");
let count = glob(&at.plus_as_string("xx*"))
@@ -546,7 +550,7 @@ fn test_up_to_match_context_overflow() {
ucmd.args(&["numbers50.txt", "/45/+10"])
.fails()
.stdout_is("141\n")
- .stderr_is("csplit: '/45/+10': line number out of range");
+ .stderr_is("csplit: '/45/+10': line number out of range\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -557,7 +561,7 @@ fn test_up_to_match_context_overflow() {
ucmd.args(&["numbers50.txt", "/45/+10", "-k"])
.fails()
.stdout_is("141\n")
- .stderr_is("csplit: '/45/+10': line number out of range");
+ .stderr_is("csplit: '/45/+10': line number out of range\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -571,8 +575,8 @@ fn test_skip_to_match_context_underflow() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "%5%-10"])
.fails()
- .stdout_is("141\n")
- .stderr_is("csplit: '%5%-10': line number out of range");
+ .stdout_is("")
+ .stderr_is("csplit: '%5%-10': line number out of range\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -582,14 +586,13 @@ fn test_skip_to_match_context_underflow() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "%5%-10", "-k"])
.fails()
- .stdout_is("141\n")
- .stderr_is("csplit: '%5%-10': line number out of range");
+ .stdout_is("")
+ .stderr_is("csplit: '%5%-10': line number out of range\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
.count();
- assert_eq!(count, 1);
- assert_eq!(at.read("xx00"), generate(1, 51));
+ assert_eq!(count, 0);
}
#[test]
@@ -597,7 +600,7 @@ fn test_skip_to_match_context_overflow() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "%45%+10"])
.fails()
- .stderr_only("csplit: '%45%+10': line number out of range");
+ .stderr_is("csplit: '%45%+10': line number out of range\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -607,7 +610,7 @@ fn test_skip_to_match_context_overflow() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "%45%+10", "-k"])
.fails()
- .stderr_only("csplit: '%45%+10': line number out of range");
+ .stderr_only("csplit: '%45%+10': line number out of range\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -621,7 +624,7 @@ fn test_up_to_no_match1() {
ucmd.args(&["numbers50.txt", "/4/", "/nope/"])
.fails()
.stdout_is("6\n135\n")
- .stderr_is("csplit: '/nope/': match not found");
+ .stderr_is("csplit: '/nope/': match not found\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -632,7 +635,7 @@ fn test_up_to_no_match1() {
ucmd.args(&["numbers50.txt", "/4/", "/nope/", "-k"])
.fails()
.stdout_is("6\n135\n")
- .stderr_is("csplit: '/nope/': match not found");
+ .stderr_is("csplit: '/nope/': match not found\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -648,7 +651,7 @@ fn test_up_to_no_match2() {
ucmd.args(&["numbers50.txt", "/4/", "/nope/", "{50}"])
.fails()
.stdout_is("6\n135\n")
- .stderr_is("csplit: '/nope/': match not found");
+ .stderr_is("csplit: '/nope/': match not found\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -659,7 +662,7 @@ fn test_up_to_no_match2() {
ucmd.args(&["numbers50.txt", "/4/", "/nope/", "{50}", "-k"])
.fails()
.stdout_is("6\n135\n")
- .stderr_is("csplit: '/nope/': match not found");
+ .stderr_is("csplit: '/nope/': match not found\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -675,7 +678,7 @@ fn test_up_to_no_match3() {
ucmd.args(&["numbers50.txt", "/0$/", "{50}"])
.fails()
.stdout_is("18\n30\n30\n30\n30\n3\n")
- .stderr_is("csplit: '/0$/': match not found on repetition 5");
+ .stderr_is("csplit: '/0$/': match not found on repetition 5\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -686,7 +689,7 @@ fn test_up_to_no_match3() {
ucmd.args(&["numbers50.txt", "/0$/", "{50}", "-k"])
.fails()
.stdout_is("18\n30\n30\n30\n30\n3\n")
- .stderr_is("csplit: '/0$/': match not found on repetition 5");
+ .stderr_is("csplit: '/0$/': match not found on repetition 5\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -706,7 +709,7 @@ fn test_up_to_no_match4() {
ucmd.args(&["numbers50.txt", "/nope/", "/4/"])
.fails()
.stdout_is("141\n")
- .stderr_is("csplit: '/nope/': match not found");
+ .stderr_is("csplit: '/nope/': match not found\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -717,7 +720,7 @@ fn test_up_to_no_match4() {
ucmd.args(&["numbers50.txt", "/nope/", "/4/", "-k"])
.fails()
.stdout_is("141\n")
- .stderr_is("csplit: '/nope/': match not found");
+ .stderr_is("csplit: '/nope/': match not found\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -746,7 +749,7 @@ fn test_up_to_no_match6() {
ucmd.args(&["numbers50.txt", "/nope/-5"])
.fails()
.stdout_is("141\n")
- .stderr_is("csplit: '/nope/-5': match not found");
+ .stderr_is("csplit: '/nope/-5': match not found\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -757,7 +760,7 @@ fn test_up_to_no_match6() {
ucmd.args(&["numbers50.txt", "/nope/-5", "-k"])
.fails()
.stdout_is("141\n")
- .stderr_is("csplit: '/nope/-5': match not found");
+ .stderr_is("csplit: '/nope/-5': match not found\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -772,7 +775,7 @@ fn test_up_to_no_match7() {
ucmd.args(&["numbers50.txt", "/nope/+5"])
.fails()
.stdout_is("141\n")
- .stderr_is("csplit: '/nope/+5': match not found");
+ .stderr_is("csplit: '/nope/+5': match not found\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -783,7 +786,7 @@ fn test_up_to_no_match7() {
ucmd.args(&["numbers50.txt", "/nope/+5", "-k"])
.fails()
.stdout_is("141\n")
- .stderr_is("csplit: '/nope/+5': match not found");
+ .stderr_is("csplit: '/nope/+5': match not found\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -797,7 +800,7 @@ fn test_skip_to_no_match1() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "%nope%"])
.fails()
- .stderr_only("csplit: '%nope%': match not found");
+ .stderr_only("csplit: '%nope%': match not found\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -810,7 +813,7 @@ fn test_skip_to_no_match2() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "%nope%", "{50}"])
.fails()
- .stderr_only("csplit: '%nope%': match not found");
+ .stderr_only("csplit: '%nope%': match not found\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -823,7 +826,7 @@ fn test_skip_to_no_match3() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "%0$%", "{50}"])
.fails()
- .stderr_only("csplit: '%0$%': match not found on repetition 5");
+ .stderr_only("csplit: '%0$%': match not found on repetition 5\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -836,7 +839,7 @@ fn test_skip_to_no_match4() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "%nope%", "/4/"])
.fails()
- .stderr_only("csplit: '%nope%': match not found");
+ .stderr_only("csplit: '%nope%': match not found\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -863,7 +866,7 @@ fn test_skip_to_no_match6() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "%nope%-5"])
.fails()
- .stderr_only("csplit: '%nope%-5': match not found");
+ .stderr_only("csplit: '%nope%-5': match not found\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -876,7 +879,7 @@ fn test_skip_to_no_match7() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "%nope%+5"])
.fails()
- .stderr_only("csplit: '%nope%+5': match not found");
+ .stderr_only("csplit: '%nope%+5': match not found\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -889,7 +892,7 @@ fn test_no_match() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "%nope%"])
.fails()
- .stderr_only("csplit: '%nope%': match not found");
+ .stderr_only("csplit: '%nope%': match not found\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -900,7 +903,7 @@ fn test_no_match() {
ucmd.args(&["numbers50.txt", "/nope/"])
.fails()
.stdout_is("141\n")
- .stderr_is("csplit: '/nope/': match not found");
+ .stderr_is("csplit: '/nope/': match not found\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -997,7 +1000,7 @@ fn test_too_small_line_num_repeat() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "/20/", "10", "{*}"])
.fails()
- .stderr_is("csplit: '10': line number out of range on repetition 5")
+ .stderr_is("csplit: '10': line number out of range on repetition 5\n")
.stdout_is("48\n0\n0\n30\n30\n30\n3\n");
let count = glob(&at.plus_as_string("xx*"))
@@ -1008,7 +1011,7 @@ fn test_too_small_line_num_repeat() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "/20/", "10", "{*}", "-k"])
.fails()
- .stderr_is("csplit: '10': line number out of range on repetition 5")
+ .stderr_is("csplit: '10': line number out of range on repetition 5\n")
.stdout_is("48\n0\n0\n30\n30\n30\n3\n");
let count = glob(&at.plus_as_string("xx*"))
@@ -1030,7 +1033,7 @@ fn test_line_num_out_of_range1() {
ucmd.args(&["numbers50.txt", "100"])
.fails()
.stdout_is("141\n")
- .stderr_is("csplit: '100': line number out of range");
+ .stderr_is("csplit: '100': line number out of range\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("there should be splits created")
@@ -1041,7 +1044,7 @@ fn test_line_num_out_of_range1() {
ucmd.args(&["numbers50.txt", "100", "-k"])
.fails()
.stdout_is("141\n")
- .stderr_is("csplit: '100': line number out of range");
+ .stderr_is("csplit: '100': line number out of range\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("there should be splits created")
@@ -1056,7 +1059,7 @@ fn test_line_num_out_of_range2() {
ucmd.args(&["numbers50.txt", "10", "100"])
.fails()
.stdout_is("18\n123\n")
- .stderr_is("csplit: '100': line number out of range");
+ .stderr_is("csplit: '100': line number out of range\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("there should be splits created")
@@ -1067,7 +1070,7 @@ fn test_line_num_out_of_range2() {
ucmd.args(&["numbers50.txt", "10", "100", "-k"])
.fails()
.stdout_is("18\n123\n")
- .stderr_is("csplit: '100': line number out of range");
+ .stderr_is("csplit: '100': line number out of range\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("there should be splits created")
@@ -1083,7 +1086,7 @@ fn test_line_num_out_of_range3() {
ucmd.args(&["numbers50.txt", "40", "{2}"])
.fails()
.stdout_is("108\n33\n")
- .stderr_is("csplit: '40': line number out of range on repetition 1");
+ .stderr_is("csplit: '40': line number out of range on repetition 1\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("there should be splits created")
@@ -1094,7 +1097,7 @@ fn test_line_num_out_of_range3() {
ucmd.args(&["numbers50.txt", "40", "{2}", "-k"])
.fails()
.stdout_is("108\n33\n")
- .stderr_is("csplit: '40': line number out of range on repetition 1");
+ .stderr_is("csplit: '40': line number out of range on repetition 1\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("there should be splits created")
@@ -1110,7 +1113,7 @@ fn test_line_num_out_of_range4() {
ucmd.args(&["numbers50.txt", "40", "{*}"])
.fails()
.stdout_is("108\n33\n")
- .stderr_is("csplit: '40': line number out of range on repetition 1");
+ .stderr_is("csplit: '40': line number out of range on repetition 1\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("there should be splits created")
@@ -1121,7 +1124,7 @@ fn test_line_num_out_of_range4() {
ucmd.args(&["numbers50.txt", "40", "{*}", "-k"])
.fails()
.stdout_is("108\n33\n")
- .stderr_is("csplit: '40': line number out of range on repetition 1");
+ .stderr_is("csplit: '40': line number out of range on repetition 1\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("there should be splits created")
@@ -1137,7 +1140,7 @@ fn test_skip_to_match_negative_offset_before_a_match() {
ucmd.args(&["numbers50.txt", "/20/-10", "/15/"])
.fails()
.stdout_is("18\n123\n")
- .stderr_is("csplit: '/15/': match not found");
+ .stderr_is("csplit: '/15/': match not found\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("there should be splits created")
@@ -1182,7 +1185,7 @@ fn test_corner_case2() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "/10/-5", "/10/"])
.fails()
- .stderr_is("csplit: '/10/': match not found")
+ .stderr_is("csplit: '/10/': match not found\n")
.stdout_is("8\n133\n");
let count = glob(&at.plus_as_string("xx*"))
@@ -1196,7 +1199,7 @@ fn test_corner_case3() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "/15/-3", "14", "/15/"])
.fails()
- .stderr_is("csplit: '/15/': match not found")
+ .stderr_is("csplit: '/15/': match not found\n")
.stdout_is("24\n6\n111\n");
let count = glob(&at.plus_as_string("xx*"))
@@ -1221,14 +1224,13 @@ fn test_corner_case4() {
assert_eq!(at.read("xx02"), generate(26, 51));
}
-// NOTE: differs from gnu's output: the empty split is not written
#[test]
fn test_up_to_match_context_underflow() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "/5/-10"])
.fails()
- .stdout_is("0\n141\n")
- .stderr_is("csplit: '/5/-10': line number out of range");
+ .stdout_is("0\n")
+ .stderr_is("csplit: '/5/-10': line number out of range\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
@@ -1238,26 +1240,24 @@ fn test_up_to_match_context_underflow() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "/5/-10", "-k"])
.fails()
- .stdout_is("0\n141\n")
- .stderr_is("csplit: '/5/-10': line number out of range");
+ .stdout_is("0\n")
+ .stderr_is("csplit: '/5/-10': line number out of range\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("counting splits")
.count();
- assert_eq!(count, 2);
+ assert_eq!(count, 1);
assert_eq!(at.read("xx00"), "");
- assert_eq!(at.read("xx01"), generate(1, 51));
}
// the offset is out of range because of the first pattern
-// NOTE: output different than gnu's: the empty split is written but the rest of the input file is not
#[test]
fn test_line_num_range_with_up_to_match1() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "10", "/12/-5"])
.fails()
- .stderr_is("csplit: '/12/-5': line number out of range")
- .stdout_is("18\n0\n123\n");
+ .stderr_is("csplit: '/12/-5': line number out of range\n")
+ .stdout_is("18\n0\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("there should be splits created")
@@ -1267,27 +1267,25 @@ fn test_line_num_range_with_up_to_match1() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "10", "/12/-5", "-k"])
.fails()
- .stderr_is("csplit: '/12/-5': line number out of range")
- .stdout_is("18\n0\n123\n");
+ .stderr_is("csplit: '/12/-5': line number out of range\n")
+ .stdout_is("18\n0\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("there should be splits created")
.count();
- assert_eq!(count, 3);
+ assert_eq!(count, 2);
assert_eq!(at.read("xx00"), generate(1, 10));
assert_eq!(at.read("xx01"), "");
- assert_eq!(at.read("xx02"), generate(10, 51));
}
// the offset is out of range because more lines are needed than physically available
-// NOTE: output different than gnu's: the empty split is not written but the rest of the input file is
#[test]
fn test_line_num_range_with_up_to_match2() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "10", "/12/-15"])
.fails()
- .stderr_is("csplit: '/12/-15': line number out of range")
- .stdout_is("18\n0\n123\n");
+ .stderr_is("csplit: '/12/-15': line number out of range\n")
+ .stdout_is("18\n0\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("there should be splits created")
@@ -1297,16 +1295,15 @@ fn test_line_num_range_with_up_to_match2() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "10", "/12/-15", "-k"])
.fails()
- .stderr_is("csplit: '/12/-15': line number out of range")
- .stdout_is("18\n0\n123\n");
+ .stderr_is("csplit: '/12/-15': line number out of range\n")
+ .stdout_is("18\n0\n");
let count = glob(&at.plus_as_string("xx*"))
.expect("there should be splits created")
.count();
- assert_eq!(count, 3);
+ assert_eq!(count, 2);
assert_eq!(at.read("xx00"), generate(1, 10));
assert_eq!(at.read("xx01"), "");
- assert_eq!(at.read("xx02"), generate(10, 51));
}
// NOTE: output different than gnu's: the pattern /10/ is matched but should not
@@ -1315,7 +1312,7 @@ fn test_line_num_range_with_up_to_match3() {
let (at, mut ucmd) = at_and_ucmd!();
ucmd.args(&["numbers50.txt", "10", "/10/", "-k"])
.fails()
- .stderr_is("csplit: '/10/': match not found")
+ .stderr_is("csplit: '/10/': match not found\n")
.stdout_is("18\n123\n");
let count = glob(&at.plus_as_string("xx*"))
@@ -1338,3 +1335,73 @@ fn test_line_num_range_with_up_to_match3() {
assert_eq!(at.read("xx01"), "");
assert_eq!(at.read("xx02"), generate(10, 51));
}
+
+#[test]
+fn precision_format() {
+ for f in ["%#6.3x", "%0#6.3x"] {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["numbers50.txt", "10", "--suffix-format", f])
+ .succeeds()
+ .stdout_only("18\n123\n");
+
+ let count = glob(&at.plus_as_string("xx*"))
+ .expect("there should be splits created")
+ .count();
+ assert_eq!(count, 2);
+ assert_eq!(at.read("xx 000"), generate(1, 10));
+ assert_eq!(at.read("xx 0x001"), generate(10, 51));
+ }
+}
+
+#[test]
+fn zero_error() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.touch("in");
+ ucmd.args(&["in", "0"])
+ .fails()
+ .stderr_contains("0: line number must be greater");
+}
+
+#[test]
+fn no_such_file() {
+ let (_, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["in", "0"])
+ .fails()
+ .stderr_contains("cannot access 'in': No such file or directory");
+}
+
+#[test]
+fn repeat_everything() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&[
+ "numbers50.txt",
+ "--suppress-matched",
+ "--suppress-matched",
+ "-kzsn", // spell-checker:disable-line
+ "2",
+ "-szkn3", // spell-checker:disable-line
+ "-b",
+ "%03d",
+ "-b%03x",
+ "-f",
+ "xxy_",
+ "-fxxz_", // spell-checker:disable-line
+ "/13/",
+ "9",
+ "{5}",
+ ])
+ .fails()
+ .no_stdout()
+ .code_is(1)
+ .stderr_only("csplit: '9': line number out of range on repetition 5\n");
+ let count = glob(&at.plus_as_string("xx*"))
+ .expect("there should be some splits created")
+ .count();
+ assert_eq!(count, 6);
+ assert_eq!(at.read("xxz_000"), generate(1, 12 + 1));
+ assert_eq!(at.read("xxz_001"), generate(14, 17 + 1)); // FIXME: GNU starts at 15
+ assert_eq!(at.read("xxz_002"), generate(19, 26 + 1));
+ assert_eq!(at.read("xxz_003"), generate(28, 35 + 1));
+ assert_eq!(at.read("xxz_004"), generate(37, 44 + 1));
+ assert_eq!(at.read("xxz_005"), generate(46, 50 + 1));
+}
diff --git a/tests/by-util/test_cut.rs b/tests/by-util/test_cut.rs
index bad60975855a35df3c4bd1037e97b6921ef123a9..86d3ddf0f3d53ea0059d758a5025a013c52b62ef 100644
--- a/tests/by-util/test_cut.rs
+++ b/tests/by-util/test_cut.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
static INPUT: &str = "lists.txt";
@@ -114,7 +118,26 @@ fn test_whitespace_with_char() {
}
#[test]
-fn test_specify_delimiter() {
+fn test_delimiter_with_byte_and_char() {
+ for conflicting_arg in ["-c", "-b"] {
+ new_ucmd!()
+ .args(&[conflicting_arg, COMPLEX_SEQUENCE.sequence, "-d="])
+ .fails()
+ .stderr_is("cut: invalid input: The '--delimiter' ('-d') option only usable if printing a sequence of fields\n")
+ .code_is(1);
+ }
+}
+
+#[test]
+fn test_too_large() {
+ new_ucmd!()
+ .args(&["-b1-18446744073709551615", "/dev/null"])
+ .fails()
+ .code_is(1);
+}
+
+#[test]
+fn test_delimiter() {
for param in ["-d", "--delimiter", "--del"] {
new_ucmd!()
.args(&[param, ":", "-f", COMPLEX_SEQUENCE.sequence, INPUT])
@@ -123,6 +146,15 @@ fn test_specify_delimiter() {
}
}
+#[test]
+fn test_delimiter_with_more_than_one_char() {
+ new_ucmd!()
+ .args(&["-d", "ab", "-f1"])
+ .fails()
+ .stderr_contains("cut: the delimiter must be a single character")
+ .no_stdout();
+}
+
#[test]
fn test_output_delimiter() {
// we use -d here to ensure output delimiter
@@ -191,20 +223,25 @@ fn test_zero_terminated_only_delimited() {
}
#[test]
-fn test_directory_and_no_such_file() {
+fn test_is_a_directory() {
let (at, mut ucmd) = at_and_ucmd!();
at.mkdir("some");
ucmd.arg("-b1")
.arg("some")
- .run()
+ .fails()
+ .code_is(1)
.stderr_is("cut: some: Is a directory\n");
+}
+#[test]
+fn test_no_such_file() {
new_ucmd!()
.arg("-b1")
.arg("some")
- .run()
+ .fails()
+ .code_is(1)
.stderr_is("cut: some: No such file or directory\n");
}
@@ -234,3 +271,52 @@ fn test_equal_as_delimiter3() {
.succeeds()
.stdout_only_bytes("abZcd\n");
}
+
+#[test]
+fn test_multiple() {
+ let result = new_ucmd!()
+ .args(&["-f2", "-d:", "-d="])
+ .pipe_in("a=b\n")
+ .succeeds();
+ assert_eq!(result.stdout_str(), "b\n");
+ assert_eq!(result.stderr_str(), "");
+}
+
+#[test]
+fn test_multiple_mode_args() {
+ for args in [
+ vec!["-b1", "-b2"],
+ vec!["-c1", "-c2"],
+ vec!["-f1", "-f2"],
+ vec!["-b1", "-c2"],
+ vec!["-b1", "-f2"],
+ vec!["-c1", "-f2"],
+ vec!["-b1", "-c2", "-f3"],
+ ] {
+ new_ucmd!()
+ .args(&args)
+ .fails()
+ .stderr_is("cut: invalid usage: expects no more than one of --fields (-f), --chars (-c) or --bytes (-b)\n");
+ }
+}
+
+#[test]
+fn test_no_argument() {
+ new_ucmd!().fails().stderr_is(
+ "cut: invalid usage: expects one of --fields (-f), --chars (-c) or --bytes (-b)\n",
+ );
+}
+
+#[test]
+#[cfg(unix)]
+fn test_8bit_non_utf8_delimiter() {
+ use std::ffi::OsStr;
+ use std::os::unix::ffi::OsStrExt;
+ let delim = OsStr::from_bytes(b"\xAD".as_slice());
+ new_ucmd!()
+ .arg("-d")
+ .arg(delim)
+ .args(&["--out=_", "-f2,3", "8bit-delim.txt"])
+ .succeeds()
+ .stdout_check(|out| out == "b_c\n".as_bytes());
+}
diff --git a/tests/by-util/test_date.rs b/tests/by-util/test_date.rs
index 6aa0031cadd9d8b298e293d1edcad30adbc0d0a2..16a01c6558dfccab606c08aadea677004c981a77 100644
--- a/tests/by-util/test_date.rs
+++ b/tests/by-util/test_date.rs
@@ -1,9 +1,11 @@
-extern crate regex;
-
-use self::regex::Regex;
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
+use regex::Regex;
#[cfg(all(unix, not(target_os = "macos")))]
-use rust_users::*;
+use uucore::process::geteuid;
#[test]
fn test_invalid_arg() {
@@ -31,29 +33,104 @@ fn test_date_rfc_3339() {
for param in ["--rfc-3339", "--rfc-3"] {
scene
.ucmd()
- .arg(format!("{}=ns", param))
+ .arg(format!("{param}=ns"))
.succeeds()
.stdout_matches(&re);
scene
.ucmd()
- .arg(format!("{}=seconds", param))
+ .arg(format!("{param}=seconds"))
.succeeds()
.stdout_matches(&re);
}
}
+#[test]
+fn test_date_rfc_3339_invalid_arg() {
+ for param in ["--iso-3339", "--rfc-3"] {
+ new_ucmd!().arg(format!("{param}=foo")).fails();
+ }
+}
+
+#[test]
+fn test_date_rfc_8601_default() {
+ let re = Regex::new(r"^\d{4}-\d{2}-\d{2}\n$").unwrap();
+ for param in ["--iso-8601", "--i"] {
+ new_ucmd!().arg(param).succeeds().stdout_matches(&re);
+ }
+}
+
#[test]
fn test_date_rfc_8601() {
+ let re = Regex::new(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2},\d{9}[+-]\d{2}:\d{2}\n$").unwrap();
+ for param in ["--iso-8601", "--i"] {
+ new_ucmd!()
+ .arg(format!("{param}=ns"))
+ .succeeds()
+ .stdout_matches(&re);
+ }
+}
+
+#[test]
+fn test_date_rfc_8601_invalid_arg() {
for param in ["--iso-8601", "--i"] {
- new_ucmd!().arg(format!("{}=ns", param)).succeeds();
+ new_ucmd!().arg(format!("{param}=@")).fails();
}
}
#[test]
fn test_date_rfc_8601_second() {
+ let re = Regex::new(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}[+-]\d{2}:\d{2}\n$").unwrap();
+ for param in ["--iso-8601", "--i"] {
+ new_ucmd!()
+ .arg(format!("{param}=second"))
+ .succeeds()
+ .stdout_matches(&re);
+ new_ucmd!()
+ .arg(format!("{param}=seconds"))
+ .succeeds()
+ .stdout_matches(&re);
+ }
+}
+
+#[test]
+fn test_date_rfc_8601_minute() {
+ let re = Regex::new(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}[+-]\d{2}:\d{2}\n$").unwrap();
+ for param in ["--iso-8601", "--i"] {
+ new_ucmd!()
+ .arg(format!("{param}=minute"))
+ .succeeds()
+ .stdout_matches(&re);
+ new_ucmd!()
+ .arg(format!("{param}=minutes"))
+ .succeeds()
+ .stdout_matches(&re);
+ }
+}
+
+#[test]
+fn test_date_rfc_8601_hour() {
+ let re = Regex::new(r"^\d{4}-\d{2}-\d{2}T\d{2}[+-]\d{2}:\d{2}\n$").unwrap();
+ for param in ["--iso-8601", "--i"] {
+ new_ucmd!()
+ .arg(format!("{param}=hour"))
+ .succeeds()
+ .stdout_matches(&re);
+ new_ucmd!()
+ .arg(format!("{param}=hours"))
+ .succeeds()
+ .stdout_matches(&re);
+ }
+}
+
+#[test]
+fn test_date_rfc_8601_date() {
+ let re = Regex::new(r"^\d{4}-\d{2}-\d{2}\n$").unwrap();
for param in ["--iso-8601", "--i"] {
- new_ucmd!().arg(format!("{}=second", param)).succeeds();
+ new_ucmd!()
+ .arg(format!("{param}=date"))
+ .succeeds()
+ .stdout_matches(&re);
}
}
@@ -68,10 +145,10 @@ fn test_date_utc() {
fn test_date_format_y() {
let scene = TestScenario::new(util_name!());
- let mut re = Regex::new(r"^\d{4}$").unwrap();
+ let mut re = Regex::new(r"^\d{4}\n$").unwrap();
scene.ucmd().arg("+%Y").succeeds().stdout_matches(&re);
- re = Regex::new(r"^\d{2}$").unwrap();
+ re = Regex::new(r"^\d{2}\n$").unwrap();
scene.ucmd().arg("+%y").succeeds().stdout_matches(&re);
}
@@ -82,7 +159,7 @@ fn test_date_format_m() {
let mut re = Regex::new(r"\S+").unwrap();
scene.ucmd().arg("+%b").succeeds().stdout_matches(&re);
- re = Regex::new(r"^\d{2}$").unwrap();
+ re = Regex::new(r"^\d{2}\n$").unwrap();
scene.ucmd().arg("+%m").succeeds().stdout_matches(&re);
}
@@ -96,7 +173,7 @@ fn test_date_format_day() {
re = Regex::new(r"\S+").unwrap();
scene.ucmd().arg("+%A").succeeds().stdout_matches(&re);
- re = Regex::new(r"^\d{1}$").unwrap();
+ re = Regex::new(r"^\d{1}\n$").unwrap();
scene.ucmd().arg("+%u").succeeds().stdout_matches(&re);
}
@@ -117,7 +194,7 @@ fn test_date_issue_3780() {
#[test]
fn test_date_nano_seconds() {
// %N nanoseconds (000000000..999999999)
- let re = Regex::new(r"^\d{1,9}$").unwrap();
+ let re = Regex::new(r"^\d{1,9}\n$").unwrap();
new_ucmd!().arg("+%N").succeeds().stdout_matches(&re);
}
@@ -140,7 +217,7 @@ fn test_date_format_literal() {
#[test]
#[cfg(all(unix, not(target_os = "macos")))]
fn test_date_set_valid() {
- if get_effective_uid() == 0 {
+ if geteuid() == 0 {
new_ucmd!()
.arg("--set")
.arg("2020-03-12 13:30:00+08:00")
@@ -161,7 +238,7 @@ fn test_date_set_invalid() {
#[test]
#[cfg(all(unix, not(any(target_os = "android", target_os = "macos"))))]
fn test_date_set_permissions_error() {
- if !(get_effective_uid() == 0 || uucore::os::is_wsl_1()) {
+ if !(geteuid() == 0 || uucore::os::is_wsl_1()) {
let result = new_ucmd!()
.arg("--set")
.arg("2020-03-11 21:45:00+08:00")
@@ -188,7 +265,7 @@ fn test_date_set_mac_unavailable() {
#[cfg(all(unix, not(target_os = "macos")))]
/// TODO: expected to fail currently; change to succeeds() when required.
fn test_date_set_valid_2() {
- if get_effective_uid() == 0 {
+ if geteuid() == 0 {
let result = new_ucmd!()
.arg("--set")
.arg("Sat 20 Mar 2021 14:53:01 AWST") // spell-checker:disable-line
@@ -198,11 +275,62 @@ fn test_date_set_valid_2() {
}
}
+#[test]
+fn test_date_for_invalid_file() {
+ let result = new_ucmd!().arg("--file").arg("invalid_file").fails();
+ result.no_stdout();
+ assert_eq!(
+ result.stderr_str().trim(),
+ "date: invalid_file: No such file or directory",
+ );
+}
+
+#[test]
+#[cfg(unix)]
+fn test_date_for_no_permission_file() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ const FILE: &str = "file-no-perm-1";
+
+ use std::os::unix::fs::PermissionsExt;
+ let file = std::fs::OpenOptions::new()
+ .create(true)
+ .truncate(true)
+ .write(true)
+ .open(at.plus(FILE))
+ .unwrap();
+ file.set_permissions(std::fs::Permissions::from_mode(0o222))
+ .unwrap();
+ let result = ucmd.arg("--file").arg(FILE).fails();
+ result.no_stdout();
+ assert_eq!(
+ result.stderr_str().trim(),
+ format!("date: {FILE}: Permission denied")
+ );
+}
+
+#[test]
+fn test_date_for_dir_as_file() {
+ let result = new_ucmd!().arg("--file").arg("/").fails();
+ result.no_stdout();
+ assert_eq!(
+ result.stderr_str().trim(),
+ "date: expected file, got directory '/'",
+ );
+}
+
+#[test]
+fn test_date_for_file() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let file = "test_date_for_file";
+ at.touch(file);
+ ucmd.arg("--file").arg(file).succeeds();
+}
+
#[test]
#[cfg(all(unix, not(target_os = "macos")))]
/// TODO: expected to fail currently; change to succeeds() when required.
fn test_date_set_valid_3() {
- if get_effective_uid() == 0 {
+ if geteuid() == 0 {
let result = new_ucmd!()
.arg("--set")
.arg("Sat 20 Mar 2021 14:53:01") // Local timezone
@@ -216,7 +344,7 @@ fn test_date_set_valid_3() {
#[cfg(all(unix, not(target_os = "macos")))]
/// TODO: expected to fail currently; change to succeeds() when required.
fn test_date_set_valid_4() {
- if get_effective_uid() == 0 {
+ if geteuid() == 0 {
let result = new_ucmd!()
.arg("--set")
.arg("2020-03-11 21:45:00") // Local timezone
@@ -232,3 +360,87 @@ fn test_invalid_format_string() {
result.no_stdout();
assert!(result.stderr_str().starts_with("date: invalid format "));
}
+
+#[test]
+fn test_unsupported_format() {
+ let result = new_ucmd!().arg("+%#z").fails();
+ result.no_stdout();
+ assert!(result.stderr_str().starts_with("date: invalid format %#z"));
+}
+
+#[test]
+fn test_date_string_human() {
+ let date_formats = vec![
+ "1 year ago",
+ "1 year",
+ "2 months ago",
+ "15 days ago",
+ "1 week ago",
+ "5 hours ago",
+ "30 minutes ago",
+ "10 seconds",
+ ];
+ let re = Regex::new(r"^\d{4}-\d{2}-\d{2} \d{2}:\d{2}\n$").unwrap();
+ for date_format in date_formats {
+ new_ucmd!()
+ .arg("-d")
+ .arg(date_format)
+ .arg("+%Y-%m-%d %S:%M")
+ .succeeds()
+ .stdout_matches(&re);
+ }
+}
+
+#[test]
+fn test_invalid_date_string() {
+ new_ucmd!()
+ .arg("-d")
+ .arg("foo")
+ .fails()
+ .no_stdout()
+ .stderr_contains("invalid date");
+}
+
+#[test]
+fn test_date_overflow() {
+ new_ucmd!()
+ .arg("-d68888888888888sms")
+ .fails()
+ .no_stdout()
+ .stderr_contains("invalid date");
+}
+
+#[test]
+fn test_date_parse_from_format() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ const FILE: &str = "file-with-dates";
+
+ at.write(
+ FILE,
+ "2023-03-27 08:30:00\n\
+ 2023-04-01 12:00:00\n\
+ 2023-04-15 18:30:00",
+ );
+ ucmd.arg("-f")
+ .arg(at.plus(FILE))
+ .arg("+%Y-%m-%d %H:%M:%S")
+ .succeeds();
+}
+
+#[test]
+fn test_date_from_stdin() {
+ new_ucmd!()
+ .arg("-f")
+ .arg("-")
+ .pipe_in(
+ "2023-03-27 08:30:00\n\
+ 2023-04-01 12:00:00\n\
+ 2023-04-15 18:30:00\n",
+ )
+ .succeeds()
+ .stdout_is(
+ "Mon Mar 27 08:30:00 2023\n\
+ Sat Apr 1 12:00:00 2023\n\
+ Sat Apr 15 18:30:00 2023\n",
+ );
+}
diff --git a/tests/by-util/test_dd.rs b/tests/by-util/test_dd.rs
index ab4d4bf6aafb27a5649c92df57df5f30fd415034..a8cb0aa6473ff0c8480a38c99a69b1724c603245 100644
--- a/tests/by-util/test_dd.rs
+++ b/tests/by-util/test_dd.rs
@@ -1,10 +1,28 @@
-// spell-checker:ignore fname, tname, fpath, specfile, testfile, unspec, ifile, ofile, outfile, fullblock, urand, fileio, atoe, atoibm, availible, behaviour, bmax, bremain, btotal, cflags, creat, ctable, ctty, datastructures, doesnt, etoa, fileout, fname, gnudd, iconvflags, iseek, nocache, noctty, noerror, nofollow, nolinks, nonblock, oconvflags, oseek, outfile, parseargs, rlen, rmax, rposition, rremain, rsofar, rstat, sigusr, sigval, wlen, wstat abcdefghijklm abcdefghi nabcde nabcdefg abcdefg
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore fname, tname, fpath, specfile, testfile, unspec, ifile, ofile, outfile, fullblock, urand, fileio, atoe, atoibm, availible, behaviour, bmax, bremain, btotal, cflags, creat, ctable, ctty, datastructures, doesnt, etoa, fileout, fname, gnudd, iconvflags, iseek, nocache, noctty, noerror, nofollow, nolinks, nonblock, oconvflags, oseek, outfile, parseargs, rlen, rmax, rposition, rremain, rsofar, rstat, sigusr, sigval, wlen, wstat abcdefghijklm abcdefghi nabcde nabcdefg abcdefg fifoname seekable
+
+#[cfg(unix)]
+use crate::common::util::run_ucmd_as_root_with_stdin_stdout;
+use crate::common::util::TestScenario;
+#[cfg(all(not(windows), feature = "printf"))]
+use crate::common::util::{UCommand, TESTS_BINARY};
-use crate::common::util::*;
+use regex::Regex;
+use uucore::io::OwnedFileDescriptorOrHandle;
use std::fs::{File, OpenOptions};
use std::io::{BufReader, Read, Write};
use std::path::PathBuf;
+#[cfg(all(
+ unix,
+ not(target_os = "macos"),
+ not(target_os = "freebsd"),
+ feature = "printf"
+))]
+use std::process::{Command, Stdio};
#[cfg(not(windows))]
use std::thread::sleep;
#[cfg(not(windows))]
@@ -211,35 +229,35 @@ fn test_x_multiplier() {
fn test_zero_multiplier_warning() {
for arg in ["count", "seek", "skip"] {
new_ucmd!()
- .args(&[format!("{}=0", arg).as_str(), "status=none"])
+ .args(&[format!("{arg}=0").as_str(), "status=none"])
.pipe_in("")
.succeeds()
.no_stdout()
.no_stderr();
new_ucmd!()
- .args(&[format!("{}=00x1", arg).as_str(), "status=none"])
+ .args(&[format!("{arg}=00x1").as_str(), "status=none"])
.pipe_in("")
.succeeds()
.no_stdout()
.no_stderr();
new_ucmd!()
- .args(&[format!("{}=0x1", arg).as_str(), "status=none"])
+ .args(&[format!("{arg}=0x1").as_str(), "status=none"])
.pipe_in("")
.succeeds()
.no_stdout()
.stderr_contains("warning: '0x' is a zero multiplier; use '00x' if that is intended");
new_ucmd!()
- .args(&[format!("{}=0x0x1", arg).as_str(), "status=none"])
+ .args(&[format!("{arg}=0x0x1").as_str(), "status=none"])
.pipe_in("")
.succeeds()
.no_stdout()
.stderr_is("dd: warning: '0x' is a zero multiplier; use '00x' if that is intended\ndd: warning: '0x' is a zero multiplier; use '00x' if that is intended\n");
new_ucmd!()
- .args(&[format!("{}=1x0x1", arg).as_str(), "status=none"])
+ .args(&[format!("{arg}=1x0x1").as_str(), "status=none"])
.pipe_in("")
.succeeds()
.no_stdout()
@@ -259,7 +277,9 @@ fn test_final_stats_noxfer() {
fn test_final_stats_unspec() {
new_ucmd!()
.run()
- .stderr_only("0+0 records in\n0+0 records out\n0 bytes copied, 0.0 s, 0.0 B/s\n")
+ .stderr_contains("0+0 records in\n0+0 records out\n0 bytes copied, ")
+ .stderr_matches(&Regex::new(r"\d(\.\d+)?(e-\d\d)? s, ").unwrap())
+ .stderr_contains("0.0 B/s")
.success();
}
@@ -325,7 +345,7 @@ fn test_nocreat_causes_failure_when_outfile_not_present() {
.pipe_in("")
.fails()
.stderr_only(
- "dd: failed to open 'this-file-does-not-exist.txt': No such file or directory",
+ "dd: failed to open 'this-file-does-not-exist.txt': No such file or directory\n",
);
assert!(!fix.file_exists(fname));
}
@@ -373,9 +393,11 @@ fn test_existing_file_truncated() {
#[test]
fn test_null_stats() {
new_ucmd!()
- .args(&["if=null.txt"])
+ .arg("if=null.txt")
.run()
- .stderr_only("0+0 records in\n0+0 records out\n0 bytes copied, 0.0 s, 0.0 B/s\n")
+ .stderr_contains("0+0 records in\n0+0 records out\n0 bytes copied, ")
+ .stderr_matches(&Regex::new(r"\d(\.\d+)?(e-\d\d)? s, ").unwrap())
+ .stderr_contains("0.0 B/s")
.success();
}
@@ -496,7 +518,7 @@ fn test_ascii_10k_to_stdout() {
#[test]
fn test_zeros_to_file() {
let tname = "zero-256k";
- let test_fn = format!("{}.txt", tname);
+ let test_fn = format!("{tname}.txt");
let tmp_fn = format!("TESTFILE-{}.tmp", &tname);
assert_fixture_exists!(test_fn);
@@ -516,7 +538,7 @@ fn test_zeros_to_file() {
#[test]
fn test_to_file_with_ibs_obs() {
let tname = "zero-256k";
- let test_fn = format!("{}.txt", tname);
+ let test_fn = format!("{tname}.txt");
let tmp_fn = format!("TESTFILE-{}.tmp", &tname);
assert_fixture_exists!(test_fn);
@@ -608,7 +630,7 @@ fn test_self_transfer() {
#[test]
fn test_unicode_filenames() {
let tname = "😎💚🦊";
- let test_fn = format!("{}.txt", tname);
+ let test_fn = format!("{tname}.txt");
let tmp_fn = format!("TESTFILE-{}.tmp", &tname);
assert_fixture_exists!(test_fn);
@@ -1284,14 +1306,14 @@ fn test_invalid_number_arg_gnu_compatibility() {
for command in commands {
new_ucmd!()
- .args(&[format!("{}=", command)])
+ .args(&[format!("{command}=")])
.fails()
- .stderr_is("dd: invalid number: ‘’");
+ .stderr_is("dd: invalid number: ‘’\n");
new_ucmd!()
- .args(&[format!("{}=29d", command)])
+ .args(&[format!("{command}=29d")])
.fails()
- .stderr_is("dd: invalid number: ‘29d’");
+ .stderr_is("dd: invalid number: ‘29d’\n");
}
}
@@ -1301,12 +1323,12 @@ fn test_invalid_flag_arg_gnu_compatibility() {
for command in commands {
new_ucmd!()
- .args(&[format!("{}=", command)])
+ .args(&[format!("{command}=")])
.fails()
.usage_error("invalid input flag: ‘’");
new_ucmd!()
- .args(&[format!("{}=29d", command)])
+ .args(&[format!("{command}=29d")])
.fails()
.usage_error("invalid input flag: ‘29d’");
}
@@ -1317,19 +1339,19 @@ fn test_invalid_file_arg_gnu_compatibility() {
new_ucmd!()
.args(&["if="])
.fails()
- .stderr_is("dd: failed to open '': No such file or directory");
+ .stderr_is("dd: failed to open '': No such file or directory\n");
new_ucmd!()
.args(&["if=81as9bn8as9g302az8ns9.pdf.zip.pl.com"])
.fails()
.stderr_is(
- "dd: failed to open '81as9bn8as9g302az8ns9.pdf.zip.pl.com': No such file or directory",
+ "dd: failed to open '81as9bn8as9g302az8ns9.pdf.zip.pl.com': No such file or directory\n",
);
new_ucmd!()
.args(&["of="])
.fails()
- .stderr_is("dd: failed to open '': No such file or directory");
+ .stderr_is("dd: failed to open '': No such file or directory\n");
new_ucmd!()
.args(&["of=81as9bn8as9g302az8ns9.pdf.zip.pl.com"])
@@ -1384,6 +1406,36 @@ fn test_bytes_suffix() {
.stdout_only("\0\0\0abcdef");
}
+#[test]
+// the recursive nature of the suffix allows any string with a 'B' in it treated as bytes.
+fn test_bytes_suffix_recursive() {
+ new_ucmd!()
+ .args(&["count=2Bx2", "status=none"])
+ .pipe_in("abcdef")
+ .succeeds()
+ .stdout_only("abcd");
+ new_ucmd!()
+ .args(&["skip=2Bx2", "status=none"])
+ .pipe_in("abcdef")
+ .succeeds()
+ .stdout_only("ef");
+ new_ucmd!()
+ .args(&["iseek=2Bx2", "status=none"])
+ .pipe_in("abcdef")
+ .succeeds()
+ .stdout_only("ef");
+ new_ucmd!()
+ .args(&["seek=2Bx2", "status=none"])
+ .pipe_in("abcdef")
+ .succeeds()
+ .stdout_only("\0\0\0\0abcdef");
+ new_ucmd!()
+ .args(&["oseek=2Bx2", "status=none"])
+ .pipe_in("abcdef")
+ .succeeds()
+ .stdout_only("\0\0\0\0abcdef");
+}
+
/// Test for "conv=sync" with a slow reader.
#[cfg(not(windows))]
#[test]
@@ -1442,3 +1494,284 @@ fn test_sparse() {
// number of blocks stored on disk may be zero.
assert_eq!(at.metadata("infile").len(), at.metadata("outfile").len());
}
+
+/// Test that a seek on an output FIFO results in a read.
+#[test]
+#[cfg(unix)]
+fn test_seek_output_fifo() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.mkfifo("fifo");
+
+ let mut ucmd = ts.ucmd();
+ let child = ucmd
+ .args(&["count=0", "seek=1", "of=fifo", "status=noxfer"])
+ .run_no_wait();
+
+ std::fs::write(at.plus("fifo"), vec![0; 512]).unwrap();
+
+ child
+ .wait()
+ .unwrap()
+ .success()
+ .stderr_only("0+0 records in\n0+0 records out\n");
+}
+
+/// Test that a skip on an input FIFO results in a read.
+#[test]
+#[cfg(unix)]
+fn test_skip_input_fifo() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.mkfifo("fifo");
+
+ let mut ucmd = ts.ucmd();
+ let child = ucmd
+ .args(&["count=0", "skip=1", "if=fifo", "status=noxfer"])
+ .run_no_wait();
+
+ std::fs::write(at.plus("fifo"), vec![0; 512]).unwrap();
+
+ child
+ .wait()
+ .unwrap()
+ .success()
+ .stderr_only("0+0 records in\n0+0 records out\n");
+}
+
+/// Test for reading part of stdin from each of two child processes.
+#[cfg(all(not(windows), feature = "printf"))]
+#[test]
+fn test_multiple_processes_reading_stdin() {
+ // TODO Investigate if this is possible on Windows.
+ let printf = format!("{TESTS_BINARY} printf 'abcdef\n'");
+ let dd_skip = format!("{TESTS_BINARY} dd bs=1 skip=3 count=0");
+ let dd = format!("{TESTS_BINARY} dd");
+ UCommand::new()
+ .arg(format!("{printf} | ( {dd_skip} && {dd} ) 2> /dev/null"))
+ .succeeds()
+ .stdout_only("def\n");
+}
+
+/// Test that discarding system file cache fails for stdin.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_nocache_stdin_error() {
+ #[cfg(not(target_env = "musl"))]
+ let detail = "Illegal seek";
+ #[cfg(target_env = "musl")]
+ let detail = "Invalid seek";
+ new_ucmd!()
+ .args(&["iflag=nocache", "count=0", "status=noxfer"])
+ .fails()
+ .code_is(1)
+ .stderr_only(format!("dd: failed to discard cache for: 'standard input': {detail}\n0+0 records in\n0+0 records out\n"));
+}
+
+/// Test that dd fails when no number in count.
+#[test]
+fn test_empty_count_number() {
+ new_ucmd!()
+ .args(&["count=B"])
+ .fails()
+ .code_is(1)
+ .stderr_only("dd: invalid number: ‘B’\n");
+}
+
+/// Test for discarding system file cache.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_nocache_file() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.write_bytes("f", b"a".repeat(1 << 20).as_slice());
+ ucmd.args(&["if=f", "of=/dev/null", "iflag=nocache", "status=noxfer"])
+ .succeeds()
+ .stderr_only("2048+0 records in\n2048+0 records out\n");
+}
+
+#[test]
+#[cfg(unix)]
+fn test_skip_past_dev() {
+ // NOTE: This test intends to trigger code which can only be reached with root permissions.
+ let ts = TestScenario::new(util_name!());
+
+ if let Ok(result) = run_ucmd_as_root_with_stdin_stdout(
+ &ts,
+ &["bs=1", "skip=10000000000000000", "count=0", "status=noxfer"],
+ Some("/dev/sda1"),
+ None,
+ ) {
+ result.stderr_contains("dd: 'standard input': cannot skip: Invalid argument");
+ result.stderr_contains("0+0 records in");
+ result.stderr_contains("0+0 records out");
+ result.code_is(1);
+ } else {
+ print!("Test skipped; requires root user");
+ }
+}
+
+#[test]
+#[cfg(unix)]
+fn test_seek_past_dev() {
+ // NOTE: This test intends to trigger code which can only be reached with root permissions.
+ let ts = TestScenario::new(util_name!());
+
+ if let Ok(result) = run_ucmd_as_root_with_stdin_stdout(
+ &ts,
+ &["bs=1", "seek=10000000000000000", "count=0", "status=noxfer"],
+ None,
+ Some("/dev/sda1"),
+ ) {
+ result.stderr_contains("dd: 'standard output': cannot seek: Invalid argument");
+ result.stderr_contains("0+0 records in");
+ result.stderr_contains("0+0 records out");
+ result.code_is(1);
+ } else {
+ print!("Test skipped; requires root user");
+ }
+}
+
+#[test]
+#[cfg(all(
+ unix,
+ not(target_os = "macos"),
+ not(target_os = "freebsd"),
+ feature = "printf"
+))]
+fn test_reading_partial_blocks_from_fifo() {
+ // Create the FIFO.
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.mkfifo("fifo");
+ let fifoname = at.plus_as_string("fifo");
+
+ // Start a `dd` process that reads from the fifo (so it will wait
+ // until the writer process starts).
+ let mut reader_command = Command::new(TESTS_BINARY);
+ let child = reader_command
+ .args(["dd", "ibs=3", "obs=3", &format!("if={}", fifoname)])
+ .stdout(Stdio::piped())
+ .stderr(Stdio::piped())
+ .spawn()
+ .unwrap();
+
+ // Start different processes to write to the FIFO, with a small
+ // pause in between.
+ let mut writer_command = Command::new("sh");
+ writer_command
+ .args([
+ "-c",
+ &format!("(printf \"ab\"; sleep 0.1; printf \"cd\") > {}", fifoname),
+ ])
+ .spawn()
+ .unwrap();
+
+ let output = child.wait_with_output().unwrap();
+ assert_eq!(output.stdout, b"abcd");
+ let expected = b"0+2 records in\n1+1 records out\n4 bytes copied";
+ assert!(output.stderr.starts_with(expected));
+}
+
+#[test]
+#[cfg(all(
+ unix,
+ not(target_os = "macos"),
+ not(target_os = "freebsd"),
+ feature = "printf"
+))]
+fn test_reading_partial_blocks_from_fifo_unbuffered() {
+ // Create the FIFO.
+ let ts = TestScenario::new(util_name!());
+ let at = ts.fixtures;
+ at.mkfifo("fifo");
+ let fifoname = at.plus_as_string("fifo");
+
+ // Start a `dd` process that reads from the fifo (so it will wait
+ // until the writer process starts).
+ //
+ // `bs=N` takes precedence over `ibs=N` and `obs=N`.
+ let mut reader_command = Command::new(TESTS_BINARY);
+ let child = reader_command
+ .args(["dd", "bs=3", "ibs=1", "obs=1", &format!("if={}", fifoname)])
+ .stdout(Stdio::piped())
+ .stderr(Stdio::piped())
+ .spawn()
+ .unwrap();
+
+ // Start different processes to write to the FIFO, with a small
+ // pause in between.
+ let mut writer_command = Command::new("sh");
+ writer_command
+ .args([
+ "-c",
+ &format!("(printf \"ab\"; sleep 0.1; printf \"cd\") > {}", fifoname),
+ ])
+ .spawn()
+ .unwrap();
+
+ let output = child.wait_with_output().unwrap();
+ assert_eq!(output.stdout, b"abcd");
+ let expected = b"0+2 records in\n0+2 records out\n4 bytes copied";
+ assert!(output.stderr.starts_with(expected));
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_iflag_directory_fails_when_file_is_passed_via_std_in() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.make_file("input");
+ let filename = at.plus_as_string("input");
+ new_ucmd!()
+ .args(&["iflag=directory", "count=0"])
+ .set_stdin(std::process::Stdio::from(File::open(filename).unwrap()))
+ .fails()
+ .stderr_contains("standard input: not a directory");
+}
+
+#[test]
+fn test_stdin_stdout_not_rewound_even_when_connected_to_seekable_file() {
+ use std::process::Stdio;
+
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+
+ at.write("in", "abcde");
+
+ let stdin = OwnedFileDescriptorOrHandle::open_file(
+ OpenOptions::new().read(true),
+ at.plus("in").as_path(),
+ )
+ .unwrap();
+ let stdout = OwnedFileDescriptorOrHandle::open_file(
+ OpenOptions::new().create(true).write(true),
+ at.plus("out").as_path(),
+ )
+ .unwrap();
+ let stderr = OwnedFileDescriptorOrHandle::open_file(
+ OpenOptions::new().create(true).write(true),
+ at.plus("err").as_path(),
+ )
+ .unwrap();
+
+ ts.ucmd()
+ .args(&["bs=1", "skip=1", "count=1"])
+ .set_stdin(Stdio::from(stdin.try_clone().unwrap()))
+ .set_stdout(Stdio::from(stdout.try_clone().unwrap()))
+ .set_stderr(Stdio::from(stderr.try_clone().unwrap()))
+ .succeeds();
+
+ ts.ucmd()
+ .args(&["bs=1", "skip=1"])
+ .set_stdin(stdin)
+ .set_stdout(stdout)
+ .set_stderr(stderr)
+ .succeeds();
+
+ let err_file_content = std::fs::read_to_string(at.plus_as_string("err")).unwrap();
+ println!("stderr:\n{}", err_file_content);
+
+ let out_file_content = std::fs::read_to_string(at.plus_as_string("out")).unwrap();
+ println!("stdout:\n{}", out_file_content);
+ assert_eq!(out_file_content, "bde");
+}
diff --git a/tests/by-util/test_df.rs b/tests/by-util/test_df.rs
index 62f6e26331f317a8a046b5d806f68a2a4c56e2e4..996b8dc29dac92d7caa53a274c38bf4d30b1b906 100644
--- a/tests/by-util/test_df.rs
+++ b/tests/by-util/test_df.rs
@@ -1,7 +1,11 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore udev pcent iuse itotal iused ipcent
use std::collections::HashSet;
-use crate::common::util::*;
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
@@ -175,13 +179,28 @@ fn test_default_headers() {
}
#[test]
-fn test_precedence_of_human_readable_header_over_output_header() {
+fn test_precedence_of_human_readable_and_si_header_over_output_header() {
+ let args = ["-h", "--human-readable", "-H", "--si"];
+
+ for arg in args {
+ let output = new_ucmd!()
+ .args(&[arg, "--output=size"])
+ .succeeds()
+ .stdout_move_str();
+ let header = output.lines().next().unwrap();
+ assert_eq!(header, " Size");
+ }
+}
+
+#[test]
+fn test_used_header_starts_with_space() {
let output = new_ucmd!()
- .args(&["-H", "--output=size"])
+ // using -h here to ensure the width of the column's content is <= 4
+ .args(&["-h", "--output=used"])
.succeeds()
.stdout_move_str();
- let header = output.lines().next().unwrap().to_string();
- assert_eq!(header.trim(), "Size");
+ let header = output.lines().next().unwrap();
+ assert_eq!(header, " Used");
}
#[test]
@@ -258,7 +277,7 @@ fn test_type_option() {
}
#[test]
-#[cfg(not(target_os = "freebsd"))] // FIXME: fix this test for FreeBSD
+#[cfg(not(any(target_os = "freebsd", target_os = "windows")))] // FIXME: fix test for FreeBSD & Win
fn test_type_option_with_file() {
let fs_type = new_ucmd!()
.args(&["--output=fstype", "."])
@@ -321,13 +340,13 @@ fn test_include_exclude_same_type() {
new_ucmd!()
.args(&["-t", "ext4", "-x", "ext4"])
.fails()
- .stderr_is("df: file system type 'ext4' both selected and excluded");
+ .stderr_is("df: file system type 'ext4' both selected and excluded\n");
new_ucmd!()
.args(&["-t", "ext4", "-x", "ext4", "-t", "ext3", "-x", "ext3"])
.fails()
.stderr_is(
"df: file system type 'ext4' both selected and excluded\n\
- df: file system type 'ext3' both selected and excluded",
+ df: file system type 'ext3' both selected and excluded\n",
);
}
@@ -418,7 +437,11 @@ fn test_total_label_in_correct_column() {
#[test]
fn test_use_percentage() {
let output = new_ucmd!()
- .args(&["--total", "--output=used,avail,pcent"])
+ // set block size = 1, otherwise the returned values for
+ // "used" and "avail" will be rounded. And using them to calculate
+ // the "percentage" values might lead to a mismatch with the returned
+ // "percentage" values.
+ .args(&["--total", "--output=used,avail,pcent", "--block-size=1"])
.succeeds()
.stdout_move_str();
@@ -519,7 +542,7 @@ fn test_default_block_size_in_posix_portability_mode() {
fn test_block_size_1024() {
fn get_header(block_size: u64) -> String {
let output = new_ucmd!()
- .args(&["-B", &format!("{}", block_size), "--output=size"])
+ .args(&["-B", &format!("{block_size}"), "--output=size"])
.succeeds()
.stdout_move_str();
output.lines().next().unwrap().trim().to_string()
@@ -693,9 +716,9 @@ fn test_ignore_block_size_from_env_in_posix_portability_mode() {
fn test_too_large_block_size() {
fn run_command(size: &str) {
new_ucmd!()
- .arg(format!("--block-size={}", size))
+ .arg(format!("--block-size={size}"))
.fails()
- .stderr_contains(format!("--block-size argument '{}' too large", size));
+ .stderr_contains(format!("--block-size argument '{size}' too large"));
}
let too_large_sizes = vec!["1Y", "1Z"];
@@ -806,7 +829,7 @@ fn test_output_file_all_filesystems() {
}
#[test]
-#[cfg(not(target_os = "freebsd"))] // FIXME: fix this test for FreeBSD
+#[cfg(not(any(target_os = "freebsd", target_os = "windows")))] // FIXME: fix test for FreeBSD & Win
fn test_output_file_specific_files() {
// Create three files.
let (at, mut ucmd) = at_and_ucmd!();
@@ -825,7 +848,7 @@ fn test_output_file_specific_files() {
}
#[test]
-#[cfg(not(target_os = "freebsd"))] // FIXME: fix this test for FreeBSD
+#[cfg(not(any(target_os = "freebsd", target_os = "windows")))] // FIXME: fix test for FreeBSD & Win
fn test_file_column_width_if_filename_contains_unicode_chars() {
let (at, mut ucmd) = at_and_ucmd!();
at.touch("äöü.txt");
@@ -848,12 +871,12 @@ fn test_output_field_no_more_than_once() {
}
#[test]
-#[cfg(not(target_os = "freebsd"))] // FIXME: fix this test for FreeBSD
+#[cfg(not(any(target_os = "freebsd", target_os = "windows")))] // FIXME: fix test for FreeBSD & Win
fn test_nonexistent_file() {
new_ucmd!()
.arg("does-not-exist")
.fails()
- .stderr_only("df: does-not-exist: No such file or directory");
+ .stderr_only("df: does-not-exist: No such file or directory\n");
new_ucmd!()
.args(&["--output=file", "does-not-exist", "."])
.fails()
diff --git a/tests/by-util/test_dir.rs b/tests/by-util/test_dir.rs
index 4d20b8e8e3953b80cb1bb36c4cce54c6d0eb0881..3d16f8a67c6a9db5af88de27b0a48c67f7b7d405 100644
--- a/tests/by-util/test_dir.rs
+++ b/tests/by-util/test_dir.rs
@@ -1,11 +1,9 @@
-#[cfg(not(windows))]
-extern crate libc;
-extern crate regex;
-#[cfg(not(windows))]
-extern crate tempfile;
-
-use self::regex::Regex;
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
+use regex::Regex;
/*
* As dir use the same functions than ls, we don't have to retest them here.
@@ -49,5 +47,5 @@ fn test_long_output() {
.ucmd()
.arg("-l")
.succeeds()
- .stdout_matches(&Regex::new("[rwx-]{10}.*some-file1$").unwrap());
+ .stdout_matches(&Regex::new("[rwx-]{10}.*some-file1\n$").unwrap());
}
diff --git a/tests/by-util/test_dircolors.rs b/tests/by-util/test_dircolors.rs
index 80b9711a2ffaf18d60e81fc9bcfa591124ce568c..d67368154823e514871c908e8150db9b5b3e42e6 100644
--- a/tests/by-util/test_dircolors.rs
+++ b/tests/by-util/test_dircolors.rs
@@ -1,8 +1,11 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore overridable
-use crate::common::util::*;
+use crate::common::util::TestScenario;
-extern crate dircolors;
-use self::dircolors::{guess_syntax, OutputFmt, StrUtils};
+use dircolors::{guess_syntax, OutputFmt, StrUtils};
#[test]
fn test_invalid_arg() {
@@ -156,6 +159,18 @@ fn test_quoting() {
.no_stderr();
}
+/*
+#[test]
+fn test_print_ls_colors() {
+ new_ucmd!()
+ .pipe_in("OWT 40;33\n")
+ .args(&["--print-ls-colors"])
+ .succeeds()
+ .stdout_is("\x1B[40;33mtw\t40;33\x1B[0m\n")
+ .no_stderr();
+}
+*/
+
#[test]
fn test_extra_operand() {
new_ucmd!()
@@ -210,14 +225,31 @@ fn test_helper(file_name: &str, term: &str) {
new_ucmd!()
.env("TERM", term)
.arg("-c")
- .arg(format!("{}.txt", file_name))
+ .arg(format!("{file_name}.txt"))
.run()
- .stdout_is_fixture(format!("{}.csh.expected", file_name));
+ .stdout_is_fixture(format!("{file_name}.csh.expected"));
new_ucmd!()
.env("TERM", term)
.arg("-b")
- .arg(format!("{}.txt", file_name))
+ .arg(format!("{file_name}.txt"))
.run()
- .stdout_is_fixture(format!("{}.sh.expected", file_name));
+ .stdout_is_fixture(format!("{file_name}.sh.expected"));
+}
+
+#[test]
+fn test_dircolors_for_dir_as_file() {
+ let result = new_ucmd!().args(&["-c", "/"]).fails();
+ result.no_stdout();
+ assert_eq!(
+ result.stderr_str().trim(),
+ "dircolors: expected file, got directory '/'",
+ );
+}
+
+#[test]
+fn test_repeated() {
+ for arg in ["-b", "-c", "--print-database", "--print-ls-colors"] {
+ new_ucmd!().arg(arg).arg(arg).succeeds().no_stderr();
+ }
}
diff --git a/tests/by-util/test_dirname.rs b/tests/by-util/test_dirname.rs
index 952f715e87e900254e079287234dc243e698ccae..8c465393cfbfaf464a9fda57ef00992a473d58b6 100644
--- a/tests/by-util/test_dirname.rs
+++ b/tests/by-util/test_dirname.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
@@ -36,6 +40,16 @@ fn test_path_without_trailing_slashes_and_zero() {
.stdout_is("/root/alpha/beta/gamma/delta/epsilon\u{0}");
}
+#[test]
+fn test_repeated_zero() {
+ new_ucmd!()
+ .arg("--zero")
+ .arg("--zero")
+ .arg("foo/bar")
+ .succeeds()
+ .stdout_only("foo\u{0}");
+}
+
#[test]
fn test_root() {
new_ucmd!().arg("/").run().stdout_is("/\n");
diff --git a/tests/by-util/test_du.rs b/tests/by-util/test_du.rs
index 09bb36e05d855b47319de11af9d235bd0ae1fa86..4527b3d5a6135af6f11c3e8f486f2150b8ca7339 100644
--- a/tests/by-util/test_du.rs
+++ b/tests/by-util/test_du.rs
@@ -1,15 +1,15 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-// spell-checker:ignore (paths) sublink subwords azerty azeaze xcwww azeaz amaz azea qzerty tazerty
+// spell-checker:ignore (paths) atim sublink subwords azerty azeaze xcwww azeaz amaz azea qzerty tazerty tsublink testfile1 testfile2 filelist fpath testdir testfile
#[cfg(not(windows))]
use regex::Regex;
-#[cfg(not(windows))]
-use std::io::Write;
-use crate::common::util::*;
+#[cfg(any(target_os = "linux", target_os = "android"))]
+use crate::common::util::expected_result;
+use crate::common::util::TestScenario;
const SUB_DIR: &str = "subdir/deeper";
const SUB_DEEPER_DIR: &str = "subdir/deeper/deeper_dir";
@@ -20,24 +20,54 @@ const SUB_LINK: &str = "subdir/links/sublink.txt";
#[test]
fn test_du_basics() {
- new_ucmd!().succeeds().no_stderr();
+ let ts = TestScenario::new(util_name!());
+
+ let result = ts.ucmd().succeeds();
+
+ #[cfg(any(target_os = "linux", target_os = "android"))]
+ {
+ let result_reference = unwrap_or_return!(expected_result(&ts, &[]));
+ if result_reference.succeeded() {
+ assert_eq!(result.stdout_str(), result_reference.stdout_str());
+ return;
+ }
+ }
+ _du_basics(result.stdout_str());
}
+
#[cfg(target_vendor = "apple")]
fn _du_basics(s: &str) {
- let answer = "32\t./subdir
-8\t./subdir/deeper
-24\t./subdir/links
-40\t.
-";
+ let answer = concat!(
+ "4\t./subdir/deeper/deeper_dir\n",
+ "8\t./subdir/deeper\n",
+ "12\t./subdir/links\n",
+ "20\t./subdir\n",
+ "24\t.\n"
+ );
+ assert_eq!(s, answer);
+}
+
+#[cfg(target_os = "windows")]
+fn _du_basics(s: &str) {
+ let answer = concat!(
+ "0\t.\\subdir\\deeper\\deeper_dir\n",
+ "0\t.\\subdir\\deeper\n",
+ "8\t.\\subdir\\links\n",
+ "8\t.\\subdir\n",
+ "8\t.\n"
+ );
assert_eq!(s, answer);
}
-#[cfg(not(target_vendor = "apple"))]
+
+#[cfg(all(not(target_vendor = "apple"), not(target_os = "windows"),))]
fn _du_basics(s: &str) {
- let answer = "28\t./subdir
-8\t./subdir/deeper
-16\t./subdir/links
-36\t.
-";
+ let answer = concat!(
+ "8\t./subdir/deeper/deeper_dir\n",
+ "16\t./subdir/deeper\n",
+ "16\t./subdir/links\n",
+ "36\t./subdir\n",
+ "44\t.\n"
+ );
assert_eq!(s, answer);
}
@@ -82,10 +112,10 @@ fn _du_basics_subdir(s: &str) {
))]
fn _du_basics_subdir(s: &str) {
// MS-WSL linux has altered expected output
- if !uucore::os::is_wsl_1() {
- assert_eq!(s, "8\tsubdir/deeper\n");
- } else {
+ if uucore::os::is_wsl_1() {
assert_eq!(s, "0\tsubdir/deeper\n");
+ } else {
+ assert_eq!(s, "8\tsubdir/deeper\n");
}
}
@@ -95,33 +125,62 @@ fn test_du_invalid_size() {
let ts = TestScenario::new(util_name!());
for s in args {
ts.ucmd()
- .arg(format!("--{}=1fb4t", s))
+ .arg(format!("--{s}=1fb4t"))
.arg("/tmp")
.fails()
.code_is(1)
- .stderr_only(format!("du: invalid suffix in --{} argument '1fb4t'", s));
+ .stderr_only(format!("du: invalid suffix in --{s} argument '1fb4t'\n"));
ts.ucmd()
- .arg(format!("--{}=x", s))
+ .arg(format!("--{s}=x"))
.arg("/tmp")
.fails()
.code_is(1)
- .stderr_only(format!("du: invalid --{} argument 'x'", s));
- #[cfg(not(target_pointer_width = "128"))]
+ .stderr_only(format!("du: invalid --{s} argument 'x'\n"));
ts.ucmd()
- .arg(format!("--{}=1Y", s))
+ .arg(format!("--{s}=1Y"))
.arg("/tmp")
.fails()
.code_is(1)
- .stderr_only(format!("du: --{} argument '1Y' too large", s));
+ .stderr_only(format!("du: --{s} argument '1Y' too large\n"));
}
}
#[test]
-fn test_du_basics_bad_name() {
+fn test_du_with_posixly_correct() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ let dir = "a";
+
+ at.mkdir(dir);
+ at.write(&format!("{dir}/file"), "some content");
+
+ let expected = ts
+ .ucmd()
+ .arg(dir)
+ .arg("--block-size=512")
+ .succeeds()
+ .stdout_move_str();
+
+ let result = ts
+ .ucmd()
+ .arg(dir)
+ .env("POSIXLY_CORRECT", "1")
+ .succeeds()
+ .stdout_move_str();
+
+ assert_eq!(expected, result);
+}
+
+#[test]
+fn test_du_non_existing_files() {
new_ucmd!()
- .arg("bad_name")
- .succeeds() // TODO: replace with ".fails()" once `du` is fixed
- .stderr_only("du: bad_name: No such file or directory\n");
+ .arg("non_existing_a")
+ .arg("non_existing_b")
+ .fails()
+ .stderr_only(concat!(
+ "du: cannot access 'non_existing_a': No such file or directory\n",
+ "du: cannot access 'non_existing_b': No such file or directory\n"
+ ));
}
#[test]
@@ -164,10 +223,10 @@ fn _du_soft_link(s: &str) {
))]
fn _du_soft_link(s: &str) {
// MS-WSL linux has altered expected output
- if !uucore::os::is_wsl_1() {
- assert_eq!(s, "16\tsubdir/links\n");
- } else {
+ if uucore::os::is_wsl_1() {
assert_eq!(s, "8\tsubdir/links\n");
+ } else {
+ assert_eq!(s, "16\tsubdir/links\n");
}
}
@@ -212,10 +271,10 @@ fn _du_hard_link(s: &str) {
))]
fn _du_hard_link(s: &str) {
// MS-WSL linux has altered expected output
- if !uucore::os::is_wsl_1() {
- assert_eq!(s, "16\tsubdir/links\n");
- } else {
+ if uucore::os::is_wsl_1() {
assert_eq!(s, "8\tsubdir/links\n");
+ } else {
+ assert_eq!(s, "16\tsubdir/links\n");
}
}
@@ -255,10 +314,10 @@ fn _du_d_flag(s: &str) {
))]
fn _du_d_flag(s: &str) {
// MS-WSL linux has altered expected output
- if !uucore::os::is_wsl_1() {
- assert_eq!(s, "28\t./subdir\n36\t.\n");
- } else {
+ if uucore::os::is_wsl_1() {
assert_eq!(s, "8\t./subdir\n8\t.\n");
+ } else {
+ assert_eq!(s, "28\t./subdir\n36\t.\n");
}
}
@@ -284,6 +343,30 @@ fn test_du_dereference() {
_du_dereference(result.stdout_str());
}
+#[cfg(not(windows))]
+#[test]
+fn test_du_dereference_args() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+
+ at.mkdir("dir");
+ at.write("dir/file-ignore1", "azeaze");
+ at.write("dir/file-ignore2", "amaz?ng");
+ at.symlink_dir("dir", "sublink");
+
+ for arg in ["-D", "-H", "--dereference-args"] {
+ let result = ts.ucmd().arg(arg).arg("-s").arg("sublink").succeeds();
+ let stdout = result.stdout_str();
+
+ assert!(!stdout.starts_with('0'));
+ assert!(stdout.contains("sublink"));
+ }
+
+ // Without the option
+ let result = ts.ucmd().arg("-s").arg("sublink").succeeds();
+ result.stdout_contains("0\tsublink\n");
+}
+
#[cfg(target_vendor = "apple")]
fn _du_dereference(s: &str) {
assert_eq!(s, "4\tsubdir/links/deeper_dir\n16\tsubdir/links\n");
@@ -303,10 +386,53 @@ fn _du_dereference(s: &str) {
))]
fn _du_dereference(s: &str) {
// MS-WSL linux has altered expected output
- if !uucore::os::is_wsl_1() {
- assert_eq!(s, "8\tsubdir/links/deeper_dir\n24\tsubdir/links\n");
- } else {
+ if uucore::os::is_wsl_1() {
assert_eq!(s, "0\tsubdir/links/deeper_dir\n8\tsubdir/links\n");
+ } else {
+ assert_eq!(s, "8\tsubdir/links/deeper_dir\n24\tsubdir/links\n");
+ }
+}
+
+#[cfg(not(any(target_os = "windows", target_os = "android", target_os = "freebsd")))]
+#[test]
+fn test_du_no_dereference() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ let dir = "a_dir";
+ let symlink = "symlink";
+
+ at.mkdir(dir);
+ at.symlink_dir(dir, symlink);
+
+ for arg in ["-P", "--no-dereference"] {
+ ts.ucmd()
+ .arg(arg)
+ .succeeds()
+ .stdout_contains(dir)
+ .stdout_does_not_contain(symlink);
+
+ // ensure no-dereference "wins"
+ ts.ucmd()
+ .arg("--dereference")
+ .arg(arg)
+ .succeeds()
+ .stdout_contains(dir)
+ .stdout_does_not_contain(symlink);
+
+ // ensure dereference "wins"
+ let result = ts.ucmd().arg(arg).arg("--dereference").succeeds();
+
+ #[cfg(target_os = "linux")]
+ {
+ let result_reference = unwrap_or_return!(expected_result(&ts, &[arg, "--dereference"]));
+
+ if result_reference.succeeded() {
+ assert_eq!(result.stdout_str(), result_reference.stdout_str());
+ }
+ }
+
+ #[cfg(not(target_os = "linux"))]
+ result.stdout_contains(symlink).stdout_does_not_contain(dir);
}
}
@@ -329,12 +455,13 @@ fn test_du_inodes_basic() {
fn _du_inodes_basic(s: &str) {
assert_eq!(
s,
- "2\t.\\subdir\\deeper\\deeper_dir
-4\t.\\subdir\\deeper
-3\t.\\subdir\\links
-8\t.\\subdir
-11\t.
-"
+ concat!(
+ "2\t.\\subdir\\deeper\\deeper_dir\n",
+ "4\t.\\subdir\\deeper\n",
+ "3\t.\\subdir\\links\n",
+ "8\t.\\subdir\n",
+ "11\t.\n",
+ )
);
}
@@ -342,12 +469,13 @@ fn _du_inodes_basic(s: &str) {
fn _du_inodes_basic(s: &str) {
assert_eq!(
s,
- "2\t./subdir/deeper/deeper_dir
-4\t./subdir/deeper
-3\t./subdir/links
-8\t./subdir
-11\t.
-"
+ concat!(
+ "2\t./subdir/deeper/deeper_dir\n",
+ "4\t./subdir/deeper\n",
+ "3\t./subdir/links\n",
+ "8\t./subdir\n",
+ "11\t.\n",
+ )
);
}
@@ -377,6 +505,34 @@ fn test_du_inodes() {
}
}
+#[cfg(not(target_os = "android"))]
+#[test]
+fn test_du_inodes_with_count_links() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+
+ at.mkdir("dir");
+ at.touch("dir/file");
+ at.hard_link("dir/file", "dir/hard_link_a");
+ at.hard_link("dir/file", "dir/hard_link_b");
+
+ // ensure the hard links are not counted without --count-links
+ ts.ucmd()
+ .arg("--inodes")
+ .arg("dir")
+ .succeeds()
+ .stdout_is("2\tdir\n");
+
+ for arg in ["-l", "--count-links"] {
+ ts.ucmd()
+ .arg("--inodes")
+ .arg(arg)
+ .arg("dir")
+ .succeeds()
+ .stdout_is("4\tdir\n");
+ }
+}
+
#[test]
fn test_du_h_flag_empty_file() {
new_ucmd!()
@@ -386,12 +542,45 @@ fn test_du_h_flag_empty_file() {
.stdout_only("0\tempty.txt\n");
}
+#[test]
+fn test_du_h_precision() {
+ let test_cases = [
+ (133456345, "128M"),
+ (12 * 1024 * 1024, "12M"),
+ (8500, "8.4K"),
+ ];
+
+ for &(test_len, expected_output) in &test_cases {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let fpath = at.plus("test.txt");
+ std::fs::File::create(&fpath)
+ .expect("cannot create test file")
+ .set_len(test_len)
+ .expect("cannot truncate test len to size");
+ ucmd.arg("-h")
+ .arg("--apparent-size")
+ .arg(&fpath)
+ .succeeds()
+ .stdout_only(format!(
+ "{}\t{}\n",
+ expected_output,
+ &fpath.to_string_lossy()
+ ));
+ }
+}
+
#[cfg(feature = "touch")]
#[test]
fn test_du_time() {
let ts = TestScenario::new(util_name!());
+ // du --time formats the timestamp according to the local timezone. We set the TZ
+ // environment variable to UTC in the commands below to ensure consistent outputs
+ // and test results regardless of the timezone of the machine this test runs in.
+
ts.ccmd("touch")
+ .env("TZ", "UTC")
.arg("-a")
.arg("-t")
.arg("201505150000")
@@ -399,19 +588,37 @@ fn test_du_time() {
.succeeds();
ts.ccmd("touch")
+ .env("TZ", "UTC")
.arg("-m")
.arg("-t")
.arg("201606160000")
.arg("date_test")
.succeeds();
- let result = ts.ucmd().arg("--time").arg("date_test").succeeds();
+ let result = ts
+ .ucmd()
+ .env("TZ", "UTC")
+ .arg("--time")
+ .arg("date_test")
+ .succeeds();
result.stdout_only("0\t2016-06-16 00:00\tdate_test\n");
- let result = ts.ucmd().arg("--time=atime").arg("date_test").succeeds();
- result.stdout_only("0\t2015-05-15 00:00\tdate_test\n");
+ for argument in ["--time=atime", "--time=atim", "--time=a"] {
+ let result = ts
+ .ucmd()
+ .env("TZ", "UTC")
+ .arg(argument)
+ .arg("date_test")
+ .succeeds();
+ result.stdout_only("0\t2015-05-15 00:00\tdate_test\n");
+ }
- let result = ts.ucmd().arg("--time=ctime").arg("date_test").succeeds();
+ let result = ts
+ .ucmd()
+ .env("TZ", "UTC")
+ .arg("--time=ctime")
+ .arg("date_test")
+ .succeeds();
result.stdout_only("0\t2016-06-16 00:00\tdate_test\n");
if birth_supported() {
@@ -511,111 +718,81 @@ fn test_du_threshold() {
let threshold = if cfg!(windows) { "7K" } else { "10K" };
ts.ucmd()
- .arg(format!("--threshold={}", threshold))
+ .arg(format!("--threshold={threshold}"))
.succeeds()
.stdout_contains("links")
.stdout_does_not_contain("deeper_dir");
ts.ucmd()
- .arg(format!("--threshold=-{}", threshold))
+ .arg(format!("--threshold=-{threshold}"))
.succeeds()
.stdout_does_not_contain("links")
.stdout_contains("deeper_dir");
}
#[test]
-fn test_du_apparent_size() {
+fn test_du_invalid_threshold() {
let ts = TestScenario::new(util_name!());
- let result = ts.ucmd().arg("--apparent-size").succeeds();
- #[cfg(any(target_os = "linux", target_os = "android"))]
- {
- let result_reference = unwrap_or_return!(expected_result(&ts, &["--apparent-size"]));
- assert_eq!(result.stdout_str(), result_reference.stdout_str());
- }
+ let threshold = "-0";
- #[cfg(not(any(target_os = "linux", target_os = "android")))]
- _du_apparent_size(result.stdout_str());
+ ts.ucmd().arg(format!("--threshold={threshold}")).fails();
}
-#[cfg(target_os = "windows")]
-fn _du_apparent_size(s: &str) {
- assert_eq!(
- s,
- "1\t.\\subdir\\deeper\\deeper_dir
-1\t.\\subdir\\deeper
-6\t.\\subdir\\links
-6\t.\\subdir
-6\t.
-"
- );
-}
-#[cfg(target_vendor = "apple")]
-fn _du_apparent_size(s: &str) {
- assert_eq!(
- s,
- "1\t./subdir/deeper/deeper_dir
-1\t./subdir/deeper
-6\t./subdir/links
-6\t./subdir
-6\t.
-"
- );
-}
-#[cfg(target_os = "freebsd")]
-fn _du_apparent_size(s: &str) {
- assert_eq!(
- s,
- "1\t./subdir/deeper/deeper_dir
-2\t./subdir/deeper
-6\t./subdir/links
-8\t./subdir
-8\t.
-"
- );
-}
-#[cfg(all(
- not(target_vendor = "apple"),
- not(target_os = "windows"),
- not(target_os = "freebsd")
-))]
-fn _du_apparent_size(s: &str) {
- assert_eq!(
- s,
- "5\t./subdir/deeper/deeper_dir
-9\t./subdir/deeper
-10\t./subdir/links
-22\t./subdir
-26\t.
-"
- );
+#[test]
+fn test_du_apparent_size() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ at.mkdir_all("a/b");
+
+ at.write("a/b/file1", "foo");
+ at.write("a/b/file2", "foobar");
+
+ let result = ucmd.args(&["--apparent-size", "--all", "a"]).succeeds();
+
+ #[cfg(not(target_os = "windows"))]
+ {
+ result.stdout_contains_line("1\ta/b/file2");
+ result.stdout_contains_line("1\ta/b/file1");
+ result.stdout_contains_line("1\ta/b");
+ result.stdout_contains_line("1\ta");
+ }
+
+ #[cfg(target_os = "windows")]
+ {
+ result.stdout_contains_line("1\ta\\b\\file2");
+ result.stdout_contains_line("1\ta\\b\\file1");
+ result.stdout_contains_line("1\ta\\b");
+ result.stdout_contains_line("1\ta");
+ }
}
#[test]
fn test_du_bytes() {
- let ts = TestScenario::new(util_name!());
- let result = ts.ucmd().arg("--bytes").succeeds();
+ let (at, mut ucmd) = at_and_ucmd!();
- #[cfg(any(target_os = "linux", target_os = "android"))]
+ at.mkdir_all("a/b");
+
+ at.write("a/b/file1", "foo");
+ at.write("a/b/file2", "foobar");
+
+ let result = ucmd.args(&["--bytes", "--all", "a"]).succeeds();
+
+ #[cfg(not(target_os = "windows"))]
{
- let result_reference = unwrap_or_return!(expected_result(&ts, &["--bytes"]));
- assert_eq!(result.stdout_str(), result_reference.stdout_str());
+ result.stdout_contains_line("6\ta/b/file2");
+ result.stdout_contains_line("3\ta/b/file1");
+ result.stdout_contains_line("9\ta/b");
+ result.stdout_contains_line("9\ta");
}
#[cfg(target_os = "windows")]
- result.stdout_contains("5145\t.\\subdir\n");
- #[cfg(target_vendor = "apple")]
- result.stdout_contains("5625\t./subdir\n");
- #[cfg(target_os = "freebsd")]
- result.stdout_contains("7193\t./subdir\n");
- #[cfg(all(
- not(target_vendor = "apple"),
- not(target_os = "windows"),
- not(target_os = "freebsd"),
- not(target_os = "linux"),
- not(target_os = "android"),
- ))]
- result.stdout_contains("21529\t./subdir\n");
+ {
+ result.stdout_contains_line("6\ta\\b\\file2");
+ result.stdout_contains_line("3\ta\\b\\file1");
+ result.stdout_contains_line("9\ta\\b");
+ result.stdout_contains_line("9\ta");
+ }
}
#[test]
@@ -703,10 +880,8 @@ fn test_du_exclude_mix() {
let ts = TestScenario::new(util_name!());
let at = &ts.fixtures;
- let mut file1 = at.make_file("file-ignore1");
- file1.write_all(b"azeaze").unwrap();
- let mut file2 = at.make_file("file-ignore2");
- file2.write_all(b"amaz?ng").unwrap();
+ at.write("file-ignore1", "azeaze");
+ at.write("file-ignore2", "amaz?ng");
at.mkdir_all("azerty/xcwww/azeaze");
at.mkdir_all("azerty/xcwww/qzerty");
@@ -819,3 +994,164 @@ fn test_du_exclude_invalid_syntax() {
.fails()
.stderr_contains("du: Invalid exclude syntax");
}
+
+#[cfg(not(windows))]
+#[test]
+fn test_du_symlink_fail() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+
+ at.symlink_file("non-existing.txt", "target.txt");
+
+ ts.ucmd().arg("-L").arg("target.txt").fails().code_is(1);
+}
+
+#[cfg(not(windows))]
+#[test]
+fn test_du_symlink_multiple_fail() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+
+ at.symlink_file("non-existing.txt", "target.txt");
+ at.write("file1", "azeaze");
+
+ let result = ts.ucmd().arg("-L").arg("target.txt").arg("file1").fails();
+ assert_eq!(result.code(), 1);
+ result.stdout_contains("4\tfile1\n");
+}
+
+#[test]
+// Disable on Windows because of different path separators and handling of null characters
+#[cfg(not(target_os = "windows"))]
+fn test_du_files0_from() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+
+ at.write("testfile1", "content1");
+ at.write("testfile2", "content2");
+
+ at.mkdir("testdir");
+ at.write("testdir/testfile3", "content3");
+
+ at.write("filelist", "testfile1\0testfile2\0testdir\0");
+
+ ts.ucmd()
+ .arg("--files0-from=filelist")
+ .succeeds()
+ .stdout_contains("testfile1")
+ .stdout_contains("testfile2")
+ .stdout_contains("testdir");
+}
+
+#[test]
+fn test_du_files0_from_ignore_duplicate_file_names() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ let file = "testfile";
+
+ at.touch(file);
+ at.write("filelist", &format!("{file}\0{file}\0"));
+
+ ts.ucmd()
+ .arg("--files0-from=filelist")
+ .succeeds()
+ .stdout_is(format!("0\t{file}\n"));
+}
+
+#[test]
+fn test_du_files0_from_with_invalid_zero_length_file_names() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+
+ at.touch("testfile");
+
+ at.write("filelist", "\0testfile\0\0");
+
+ ts.ucmd()
+ .arg("--files0-from=filelist")
+ .fails()
+ .code_is(1)
+ .stdout_contains("testfile")
+ .stderr_contains("filelist:1: invalid zero-length file name")
+ .stderr_contains("filelist:3: invalid zero-length file name");
+}
+
+#[test]
+fn test_du_files0_from_stdin() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+
+ at.write("testfile1", "content1");
+ at.write("testfile2", "content2");
+
+ let input = "testfile1\0testfile2\0";
+
+ ts.ucmd()
+ .arg("--files0-from=-")
+ .pipe_in(input)
+ .succeeds()
+ .stdout_contains("testfile1")
+ .stdout_contains("testfile2");
+}
+
+#[test]
+fn test_du_files0_from_stdin_ignore_duplicate_file_names() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ let file = "testfile";
+
+ at.touch(file);
+
+ let input = format!("{file}\0{file}");
+
+ ts.ucmd()
+ .arg("--files0-from=-")
+ .pipe_in(input)
+ .succeeds()
+ .stdout_is(format!("0\t{file}\n"));
+}
+
+#[test]
+fn test_du_files0_from_stdin_with_invalid_zero_length_file_names() {
+ new_ucmd!()
+ .arg("--files0-from=-")
+ .pipe_in("\0\0")
+ .fails()
+ .code_is(1)
+ .stderr_contains("-:1: invalid zero-length file name")
+ .stderr_contains("-:2: invalid zero-length file name");
+}
+
+#[test]
+fn test_du_files0_from_dir() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+
+ at.mkdir("dir");
+
+ let result = ts.ucmd().arg("--files0-from=dir").fails();
+ assert_eq!(result.stderr_str(), "du: dir: read error: Is a directory\n");
+}
+
+#[test]
+fn test_du_files0_from_combined() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+
+ at.mkdir("dir");
+
+ let result = ts.ucmd().arg("--files0-from=-").arg("foo").fails();
+ let stderr = result.stderr_str();
+
+ assert!(stderr.contains("file operands cannot be combined with --files0-from"));
+}
+
+#[test]
+fn test_invalid_time_style() {
+ let ts = TestScenario::new(util_name!());
+ ts.ucmd()
+ .arg("-s")
+ .arg("--time-style=banana")
+ .succeeds()
+ .stdout_does_not_contain("du: invalid argument 'banana' for 'time style'");
+}
diff --git a/tests/by-util/test_echo.rs b/tests/by-util/test_echo.rs
index 401e16706bdd83eeea30315b44e2461c961741ef..4ae623f2f6fd9286f05f56175743d403b73a9d53 100644
--- a/tests/by-util/test_echo.rs
+++ b/tests/by-util/test_echo.rs
@@ -1,6 +1,10 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (words) araba merci
-use crate::common::util::*;
+use crate::common::util::TestScenario;
#[test]
fn test_default() {
@@ -113,12 +117,25 @@ fn test_escape_newline() {
.stdout_only("\na\n");
}
+#[test]
+fn test_escape_override() {
+ new_ucmd!()
+ .args(&["-e", "-E", "\\na"])
+ .succeeds()
+ .stdout_only("\\na\n");
+
+ new_ucmd!()
+ .args(&["-E", "-e", "\\na"])
+ .succeeds()
+ .stdout_only("\na\n");
+}
+
#[test]
fn test_escape_no_further_output() {
new_ucmd!()
.args(&["-e", "a\\cb", "c"])
.succeeds()
- .stdout_only("a\n");
+ .stdout_only("a");
}
#[test]
@@ -176,7 +193,7 @@ fn test_disable_escapes() {
.arg("-E")
.arg(input_str)
.succeeds()
- .stdout_only(format!("{}\n", input_str));
+ .stdout_only(format!("{input_str}\n"));
}
#[test]
@@ -232,3 +249,57 @@ fn test_hyphen_values_between() {
.success()
.stdout_is("dumdum dum dum dum -e dum\n");
}
+
+#[test]
+fn wrapping_octal() {
+ // Some odd behavior of GNU. Values of \0400 and greater do not fit in the
+ // u8 that we write to stdout. So we test that it wraps:
+ //
+ // We give it this input:
+ // \o501 = 1_0100_0001 (yes, **9** bits)
+ // This should be wrapped into:
+ // \o101 = 'A' = 0100_0001,
+ // because we only write a single character
+ new_ucmd!()
+ .arg("-e")
+ .arg("\\0501")
+ .succeeds()
+ .stdout_is("A\n");
+}
+
+#[test]
+fn old_octal_syntax() {
+ new_ucmd!()
+ .arg("-e")
+ .arg("\\1foo")
+ .succeeds()
+ .stdout_is("\x01foo\n");
+
+ new_ucmd!()
+ .arg("-e")
+ .arg("\\43foo")
+ .succeeds()
+ .stdout_is("#foo\n");
+
+ new_ucmd!()
+ .arg("-e")
+ .arg("\\101 foo")
+ .succeeds()
+ .stdout_is("A foo\n");
+
+ new_ucmd!()
+ .arg("-e")
+ .arg("\\1011")
+ .succeeds()
+ .stdout_is("A1\n");
+}
+
+#[test]
+fn partial_version_argument() {
+ new_ucmd!().arg("--ver").succeeds().stdout_is("--ver\n");
+}
+
+#[test]
+fn partial_help_argument() {
+ new_ucmd!().arg("--he").succeeds().stdout_is("--he\n");
+}
diff --git a/tests/by-util/test_env.rs b/tests/by-util/test_env.rs
index 9b64525486e1b85ed14cdaeb2489b499e4f3c826..f8c5c66d12673c35c6ffbe4c54f06db545dbd554 100644
--- a/tests/by-util/test_env.rs
+++ b/tests/by-util/test_env.rs
@@ -1,10 +1,59 @@
-// spell-checker:ignore (words) bamf chdir rlimit prlimit COMSPEC
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore (words) bamf chdir rlimit prlimit COMSPEC cout cerr FFFD
-use crate::common::util::*;
+use crate::common::util::TestScenario;
+#[cfg(unix)]
+use crate::common::util::UChild;
+#[cfg(unix)]
+use nix::sys::signal::Signal;
+use regex::Regex;
use std::env;
use std::path::Path;
+#[cfg(unix)]
+use std::process::Command;
use tempfile::tempdir;
+#[cfg(unix)]
+struct Target {
+ child: UChild,
+}
+#[cfg(unix)]
+impl Target {
+ fn new(signals: &[&str]) -> Self {
+ let mut child = new_ucmd!()
+ .args(&[
+ format!("--ignore-signal={}", signals.join(",")).as_str(),
+ "sleep",
+ "1000",
+ ])
+ .run_no_wait();
+ child.delay(500);
+ Self { child }
+ }
+ fn send_signal(&mut self, signal: Signal) {
+ Command::new("kill")
+ .args(&[
+ format!("-{}", signal as i32),
+ format!("{}", self.child.id()),
+ ])
+ .spawn()
+ .expect("failed to send signal");
+ self.child.delay(100);
+ }
+ fn is_alive(&mut self) -> bool {
+ self.child.is_alive()
+ }
+}
+#[cfg(unix)]
+impl Drop for Target {
+ fn drop(&mut self) {
+ self.child.kill();
+ }
+}
+
#[test]
fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(125);
@@ -30,11 +79,117 @@ fn test_env_version() {
#[test]
fn test_echo() {
- let result = new_ucmd!().arg("echo").arg("FOO-bar").succeeds();
+ #[cfg(target_os = "windows")]
+ let args = ["cmd", "/d/c", "echo"];
+ #[cfg(not(target_os = "windows"))]
+ let args = ["echo"];
+
+ let result = new_ucmd!().args(&args).arg("FOO-bar").succeeds();
assert_eq!(result.stdout_str().trim(), "FOO-bar");
}
+#[cfg(target_os = "windows")]
+#[test]
+fn test_if_windows_batch_files_can_be_executed() {
+ let result = new_ucmd!().arg("./runBat.bat").succeeds();
+
+ assert!(result.stdout_str().contains("Hello Windows World!"));
+}
+
+#[test]
+fn test_debug_1() {
+ let ts = TestScenario::new(util_name!());
+ let result = ts
+ .ucmd()
+ .arg("-v")
+ .arg(&ts.bin_path)
+ .args(&["echo", "hello"])
+ .succeeds();
+ result.stderr_matches(
+ &Regex::new(concat!(
+ r"executing: [^\n]+(\/|\\)coreutils(\.exe)?\n",
+ r" arg\[0\]= '[^\n]+(\/|\\)coreutils(\.exe)?'\n",
+ r" arg\[1\]= 'echo'\n",
+ r" arg\[2\]= 'hello'"
+ ))
+ .unwrap(),
+ );
+}
+
+#[test]
+fn test_debug_2() {
+ let ts = TestScenario::new(util_name!());
+ let result = ts
+ .ucmd()
+ .arg("-vv")
+ .arg(ts.bin_path)
+ .args(&["echo", "hello2"])
+ .succeeds();
+ result.stderr_matches(
+ &Regex::new(concat!(
+ r"input args:\n",
+ r"arg\[0\]: 'env'\n",
+ r"arg\[1\]: '-vv'\n",
+ r"arg\[2\]: '[^\n]+(\/|\\)coreutils(.exe)?'\n",
+ r"arg\[3\]: 'echo'\n",
+ r"arg\[4\]: 'hello2'\n",
+ r"executing: [^\n]+(\/|\\)coreutils(.exe)?\n",
+ r" arg\[0\]= '[^\n]+(\/|\\)coreutils(.exe)?'\n",
+ r" arg\[1\]= 'echo'\n",
+ r" arg\[2\]= 'hello2'"
+ ))
+ .unwrap(),
+ );
+}
+
+#[test]
+fn test_debug1_part_of_string_arg() {
+ let ts = TestScenario::new(util_name!());
+
+ let result = ts
+ .ucmd()
+ .arg("-vS FOO=BAR")
+ .arg(ts.bin_path)
+ .args(&["echo", "hello1"])
+ .succeeds();
+ result.stderr_matches(
+ &Regex::new(concat!(
+ r"executing: [^\n]+(\/|\\)coreutils(\.exe)?\n",
+ r" arg\[0\]= '[^\n]+(\/|\\)coreutils(\.exe)?'\n",
+ r" arg\[1\]= 'echo'\n",
+ r" arg\[2\]= 'hello1'"
+ ))
+ .unwrap(),
+ );
+}
+
+#[test]
+fn test_debug2_part_of_string_arg() {
+ let ts = TestScenario::new(util_name!());
+ let result = ts
+ .ucmd()
+ .arg("-vvS FOO=BAR")
+ .arg(ts.bin_path)
+ .args(&["echo", "hello2"])
+ .succeeds();
+ result.stderr_matches(
+ &Regex::new(concat!(
+ r"input args:\n",
+ r"arg\[0\]: 'env'\n",
+ r"arg\[1\]: '-vvS FOO=BAR'\n",
+ r"arg\[2\]: '[^\n]+(\/|\\)coreutils(.exe)?'\n",
+ r"arg\[3\]: 'echo'\n",
+ r"arg\[4\]: 'hello2'\n",
+ r"executing: [^\n]+(\/|\\)coreutils(.exe)?\n",
+ r" arg\[0\]= '[^\n]+(\/|\\)coreutils(.exe)?'\n",
+ r" arg\[1\]= 'echo'\n",
+ r" arg\[2\]= 'hello2'"
+ ))
+ .unwrap(),
+ );
+}
+
#[test]
fn test_file_option() {
let out = new_ucmd!()
@@ -90,7 +245,7 @@ fn test_unset_invalid_variables() {
// with this error: Error { kind: InvalidInput, message: "nul byte found in provided data" }
for var in ["", "a=b"] {
new_ucmd!().arg("-u").arg(var).run().stderr_only(format!(
- "env: cannot unset {}: Invalid argument",
+ "env: cannot unset {}: Invalid argument\n",
var.quote()
));
}
@@ -130,7 +285,7 @@ fn test_empty_name() {
.arg("-i")
.arg("=xyz")
.run()
- .stderr_only("env: warning: no name specified for value 'xyz'");
+ .stderr_only("env: warning: no name specified for value 'xyz'\n");
}
#[test]
@@ -153,10 +308,9 @@ fn test_null_delimiter() {
#[test]
fn test_unset_variable() {
- // This test depends on the HOME variable being pre-defined by the
- // default shell
let out = TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
+ .env("HOME", "FOO")
.arg("-u")
.arg("HOME")
.succeeds()
@@ -242,3 +396,1112 @@ fn test_fail_change_directory() {
.stderr_move_str();
assert!(out.contains("env: cannot change directory to "));
}
+
+#[cfg(not(target_os = "windows"))] // windows has no executable "echo", its only supported as part of a batch-file
+#[test]
+fn test_split_string_into_args_one_argument_no_quotes() {
+ let scene = TestScenario::new(util_name!());
+
+ let out = scene
+ .ucmd()
+ .arg("-S echo hello world")
+ .succeeds()
+ .stdout_move_str();
+ assert_eq!(out, "hello world\n");
+}
+
+#[cfg(not(target_os = "windows"))] // windows has no executable "echo", its only supported as part of a batch-file
+#[test]
+fn test_split_string_into_args_one_argument() {
+ let scene = TestScenario::new(util_name!());
+
+ let out = scene
+ .ucmd()
+ .arg("-S echo \"hello world\"")
+ .succeeds()
+ .stdout_move_str();
+ assert_eq!(out, "hello world\n");
+}
+
+#[cfg(not(target_os = "windows"))] // windows has no executable "echo", its only supported as part of a batch-file
+#[test]
+fn test_split_string_into_args_s_escaping_challenge() {
+ let scene = TestScenario::new(util_name!());
+
+ let out = scene
+ .ucmd()
+ .args(&[r#"-S echo "hello \"great\" world""#])
+ .succeeds()
+ .stdout_move_str();
+ assert_eq!(out, "hello \"great\" world\n");
+}
+
+#[test]
+fn test_split_string_into_args_s_escaped_c_not_allowed() {
+ let scene = TestScenario::new(util_name!());
+
+ let out = scene.ucmd().args(&[r#"-S"\c""#]).fails().stderr_move_str();
+ assert_eq!(
+ out,
+ "env: '\\c' must not appear in double-quoted -S string\n"
+ );
+}
+
+#[cfg(not(target_os = "windows"))] // no printf available
+#[test]
+fn test_split_string_into_args_s_whitespace_handling() {
+ let scene = TestScenario::new(util_name!());
+
+ let out = scene
+ .ucmd()
+ .args(&["-Sprintf x%sx\\n A \t B \x0B\x0C\r\n"])
+ .succeeds()
+ .stdout_move_str();
+ assert_eq!(out, "xAx\nxBx\n");
+}
+
+#[cfg(not(target_os = "windows"))] // no printf available
+#[test]
+fn test_split_string_into_args_long_option_whitespace_handling() {
+ let scene = TestScenario::new(util_name!());
+
+ let out = scene
+ .ucmd()
+ .args(&["--split-string printf x%sx\\n A \t B \x0B\x0C\r\n"])
+ .succeeds()
+ .stdout_move_str();
+ assert_eq!(out, "xAx\nxBx\n");
+}
+
+#[cfg(not(target_os = "windows"))] // no printf available
+#[test]
+fn test_split_string_into_args_debug_output_whitespace_handling() {
+ let scene = TestScenario::new(util_name!());
+
+ let out = scene
+ .ucmd()
+ .args(&["-vvS printf x%sx\\n A \t B \x0B\x0C\r\n"])
+ .succeeds();
+ assert_eq!(out.stdout_str(), "xAx\nxBx\n");
+ assert_eq!(
+ out.stderr_str(),
+ "input args:\narg[0]: 'env'\narg[1]: $\
+ '-vvS printf x%sx\\\\n A \\t B \\x0B\\x0C\\r\\n'\nexecuting: printf\
+ \n arg[0]= 'printf'\n arg[1]= $'x%sx\\n'\n arg[2]= 'A'\n arg[3]= 'B'\n"
+ );
+}
+
+// FixMe: This test fails on MACOS:
+// thread 'test_env::test_gnu_e20' panicked at 'assertion failed: `(left == right)`
+// left: `"A=B C=D\n__CF_USER_TEXT_ENCODING=0x1F5:0x0:0x0\n"`,
+// right: `"A=B C=D\n"`', tests/by-util/test_env.rs:369:5
+#[cfg(not(target_os = "macos"))]
+#[test]
+fn test_gnu_e20() {
+ let scene = TestScenario::new(util_name!());
+
+ let env_bin = String::from(crate::common::util::TESTS_BINARY) + " " + util_name!();
+
+ let (input, output) = (
+ [
+ String::from("-i"),
+ String::from(r#"-SA="B\_C=D" "#) + env_bin.escape_default().to_string().as_str() + "",
+ ],
+ "A=B C=D\n",
+ );
+
+ let out = scene.ucmd().args(&input).succeeds();
+ assert_eq!(out.stdout_str(), output);
+}
+
+#[test]
+#[allow(clippy::cognitive_complexity)] // Ignore clippy lint of too long function sign
+fn test_env_parsing_errors() {
+ let ts = TestScenario::new(util_name!());
+
+ ts.ucmd()
+ .arg("-S\\|echo hallo") // no quotes, invalid escape sequence |
+ .fails()
+ .code_is(125)
+ .no_stdout()
+ .stderr_is("env: invalid sequence '\\|' in -S\n");
+
+ ts.ucmd()
+ .arg("-S\\a") // no quotes, invalid escape sequence a
+ .fails()
+ .code_is(125)
+ .no_stdout()
+ .stderr_is("env: invalid sequence '\\a' in -S\n");
+
+ ts.ucmd()
+ .arg("-S\"\\a\"") // double quotes, invalid escape sequence a
+ .fails()
+ .code_is(125)
+ .no_stdout()
+ .stderr_is("env: invalid sequence '\\a' in -S\n");
+
+ ts.ucmd()
+ .arg(r#"-S"\a""#) // same as before, just using r#""#
+ .fails()
+ .code_is(125)
+ .no_stdout()
+ .stderr_is("env: invalid sequence '\\a' in -S\n");
+
+ ts.ucmd()
+ .arg("-S'\\a'") // single quotes, invalid escape sequence a
+ .fails()
+ .code_is(125)
+ .no_stdout()
+ .stderr_is("env: invalid sequence '\\a' in -S\n");
+
+ ts.ucmd()
+ .arg(r#"-S\|\&\;"#) // no quotes, invalid escape sequence |
+ .fails()
+ .code_is(125)
+ .no_stdout()
+ .stderr_is("env: invalid sequence '\\|' in -S\n");
+
+ ts.ucmd()
+ .arg(r#"-S\<\&\;"#) // no quotes, invalid escape sequence <
+ .fails()
+ .code_is(125)
+ .no_stdout()
+ .stderr_is("env: invalid sequence '\\<' in -S\n");
+
+ ts.ucmd()
+ .arg(r#"-S\>\&\;"#) // no quotes, invalid escape sequence >
+ .fails()
+ .code_is(125)
+ .no_stdout()
+ .stderr_is("env: invalid sequence '\\>' in -S\n");
+
+ ts.ucmd()
+ .arg(r#"-S\`\&\;"#) // no quotes, invalid escape sequence `
+ .fails()
+ .code_is(125)
+ .no_stdout()
+ .stderr_is("env: invalid sequence '\\`' in -S\n");
+
+ ts.ucmd()
+ .arg(r#"-S"\`\&\;""#) // double quotes, invalid escape sequence `
+ .fails()
+ .code_is(125)
+ .no_stdout()
+ .stderr_is("env: invalid sequence '\\`' in -S\n");
+
+ ts.ucmd()
+ .arg(r#"-S'\`\&\;'"#) // single quotes, invalid escape sequence `
+ .fails()
+ .code_is(125)
+ .no_stdout()
+ .stderr_is("env: invalid sequence '\\`' in -S\n");
+
+ ts.ucmd()
+ .arg(r#"-S\`"#) // ` escaped without quotes
+ .fails()
+ .code_is(125)
+ .no_stdout()
+ .stderr_is("env: invalid sequence '\\`' in -S\n");
+
+ ts.ucmd()
+ .arg(r#"-S"\`""#) // ` escaped in double quotes
+ .fails()
+ .code_is(125)
+ .no_stdout()
+ .stderr_is("env: invalid sequence '\\`' in -S\n");
+
+ ts.ucmd()
+ .arg(r#"-S'\`'"#) // ` escaped in single quotes
+ .fails()
+ .code_is(125)
+ .no_stdout()
+ .stderr_is("env: invalid sequence '\\`' in -S\n");
+
+ ts.ucmd()
+ .args(&[r#"-S\🦉"#]) // ` escaped in single quotes
+ .fails()
+ .code_is(125)
+ .no_stdout()
+ .stderr_is("env: invalid sequence '\\\u{FFFD}' in -S\n"); // gnu doesn't show the owl. Instead a invalid unicode ?
+}
+
+#[test]
+fn test_env_with_empty_executable_single_quotes() {
+ let ts = TestScenario::new(util_name!());
+
+ ts.ucmd()
+ .args(&["-S''"]) // empty single quotes, considered as program name
+ .fails()
+ .code_is(127)
+ .no_stdout()
+ .stderr_is("env: '': No such file or directory\n"); // gnu version again adds escaping here
+}
+
+#[test]
+fn test_env_with_empty_executable_double_quotes() {
+ let ts = TestScenario::new(util_name!());
+
+ ts.ucmd()
+ .args(&["-S\"\""]) // empty double quotes, considered as program name
+ .fails()
+ .code_is(127)
+ .no_stdout()
+ .stderr_is("env: '': No such file or directory\n");
+}
+
+#[test]
+#[cfg(unix)]
+fn test_env_overwrite_arg0() {
+ let ts = TestScenario::new(util_name!());
+
+ let bin = ts.bin_path.clone();
+
+ ts.ucmd()
+ .args(&["--argv0", "echo"])
+ .arg(&bin)
+ .args(&["-n", "hello", "world!"])
+ .succeeds()
+ .stdout_is("hello world!")
+ .stderr_is("");
+
+ ts.ucmd()
+ .args(&["-a", "dirname"])
+ .arg(bin)
+ .args(&["aa/bb/cc"])
+ .succeeds()
+ .stdout_is("aa/bb\n")
+ .stderr_is("");
+}
+
+#[test]
+#[cfg(unix)]
+fn test_env_arg_argv0_overwrite() {
+ let ts = TestScenario::new(util_name!());
+
+ let bin = &ts.bin_path;
+
+ // overwrite --argv0 by --argv0
+ ts.ucmd()
+ .args(&["--argv0", "dirname"])
+ .args(&["--argv0", "echo"])
+ .arg(bin)
+ .args(&["aa/bb/cc"])
+ .succeeds()
+ .stdout_is("aa/bb/cc\n")
+ .stderr_is("");
+
+ // overwrite -a by -a
+ ts.ucmd()
+ .args(&["-a", "dirname"])
+ .args(&["-a", "echo"])
+ .arg(bin)
+ .args(&["aa/bb/cc"])
+ .succeeds()
+ .stdout_is("aa/bb/cc\n")
+ .stderr_is("");
+
+ // overwrite --argv0 by -a
+ ts.ucmd()
+ .args(&["--argv0", "dirname"])
+ .args(&["-a", "echo"])
+ .arg(bin)
+ .args(&["aa/bb/cc"])
+ .succeeds()
+ .stdout_is("aa/bb/cc\n")
+ .stderr_is("");
+
+ // overwrite -a by --argv0
+ ts.ucmd()
+ .args(&["-a", "dirname"])
+ .args(&["--argv0", "echo"])
+ .arg(bin)
+ .args(&["aa/bb/cc"])
+ .succeeds()
+ .stdout_is("aa/bb/cc\n")
+ .stderr_is("");
+}
+
+#[test]
+#[cfg(unix)]
+fn test_env_arg_argv0_overwrite_mixed_with_string_args() {
+ let ts = TestScenario::new(util_name!());
+
+ let bin = &ts.bin_path;
+
+ // string arg following normal
+ ts.ucmd()
+ .args(&["-S--argv0 dirname"])
+ .args(&["--argv0", "echo"])
+ .arg(bin)
+ .args(&["aa/bb/cc"])
+ .succeeds()
+ .stdout_is("aa/bb/cc\n")
+ .stderr_is("");
+
+ // normal following string arg
+ ts.ucmd()
+ .args(&["-a", "dirname"])
+ .args(&["-S-a echo"])
+ .arg(bin)
+ .args(&["aa/bb/cc"])
+ .succeeds()
+ .stdout_is("aa/bb/cc\n")
+ .stderr_is("");
+
+ // one large string arg
+ ts.ucmd()
+ .args(&["-S--argv0 dirname -a echo"])
+ .arg(bin)
+ .args(&["aa/bb/cc"])
+ .succeeds()
+ .stdout_is("aa/bb/cc\n")
+ .stderr_is("");
+
+ // two string args
+ ts.ucmd()
+ .args(&["-S-a dirname"])
+ .args(&["-S--argv0 echo"])
+ .arg(bin)
+ .args(&["aa/bb/cc"])
+ .succeeds()
+ .stdout_is("aa/bb/cc\n")
+ .stderr_is("");
+
+ // three args: normal, string, normal
+ ts.ucmd()
+ .args(&["-a", "sleep"])
+ .args(&["-S-a dirname"])
+ .args(&["-a", "echo"])
+ .arg(bin)
+ .args(&["aa/bb/cc"])
+ .succeeds()
+ .stdout_is("aa/bb/cc\n")
+ .stderr_is("");
+}
+
+#[test]
+#[cfg(unix)]
+fn test_env_arg_ignore_signal_invalid_signals() {
+ let ts = TestScenario::new(util_name!());
+ ts.ucmd()
+ .args(&["--ignore-signal=banana"])
+ .fails()
+ .code_is(125)
+ .stderr_contains("env: 'banana': invalid signal");
+ ts.ucmd()
+ .args(&["--ignore-signal=SIGbanana"])
+ .fails()
+ .code_is(125)
+ .stderr_contains("env: 'SIGbanana': invalid signal");
+ ts.ucmd()
+ .args(&["--ignore-signal=exit"])
+ .fails()
+ .code_is(125)
+ .stderr_contains("env: 'exit': invalid signal");
+ ts.ucmd()
+ .args(&["--ignore-signal=SIGexit"])
+ .fails()
+ .code_is(125)
+ .stderr_contains("env: 'SIGexit': invalid signal");
+}
+
+#[test]
+#[cfg(unix)]
+fn test_env_arg_ignore_signal_special_signals() {
+ let ts = TestScenario::new(util_name!());
+ let signal_stop = nix::sys::signal::SIGSTOP;
+ let signal_kill = nix::sys::signal::SIGKILL;
+ ts.ucmd()
+ .args(&["--ignore-signal=stop", "echo", "hello"])
+ .fails()
+ .code_is(125)
+ .stderr_contains(format!(
+ "env: failed to set signal action for signal {}: Invalid argument",
+ signal_stop as i32
+ ));
+ ts.ucmd()
+ .args(&["--ignore-signal=kill", "echo", "hello"])
+ .fails()
+ .code_is(125)
+ .stderr_contains(format!(
+ "env: failed to set signal action for signal {}: Invalid argument",
+ signal_kill as i32
+ ));
+ ts.ucmd()
+ .args(&["--ignore-signal=SToP", "echo", "hello"])
+ .fails()
+ .code_is(125)
+ .stderr_contains(format!(
+ "env: failed to set signal action for signal {}: Invalid argument",
+ signal_stop as i32
+ ));
+ ts.ucmd()
+ .args(&["--ignore-signal=SIGKILL", "echo", "hello"])
+ .fails()
+ .code_is(125)
+ .stderr_contains(format!(
+ "env: failed to set signal action for signal {}: Invalid argument",
+ signal_kill as i32
+ ));
+}
+
+#[test]
+#[cfg(unix)]
+fn test_env_arg_ignore_signal_valid_signals() {
+ {
+ let mut target = Target::new(&["int"]);
+ target.send_signal(Signal::SIGINT);
+ assert!(target.is_alive());
+ }
+ {
+ let mut target = Target::new(&["usr2"]);
+ target.send_signal(Signal::SIGUSR2);
+ assert!(target.is_alive());
+ }
+ {
+ let mut target = Target::new(&["int", "usr2"]);
+ target.send_signal(Signal::SIGUSR1);
+ assert!(!target.is_alive());
+ }
+}
+
+#[test]
+#[cfg(unix)]
+fn test_env_arg_ignore_signal_empty() {
+ let ts = TestScenario::new(util_name!());
+ ts.ucmd()
+ .args(&["--ignore-signal=", "echo", "hello"])
+ .succeeds()
+ .no_stderr()
+ .stdout_contains("hello");
+}
+#[cfg(test)]
+mod tests_split_iterator {
+
+ enum EscapeStyle {
+ /// No escaping.
+ None,
+ /// Wrap in single quotes.
+ SingleQuoted,
+ /// Single quotes combined with backslash.
+ Mixed,
+ }
+
+ /// Determines escaping style to use.
+ fn escape_style(s: &str) -> EscapeStyle {
+ if s.is_empty() {
+ return EscapeStyle::SingleQuoted;
+ }
+
+ let mut special = false;
+ let mut newline = false;
+ let mut single_quote = false;
+
+ for c in s.chars() {
+ match c {
+ '\n' => {
+ newline = true;
+ special = true;
+ }
+ '\'' => {
+ single_quote = true;
+ special = true;
+ }
+ '|' | '&' | ';' | '<' | '>' | '(' | ')' | '$' | '`' | '\\' | '"' | ' ' | '\t'
+ | '*' | '?' | '[' | '#' | '˜' | '=' | '%' => {
+ special = true;
+ }
+ _ => continue,
+ }
+ }
+
+ if !special {
+ EscapeStyle::None
+ } else if newline && !single_quote {
+ EscapeStyle::SingleQuoted
+ } else {
+ EscapeStyle::Mixed
+ }
+ }
+
+ /// Escapes special characters in a string, so that it will retain its literal
+ /// meaning when used as a part of command in Unix shell.
+ ///
+ /// It tries to avoid introducing any unnecessary quotes or escape characters,
+ /// but specifics regarding quoting style are left unspecified.
+ pub fn quote(s: &str) -> std::borrow::Cow<str> {
+ // We are going somewhat out of the way to provide
+ // minimal amount of quoting in typical cases.
+ match escape_style(s) {
+ EscapeStyle::None => s.into(),
+ EscapeStyle::SingleQuoted => format!("'{}'", s).into(),
+ EscapeStyle::Mixed => {
+ let mut quoted = String::new();
+ quoted.push('\'');
+ for c in s.chars() {
+ if c == '\'' {
+ quoted.push_str("'\\''");
+ } else {
+ quoted.push(c);
+ }
+ }
+ quoted.push('\'');
+ quoted.into()
+ }
+ }
+ }
+
+ /// Joins arguments into a single command line suitable for execution in Unix
+ /// shell.
+ ///
+ /// Each argument is quoted using [`quote`] to preserve its literal meaning when
+ /// parsed by Unix shell.
+ ///
+ /// Note: This function is essentially an inverse of [`split`].
+ ///
+ /// # Examples
+ ///
+ /// Logging executed commands in format that can be easily copied and pasted
+ /// into an actual shell:
+ ///
+ /// ```rust,no_run
+ /// fn execute(args: &[&str]) {
+ /// use std::process::Command;
+ /// println!("Executing: {}", shell_words::join(args));
+ /// Command::new(&args[0])
+ /// .args(&args[1..])
+ /// .spawn()
+ /// .expect("failed to start subprocess")
+ /// .wait()
+ /// .expect("failed to wait for subprocess");
+ /// }
+ ///
+ /// execute(&["python", "-c", "print('Hello world!')"]);
+ /// ```
+ ///
+ /// [`quote`]: fn.quote.html
+ /// [`split`]: fn.split.html
+ pub fn join<I, S>(words: I) -> String
+ where
+ I: IntoIterator<Item = S>,
+ S: AsRef<str>,
+ {
+ let mut line = words.into_iter().fold(String::new(), |mut line, word| {
+ let quoted = quote(word.as_ref());
+ line.push_str(quoted.as_ref());
+ line.push(' ');
+ line
+ });
+ line.pop();
+ line
+ }
+
+ use std::ffi::OsString;
+
+ use env::native_int_str::{from_native_int_representation_owned, Convert, NCvt};
+ use env::parse_error::ParseError;
+
+ fn split(input: &str) -> Result<Vec<OsString>, ParseError> {
+ ::env::split_iterator::split(&NCvt::convert(input)).map(|vec| {
+ vec.into_iter()
+ .map(from_native_int_representation_owned)
+ .collect()
+ })
+ }
+
+ fn split_ok(cases: &[(&str, &[&str])]) {
+ for (i, &(input, expected)) in cases.iter().enumerate() {
+ match split(input) {
+ Err(actual) => {
+ panic!(
+ "[{i}] calling split({:?}):\nexpected: Ok({:?})\n actual: Err({:?})\n",
+ input, expected, actual
+ );
+ }
+ Ok(actual) => {
+ assert!(
+ expected == actual.as_slice(),
+ "[{i}] After split({:?}).unwrap()\nexpected: {:?}\n actual: {:?}\n",
+ input,
+ expected,
+ actual
+ );
+ }
+ }
+ }
+ }
+
+ #[test]
+ fn split_empty() {
+ split_ok(&[("", &[])]);
+ }
+
+ #[test]
+ fn split_initial_whitespace_is_removed() {
+ split_ok(&[
+ (" a", &["a"]),
+ ("\t\t\t\tbar", &["bar"]),
+ ("\t \nc", &["c"]),
+ ]);
+ }
+
+ #[test]
+ fn split_trailing_whitespace_is_removed() {
+ split_ok(&[
+ ("a ", &["a"]),
+ ("b\t", &["b"]),
+ ("c\t \n \n \n", &["c"]),
+ ("d\n\n", &["d"]),
+ ]);
+ }
+
+ #[test]
+ fn split_carriage_return() {
+ split_ok(&[("c\ra\r'\r'\r", &["c", "a", "\r"])]);
+ }
+
+ #[test]
+ fn split_() {
+ split_ok(&[("\\'\\'", &["''"])]);
+ }
+
+ #[test]
+ fn split_single_quotes() {
+ split_ok(&[
+ (r#"''"#, &[r#""#]),
+ (r#"'a'"#, &[r#"a"#]),
+ (r#"'\\'"#, &[r#"\"#]),
+ (r#"' \\ '"#, &[r#" \ "#]),
+ (r#"'#'"#, &[r#"#"#]),
+ ]);
+ }
+
+ #[test]
+ fn split_double_quotes() {
+ split_ok(&[
+ (r#""""#, &[""]),
+ (r#""""""#, &[""]),
+ (r#""a b c' d""#, &["a b c' d"]),
+ (r#""\$""#, &["$"]),
+ (r#""`""#, &["`"]),
+ (r#""\"""#, &["\""]),
+ (r#""\\""#, &["\\"]),
+ ("\"\n\"", &["\n"]),
+ ("\"\\\n\"", &[""]),
+ ]);
+ }
+
+ #[test]
+ fn split_unquoted() {
+ split_ok(&[
+ (r#"\\|\\&\\;"#, &[r#"\|\&\;"#]),
+ (r#"\\<\\>"#, &[r#"\<\>"#]),
+ (r#"\\(\\)"#, &[r#"\(\)"#]),
+ (r#"\$"#, &[r#"$"#]),
+ (r#"\""#, &[r#"""#]),
+ (r#"\'"#, &[r#"'"#]),
+ ("\\\n", &[]),
+ (" \\\n \n", &[]),
+ ("a\nb\nc", &["a", "b", "c"]),
+ ("a\\\nb\\\nc", &["abc"]),
+ ("foo bar baz", &["foo", "bar", "baz"]),
+ ]);
+ }
+
+ #[test]
+ fn split_trailing_backslash() {
+ assert_eq!(
+ split("\\"),
+ Err(ParseError::InvalidBackslashAtEndOfStringInMinusS {
+ pos: 1,
+ quoting: "Delimiter".into()
+ })
+ );
+ assert_eq!(
+ split(" \\"),
+ Err(ParseError::InvalidBackslashAtEndOfStringInMinusS {
+ pos: 2,
+ quoting: "Delimiter".into()
+ })
+ );
+ assert_eq!(
+ split("a\\"),
+ Err(ParseError::InvalidBackslashAtEndOfStringInMinusS {
+ pos: 2,
+ quoting: "Unquoted".into()
+ })
+ );
+ }
+
+ #[test]
+ fn split_errors() {
+ assert_eq!(
+ split("'abc"),
+ Err(ParseError::MissingClosingQuote { pos: 4, c: '\'' })
+ );
+ assert_eq!(
+ split("\""),
+ Err(ParseError::MissingClosingQuote { pos: 1, c: '"' })
+ );
+ assert_eq!(
+ split("'\\"),
+ Err(ParseError::MissingClosingQuote { pos: 2, c: '\'' })
+ );
+ assert_eq!(
+ split("'\\"),
+ Err(ParseError::MissingClosingQuote { pos: 2, c: '\'' })
+ );
+ assert_eq!(
+ split(r#""$""#),
+ Err(ParseError::ParsingOfVariableNameFailed {
+ pos: 2,
+ msg: "Missing variable name".into()
+ }),
+ );
+ }
+
+ #[test]
+ fn split_error_fail_with_unknown_escape_sequences() {
+ assert_eq!(
+ split("\\a"),
+ Err(ParseError::InvalidSequenceBackslashXInMinusS { pos: 1, c: 'a' })
+ );
+ assert_eq!(
+ split("\"\\a\""),
+ Err(ParseError::InvalidSequenceBackslashXInMinusS { pos: 2, c: 'a' })
+ );
+ assert_eq!(
+ split("'\\a'"),
+ Err(ParseError::InvalidSequenceBackslashXInMinusS { pos: 2, c: 'a' })
+ );
+ assert_eq!(
+ split(r#""\a""#),
+ Err(ParseError::InvalidSequenceBackslashXInMinusS { pos: 2, c: 'a' })
+ );
+ assert_eq!(
+ split(r#"\🦉"#),
+ Err(ParseError::InvalidSequenceBackslashXInMinusS {
+ pos: 1,
+ c: '\u{FFFD}'
+ })
+ );
+ }
+
+ #[test]
+ fn split_comments() {
+ split_ok(&[
+ (r#" x # comment "#, &["x"]),
+ (r#" w1#w2 "#, &["w1#w2"]),
+ (r#"'not really a # comment'"#, &["not really a # comment"]),
+ (" a # very long comment \n b # another comment", &["a", "b"]),
+ ]);
+ }
+
+ #[test]
+ fn test_quote() {
+ assert_eq!(quote(""), "''");
+ assert_eq!(quote("'"), "''\\'''");
+ assert_eq!(quote("abc"), "abc");
+ assert_eq!(quote("a \n b"), "'a \n b'");
+ assert_eq!(quote("X'\nY"), "'X'\\''\nY'");
+ }
+
+ #[test]
+ fn test_join() {
+ assert_eq!(join(["a", "b", "c"]), "a b c");
+ assert_eq!(join([" ", "$", "\n"]), "' ' '$' '\n'");
+ }
+
+ #[test]
+ fn join_followed_by_split_is_identity() {
+ let cases: Vec<&[&str]> = vec![
+ &["a"],
+ &["python", "-c", "print('Hello world!')"],
+ &["echo", " arg with spaces ", "arg \' with \" quotes"],
+ &["even newlines are quoted correctly\n", "\n", "\n\n\t "],
+ &["$", "`test`"],
+ &["cat", "~user/log*"],
+ &["test", "'a \"b", "\"X'"],
+ &["empty", "", "", ""],
+ ];
+ for argv in cases {
+ let args = join(argv);
+ assert_eq!(split(&args).unwrap(), argv);
+ }
+ }
+}
+
+mod test_raw_string_parser {
+ use std::{
+ borrow::Cow,
+ ffi::{OsStr, OsString},
+ };
+
+ use env::{
+ native_int_str::{
+ from_native_int_representation, from_native_int_representation_owned,
+ to_native_int_representation, NativeStr,
+ },
+ string_expander::StringExpander,
+ string_parser,
+ };
+
+ const LEN_OWL: usize = if cfg!(target_os = "windows") { 2 } else { 4 };
+
+ #[test]
+ fn test_ascii_only_take_one_look_at_correct_data_and_end_behavior() {
+ let input = "hello";
+ let cow = to_native_int_representation(OsStr::new(input));
+ let mut uut = StringExpander::new(&cow);
+ for c in input.chars() {
+ assert_eq!(c, uut.get_parser().peek().unwrap());
+ uut.take_one().unwrap();
+ }
+ assert_eq!(
+ uut.get_parser().peek(),
+ Err(string_parser::Error {
+ peek_position: 5,
+ err_type: string_parser::ErrorType::EndOfInput
+ })
+ );
+ uut.take_one().unwrap_err();
+ uut.take_one().unwrap_err();
+ assert_eq!(
+ from_native_int_representation_owned(uut.take_collected_output()),
+ input
+ );
+ uut.take_one().unwrap_err();
+ assert_eq!(
+ from_native_int_representation_owned(uut.take_collected_output()),
+ ""
+ );
+ }
+
+ #[test]
+ fn test_multi_byte_codes_take_one_look_at_correct_data_and_end_behavior() {
+ let input = OsString::from("🦉🦉🦉x🦉🦉x🦉x🦉🦉🦉🦉");
+ let cow = to_native_int_representation(input.as_os_str());
+ let mut uut = StringExpander::new(&cow);
+ for _i in 0..3 {
+ assert_eq!(uut.get_parser().peek().unwrap(), '\u{FFFD}');
+ uut.take_one().unwrap();
+ assert_eq!(uut.get_parser().peek().unwrap(), 'x');
+ uut.take_one().unwrap();
+ }
+ assert_eq!(uut.get_parser().peek().unwrap(), '\u{FFFD}');
+ uut.take_one().unwrap();
+ assert_eq!(
+ uut.get_parser().peek(),
+ Err(string_parser::Error {
+ peek_position: 10 * LEN_OWL + 3,
+ err_type: string_parser::ErrorType::EndOfInput
+ })
+ );
+ uut.take_one().unwrap_err();
+ uut.take_one().unwrap_err();
+ assert_eq!(
+ from_native_int_representation_owned(uut.take_collected_output()),
+ input
+ );
+ uut.take_one().unwrap_err();
+ assert_eq!(
+ from_native_int_representation_owned(uut.take_collected_output()),
+ ""
+ );
+ }
+
+ #[test]
+ fn test_multi_byte_codes_put_one_ascii_start_middle_end_try_invalid_ascii() {
+ let input = OsString::from("🦉🦉🦉x🦉🦉x🦉x🦉🦉🦉🦉");
+ let cow = to_native_int_representation(input.as_os_str());
+ let owl: char = '🦉';
+ let mut uut = StringExpander::new(&cow);
+ uut.put_one_char('a');
+ for _i in 0..3 {
+ assert_eq!(uut.get_parser().peek().unwrap(), '\u{FFFD}');
+ uut.take_one().unwrap();
+ uut.put_one_char('a');
+ assert_eq!(uut.get_parser().peek().unwrap(), 'x');
+ uut.take_one().unwrap();
+ uut.put_one_char('a');
+ }
+ assert_eq!(uut.get_parser().peek().unwrap(), '\u{FFFD}');
+ uut.take_one().unwrap();
+ uut.put_one_char(owl);
+ uut.put_one_char('a');
+ assert_eq!(
+ uut.get_parser().peek(),
+ Err(string_parser::Error {
+ peek_position: LEN_OWL * 10 + 3,
+ err_type: string_parser::ErrorType::EndOfInput
+ })
+ );
+ uut.take_one().unwrap_err();
+ uut.put_one_char('a');
+ uut.take_one().unwrap_err();
+ assert_eq!(
+ from_native_int_representation_owned(uut.take_collected_output()),
+ "a🦉🦉🦉axa🦉🦉axa🦉axa🦉🦉🦉🦉🦉aa"
+ );
+ uut.take_one().unwrap_err();
+ assert_eq!(
+ from_native_int_representation_owned(uut.take_collected_output()),
+ ""
+ );
+ }
+
+ #[test]
+ fn test_multi_byte_codes_skip_one_take_one_skip_until_ascii_char_or_end() {
+ let input = OsString::from("🦉🦉🦉x🦉🦉x🦉x🦉🦉🦉🦉");
+ let cow = to_native_int_representation(input.as_os_str());
+ let mut uut = StringExpander::new(&cow);
+
+ uut.skip_one().unwrap(); // skip 🦉🦉🦉
+ let p = LEN_OWL * 3;
+ assert_eq!(uut.get_peek_position(), p);
+
+ uut.skip_one().unwrap(); // skip x
+ assert_eq!(uut.get_peek_position(), p + 1);
+ uut.take_one().unwrap(); // take 🦉🦉
+ let p = p + 1 + LEN_OWL * 2;
+ assert_eq!(uut.get_peek_position(), p);
+
+ uut.skip_one().unwrap(); // skip x
+ assert_eq!(uut.get_peek_position(), p + 1);
+ uut.get_parser_mut().skip_until_char_or_end('x'); // skip 🦉
+ let p = p + 1 + LEN_OWL;
+ assert_eq!(uut.get_peek_position(), p);
+ uut.take_one().unwrap(); // take x
+ uut.get_parser_mut().skip_until_char_or_end('x'); // skip 🦉🦉🦉🦉 till end
+ let p = p + 1 + LEN_OWL * 4;
+ assert_eq!(uut.get_peek_position(), p);
+
+ uut.take_one().unwrap_err();
+ assert_eq!(
+ from_native_int_representation_owned(uut.take_collected_output()),
+ "🦉🦉x"
+ );
+ }
+
+ #[test]
+ fn test_multi_byte_codes_skip_multiple_ascii_bounded_good_and_bad() {
+ let input = OsString::from("🦉🦉🦉x🦉🦉x🦉x🦉🦉🦉🦉");
+ let cow = to_native_int_representation(input.as_os_str());
+ let mut uut = StringExpander::new(&cow);
+
+ uut.get_parser_mut().skip_multiple(0);
+ assert_eq!(uut.get_peek_position(), 0);
+ let p = LEN_OWL * 3;
+ uut.get_parser_mut().skip_multiple(p); // skips 🦉🦉🦉
+ assert_eq!(uut.get_peek_position(), p);
+
+ uut.take_one().unwrap(); // take x
+ assert_eq!(uut.get_peek_position(), p + 1);
+ let step = LEN_OWL * 3 + 1;
+ uut.get_parser_mut().skip_multiple(step); // skips 🦉🦉x🦉
+ let p = p + 1 + step;
+ assert_eq!(uut.get_peek_position(), p);
+ uut.take_one().unwrap(); // take x
+
+ assert_eq!(uut.get_peek_position(), p + 1);
+ let step = 4 * LEN_OWL;
+ uut.get_parser_mut().skip_multiple(step); // skips 🦉🦉🦉🦉
+ let p = p + 1 + step;
+ assert_eq!(uut.get_peek_position(), p);
+
+ uut.take_one().unwrap_err();
+ assert_eq!(
+ from_native_int_representation_owned(uut.take_collected_output()),
+ "xx"
+ );
+ }
+
+ #[test]
+ fn test_multi_byte_codes_put_string_utf8_start_middle_end() {
+ let input = OsString::from("🦉🦉🦉x🦉🦉x🦉x🦉🦉🦉🦉");
+ let cow = to_native_int_representation(input.as_os_str());
+ let mut uut = StringExpander::new(&cow);
+
+ uut.put_string("🦔oo");
+ uut.take_one().unwrap(); // takes 🦉🦉🦉
+ uut.put_string("oo🦔");
+ uut.take_one().unwrap(); // take x
+ uut.get_parser_mut().skip_until_char_or_end('\n'); // skips till end
+ uut.put_string("o🦔o");
+
+ uut.take_one().unwrap_err();
+ assert_eq!(
+ from_native_int_representation_owned(uut.take_collected_output()),
+ "🦔oo🦉🦉🦉oo🦔xo🦔o"
+ );
+ }
+
+ #[test]
+ fn test_multi_byte_codes_look_at_remaining_start_middle_end() {
+ let input = "🦉🦉🦉x🦉🦉x🦉x🦉🦉🦉🦉";
+ let cow = to_native_int_representation(OsStr::new(input));
+ let mut uut = StringExpander::new(&cow);
+
+ assert_eq!(uut.get_parser().peek_remaining(), OsStr::new(input));
+ uut.take_one().unwrap(); // takes 🦉🦉🦉
+ assert_eq!(uut.get_parser().peek_remaining(), OsStr::new(&input[12..]));
+ uut.get_parser_mut().skip_until_char_or_end('\n'); // skips till end
+ assert_eq!(uut.get_parser().peek_remaining(), OsStr::new(""));
+
+ uut.take_one().unwrap_err();
+ assert_eq!(
+ from_native_int_representation_owned(uut.take_collected_output()),
+ "🦉🦉🦉"
+ );
+ }
+
+ #[test]
+ fn test_deal_with_invalid_encoding() {
+ let owl_invalid_part;
+ let (brace_1, brace_2);
+ #[cfg(target_os = "windows")]
+ {
+ let mut buffer = [0u16; 2];
+ let owl = '🦉'.encode_utf16(&mut buffer);
+ owl_invalid_part = owl[0];
+ brace_1 = '<'.encode_utf16(&mut buffer).to_vec();
+ brace_2 = '>'.encode_utf16(&mut buffer).to_vec();
+ }
+ #[cfg(not(target_os = "windows"))]
+ {
+ let mut buffer = [0u8; 4];
+ let owl = '🦉'.encode_utf8(&mut buffer);
+ owl_invalid_part = owl.bytes().next().unwrap();
+ brace_1 = [b'<'].to_vec();
+ brace_2 = [b'>'].to_vec();
+ }
+ let mut input_ux = brace_1;
+ input_ux.push(owl_invalid_part);
+ input_ux.extend(brace_2);
+ let input_str = from_native_int_representation(Cow::Borrowed(&input_ux));
+ let mut uut = StringExpander::new(&input_ux);
+
+ assert_eq!(uut.get_parser().peek_remaining(), input_str);
+ assert_eq!(uut.get_parser().peek().unwrap(), '<');
+ uut.take_one().unwrap(); // takes "<"
+ assert_eq!(
+ uut.get_parser().peek_remaining(),
+ NativeStr::new(&input_str).split_at(1).1
+ );
+ assert_eq!(uut.get_parser().peek().unwrap(), '\u{FFFD}');
+ uut.take_one().unwrap(); // takes owl_b
+ assert_eq!(
+ uut.get_parser().peek_remaining(),
+ NativeStr::new(&input_str).split_at(2).1
+ );
+ assert_eq!(uut.get_parser().peek().unwrap(), '>');
+ uut.get_parser_mut().skip_until_char_or_end('\n');
+ assert_eq!(uut.get_parser().peek_remaining(), OsStr::new(""));
+
+ uut.take_one().unwrap_err();
+ assert_eq!(
+ from_native_int_representation_owned(uut.take_collected_output()),
+ NativeStr::new(&input_str).split_at(2).0
+ );
+ }
+}
diff --git a/tests/by-util/test_expand.rs b/tests/by-util/test_expand.rs
index ac9eb1fad55e09d08f03de9310640d377857ad10..ce105e78c7adb67369c863700695a6c23b6cd206 100644
--- a/tests/by-util/test_expand.rs
+++ b/tests/by-util/test_expand.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
use uucore::display::Quotable;
// spell-checker:ignore (ToDO) taaaa tbbbb tcccc
@@ -298,3 +302,127 @@ fn test_tabs_and_tabs_shortcut_mixed() {
// 01234567890
.stdout_is(" a b c");
}
+
+#[test]
+fn test_ignore_initial_plus() {
+ new_ucmd!()
+ .args(&["--tabs=+3"])
+ .pipe_in("\ta\tb\tc")
+ .succeeds()
+ // 01234567890
+ .stdout_is(" a b c");
+}
+
+#[test]
+fn test_ignore_initial_pluses() {
+ new_ucmd!()
+ .args(&["--tabs=++3"])
+ .pipe_in("\ta\tb\tc")
+ .succeeds()
+ // 01234567890
+ .stdout_is(" a b c");
+}
+
+#[test]
+fn test_ignore_initial_slash() {
+ new_ucmd!()
+ .args(&["--tabs=/3"])
+ .pipe_in("\ta\tb\tc")
+ .succeeds()
+ // 01234567890
+ .stdout_is(" a b c");
+}
+
+#[test]
+fn test_ignore_initial_slashes() {
+ new_ucmd!()
+ .args(&["--tabs=//3"])
+ .pipe_in("\ta\tb\tc")
+ .succeeds()
+ // 01234567890
+ .stdout_is(" a b c");
+}
+
+#[test]
+fn test_ignore_initial_plus_slash_combination() {
+ new_ucmd!()
+ .args(&["--tabs=+/3"])
+ .pipe_in("\ta\tb\tc")
+ .succeeds()
+ // 01234567890
+ .stdout_is(" a b c");
+}
+
+#[test]
+fn test_comma_with_plus_1() {
+ new_ucmd!()
+ .args(&["--tabs=3,+6"])
+ .pipe_in("\t111\t222\t333")
+ .succeeds()
+ // 01234567890
+ .stdout_is(" 111 222 333");
+}
+
+#[test]
+fn test_comma_with_plus_2() {
+ new_ucmd!()
+ .args(&["--tabs=1,+5"])
+ .pipe_in("\ta\tb\tc")
+ .succeeds()
+ // 01234567890
+ .stdout_is(" a b c");
+}
+
+#[test]
+fn test_comma_with_plus_3() {
+ new_ucmd!()
+ .args(&["--tabs=2,+5"])
+ .pipe_in("a\tb\tc")
+ .succeeds()
+ // 01234567890
+ .stdout_is("a b c");
+}
+
+#[test]
+fn test_comma_with_plus_4() {
+ new_ucmd!()
+ .args(&["--tabs=1,3,+5"])
+ .pipe_in("a\tb\tc")
+ .succeeds()
+ // 01234567890
+ .stdout_is("a b c");
+}
+
+#[test]
+fn test_args_override() {
+ new_ucmd!()
+ .args(&["-i", "-i", "with-trailing-tab.txt"])
+ .run()
+ .stdout_is(
+ "// !note: file contains significant whitespace
+// * indentation uses <TAB> characters
+int main() {
+ // * next line has both a leading & trailing tab
+ // with tabs=>\t
+ return 0;
+}
+",
+ );
+}
+
+#[test]
+fn test_expand_directory() {
+ new_ucmd!()
+ .args(&["."])
+ .fails()
+ .stderr_contains("expand: .: Is a directory");
+}
+
+#[test]
+fn test_nonexisting_file() {
+ new_ucmd!()
+ .args(&["nonexistent", "with-spaces.txt"])
+ .fails()
+ .stderr_contains("expand: nonexistent: No such file or directory")
+ .stdout_contains_line("// !note: file contains significant whitespace");
+}
diff --git a/tests/by-util/test_expr.rs b/tests/by-util/test_expr.rs
index 1eebf35f0949d24205433582c07cdfb2884e21ae..5cbf91e0c6a6906149a495930c43aff517ae39d2 100644
--- a/tests/by-util/test_expr.rs
+++ b/tests/by-util/test_expr.rs
@@ -1,6 +1,18 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore αbcdef ; (people) kkos
-use crate::common::util::*;
+use crate::common::util::TestScenario;
+
+#[test]
+fn test_no_arguments() {
+ new_ucmd!()
+ .fails()
+ .code_is(2)
+ .usage_error("missing operand");
+}
#[test]
fn test_simple_values() {
@@ -96,6 +108,12 @@ fn test_parenthesis() {
.args(&["(", "1", "+", "1", ")", "*", "2"])
.succeeds()
.stdout_only("4\n");
+
+ new_ucmd!()
+ .args(&["1", "(", ")"])
+ .fails()
+ .code_is(2)
+ .stderr_only("expr: syntax error: unexpected argument '('\n");
}
#[test]
@@ -109,6 +127,44 @@ fn test_or() {
.args(&["foo", "|", "bar"])
.succeeds()
.stdout_only("foo\n");
+
+ new_ucmd!()
+ .args(&["14", "|", "1"])
+ .succeeds()
+ .stdout_only("14\n");
+
+ new_ucmd!()
+ .args(&["-14", "|", "1"])
+ .succeeds()
+ .stdout_only("-14\n");
+
+ new_ucmd!()
+ .args(&["1", "|", "a", "/", "5"])
+ .succeeds()
+ .stdout_only("1\n");
+
+ new_ucmd!()
+ .args(&["foo", "|", "a", "/", "5"])
+ .succeeds()
+ .stdout_only("foo\n");
+
+ new_ucmd!()
+ .args(&["0", "|", "10", "/", "5"])
+ .succeeds()
+ .stdout_only("2\n");
+
+ new_ucmd!()
+ .args(&["12", "|", "9a", "+", "1"])
+ .succeeds()
+ .stdout_only("12\n");
+
+ new_ucmd!().args(&["", "|", ""]).run().stdout_only("0\n");
+
+ new_ucmd!().args(&["", "|", "0"]).run().stdout_only("0\n");
+
+ new_ucmd!().args(&["", "|", "00"]).run().stdout_only("0\n");
+
+ new_ucmd!().args(&["", "|", "-0"]).run().stdout_only("0\n");
}
#[test]
@@ -118,7 +174,34 @@ fn test_and() {
.succeeds()
.stdout_only("foo\n");
- new_ucmd!().args(&["", "&", "1"]).run().stdout_is("0\n");
+ new_ucmd!()
+ .args(&["14", "&", "1"])
+ .succeeds()
+ .stdout_only("14\n");
+
+ new_ucmd!()
+ .args(&["-14", "&", "1"])
+ .succeeds()
+ .stdout_only("-14\n");
+
+ new_ucmd!()
+ .args(&["-1", "&", "10", "/", "5"])
+ .succeeds()
+ .stdout_only("-1\n");
+
+ new_ucmd!()
+ .args(&["0", "&", "a", "/", "5"])
+ .run()
+ .stdout_only("0\n");
+
+ new_ucmd!()
+ .args(&["", "&", "a", "/", "5"])
+ .run()
+ .stdout_only("0\n");
+
+ new_ucmd!().args(&["", "&", "1"]).run().stdout_only("0\n");
+
+ new_ucmd!().args(&["", "&", ""]).run().stdout_only("0\n");
}
#[test]
@@ -152,6 +235,12 @@ fn test_index() {
.args(&["index", "αbcdef_f", "f"])
.succeeds()
.stdout_only("6\n");
+
+ new_ucmd!()
+ .args(&["αbcdef", "index", "α"])
+ .fails()
+ .code_is(2)
+ .stderr_only("expr: syntax error: unexpected argument 'index'\n");
}
#[test]
@@ -165,6 +254,12 @@ fn test_length() {
.args(&["length", "abcdef"])
.succeeds()
.stdout_only("6\n");
+
+ new_ucmd!()
+ .args(&["abcdef", "length"])
+ .fails()
+ .code_is(2)
+ .stderr_only("expr: syntax error: unexpected argument 'length'\n");
}
#[test]
@@ -194,6 +289,10 @@ fn test_regex() {
.args(&["-5", ":", "-\\{0,1\\}[0-9]*$"])
.succeeds()
.stdout_only("2\n");
+ new_ucmd!()
+ .args(&["abc", ":", "bc"])
+ .fails()
+ .stdout_only("0\n");
}
#[test]
@@ -202,6 +301,12 @@ fn test_substr() {
.args(&["substr", "abc", "1", "1"])
.succeeds()
.stdout_only("a\n");
+
+ new_ucmd!()
+ .args(&["abc", "substr", "1", "1"])
+ .fails()
+ .code_is(2)
+ .stderr_only("expr: syntax error: unexpected argument 'substr'\n");
}
#[test]
@@ -213,14 +318,55 @@ fn test_invalid_substr() {
.stdout_only("\n");
new_ucmd!()
- .args(&["substr", "abc", &(std::usize::MAX.to_string() + "0"), "1"])
+ .args(&["substr", "abc", &(usize::MAX.to_string() + "0"), "1"])
.fails()
.code_is(1)
.stdout_only("\n");
new_ucmd!()
- .args(&["substr", "abc", "0", &(std::usize::MAX.to_string() + "0")])
+ .args(&["substr", "abc", "0", &(usize::MAX.to_string() + "0")])
.fails()
.code_is(1)
.stdout_only("\n");
}
+
+#[test]
+fn test_escape() {
+ new_ucmd!().args(&["+", "1"]).succeeds().stdout_only("1\n");
+
+ new_ucmd!()
+ .args(&["1", "+", "+", "1"])
+ .succeeds()
+ .stdout_only("2\n");
+
+ new_ucmd!()
+ .args(&["2", "*", "+", "3"])
+ .succeeds()
+ .stdout_only("6\n");
+
+ new_ucmd!()
+ .args(&["(", "1", ")", "+", "1"])
+ .succeeds()
+ .stdout_only("2\n");
+}
+
+#[test]
+fn test_invalid_syntax() {
+ let invalid_syntaxes = [["12", "12"], ["12", "|"], ["|", "12"]];
+
+ for invalid_syntax in invalid_syntaxes {
+ new_ucmd!()
+ .args(&invalid_syntax)
+ .fails()
+ .code_is(2)
+ .stderr_contains("syntax error");
+ }
+}
+
+#[test]
+fn test_num_str_comparison() {
+ new_ucmd!()
+ .args(&["1a", "<", "1", "+", "1"])
+ .succeeds()
+ .stdout_is("1\n");
+}
diff --git a/tests/by-util/test_factor.rs b/tests/by-util/test_factor.rs
index 6a17c00ff6deb6bd9e93f8050008757cc2c66f9f..f643a404997d0bdcfa10c7ed3614f8dddfeb4c14 100644
--- a/tests/by-util/test_factor.rs
+++ b/tests/by-util/test_factor.rs
@@ -1,26 +1,16 @@
// This file is part of the uutils coreutils package.
//
-// (c) kwantam <kwantam@gmail.com>
-//
-// For the full copyright and license information, please view the LICENSE file
-// that was distributed with this source code.
-#![allow(clippy::unreadable_literal)]
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-// spell-checker:ignore (methods) hexdigest
+// spell-checker:ignore (methods) hexdigest funcs nprimes
-use crate::common::util::*;
+use crate::common::util::TestScenario;
use std::time::{Duration, SystemTime};
-#[path = "../../src/uu/factor/sieve.rs"]
-mod sieve;
-
-extern crate conv;
-extern crate rand;
-
-use self::rand::distributions::{Distribution, Uniform};
-use self::rand::{rngs::SmallRng, Rng, SeedableRng};
-use self::sieve::Sieve;
+use rand::distributions::{Distribution, Uniform};
+use rand::{rngs::SmallRng, Rng, SeedableRng};
const NUM_PRIMES: usize = 10000;
const NUM_TESTS: usize = 100;
@@ -30,9 +20,26 @@ fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
}
+#[test]
+fn test_valid_arg_exponents() {
+ new_ucmd!().arg("-h").succeeds().code_is(0);
+ new_ucmd!().arg("--exponents").succeeds().code_is(0);
+}
+
+#[test]
+fn test_repeated_exponents() {
+ new_ucmd!()
+ .args(&["-hh", "1234", "10240"])
+ .succeeds()
+ .stdout_only("1234: 2 617\n10240: 2^11 5\n")
+ .no_stderr();
+}
+
#[test]
#[cfg(feature = "sort")]
+#[cfg(not(target_os = "android"))]
fn test_parallel() {
+ use crate::common::util::AtPath;
use hex_literal::hex;
use sha1::{Digest, Sha1};
use std::{fs::OpenOptions, time::Duration};
@@ -41,7 +48,7 @@ fn test_parallel() {
let n_integers = 100_000;
let mut input_string = String::new();
for i in 0..=n_integers {
- input_string.push_str(&(format!("{} ", i))[..]);
+ input_string.push_str(&(format!("{i} "))[..]);
}
let tmp_dir = TempDir::new().unwrap();
@@ -80,17 +87,16 @@ fn test_parallel() {
#[test]
fn test_first_1000_integers() {
- extern crate sha1;
use hex_literal::hex;
use sha1::{Digest, Sha1};
let n_integers = 1000;
let mut input_string = String::new();
for i in 0..=n_integers {
- input_string.push_str(&(format!("{} ", i))[..]);
+ input_string.push_str(&(format!("{i} "))[..]);
}
- println!("STDIN='{}'", input_string);
+ println!("STDIN='{input_string}'");
let result = new_ucmd!().pipe_in(input_string.as_bytes()).succeeds();
// `seq 0 1000 | factor | sha1sum` => "c734327bd18b90fca5762f671672b5eda19f7dca"
@@ -103,6 +109,33 @@ fn test_first_1000_integers() {
);
}
+#[test]
+fn test_first_1000_integers_with_exponents() {
+ use hex_literal::hex;
+ use sha1::{Digest, Sha1};
+
+ let n_integers = 1000;
+ let mut input_string = String::new();
+ for i in 0..=n_integers {
+ input_string.push_str(&(format!("{i} "))[..]);
+ }
+
+ println!("STDIN='{input_string}'");
+ let result = new_ucmd!()
+ .arg("-h")
+ .pipe_in(input_string.as_bytes())
+ .succeeds();
+
+ // Using factor from GNU Coreutils 9.2
+ // `seq 0 1000 | factor -h | sha1sum` => "45f5f758a9319870770bd1fec2de23d54331944d"
+ let mut hasher = Sha1::new();
+ hasher.update(result.stdout());
+ let hash_check = hasher.finalize();
+ assert_eq!(
+ hash_check[..],
+ hex!("45f5f758a9319870770bd1fec2de23d54331944d")
+ );
+}
#[test]
fn test_cli_args() {
// Make sure that factor works with CLI arguments as well.
@@ -117,16 +150,14 @@ fn test_cli_args() {
#[test]
fn test_random() {
- use conv::prelude::*;
-
- let log_num_primes = f64::value_from(NUM_PRIMES).unwrap().log2().ceil();
- let primes = Sieve::primes().take(NUM_PRIMES).collect::<Vec<u64>>();
+ let log_num_primes = f64::from(u32::try_from(NUM_PRIMES).unwrap()).log2().ceil();
+ let primes = num_prime::nt_funcs::nprimes(NUM_PRIMES);
let rng_seed = SystemTime::now()
.duration_since(SystemTime::UNIX_EPOCH)
.unwrap()
.as_secs();
- println!("rng_seed={:?}", rng_seed);
+ println!("rng_seed={rng_seed:?}");
let mut rng = SmallRng::seed_from_u64(rng_seed);
let mut rand_gt = move |min: u64| {
@@ -134,15 +165,12 @@ fn test_random() {
let mut factors = Vec::new();
while product < min {
// log distribution---higher probability for lower numbers
- let factor;
- loop {
+ let factor = loop {
let next = rng.gen_range(0_f64..log_num_primes).exp2().floor() as usize;
if next < NUM_PRIMES {
- factor = primes[next];
- break;
+ break primes[next];
}
- }
- let factor = factor;
+ };
match product.checked_mul(factor) {
Some(p) => {
@@ -162,11 +190,11 @@ fn test_random() {
let mut output_string = String::new();
for _ in 0..NUM_TESTS {
let (product, factors) = rand_gt(1 << 63);
- input_string.push_str(&(format!("{} ", product))[..]);
+ input_string.push_str(&(format!("{product} "))[..]);
- output_string.push_str(&(format!("{}:", product))[..]);
+ output_string.push_str(&(format!("{product}:"))[..]);
for factor in factors {
- output_string.push_str(&(format!(" {}", factor))[..]);
+ output_string.push_str(&(format!(" {factor}"))[..]);
}
output_string.push('\n');
}
@@ -180,7 +208,7 @@ fn test_random_big() {
.duration_since(SystemTime::UNIX_EPOCH)
.unwrap()
.as_secs();
- println!("rng_seed={:?}", rng_seed);
+ println!("rng_seed={rng_seed:?}");
let mut rng = SmallRng::seed_from_u64(rng_seed);
let bit_range_1 = Uniform::new(14_usize, 51);
@@ -202,7 +230,7 @@ fn test_random_big() {
// to generate an even split of this range, generate n-1 random elements
// in the range, add the desired total value to the end, sort this list,
// and then compute the sequential differences.
- let mut f_bits = Vec::new();
+ let mut f_bits = Vec::with_capacity(n_factors + 1);
for _ in 0..n_factors {
f_bits.push(extra_range.sample(&mut rng));
}
@@ -225,7 +253,7 @@ fn test_random_big() {
let mut n_bits = 0;
let mut product = 1_u64;
- let mut factors = Vec::new();
+ let mut factors = Vec::with_capacity(f_bits.len());
for bit in f_bits {
assert!(bit < 37);
n_bits += 14 + bit;
@@ -244,11 +272,11 @@ fn test_random_big() {
let mut output_string = String::new();
for _ in 0..NUM_TESTS {
let (product, factors) = rand_64();
- input_string.push_str(&(format!("{} ", product))[..]);
+ input_string.push_str(&(format!("{product} "))[..]);
- output_string.push_str(&(format!("{}:", product))[..]);
+ output_string.push_str(&(format!("{product}:"))[..]);
for factor in factors {
- output_string.push_str(&(format!(" {}", factor))[..]);
+ output_string.push_str(&(format!(" {factor}"))[..]);
}
output_string.push('\n');
}
@@ -261,8 +289,8 @@ fn test_big_primes() {
let mut input_string = String::new();
let mut output_string = String::new();
for prime in PRIMES64 {
- input_string.push_str(&(format!("{} ", prime))[..]);
- output_string.push_str(&(format!("{0}: {0}\n", prime))[..]);
+ input_string.push_str(&(format!("{prime} "))[..]);
+ output_string.push_str(&(format!("{prime}: {prime}\n"))[..]);
}
run(input_string.as_bytes(), output_string.as_bytes());
@@ -282,6 +310,66 @@ fn run(input_string: &[u8], output_string: &[u8]) {
.stdout_is(String::from_utf8(output_string.to_owned()).unwrap());
}
+#[test]
+fn test_primes_with_exponents() {
+ let mut input_string = String::new();
+ let mut output_string = String::new();
+ for primes in PRIMES_BY_BITS {
+ for &prime in *primes {
+ input_string.push_str(&(format!("{prime} "))[..]);
+ output_string.push_str(&(format!("{prime}: {prime}\n"))[..]);
+ }
+ }
+
+ println!(
+ "STDIN='{}'",
+ String::from_utf8_lossy(input_string.as_bytes())
+ );
+ println!(
+ "STDOUT(expected)='{}'",
+ String::from_utf8_lossy(output_string.as_bytes())
+ );
+
+ // run factor with --exponents
+ new_ucmd!()
+ .timeout(Duration::from_secs(240))
+ .arg("--exponents")
+ .pipe_in(input_string)
+ .run()
+ .stdout_is(String::from_utf8(output_string.as_bytes().to_owned()).unwrap());
+}
+
+#[test]
+fn fails_on_invalid_number() {
+ new_ucmd!().arg("not-a-valid-number").fails();
+ new_ucmd!()
+ .arg("not-a-valid-number")
+ .arg("12")
+ .fails()
+ .stdout_contains("12: 2 2 3");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "netbsd"))]
+fn short_circuit_write_error() {
+ use std::fs::OpenOptions;
+
+ // Check that the error is printed exactly once and factor does not move on
+ // to the next number when a write error happens.
+ //
+ // Note: Technically, GNU prints the error twice, not because it does not
+ // short circuit the error, but because it always prints the error twice,
+ // for any number of inputs. That's silly behavior and printing once is
+ // clearly better.
+ let f = OpenOptions::new().write(true).open("/dev/full").unwrap();
+ new_ucmd!()
+ .arg("12")
+ .arg("10")
+ .set_stdout(f)
+ .fails()
+ .stderr_is("factor: write error: No space left on device\n");
+}
+
const PRIMES_BY_BITS: &[&[u64]] = &[
PRIMES14, PRIMES15, PRIMES16, PRIMES17, PRIMES18, PRIMES19, PRIMES20, PRIMES21, PRIMES22,
PRIMES23, PRIMES24, PRIMES25, PRIMES26, PRIMES27, PRIMES28, PRIMES29, PRIMES30, PRIMES31,
@@ -1172,3 +1260,58 @@ const PRIMES50: &[u64] = &[
1125899906841623,
1125899906841613,
];
+
+#[test]
+fn fails_on_directory() {
+ new_ucmd!().pipe_in(".").fails();
+}
+
+#[test]
+fn succeeds_with_numbers_larger_than_u64() {
+ new_ucmd!()
+ .arg("158909489063877810457")
+ .succeeds()
+ .stdout_is("158909489063877810457: 3401347 3861211 12099721\n");
+ new_ucmd!()
+ .arg("222087527029934481871")
+ .succeeds()
+ .stdout_is("222087527029934481871: 15601 26449 111427 4830277\n");
+ new_ucmd!()
+ .arg("12847291069740315094892340035")
+ .succeeds()
+ .stdout_is(
+ "12847291069740315094892340035: \
+ 5 4073 18899 522591721 63874247821\n",
+ );
+}
+
+#[test]
+fn succeeds_with_numbers_larger_than_u128() {
+ new_ucmd!()
+ .arg("-h")
+ .arg("340282366920938463463374607431768211456")
+ .succeeds()
+ .stdout_is("340282366920938463463374607431768211456: 2^128\n");
+ new_ucmd!()
+ .arg("+170141183460469231731687303715884105729")
+ .succeeds()
+ .stdout_is(
+ "170141183460469231731687303715884105729: \
+ 3 56713727820156410577229101238628035243\n",
+ );
+}
+
+#[test]
+fn succeeds_with_numbers_larger_than_u256() {
+ new_ucmd!()
+ .arg("-h")
+ .arg(
+ "115792089237316195423570985008687907853\
+ 269984665640564039457584007913129639936",
+ )
+ .succeeds()
+ .stdout_is(
+ "115792089237316195423570985008687907853\
+ 269984665640564039457584007913129639936: 2^256\n",
+ );
+}
diff --git a/tests/by-util/test_false.rs b/tests/by-util/test_false.rs
index 5ce64e7a8bf28525727621246bc87cfc2a73df8a..01916ec622a096e63cfee6890104c5838c28ee42 100644
--- a/tests/by-util/test_false.rs
+++ b/tests/by-util/test_false.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "netbsd"))]
use std::fs::OpenOptions;
diff --git a/tests/by-util/test_fmt.rs b/tests/by-util/test_fmt.rs
index 02d2054661834b2860d1a820d24d2e9d538c5e21..9bb82ede562674222c720f1560bf555fd081ba23 100644
--- a/tests/by-util/test_fmt.rs
+++ b/tests/by-util/test_fmt.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
@@ -7,47 +11,299 @@ fn test_invalid_arg() {
#[test]
fn test_fmt() {
- let result = new_ucmd!().arg("one-word-per-line.txt").run();
- //.stdout_is_fixture("call_graph.expected");
- assert_eq!(
- result.stdout_str().trim(),
- "this is a file with one word per line"
- );
+ new_ucmd!()
+ .arg("one-word-per-line.txt")
+ .succeeds()
+ .stdout_is("this is a file with one word per line\n");
}
#[test]
-fn test_fmt_q() {
- let result = new_ucmd!().arg("-q").arg("one-word-per-line.txt").run();
- //.stdout_is_fixture("call_graph.expected");
- assert_eq!(
- result.stdout_str().trim(),
- "this is a file with one word per line"
- );
+fn test_fmt_quick() {
+ for param in ["-q", "--quick", "-qq"] {
+ new_ucmd!()
+ .args(&["one-word-per-line.txt", param])
+ .succeeds()
+ .stdout_is("this is a file with one word per line\n");
+ }
}
#[test]
-fn test_fmt_w_too_big() {
- let result = new_ucmd!()
- .arg("-w")
- .arg("2501")
- .arg("one-word-per-line.txt")
- .run();
- //.stdout_is_fixture("call_graph.expected");
- assert_eq!(
- result.stderr_str().trim(),
- "fmt: invalid width: '2501': Numerical result out of range"
- );
-}
-#[test]
-fn test_fmt_w() {
- let result = new_ucmd!()
- .arg("-w")
- .arg("10")
- .arg("one-word-per-line.txt")
- .run();
- //.stdout_is_fixture("call_graph.expected");
- assert_eq!(
- result.stdout_str().trim(),
- "this is\na file\nwith one\nword per\nline"
- );
+fn test_fmt_width() {
+ for param in ["-w", "--width"] {
+ new_ucmd!()
+ .args(&["one-word-per-line.txt", param, "10"])
+ .succeeds()
+ .stdout_is("this is a\nfile with\none word\nper line\n");
+ }
+ new_ucmd!()
+ .args(&["one-word-per-line.txt", "-w50", "--width", "10"])
+ .succeeds()
+ .stdout_is("this is a\nfile with\none word\nper line\n");
+}
+
+#[test]
+fn test_fmt_width_invalid() {
+ new_ucmd!()
+ .args(&["one-word-per-line.txt", "-w", "apple"])
+ .fails()
+ .code_is(1)
+ .no_stdout()
+ .stderr_is("fmt: invalid width: 'apple'\n");
+ // an invalid width can be successfully overwritten later:
+ new_ucmd!()
+ .args(&["one-word-per-line.txt", "-w", "apple", "-w10"])
+ .succeeds()
+ .stdout_is("this is a\nfile with\none word\nper line\n");
+}
+
+#[test]
+fn test_fmt_positional_width() {
+ new_ucmd!()
+ .args(&["-10", "one-word-per-line.txt"])
+ .succeeds()
+ .stdout_is("this is a\nfile with\none word\nper line\n");
+}
+
+#[test]
+fn test_small_width() {
+ for width in ["0", "1", "2", "3"] {
+ for param in ["-w", "--width"] {
+ new_ucmd!()
+ .args(&[param, width, "one-word-per-line.txt"])
+ .succeeds()
+ .stdout_is("this\nis\na\nfile\nwith\none\nword\nper\nline\n");
+ }
+ }
+}
+
+#[test]
+fn test_fmt_width_too_big() {
+ for param in ["-w", "--width"] {
+ new_ucmd!()
+ .args(&["one-word-per-line.txt", param, "2501"])
+ .fails()
+ .code_is(1)
+ .stderr_is("fmt: invalid width: '2501': Numerical result out of range\n");
+ }
+ // However, as a temporary value it is okay:
+ new_ucmd!()
+ .args(&["one-word-per-line.txt", "-w2501", "--width", "10"])
+ .succeeds()
+ .stdout_is("this is a\nfile with\none word\nper line\n");
+}
+
+#[test]
+fn test_fmt_invalid_width() {
+ for param in ["-w", "--width"] {
+ new_ucmd!()
+ .args(&["one-word-per-line.txt", param, "invalid"])
+ .fails()
+ .code_is(1)
+ .stderr_contains("invalid width: 'invalid'");
+ }
+}
+
+#[test]
+fn test_fmt_positional_width_not_first() {
+ new_ucmd!()
+ .args(&["one-word-per-line.txt", "-10"])
+ .fails()
+ .code_is(1)
+ .stderr_contains("fmt: invalid option -- 1; -WIDTH is recognized only when it is the first\noption; use -w N instead");
+}
+
+#[test]
+fn test_fmt_width_not_valid_number() {
+ new_ucmd!()
+ .args(&["-25x", "one-word-per-line.txt"])
+ .fails()
+ .code_is(1)
+ .stderr_contains("fmt: invalid width: '25x'");
+}
+
+#[ignore = "our 'goal' algorithm is very different from GNU; fix this!"]
+#[test]
+fn test_fmt_goal() {
+ for param in ["-g", "--goal"] {
+ new_ucmd!()
+ .args(&["one-word-per-line.txt", param, "7"])
+ .succeeds()
+ .stdout_is("this is a\nfile with one\nword per line\n");
+ }
+ new_ucmd!()
+ .args(&["one-word-per-line.txt", "-g40", "-g7"])
+ .succeeds()
+ .stdout_is("this is a\nfile with one\nword per line\n");
+}
+
+#[test]
+fn test_fmt_goal_too_big() {
+ for param in ["-g", "--goal"] {
+ new_ucmd!()
+ .args(&["one-word-per-line.txt", "--width=75", param, "76"])
+ .fails()
+ .code_is(1)
+ .stderr_is("fmt: GOAL cannot be greater than WIDTH.\n");
+ }
+}
+
+#[test]
+fn test_fmt_goal_bigger_than_default_width_of_75() {
+ for param in ["-g", "--goal"] {
+ new_ucmd!()
+ .args(&["one-word-per-line.txt", param, "76"])
+ .fails()
+ .code_is(1)
+ .stderr_is("fmt: GOAL cannot be greater than WIDTH.\n");
+ }
+}
+
+#[ignore = "our 'goal' algorithm is very different from GNU; fix this!"]
+#[test]
+fn test_fmt_too_big_goal_sometimes_okay() {
+ new_ucmd!()
+ .args(&["one-word-per-line.txt", "--width=75", "-g76", "-g10"])
+ .succeeds()
+ .stdout_is("this is a\nfile with one\nword per line\n");
+ new_ucmd!()
+ .args(&["one-word-per-line.txt", "-g76", "-g10"])
+ .succeeds()
+ .stdout_is("this is a\nfile with one\nword per line\n");
+}
+
+#[test]
+fn test_fmt_goal_too_small_to_check_negative_minlength() {
+ for param in ["-g", "--goal"] {
+ new_ucmd!()
+ .args(&["one-word-per-line.txt", "--width=75", param, "10"])
+ .succeeds()
+ .stdout_is("this is a file with one word per line\n");
+ }
+}
+
+#[test]
+fn test_fmt_non_existent_file() {
+ new_ucmd!()
+ .args(&["non-existing"])
+ .fails()
+ .code_is(1)
+ .stderr_is("fmt: cannot open 'non-existing' for reading: No such file or directory\n");
+}
+
+#[test]
+fn test_fmt_invalid_goal() {
+ for param in ["-g", "--goal"] {
+ new_ucmd!()
+ .args(&["one-word-per-line.txt", param, "invalid"])
+ .fails()
+ .code_is(1)
+ // GNU complains about "invalid width", which is confusing.
+ // We intentionally deviate from GNU, and show a more helpful message:
+ .stderr_contains("invalid goal: 'invalid'");
+ }
+}
+
+#[test]
+fn test_fmt_invalid_goal_override() {
+ new_ucmd!()
+ .args(&["one-word-per-line.txt", "-g", "apple", "-g", "74"])
+ .succeeds()
+ .stdout_is("this is a file with one word per line\n");
+}
+
+#[test]
+fn test_fmt_invalid_goal_width_priority() {
+ new_ucmd!()
+ .args(&["one-word-per-line.txt", "-g", "apple", "-w", "banana"])
+ .fails()
+ .code_is(1)
+ .no_stdout()
+ .stderr_is("fmt: invalid width: 'banana'\n");
+ new_ucmd!()
+ .args(&["one-word-per-line.txt", "-w", "banana", "-g", "apple"])
+ .fails()
+ .code_is(1)
+ .no_stdout()
+ .stderr_is("fmt: invalid width: 'banana'\n");
+}
+
+#[test]
+fn test_fmt_set_goal_not_contain_width() {
+ for param in ["-g", "--goal"] {
+ new_ucmd!()
+ .args(&["one-word-per-line.txt", param, "74"])
+ .succeeds()
+ .stdout_is("this is a file with one word per line\n");
+ }
+}
+
+#[test]
+fn split_does_not_reflow() {
+ for arg in ["-s", "-ss", "--split-only"] {
+ new_ucmd!()
+ .arg("one-word-per-line.txt")
+ .arg(arg)
+ .succeeds()
+ .stdout_is_fixture("one-word-per-line.txt");
+ }
+}
+
+#[test]
+fn prefix_minus() {
+ for prefix_args in [
+ vec!["-p-"],
+ vec!["-p", "-"],
+ vec!["--prefix=-"],
+ vec!["--prefix", "-"],
+ vec!["--pref=-"],
+ vec!["--pref", "-"],
+ // Test self-overriding:
+ vec!["--prefix==", "--prefix=-"],
+ ] {
+ new_ucmd!()
+ .args(&prefix_args)
+ .arg("prefixed-one-word-per-line.txt")
+ .succeeds()
+ .stdout_is_fixture("prefixed-one-word-per-line_p-.txt");
+ }
+}
+
+#[test]
+fn prefix_equal() {
+ for prefix_args in [
+ // FIXME: #6353 vec!["-p="],
+ vec!["-p", "="],
+ vec!["--prefix=="],
+ vec!["--prefix", "="],
+ vec!["--pref=="],
+ vec!["--pref", "="],
+ // Test self-overriding:
+ vec!["--prefix=-", "--prefix=="],
+ ] {
+ new_ucmd!()
+ .args(&prefix_args)
+ .arg("prefixed-one-word-per-line.txt")
+ .succeeds()
+ .stdout_is_fixture("prefixed-one-word-per-line_p=.txt");
+ }
+}
+
+#[test]
+fn prefix_equal_skip_prefix_equal_two() {
+ for prefix_args in [
+ // FIXME: #6353 vec!["--prefix==", "-P=2"],
+ vec!["--prefix==", "-P", "=2"],
+ vec!["--prefix==", "--skip-prefix==2"],
+ vec!["--prefix==", "--skip-prefix", "=2"],
+ vec!["--prefix==", "--skip-pref==2"],
+ vec!["--prefix==", "--skip-pref", "=2"],
+ // Test self-overriding:
+ vec!["--prefix==", "--skip-pref", "asdf", "-P", "=2"],
+ ] {
+ new_ucmd!()
+ .args(&prefix_args)
+ .arg("prefixed-one-word-per-line.txt")
+ .succeeds()
+ .stdout_is_fixture("prefixed-one-word-per-line_p=_P=2.txt");
+ }
}
diff --git a/tests/by-util/test_fold.rs b/tests/by-util/test_fold.rs
index 04953542219eedcc05c95b9c1d59a75b9e504011..6895f51b6e414ba2e53a23083322d55e2aebbad0 100644
--- a/tests/by-util/test_fold.rs
+++ b/tests/by-util/test_fold.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
diff --git a/tests/by-util/test_groups.rs b/tests/by-util/test_groups.rs
index 1432e8c9c6491773b51d4e6a1fd882b12d0fff0d..47cb89249b37a8e4ed5c11fe7e699a664e6b6793 100644
--- a/tests/by-util/test_groups.rs
+++ b/tests/by-util/test_groups.rs
@@ -1,11 +1,11 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
//spell-checker: ignore coreutil
-use crate::common::util::*;
+use crate::common::util::{check_coreutil_version, expected_result, whoami, TestScenario};
const VERSION_MIN_MULTIPLE_USERS: &str = "8.31"; // this feature was introduced in GNU's coreutils 8.31
diff --git a/tests/by-util/test_hashsum.rs b/tests/by-util/test_hashsum.rs
index e8f71681526206744ddbd751aa35822b7bbe8fd2..f9863a30fb3eed103da85a7a97712774f471f058 100644
--- a/tests/by-util/test_hashsum.rs
+++ b/tests/by-util/test_hashsum.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
// spell-checker:ignore checkfile, nonames, testf, ntestf
macro_rules! get_hash(
($str:expr) => (
@@ -46,6 +50,9 @@ macro_rules! test_digest {
#[test]
fn test_check() {
let ts = TestScenario::new("hashsum");
+ println!("File content='{}'", ts.fixtures.read("input.txt"));
+ println!("Check file='{}'", ts.fixtures.read(CHECK_FILE));
+
ts.ucmd()
.args(&[DIGEST_ARG, BITS_ARG, "--check", CHECK_FILE])
.succeeds()
@@ -53,6 +60,14 @@ macro_rules! test_digest {
.stdout_is("input.txt: OK\n");
}
+ #[test]
+ fn test_zero() {
+ let ts = TestScenario::new("hashsum");
+ assert_eq!(ts.fixtures.read(EXPECTED_FILE),
+ get_hash!(ts.ucmd().arg(DIGEST_ARG).arg(BITS_ARG).arg("--zero").arg("input.txt").succeeds().no_stderr().stdout_str()));
+ }
+
+
#[cfg(windows)]
#[test]
fn test_text_mode() {
@@ -117,6 +132,168 @@ fn test_check_sha1() {
.stderr_is("");
}
+#[test]
+fn test_check_md5_ignore_missing() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.write("testf", "foobar\n");
+ at.write(
+ "testf.sha1",
+ "14758f1afd44c09b7992073ccf00b43d testf\n14758f1afd44c09b7992073ccf00b43d testf2\n",
+ );
+ scene
+ .ccmd("md5sum")
+ .arg("-c")
+ .arg(at.subdir.join("testf.sha1"))
+ .fails()
+ .stdout_contains("testf2: FAILED open or read");
+
+ scene
+ .ccmd("md5sum")
+ .arg("-c")
+ .arg("--ignore-missing")
+ .arg(at.subdir.join("testf.sha1"))
+ .succeeds()
+ .stdout_is("testf: OK\n")
+ .stderr_is("");
+
+ scene
+ .ccmd("md5sum")
+ .arg("--ignore-missing")
+ .arg(at.subdir.join("testf.sha1"))
+ .fails()
+ .stderr_contains("the --ignore-missing option is meaningful only when verifying checksums");
+}
+
+#[test]
+fn test_check_b2sum_length_option_0() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.write("testf", "foobar\n");
+ at.write("testf.b2sum", "9e2bf63e933e610efee4a8d6cd4a9387e80860edee97e27db3b37a828d226ab1eb92a9cdd8ca9ca67a753edaf8bd89a0558496f67a30af6f766943839acf0110 testf\n");
+
+ scene
+ .ccmd("b2sum")
+ .arg("--length=0")
+ .arg("-c")
+ .arg(at.subdir.join("testf.b2sum"))
+ .succeeds()
+ .stdout_only("testf: OK\n");
+}
+
+#[test]
+fn test_check_b2sum_length_duplicate() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.write("testf", "foobar\n");
+
+ scene
+ .ccmd("b2sum")
+ .arg("--length=123")
+ .arg("--length=128")
+ .arg("testf")
+ .succeeds()
+ .stdout_contains("d6d45901dec53e65d2b55fb6e2ab67b0");
+}
+
+#[test]
+fn test_check_b2sum_length_option_8() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.write("testf", "foobar\n");
+ at.write("testf.b2sum", "6a testf\n");
+
+ scene
+ .ccmd("b2sum")
+ .arg("--length=8")
+ .arg("-c")
+ .arg(at.subdir.join("testf.b2sum"))
+ .succeeds()
+ .stdout_only("testf: OK\n");
+}
+
+#[test]
+fn test_invalid_b2sum_length_option_not_multiple_of_8() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.write("testf", "foobar\n");
+
+ scene
+ .ccmd("b2sum")
+ .arg("--length=9")
+ .arg(at.subdir.join("testf"))
+ .fails()
+ .code_is(1);
+}
+
+#[test]
+fn test_invalid_b2sum_length_option_too_large() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.write("testf", "foobar\n");
+
+ scene
+ .ccmd("b2sum")
+ .arg("--length=513")
+ .arg(at.subdir.join("testf"))
+ .fails()
+ .code_is(1);
+}
+
+#[test]
+fn test_check_b2sum_tag_output() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+
+ scene
+ .ccmd("b2sum")
+ .arg("--length=0")
+ .arg("--tag")
+ .arg("f")
+ .succeeds()
+ .stdout_only("BLAKE2b (f) = 786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce\n");
+
+ scene
+ .ccmd("b2sum")
+ .arg("--length=128")
+ .arg("--tag")
+ .arg("f")
+ .succeeds()
+ .stdout_only("BLAKE2b-128 (f) = cae66941d9efbd404e4d88758ea67670\n");
+}
+
+#[test]
+fn test_check_b2sum_verify() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.write("a", "a\n");
+
+ scene
+ .ccmd("b2sum")
+ .arg("--tag")
+ .arg("a")
+ .succeeds()
+ .stdout_only("BLAKE2b (a) = bedfbb90d858c2d67b7ee8f7523be3d3b54004ef9e4f02f2ad79a1d05bfdfe49b81e3c92ebf99b504102b6bf003fa342587f5b3124c205f55204e8c4b4ce7d7c\n");
+
+ scene
+ .ccmd("b2sum")
+ .arg("--tag")
+ .arg("-l")
+ .arg("128")
+ .arg("a")
+ .succeeds()
+ .stdout_only("BLAKE2b-128 (a) = b93e0fc7bb21633c08bba07c5e71dc00\n");
+}
+
#[test]
fn test_check_file_not_found_warning() {
let scene = TestScenario::new(util_name!());
@@ -132,12 +309,584 @@ fn test_check_file_not_found_warning() {
.ccmd("sha1sum")
.arg("-c")
.arg(at.subdir.join("testf.sha1"))
+ .fails()
+ .stdout_is("testf: FAILED open or read\n")
+ .stderr_is("sha1sum: testf: No such file or directory\nsha1sum: WARNING: 1 listed file could not be read\n");
+}
+
+// Asterisk `*` is a reserved paths character on win32, nor the path can end with a whitespace.
+// ref: https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#naming-conventions
+#[test]
+fn test_check_md5sum() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ #[cfg(not(windows))]
+ {
+ for f in &["a", " b", "*c", "dd", " "] {
+ at.write(f, &format!("{f}\n"));
+ }
+ at.write(
+ "check.md5sum",
+ "60b725f10c9c85c70d97880dfe8191b3 a\n\
+ bf35d7536c785cf06730d5a40301eba2 b\n\
+ f5b61709718c1ecf8db1aea8547d4698 *c\n\
+ b064a020db8018f18ff5ae367d01b212 dd\n\
+ d784fa8b6d98d27699781bd9a7cf19f0 ",
+ );
+ scene
+ .ccmd("md5sum")
+ .arg("--strict")
+ .arg("-c")
+ .arg("check.md5sum")
+ .succeeds()
+ .stdout_is("a: OK\n b: OK\n*c: OK\ndd: OK\n : OK\n")
+ .stderr_is("");
+ }
+ #[cfg(windows)]
+ {
+ for f in &["a", " b", "dd"] {
+ at.write(f, &format!("{f}\n"));
+ }
+ at.write(
+ "check.md5sum",
+ "60b725f10c9c85c70d97880dfe8191b3 a\n\
+ bf35d7536c785cf06730d5a40301eba2 b\n\
+ b064a020db8018f18ff5ae367d01b212 dd",
+ );
+ scene
+ .ccmd("md5sum")
+ .arg("--strict")
+ .arg("-c")
+ .arg("check.md5sum")
+ .succeeds()
+ .stdout_is("a: OK\n b: OK\ndd: OK\n")
+ .stderr_is("");
+ }
+}
+
+// GNU also supports one line sep
+#[test]
+fn test_check_md5sum_only_one_space() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ for f in ["a", " b", "c"] {
+ at.write(f, &format!("{f}\n"));
+ }
+ at.write(
+ "check.md5sum",
+ "60b725f10c9c85c70d97880dfe8191b3 a\n\
+ bf35d7536c785cf06730d5a40301eba2 b\n\
+ 2cd6ee2c70b0bde53fbe6cac3c8b8bb1 c\n",
+ );
+ scene
+ .ccmd("md5sum")
+ .arg("--strict")
+ .arg("-c")
+ .arg("check.md5sum")
.succeeds()
- .stdout_is("sha1sum: testf: No such file or directory\ntestf: FAILED open or read\n")
- .stderr_is("sha1sum: warning: 1 listed file could not be read");
+ .stdout_only("a: OK\n b: OK\nc: OK\n");
+}
+
+#[test]
+fn test_check_md5sum_reverse_bsd() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ #[cfg(not(windows))]
+ {
+ for f in &["a", " b", "*c", "dd", " "] {
+ at.write(f, &format!("{f}\n"));
+ }
+ at.write(
+ "check.md5sum",
+ "60b725f10c9c85c70d97880dfe8191b3 a\n\
+ bf35d7536c785cf06730d5a40301eba2 b\n\
+ f5b61709718c1ecf8db1aea8547d4698 *c\n\
+ b064a020db8018f18ff5ae367d01b212 dd\n\
+ d784fa8b6d98d27699781bd9a7cf19f0 ",
+ );
+ scene
+ .ccmd("md5sum")
+ .arg("--strict")
+ .arg("-c")
+ .arg("check.md5sum")
+ .succeeds()
+ .stdout_is("a: OK\n b: OK\n*c: OK\ndd: OK\n : OK\n")
+ .stderr_is("");
+ }
+ #[cfg(windows)]
+ {
+ for f in &["a", " b", "dd"] {
+ at.write(f, &format!("{f}\n"));
+ }
+ at.write(
+ "check.md5sum",
+ "60b725f10c9c85c70d97880dfe8191b3 a\n\
+ bf35d7536c785cf06730d5a40301eba2 b\n\
+ b064a020db8018f18ff5ae367d01b212 dd",
+ );
+ scene
+ .ccmd("md5sum")
+ .arg("--strict")
+ .arg("-c")
+ .arg("check.md5sum")
+ .succeeds()
+ .stdout_is("a: OK\n b: OK\ndd: OK\n")
+ .stderr_is("");
+ }
+}
+
+#[test]
+fn test_check_md5sum_mixed_format() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ #[cfg(not(windows))]
+ {
+ for f in &[" b", "*c", "dd", " "] {
+ at.write(f, &format!("{f}\n"));
+ }
+ at.write(
+ "check.md5sum",
+ "bf35d7536c785cf06730d5a40301eba2 b\n\
+ f5b61709718c1ecf8db1aea8547d4698 *c\n\
+ b064a020db8018f18ff5ae367d01b212 dd\n\
+ d784fa8b6d98d27699781bd9a7cf19f0 ",
+ );
+ }
+ #[cfg(windows)]
+ {
+ for f in &[" b", "dd"] {
+ at.write(f, &format!("{f}\n"));
+ }
+ at.write(
+ "check.md5sum",
+ "bf35d7536c785cf06730d5a40301eba2 b\n\
+ b064a020db8018f18ff5ae367d01b212 dd",
+ );
+ }
+ scene
+ .ccmd("md5sum")
+ .arg("--strict")
+ .arg("-c")
+ .arg("check.md5sum")
+ .fails()
+ .code_is(1);
}
#[test]
fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
}
+
+#[test]
+fn test_conflicting_arg() {
+ new_ucmd!()
+ .arg("--tag")
+ .arg("--check")
+ .arg("--md5")
+ .fails()
+ .code_is(1);
+ new_ucmd!()
+ .arg("--tag")
+ .arg("--text")
+ .arg("--md5")
+ .fails()
+ .code_is(1);
+}
+
+#[test]
+fn test_tag() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.write("foobar", "foo bar\n");
+ scene
+ .ccmd("sha256sum")
+ .arg("--tag")
+ .arg("foobar")
+ .succeeds()
+ .stdout_is(
+ "SHA256 (foobar) = 1f2ec52b774368781bed1d1fb140a92e0eb6348090619c9291f9a5a3c8e8d151\n",
+ );
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_with_escape_filename() {
+ let scene = TestScenario::new(util_name!());
+
+ let at = &scene.fixtures;
+ let filename = "a\nb";
+ at.touch(filename);
+ let result = scene.ccmd("md5sum").arg("--text").arg(filename).succeeds();
+ let stdout = result.stdout_str();
+ println!("stdout {stdout}");
+ assert!(stdout.starts_with('\\'));
+ assert!(stdout.trim().ends_with("a\\nb"));
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_with_escape_filename_zero_text() {
+ let scene = TestScenario::new(util_name!());
+
+ let at = &scene.fixtures;
+ let filename = "a\nb";
+ at.touch(filename);
+ let result = scene
+ .ccmd("md5sum")
+ .arg("--text")
+ .arg("--zero")
+ .arg(filename)
+ .succeeds();
+ let stdout = result.stdout_str();
+ println!("stdout {stdout}");
+ assert!(!stdout.starts_with('\\'));
+ assert!(stdout.contains("a\nb"));
+}
+
+#[test]
+fn test_check_empty_line() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+ at.write(
+ "in.md5",
+ "d41d8cd98f00b204e9800998ecf8427e f\n\nd41d8cd98f00b204e9800998ecf8427e f\ninvalid\n\n",
+ );
+ scene
+ .ccmd("md5sum")
+ .arg("--check")
+ .arg(at.subdir.join("in.md5"))
+ .succeeds()
+ .stderr_contains("WARNING: 1 line is improperly formatted");
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_check_with_escape_filename() {
+ let scene = TestScenario::new(util_name!());
+
+ let at = &scene.fixtures;
+
+ let filename = "a\nb";
+ at.touch(filename);
+ let result = scene.ccmd("md5sum").arg("--tag").arg(filename).succeeds();
+ let stdout = result.stdout_str();
+ println!("stdout {stdout}");
+ assert!(stdout.starts_with("\\MD5"));
+ assert!(stdout.contains("a\\nb"));
+ at.write("check.md5", stdout);
+ let result = scene
+ .ccmd("md5sum")
+ .arg("--strict")
+ .arg("-c")
+ .arg("check.md5")
+ .succeeds();
+ result.stdout_is("\\a\\nb: OK\n");
+}
+
+#[test]
+fn test_check_strict_error() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+ at.write(
+ "in.md5",
+ "ERR\nERR\nd41d8cd98f00b204e9800998ecf8427e f\nERR\n",
+ );
+ scene
+ .ccmd("md5sum")
+ .arg("--check")
+ .arg("--strict")
+ .arg(at.subdir.join("in.md5"))
+ .fails()
+ .stderr_contains("WARNING: 3 lines are improperly formatted");
+}
+
+#[test]
+fn test_check_warn() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+ at.write(
+ "in.md5",
+ "d41d8cd98f00b204e9800998ecf8427e f\nd41d8cd98f00b204e9800998ecf8427e f\ninvalid\n",
+ );
+ scene
+ .ccmd("md5sum")
+ .arg("--check")
+ .arg("--warn")
+ .arg(at.subdir.join("in.md5"))
+ .succeeds()
+ .stderr_contains("in.md5: 3: improperly formatted MD5 checksum line")
+ .stderr_contains("WARNING: 1 line is improperly formatted");
+
+ // with strict, we should fail the execution
+ scene
+ .ccmd("md5sum")
+ .arg("--check")
+ .arg("--strict")
+ .arg(at.subdir.join("in.md5"))
+ .fails();
+}
+
+#[test]
+fn test_check_status() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+ at.write("in.md5", "MD5(f)= d41d8cd98f00b204e9800998ecf8427f\n");
+ scene
+ .ccmd("md5sum")
+ .arg("--check")
+ .arg("--status")
+ .arg(at.subdir.join("in.md5"))
+ .fails()
+ .no_output();
+}
+
+#[test]
+fn test_check_status_code() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+ at.write("in.md5", "d41d8cd98f00b204e9800998ecf8427f f\n");
+ scene
+ .ccmd("md5sum")
+ .arg("--check")
+ .arg("--status")
+ .arg(at.subdir.join("in.md5"))
+ .fails()
+ .stderr_is("")
+ .stdout_is("");
+}
+
+#[test]
+fn test_sha1_with_md5sum_should_fail() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+ at.write("f.sha1", "SHA1 (f) = d41d8cd98f00b204e9800998ecf8427e\n");
+ scene
+ .ccmd("md5sum")
+ .arg("--check")
+ .arg(at.subdir.join("f.sha1"))
+ .fails()
+ .stderr_contains("f.sha1: no properly formatted checksum lines found")
+ .stderr_does_not_contain("WARNING: 1 line is improperly formatted");
+}
+
+#[test]
+// Disabled on Windows because of the "*"
+#[cfg(not(windows))]
+fn test_check_one_two_space_star() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("empty");
+
+ // with one space, the "*" is removed
+ at.write("in.md5", "d41d8cd98f00b204e9800998ecf8427e *empty\n");
+
+ scene
+ .ccmd("md5sum")
+ .arg("--check")
+ .arg(at.subdir.join("in.md5"))
+ .succeeds()
+ .stdout_is("empty: OK\n");
+
+ // with two spaces, the "*" is not removed
+ at.write("in.md5", "d41d8cd98f00b204e9800998ecf8427e *empty\n");
+ // First should fail as *empty doesn't exit
+ scene
+ .ccmd("md5sum")
+ .arg("--check")
+ .arg(at.subdir.join("in.md5"))
+ .fails()
+ .stdout_is("*empty: FAILED open or read\n");
+
+ at.touch("*empty");
+ // Should pass as we have the file
+ scene
+ .ccmd("md5sum")
+ .arg("--check")
+ .arg(at.subdir.join("in.md5"))
+ .succeeds()
+ .stdout_is("*empty: OK\n");
+}
+
+#[test]
+// Disabled on Windows because of the "*"
+#[cfg(not(windows))]
+fn test_check_space_star_or_not() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("a");
+ at.touch("*c");
+
+ // with one space, the "*" is removed
+ at.write(
+ "in.md5",
+ "d41d8cd98f00b204e9800998ecf8427e *c\n
+ d41d8cd98f00b204e9800998ecf8427e a\n",
+ );
+
+ scene
+ .ccmd("md5sum")
+ .arg("--check")
+ .arg(at.subdir.join("in.md5"))
+ .fails()
+ .stdout_contains("c: FAILED")
+ .stdout_does_not_contain("a: FAILED")
+ .stderr_contains("WARNING: 1 line is improperly formatted");
+
+ at.write(
+ "in.md5",
+ "d41d8cd98f00b204e9800998ecf8427e a\n
+ d41d8cd98f00b204e9800998ecf8427e *c\n",
+ );
+
+ // First should fail as *empty doesn't exit
+ scene
+ .ccmd("md5sum")
+ .arg("--check")
+ .arg(at.subdir.join("in.md5"))
+ .succeeds()
+ .stdout_contains("a: OK")
+ .stderr_contains("WARNING: 1 line is improperly formatted");
+}
+
+#[test]
+fn test_check_no_backslash_no_space() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+ at.write("in.md5", "MD5(f)= d41d8cd98f00b204e9800998ecf8427e\n");
+ scene
+ .ccmd("md5sum")
+ .arg("--check")
+ .arg(at.subdir.join("in.md5"))
+ .succeeds()
+ .stdout_is("f: OK\n");
+}
+
+#[test]
+fn test_incomplete_format() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+ at.write("in.md5", "MD5 (\n");
+ scene
+ .ccmd("md5sum")
+ .arg("--check")
+ .arg(at.subdir.join("in.md5"))
+ .fails()
+ .stderr_contains("no properly formatted checksum lines found");
+}
+
+#[test]
+fn test_start_error() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+ at.write("in.md5", "ERR\nd41d8cd98f00b204e9800998ecf8427e f\n");
+ scene
+ .ccmd("md5sum")
+ .arg("--check")
+ .arg("--strict")
+ .arg(at.subdir.join("in.md5"))
+ .fails()
+ .stdout_is("f: OK\n")
+ .stderr_contains("WARNING: 1 line is improperly formatted");
+}
+
+#[test]
+fn test_check_check_ignore_no_file() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+ at.write("in.md5", "d41d8cd98f00b204e9800998ecf8427f missing\n");
+ scene
+ .ccmd("md5sum")
+ .arg("--check")
+ .arg("--ignore-missing")
+ .arg(at.subdir.join("in.md5"))
+ .fails()
+ .stderr_contains("in.md5: no file was verified");
+}
+
+#[test]
+fn test_check_directory_error() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.mkdir("d");
+ at.write("in.md5", "d41d8cd98f00b204e9800998ecf8427f d\n");
+ #[cfg(not(windows))]
+ let err_msg = "md5sum: d: Is a directory\n";
+ #[cfg(windows)]
+ let err_msg = "md5sum: d: Permission denied\n";
+ scene
+ .ccmd("md5sum")
+ .arg("--check")
+ .arg(at.subdir.join("in.md5"))
+ .fails()
+ .stderr_contains(err_msg);
+}
+
+#[test]
+fn test_check_quiet() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+ at.write("in.md5", "d41d8cd98f00b204e9800998ecf8427e f\n");
+ scene
+ .ccmd("md5sum")
+ .arg("--quiet")
+ .arg("--check")
+ .arg(at.subdir.join("in.md5"))
+ .succeeds()
+ .no_output();
+
+ // incorrect md5
+ at.write("in.md5", "d41d8cd98f00b204e9800998ecf8427f f\n");
+ scene
+ .ccmd("md5sum")
+ .arg("--quiet")
+ .arg("--check")
+ .arg(at.subdir.join("in.md5"))
+ .fails()
+ .stdout_contains("f: FAILED")
+ .stderr_contains("WARNING: 1 computed checksum did NOT match");
+}
+
+#[test]
+fn test_star_to_start() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("f");
+ at.write("in.md5", "d41d8cd98f00b204e9800998ecf8427e *f\n");
+ scene
+ .ccmd("md5sum")
+ .arg("--check")
+ .arg(at.subdir.join("in.md5"))
+ .succeeds()
+ .stdout_only("f: OK\n");
+}
diff --git a/tests/by-util/test_head.rs b/tests/by-util/test_head.rs
index cefb5c0ae7d136efc646f2656b4be7ad78d39acf..11a18f34cb7b842a8a00555d30bc27b56904e1d0 100644
--- a/tests/by-util/test_head.rs
+++ b/tests/by-util/test_head.rs
@@ -1,11 +1,11 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (words) bogusfile emptyfile abcdefghijklmnopqrstuvwxyz abcdefghijklmnopqrstu
-use crate::common::util::*;
+use crate::common::util::TestScenario;
static INPUT: &str = "lorem_ipsum.txt";
@@ -99,10 +99,8 @@ fn test_verbose() {
}
#[test]
-#[ignore]
fn test_spams_newline() {
- //this test is does not mirror what GNU does
- new_ucmd!().pipe_in("a").succeeds().stdout_is("a\n");
+ new_ucmd!().pipe_in("a").succeeds().stdout_is("a");
}
#[test]
@@ -189,6 +187,15 @@ fn test_no_such_file_or_directory() {
.stderr_contains("cannot open 'no_such_file.toml' for reading: No such file or directory");
}
+#[test]
+fn test_lines_leading_zeros() {
+ new_ucmd!()
+ .arg("--lines=010")
+ .pipe_in("\n\n\n\n\n\n\n\n\n\n\n\n")
+ .succeeds()
+ .stdout_is("\n\n\n\n\n\n\n\n\n\n");
+}
+
/// Test that each non-existent files gets its own error message printed.
#[test]
fn test_multiple_nonexistent_files() {
@@ -288,21 +295,23 @@ fn test_head_invalid_num() {
new_ucmd!()
.args(&["-c", "1024R", "emptyfile.txt"])
.fails()
- .stderr_is("head: invalid number of bytes: '1024R'");
+ .stderr_is(
+ "head: invalid number of bytes: '1024R': Value too large for defined data type\n",
+ );
new_ucmd!()
.args(&["-n", "1024R", "emptyfile.txt"])
.fails()
- .stderr_is("head: invalid number of lines: '1024R'");
- #[cfg(not(target_pointer_width = "128"))]
+ .stderr_is(
+ "head: invalid number of lines: '1024R': Value too large for defined data type\n",
+ );
new_ucmd!()
.args(&["-c", "1Y", "emptyfile.txt"])
.fails()
- .stderr_is("head: invalid number of bytes: '1Y': Value too large for defined data type");
- #[cfg(not(target_pointer_width = "128"))]
+ .stderr_is("head: invalid number of bytes: '1Y': Value too large for defined data type\n");
new_ucmd!()
.args(&["-n", "1Y", "emptyfile.txt"])
.fails()
- .stderr_is("head: invalid number of lines: '1Y': Value too large for defined data type");
+ .stderr_is("head: invalid number of lines: '1Y': Value too large for defined data type\n");
#[cfg(target_pointer_width = "32")]
{
let sizes = ["1000G", "10T"];
@@ -317,13 +326,13 @@ fn test_head_invalid_num() {
new_ucmd!()
.args(&["-c", size])
.fails()
- .stderr_is("head: out of range integral type conversion attempted: number of bytes is too large");
+ .stderr_is("head: out of range integral type conversion attempted: number of -bytes or -lines is too large\n");
}
}
new_ucmd!()
.args(&["-c", "-³"])
.fails()
- .stderr_is("head: invalid number of bytes: '³'");
+ .stderr_is("head: invalid number of bytes: '³'\n");
}
#[test]
@@ -365,3 +374,83 @@ fn test_presume_input_pipe_5_chars() {
.run()
.stdout_is_fixture("lorem_ipsum_5_chars.expected");
}
+
+#[cfg(all(
+ not(target_os = "windows"),
+ not(target_os = "macos"),
+ not(target_os = "android"),
+ not(target_os = "freebsd")
+))]
+#[test]
+fn test_read_backwards_bytes_proc_fs_version() {
+ let ts = TestScenario::new(util_name!());
+
+ let args = ["-c", "-1", "/proc/version"];
+ let result = ts.ucmd().args(&args).succeeds();
+ assert!(!result.stdout().is_empty());
+}
+
+#[cfg(all(
+ not(target_os = "windows"),
+ not(target_os = "macos"),
+ not(target_os = "android"),
+ not(target_os = "freebsd")
+))]
+#[test]
+fn test_read_backwards_bytes_proc_fs_modules() {
+ let ts = TestScenario::new(util_name!());
+
+ let args = ["-c", "-1", "/proc/modules"];
+ let result = ts.ucmd().args(&args).succeeds();
+ assert!(!result.stdout().is_empty());
+}
+
+#[cfg(all(
+ not(target_os = "windows"),
+ not(target_os = "macos"),
+ not(target_os = "android"),
+ not(target_os = "freebsd")
+))]
+#[test]
+fn test_read_backwards_lines_proc_fs_modules() {
+ let ts = TestScenario::new(util_name!());
+
+ let args = ["--lines", "-1", "/proc/modules"];
+ let result = ts.ucmd().args(&args).succeeds();
+ assert!(!result.stdout().is_empty());
+}
+
+#[cfg(all(
+ not(target_os = "windows"),
+ not(target_os = "macos"),
+ not(target_os = "android"),
+ not(target_os = "freebsd")
+))]
+#[test]
+fn test_read_backwards_bytes_sys_kernel_profiling() {
+ let ts = TestScenario::new(util_name!());
+
+ let args = ["-c", "-1", "/sys/kernel/profiling"];
+ let result = ts.ucmd().args(&args).succeeds();
+ let stdout_str = result.stdout_str();
+ assert_eq!(stdout_str.len(), 1);
+ assert!(stdout_str == "0" || stdout_str == "1");
+}
+
+#[test]
+fn test_value_too_large() {
+ const MAX: u64 = u64::MAX;
+
+ new_ucmd!()
+ .args(&["-n", format!("{MAX}0").as_str(), "lorem_ipsum.txt"])
+ .fails()
+ .stderr_contains("Value too large for defined data type");
+}
+
+#[test]
+fn test_all_but_last_lines() {
+ new_ucmd!()
+ .args(&["-n", "-15", "lorem_ipsum.txt"])
+ .succeeds()
+ .stdout_is_fixture("lorem_ipsum_backwards_15_lines.expected");
+}
diff --git a/tests/by-util/test_hostid.rs b/tests/by-util/test_hostid.rs
index 3ea818480b60f0766512c8dbaa70163fba40b97f..7525f5e08825b02e28ac255e7d44601146b17ad7 100644
--- a/tests/by-util/test_hostid.rs
+++ b/tests/by-util/test_hostid.rs
@@ -1,9 +1,21 @@
-use crate::common::util::*;
-extern crate regex;
-use self::regex::Regex;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
+use regex::Regex;
#[test]
fn test_normal() {
let re = Regex::new(r"^[0-9a-f]{8}").unwrap();
new_ucmd!().succeeds().stdout_matches(&re);
}
+
+#[test]
+fn test_invalid_flag() {
+ new_ucmd!()
+ .arg("--invalid-argument")
+ .fails()
+ .no_stdout()
+ .code_is(1);
+}
diff --git a/tests/by-util/test_hostname.rs b/tests/by-util/test_hostname.rs
index 474be8b3e172d283fbda5b62bb3d30832ec0fb95..972ec4aabbf373f43e67d51b07278da6796ecb50 100644
--- a/tests/by-util/test_hostname.rs
+++ b/tests/by-util/test_hostname.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
#[test]
fn test_hostname() {
@@ -10,8 +14,8 @@ fn test_hostname() {
assert!(ls_default_res.stdout().len() >= ls_domain_res.stdout().len());
}
-// FixME: fails for "MacOS" and "freebsd" "failed to lookup address information: Name does not resolve"
-#[cfg(not(any(target_os = "macos", target_os = "freebsd")))]
+// FixME: fails for "MacOS", "freebsd" and "openbsd" "failed to lookup address information: Name does not resolve"
+#[cfg(not(any(target_os = "macos", target_os = "freebsd", target_os = "openbsd")))]
#[test]
fn test_hostname_ip() {
let result = new_ucmd!().arg("-i").succeeds();
diff --git a/tests/by-util/test_id.rs b/tests/by-util/test_id.rs
index b7b36c58db55b5caf62f20e9e69b924076be6e49..070ed011e2678995833c79fd1c3d986f5f5346a4 100644
--- a/tests/by-util/test_id.rs
+++ b/tests/by-util/test_id.rs
@@ -1,11 +1,11 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) coreutil
-use crate::common::util::*;
+use crate::common::util::{check_coreutil_version, expected_result, is_ci, whoami, TestScenario};
const VERSION_MIN_MULTIPLE_USERS: &str = "8.31"; // this feature was introduced in GNU's coreutils 8.31
@@ -327,6 +327,11 @@ fn test_id_default_format() {
.args(&args)
.succeeds()
.stdout_only(unwrap_or_return!(expected_result(&ts, &args)).stdout_str());
+ let args = [opt2, opt2];
+ ts.ucmd()
+ .args(&args)
+ .succeeds()
+ .stdout_only(unwrap_or_return!(expected_result(&ts, &args)).stdout_str());
}
}
@@ -456,3 +461,16 @@ fn test_id_no_specified_user_posixly() {
}
}
}
+
+#[test]
+#[cfg(all(unix, not(target_os = "android")))]
+fn test_id_pretty_print_password_record() {
+ // `-p` is BSD only and not supported on GNU's `id`.
+ // `-P` is our own extension, and not supported by either GNU nor BSD.
+ // These must conflict, because they both set the output format.
+ new_ucmd!()
+ .arg("-p")
+ .arg("-P")
+ .fails()
+ .stderr_contains("the argument '-p' cannot be used with '-P'");
+}
diff --git a/tests/by-util/test_install.rs b/tests/by-util/test_install.rs
index 4d2ead83bcb9a6b0ecf645fda99a74dcae4541bd..b07da43dc755583d14bdd19bad35688a32a74763 100644
--- a/tests/by-util/test_install.rs
+++ b/tests/by-util/test_install.rs
@@ -1,13 +1,18 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (words) helloworld nodir objdump n'source
-use crate::common::util::*;
+use crate::common::util::{is_ci, run_ucmd_as_root, TestScenario};
use filetime::FileTime;
-use rust_users::*;
-use std::os::unix::fs::PermissionsExt;
-#[cfg(not(any(windows, target_os = "freebsd")))]
+use std::fs;
+use std::os::unix::fs::{MetadataExt, PermissionsExt};
+#[cfg(not(windows))]
use std::process::Command;
#[cfg(any(target_os = "linux", target_os = "android"))]
use std::thread::sleep;
+use uucore::process::{getegid, geteuid};
#[test]
fn test_invalid_arg() {
@@ -28,8 +33,8 @@ fn test_install_basic() {
assert!(at.file_exists(file1));
assert!(at.file_exists(file2));
- assert!(at.file_exists(&format!("{}/{}", dir, file1)));
- assert!(at.file_exists(&format!("{}/{}", dir, file2)));
+ assert!(at.file_exists(format!("{dir}/{file1}")));
+ assert!(at.file_exists(format!("{dir}/{file2}")));
}
#[test]
@@ -76,7 +81,7 @@ fn test_install_unimplemented_arg() {
.fails()
.stderr_contains("Unimplemented");
- assert!(!at.file_exists(&format!("{}/{}", dir, file)));
+ assert!(!at.file_exists(format!("{dir}/{file}")));
}
#[test]
@@ -124,6 +129,37 @@ fn test_install_ancestors_mode_directories() {
assert_eq!(0o40_200_u32, at.metadata(target_dir).permissions().mode());
}
+#[test]
+fn test_install_ancestors_mode_directories_with_file() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let ancestor1 = "ancestor1";
+ let ancestor2 = "ancestor1/ancestor2";
+ let target_file = "ancestor1/ancestor2/target_file";
+ let directories_arg = "-D";
+ let mode_arg = "--mode=200";
+ let file = "file";
+ let probe = "probe";
+
+ at.mkdir(probe);
+ let default_perms = at.metadata(probe).permissions().mode();
+
+ at.touch(file);
+
+ ucmd.args(&[mode_arg, directories_arg, file, target_file])
+ .succeeds()
+ .no_stderr();
+
+ assert!(at.dir_exists(ancestor1));
+ assert!(at.dir_exists(ancestor2));
+ assert!(at.file_exists(target_file));
+
+ assert_eq!(default_perms, at.metadata(ancestor1).permissions().mode());
+ assert_eq!(default_perms, at.metadata(ancestor2).permissions().mode());
+
+ // Expected mode only on the target_file.
+ assert_eq!(0o100_200_u32, at.metadata(target_file).permissions().mode());
+}
+
#[test]
fn test_install_parent_directories() {
let (at, mut ucmd) = at_and_ucmd!();
@@ -181,7 +217,7 @@ fn test_install_mode_numeric() {
.succeeds()
.no_stderr();
- let dest_file = &format!("{}/{}", dir, file);
+ let dest_file = &format!("{dir}/{file}");
assert!(at.file_exists(file));
assert!(at.file_exists(dest_file));
let permissions = at.metadata(dest_file).permissions();
@@ -192,7 +228,7 @@ fn test_install_mode_numeric() {
scene.ucmd().arg(mode_arg).arg(file).arg(dir2).succeeds();
- let dest_file = &format!("{}/{}", dir2, file);
+ let dest_file = &format!("{dir2}/{file}");
assert!(at.file_exists(file));
assert!(at.file_exists(dest_file));
let permissions = at.metadata(dest_file).permissions();
@@ -210,7 +246,7 @@ fn test_install_mode_symbolic() {
at.mkdir(dir);
ucmd.arg(file).arg(dir).arg(mode_arg).succeeds().no_stderr();
- let dest_file = &format!("{}/{}", dir, file);
+ let dest_file = &format!("{dir}/{file}");
assert!(at.file_exists(file));
assert!(at.file_exists(dest_file));
let permissions = at.metadata(dest_file).permissions();
@@ -232,7 +268,7 @@ fn test_install_mode_failing() {
.fails()
.stderr_contains("Invalid mode string: invalid digit found in string");
- let dest_file = &format!("{}/{}", dir, file);
+ let dest_file = &format!("{dir}/{file}");
assert!(at.file_exists(file));
assert!(!at.file_exists(dest_file));
}
@@ -278,12 +314,12 @@ fn test_install_target_new_file() {
at.touch(file);
at.mkdir(dir);
ucmd.arg(file)
- .arg(format!("{}/{}", dir, file))
+ .arg(format!("{dir}/{file}"))
.succeeds()
.no_stderr();
assert!(at.file_exists(file));
- assert!(at.file_exists(&format!("{}/{}", dir, file)));
+ assert!(at.file_exists(format!("{dir}/{file}")));
}
#[test]
@@ -291,7 +327,7 @@ fn test_install_target_new_file_with_group() {
let (at, mut ucmd) = at_and_ucmd!();
let file = "file";
let dir = "target_dir";
- let gid = get_effective_gid();
+ let gid = getegid();
at.touch(file);
at.mkdir(dir);
@@ -299,7 +335,7 @@ fn test_install_target_new_file_with_group() {
.arg(file)
.arg("--group")
.arg(gid.to_string())
- .arg(format!("{}/{}", dir, file))
+ .arg(format!("{dir}/{file}"))
.run();
if is_ci() && result.stderr_str().contains("no such group:") {
@@ -310,7 +346,7 @@ fn test_install_target_new_file_with_group() {
result.success();
assert!(at.file_exists(file));
- assert!(at.file_exists(&format!("{}/{}", dir, file)));
+ assert!(at.file_exists(format!("{dir}/{file}")));
}
#[test]
@@ -318,7 +354,7 @@ fn test_install_target_new_file_with_owner() {
let (at, mut ucmd) = at_and_ucmd!();
let file = "file";
let dir = "target_dir";
- let uid = get_effective_uid();
+ let uid = geteuid();
at.touch(file);
at.mkdir(dir);
@@ -326,7 +362,7 @@ fn test_install_target_new_file_with_owner() {
.arg(file)
.arg("--owner")
.arg(uid.to_string())
- .arg(format!("{}/{}", dir, file))
+ .arg(format!("{dir}/{file}"))
.run();
if is_ci() && result.stderr_str().contains("no such user:") {
@@ -337,7 +373,7 @@ fn test_install_target_new_file_with_owner() {
result.success();
assert!(at.file_exists(file));
- assert!(at.file_exists(&format!("{}/{}", dir, file)));
+ assert!(at.file_exists(format!("{dir}/{file}")));
}
#[test]
@@ -350,7 +386,7 @@ fn test_install_target_new_file_failing_nonexistent_parent() {
at.touch(file1);
ucmd.arg(file1)
- .arg(format!("{}/{}", dir, file2))
+ .arg(format!("{dir}/{file2}"))
.fails()
.stderr_contains("No such file or directory");
}
@@ -416,13 +452,13 @@ fn test_install_nested_paths_copy_file() {
at.mkdir(dir1);
at.mkdir(dir2);
- at.touch(&format!("{}/{}", dir1, file1));
+ at.touch(format!("{dir1}/{file1}"));
- ucmd.arg(format!("{}/{}", dir1, file1))
+ ucmd.arg(format!("{dir1}/{file1}"))
.arg(dir2)
.succeeds()
.no_stderr();
- assert!(at.file_exists(&format!("{}/{}", dir2, file1)));
+ assert!(at.file_exists(format!("{dir2}/{file1}")));
}
#[test]
@@ -456,7 +492,7 @@ fn test_install_failing_omitting_directory() {
.fails()
.code_is(1)
.stderr_contains("omitting directory");
- assert!(at.file_exists(&format!("{}/{}", dir3, file1)));
+ assert!(at.file_exists(format!("{dir3}/{file1}")));
// install also fails, when only one source param is given
scene
@@ -574,13 +610,17 @@ fn test_install_copy_then_compare_file_with_extra_mode() {
}
const STRIP_TARGET_FILE: &str = "helloworld_installed";
-#[cfg(not(any(windows, target_os = "freebsd")))]
+#[cfg(all(not(windows), not(target_os = "freebsd")))]
const SYMBOL_DUMP_PROGRAM: &str = "objdump";
-#[cfg(not(any(windows, target_os = "freebsd")))]
+#[cfg(target_os = "freebsd")]
+const SYMBOL_DUMP_PROGRAM: &str = "llvm-objdump";
+#[cfg(not(windows))]
const STRIP_SOURCE_FILE_SYMBOL: &str = "main";
fn strip_source_file() -> &'static str {
- if cfg!(target_os = "macos") {
+ if cfg!(target_os = "freebsd") {
+ "helloworld_freebsd"
+ } else if cfg!(target_os = "macos") {
"helloworld_macos"
} else if cfg!(target_arch = "arm") || cfg!(target_arch = "aarch64") {
"helloworld_android"
@@ -590,8 +630,7 @@ fn strip_source_file() -> &'static str {
}
#[test]
-// FixME: Freebsd fails on 'No such file or directory'
-#[cfg(not(any(windows, target_os = "freebsd")))]
+#[cfg(not(windows))]
fn test_install_and_strip() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
@@ -614,8 +653,7 @@ fn test_install_and_strip() {
}
#[test]
-// FixME: Freebsd fails on 'No such file or directory'
-#[cfg(not(any(windows, target_os = "freebsd")))]
+#[cfg(not(windows))]
fn test_install_and_strip_with_program() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
@@ -639,6 +677,102 @@ fn test_install_and_strip_with_program() {
assert!(!stdout.contains(STRIP_SOURCE_FILE_SYMBOL));
}
+#[cfg(all(unix, feature = "chmod"))]
+#[test]
+fn test_install_and_strip_with_program_hyphen() {
+ let scene = TestScenario::new(util_name!());
+
+ let at = &scene.fixtures;
+ let content = r#"#!/bin/sh
+ printf -- '%s\n' "$1" | grep '^[^-]'
+ "#;
+ at.write("no-hyphen", content);
+ scene.ccmd("chmod").arg("+x").arg("no-hyphen").succeeds();
+
+ at.touch("src");
+ scene
+ .ucmd()
+ .arg("-s")
+ .arg("--strip-program")
+ .arg("./no-hyphen")
+ .arg("--")
+ .arg("src")
+ .arg("-dest")
+ .succeeds()
+ .no_stderr()
+ .stdout_is("./-dest\n");
+
+ scene
+ .ucmd()
+ .arg("-s")
+ .arg("--strip-program")
+ .arg("./no-hyphen")
+ .arg("--")
+ .arg("src")
+ .arg("./-dest")
+ .succeeds()
+ .no_stderr()
+ .stdout_is("./-dest\n");
+}
+
+#[cfg(all(unix, feature = "chmod"))]
+#[test]
+fn test_install_on_invalid_link_at_destination() {
+ let scene = TestScenario::new(util_name!());
+
+ let at = &scene.fixtures;
+ at.mkdir("src");
+ at.mkdir("dest");
+ let src_dir = at.plus("src");
+ let dst_dir = at.plus("dest");
+
+ at.touch("test.sh");
+ at.symlink_file(
+ "/opt/FakeDestination",
+ &dst_dir.join("test.sh").to_string_lossy(),
+ );
+ scene.ccmd("chmod").arg("+x").arg("test.sh").succeeds();
+ at.symlink_file("test.sh", &src_dir.join("test.sh").to_string_lossy());
+
+ scene
+ .ucmd()
+ .current_dir(&src_dir)
+ .arg(src_dir.join("test.sh"))
+ .arg(dst_dir.join("test.sh"))
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+}
+
+#[cfg(all(unix, feature = "chmod"))]
+#[test]
+fn test_install_on_invalid_link_at_destination_and_dev_null_at_source() {
+ let scene = TestScenario::new(util_name!());
+
+ let at = &scene.fixtures;
+ at.mkdir("src");
+ at.mkdir("dest");
+ let src_dir = at.plus("src");
+ let dst_dir = at.plus("dest");
+
+ at.touch("test.sh");
+ at.symlink_file(
+ "/opt/FakeDestination",
+ &dst_dir.join("test.sh").to_string_lossy(),
+ );
+ scene.ccmd("chmod").arg("+x").arg("test.sh").succeeds();
+ at.symlink_file("test.sh", &src_dir.join("test.sh").to_string_lossy());
+
+ scene
+ .ucmd()
+ .current_dir(&src_dir)
+ .arg("/dev/null")
+ .arg(dst_dir.join("test.sh"))
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+}
+
#[test]
#[cfg(not(windows))]
fn test_install_and_strip_with_invalid_program() {
@@ -754,7 +888,7 @@ fn test_install_creating_leading_dirs_with_single_source_and_target_dir() {
.succeeds()
.no_stderr();
- assert!(at.file_exists(&format!("{target_dir}/{source1}")));
+ assert!(at.file_exists(format!("{target_dir}/{source1}")));
}
#[test]
@@ -826,14 +960,14 @@ fn test_install_dir() {
at.mkdir(dir);
ucmd.arg(file1)
.arg(file2)
- .arg(&format!("--target-directory={}", dir))
+ .arg(&format!("--target-directory={dir}"))
.succeeds()
.no_stderr();
assert!(at.file_exists(file1));
assert!(at.file_exists(file2));
- assert!(at.file_exists(&format!("{}/{}", dir, file1)));
- assert!(at.file_exists(&format!("{}/{}", dir, file2)));
+ assert!(at.file_exists(format!("{dir}/{file1}")));
+ assert!(at.file_exists(format!("{dir}/{file2}")));
}
//
// test backup functionality
@@ -857,7 +991,7 @@ fn test_install_backup_short_no_args_files() {
assert!(at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}~", file_b)));
+ assert!(at.file_exists(format!("{file_b}~")));
}
#[test]
@@ -867,7 +1001,7 @@ fn test_install_backup_short_no_args_file_to_dir() {
let file = "test_install_simple_backup_file_a";
let dest_dir = "test_install_dest/";
- let expect = format!("{}{}", dest_dir, file);
+ let expect = format!("{dest_dir}{file}");
at.touch(file);
at.mkdir(dest_dir);
@@ -882,7 +1016,7 @@ fn test_install_backup_short_no_args_file_to_dir() {
assert!(at.file_exists(file));
assert!(at.file_exists(&expect));
- assert!(at.file_exists(&format!("{}~", expect)));
+ assert!(at.file_exists(format!("{expect}~")));
}
// Long --backup option is tested separately as it requires a slightly different
@@ -907,7 +1041,7 @@ fn test_install_backup_long_no_args_files() {
assert!(at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}~", file_b)));
+ assert!(at.file_exists(format!("{file_b}~")));
}
#[test]
@@ -917,7 +1051,7 @@ fn test_install_backup_long_no_args_file_to_dir() {
let file = "test_install_simple_backup_file_a";
let dest_dir = "test_install_dest/";
- let expect = format!("{}{}", dest_dir, file);
+ let expect = format!("{dest_dir}{file}");
at.touch(file);
at.mkdir(dest_dir);
@@ -932,7 +1066,7 @@ fn test_install_backup_long_no_args_file_to_dir() {
assert!(at.file_exists(file));
assert!(at.file_exists(&expect));
- assert!(at.file_exists(&format!("{}~", expect)));
+ assert!(at.file_exists(format!("{expect}~")));
}
#[test]
@@ -949,7 +1083,7 @@ fn test_install_backup_short_custom_suffix() {
scene
.ucmd()
.arg("-b")
- .arg(format!("--suffix={}", suffix))
+ .arg(format!("--suffix={suffix}"))
.arg(file_a)
.arg(file_b)
.succeeds()
@@ -957,7 +1091,7 @@ fn test_install_backup_short_custom_suffix() {
assert!(at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}{}", file_b, suffix)));
+ assert!(at.file_exists(format!("{file_b}{suffix}")));
}
#[test]
@@ -974,7 +1108,7 @@ fn test_install_backup_short_custom_suffix_hyphen_value() {
scene
.ucmd()
.arg("-b")
- .arg(format!("--suffix={}", suffix))
+ .arg(format!("--suffix={suffix}"))
.arg(file_a)
.arg(file_b)
.succeeds()
@@ -982,7 +1116,7 @@ fn test_install_backup_short_custom_suffix_hyphen_value() {
assert!(at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}{}", file_b, suffix)));
+ assert!(at.file_exists(format!("{file_b}{suffix}")));
}
#[test]
@@ -1007,7 +1141,7 @@ fn test_install_backup_custom_suffix_via_env() {
assert!(at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}{}", file_b, suffix)));
+ assert!(at.file_exists(format!("{file_b}{suffix}")));
}
#[test]
@@ -1030,7 +1164,7 @@ fn test_install_backup_numbered_with_t() {
assert!(at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}.~1~", file_b)));
+ assert!(at.file_exists(format!("{file_b}.~1~")));
}
#[test]
@@ -1053,7 +1187,7 @@ fn test_install_backup_numbered_with_numbered() {
assert!(at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}.~1~", file_b)));
+ assert!(at.file_exists(format!("{file_b}.~1~")));
}
#[test]
@@ -1076,7 +1210,7 @@ fn test_install_backup_existing() {
assert!(at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}~", file_b)));
+ assert!(at.file_exists(format!("{file_b}~")));
}
#[test]
@@ -1099,7 +1233,7 @@ fn test_install_backup_nil() {
assert!(at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}~", file_b)));
+ assert!(at.file_exists(format!("{file_b}~")));
}
#[test]
@@ -1125,7 +1259,7 @@ fn test_install_backup_numbered_if_existing_backup_existing() {
assert!(at.file_exists(file_a));
assert!(at.file_exists(file_b));
assert!(at.file_exists(file_b_backup));
- assert!(at.file_exists(&format!("{}.~2~", file_b)));
+ assert!(at.file_exists(format!("{file_b}.~2~")));
}
#[test]
@@ -1151,7 +1285,7 @@ fn test_install_backup_numbered_if_existing_backup_nil() {
assert!(at.file_exists(file_a));
assert!(at.file_exists(file_b));
assert!(at.file_exists(file_b_backup));
- assert!(at.file_exists(&format!("{}.~2~", file_b)));
+ assert!(at.file_exists(format!("{file_b}.~2~")));
}
#[test]
@@ -1174,7 +1308,7 @@ fn test_install_backup_simple() {
assert!(at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}~", file_b)));
+ assert!(at.file_exists(format!("{file_b}~")));
}
#[test]
@@ -1197,7 +1331,7 @@ fn test_install_backup_never() {
assert!(at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}~", file_b)));
+ assert!(at.file_exists(format!("{file_b}~")));
}
#[test]
@@ -1220,7 +1354,7 @@ fn test_install_backup_none() {
assert!(at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(!at.file_exists(&format!("{}~", file_b)));
+ assert!(!at.file_exists(format!("{file_b}~")));
}
#[test]
@@ -1243,7 +1377,7 @@ fn test_install_backup_off() {
assert!(at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(!at.file_exists(&format!("{}~", file_b)));
+ assert!(!at.file_exists(format!("{file_b}~")));
}
#[test]
@@ -1262,7 +1396,7 @@ fn test_install_missing_arguments() {
scene
.ucmd()
.arg("-D")
- .arg(format!("-t {}", no_target_dir))
+ .arg(format!("-t {no_target_dir}"))
.fails()
.usage_error("missing file operand");
assert!(!at.dir_exists(no_target_dir));
@@ -1280,17 +1414,19 @@ fn test_install_missing_destination() {
at.mkdir(dir_1);
// will fail and also print some info on correct usage
- scene.ucmd().arg(file_1).fails().usage_error(format!(
- "missing destination file operand after '{}'",
- file_1
- ));
+ scene
+ .ucmd()
+ .arg(file_1)
+ .fails()
+ .usage_error(format!("missing destination file operand after '{file_1}'"));
// GNU's install will check for correct num of arguments and then fail
// and it does not recognize, that the source is not a file but a directory.
- scene.ucmd().arg(dir_1).fails().usage_error(format!(
- "missing destination file operand after '{}'",
- dir_1
- ));
+ scene
+ .ucmd()
+ .arg(dir_1)
+ .fails()
+ .usage_error(format!("missing destination file operand after '{dir_1}'"));
}
#[test]
@@ -1367,6 +1503,100 @@ fn test_install_dir_req_verbose() {
.stdout_contains("install: creating directory 'sub5/a'\ninstall: creating directory 'sub5/a/b'\ninstall: creating directory 'sub5/a/b/c'\n'source_file1' -> 'sub5/a/b/c/file'");
}
+#[test]
+fn test_install_chown_file_invalid() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ let file_1 = "source_file1";
+ at.touch(file_1);
+
+ scene
+ .ucmd()
+ .arg("-o")
+ .arg("test_invalid_user")
+ .arg(file_1)
+ .arg("target_file1")
+ .fails()
+ .stderr_contains("install: invalid user: 'test_invalid_user'");
+
+ scene
+ .ucmd()
+ .arg("-g")
+ .arg("test_invalid_group")
+ .arg(file_1)
+ .arg("target_file1")
+ .fails()
+ .stderr_contains("install: invalid group: 'test_invalid_group'");
+
+ scene
+ .ucmd()
+ .arg("-o")
+ .arg("test_invalid_user")
+ .arg("-g")
+ .arg("test_invalid_group")
+ .arg(file_1)
+ .arg("target_file1")
+ .fails()
+ .stderr_contains("install: invalid user: 'test_invalid_user'");
+
+ scene
+ .ucmd()
+ .arg("-g")
+ .arg("test_invalid_group")
+ .arg("-o")
+ .arg("test_invalid_user")
+ .arg(file_1)
+ .arg("target_file1")
+ .fails()
+ .stderr_contains("install: invalid user: 'test_invalid_user'");
+}
+
+#[test]
+fn test_install_chown_directory_invalid() {
+ let scene = TestScenario::new(util_name!());
+
+ scene
+ .ucmd()
+ .arg("-o")
+ .arg("test_invalid_user")
+ .arg("-d")
+ .arg("dir1/dir2")
+ .fails()
+ .stderr_contains("install: invalid user: 'test_invalid_user'");
+
+ scene
+ .ucmd()
+ .arg("-g")
+ .arg("test_invalid_group")
+ .arg("-d")
+ .arg("dir1/dir2")
+ .fails()
+ .stderr_contains("install: invalid group: 'test_invalid_group'");
+
+ scene
+ .ucmd()
+ .arg("-o")
+ .arg("test_invalid_user")
+ .arg("-g")
+ .arg("test_invalid_group")
+ .arg("-d")
+ .arg("dir1/dir2")
+ .fails()
+ .stderr_contains("install: invalid user: 'test_invalid_user'");
+
+ scene
+ .ucmd()
+ .arg("-g")
+ .arg("test_invalid_group")
+ .arg("-o")
+ .arg("test_invalid_user")
+ .arg("-d")
+ .arg("dir1/dir2")
+ .fails()
+ .stderr_contains("install: invalid user: 'test_invalid_user'");
+}
+
#[test]
fn test_install_compare_option() {
let scene = TestScenario::new(util_name!());
@@ -1378,7 +1608,7 @@ fn test_install_compare_option() {
.ucmd()
.args(&["-Cv", first, second])
.succeeds()
- .stdout_contains(format!("'{}' -> '{}'", first, second));
+ .stdout_contains(format!("'{first}' -> '{second}'"));
scene
.ucmd()
.args(&["-Cv", first, second])
@@ -1388,12 +1618,12 @@ fn test_install_compare_option() {
.ucmd()
.args(&["-Cv", "-m0644", first, second])
.succeeds()
- .stdout_contains(format!("removed '{}'\n'{}' -> '{}'", second, first, second));
+ .stdout_contains(format!("removed '{second}'\n'{first}' -> '{second}'"));
scene
.ucmd()
.args(&["-Cv", first, second])
.succeeds()
- .stdout_contains(format!("removed '{}'\n'{}' -> '{}'", second, first, second));
+ .stdout_contains(format!("removed '{second}'\n'{first}' -> '{second}'"));
scene
.ucmd()
.args(&["-C", "--preserve-timestamps", first, second])
@@ -1407,3 +1637,80 @@ fn test_install_compare_option() {
.code_is(1)
.stderr_contains("Options --compare and --strip are mutually exclusive");
}
+
+#[test]
+// Matches part of tests/install/basic-1
+fn test_t_exist_dir() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ let source1 = "file";
+ let target_dir = "sub4/";
+ let target_file = "sub4/file_exists";
+
+ at.touch(source1);
+ at.mkdir(target_dir);
+ at.touch(target_file);
+
+ scene
+ .ucmd()
+ .arg("-t")
+ .arg(target_file)
+ .arg("-Dv")
+ .arg(source1)
+ .fails()
+ .stderr_contains("failed to access 'sub4/file_exists': Not a directory");
+}
+
+#[test]
+fn test_target_file_ends_with_slash() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ let source = "source_file";
+ let target_dir = "dir";
+ let target_file = "dir/target_file";
+ let target_file_slash = format!("{}/", target_file);
+
+ at.touch(source);
+ at.mkdir(target_dir);
+ at.touch(target_file);
+
+ scene
+ .ucmd()
+ .arg("-t")
+ .arg(target_file_slash)
+ .arg("-D")
+ .arg(source)
+ .fails()
+ .stderr_contains("failed to access 'dir/target_file/': Not a directory");
+}
+
+#[test]
+fn test_install_root_combined() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.touch("a");
+ at.touch("c");
+
+ let run_and_check = |args: &[&str], target: &str, expected_uid: u32, expected_gid: u32| {
+ if let Ok(result) = run_ucmd_as_root(&ts, args) {
+ result.success();
+ assert!(at.file_exists(target));
+
+ let metadata = fs::metadata(at.plus(target)).unwrap();
+ assert_eq!(metadata.uid(), expected_uid);
+ assert_eq!(metadata.gid(), expected_gid);
+ } else {
+ print!("Test skipped; requires root user");
+ }
+ };
+
+ run_and_check(&["-Cv", "-o1", "-g1", "a", "b"], "b", 1, 1);
+ run_and_check(&["-Cv", "-o2", "-g1", "a", "b"], "b", 2, 1);
+ run_and_check(&["-Cv", "-o2", "-g2", "a", "b"], "b", 2, 2);
+
+ run_and_check(&["-Cv", "-o2", "c", "d"], "d", 2, 0);
+ run_and_check(&["-Cv", "c", "d"], "d", 0, 0);
+ run_and_check(&["-Cv", "c", "d"], "d", 0, 0);
+}
diff --git a/tests/by-util/test_join.rs b/tests/by-util/test_join.rs
index 10af26ec5a8ada3a68974e91fbd293cdefa5756e..e2e5dc8688b6d8d7a95c84c9cfeb3970eccbcee4 100644
--- a/tests/by-util/test_join.rs
+++ b/tests/by-util/test_join.rs
@@ -1,6 +1,10 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (words) autoformat nocheck
-use crate::common::util::*;
+use crate::common::util::TestScenario;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "netbsd"))]
use std::fs::OpenOptions;
#[cfg(unix)]
@@ -206,7 +210,7 @@ fn tab_multi_character() {
.arg("-t")
.arg("Ñ")
.fails()
- .stderr_is("join: multi-character tab Ñ");
+ .stderr_is("join: multi-character tab Ñ\n");
}
#[test]
@@ -282,7 +286,7 @@ fn empty_format() {
.arg("-o")
.arg("")
.fails()
- .stderr_is("join: invalid file number in field spec: ''");
+ .stderr_is("join: invalid file number in field spec: ''\n");
}
#[test]
@@ -332,7 +336,7 @@ fn wrong_line_order() {
.fails()
.stdout_contains("7 g f 4 fg")
.stderr_is(&format!(
- "{0} {1}: fields_4.txt:5: is not sorted: 11 g 5 gh\n{0} {1}: input is not in sorted order",
+ "{0} {1}: fields_4.txt:5: is not sorted: 11 g 5 gh\n{0} {1}: input is not in sorted order\n",
ts.bin_path.to_string_lossy(),
ts.util_name
));
@@ -344,7 +348,7 @@ fn wrong_line_order() {
.fails()
.stdout_does_not_contain("7 g f 4 fg")
.stderr_is(&format!(
- "{0}: fields_4.txt:5: is not sorted: 11 g 5 gh",
+ "{0}: fields_4.txt:5: is not sorted: 11 g 5 gh\n",
ts.util_name
));
}
@@ -358,7 +362,7 @@ fn both_files_wrong_line_order() {
.fails()
.stdout_contains("5 e 3 ef")
.stderr_is(&format!(
- "{0} {1}: fields_5.txt:4: is not sorted: 3\n{0} {1}: fields_4.txt:5: is not sorted: 11 g 5 gh\n{0} {1}: input is not in sorted order",
+ "{0} {1}: fields_5.txt:4: is not sorted: 3\n{0} {1}: fields_4.txt:5: is not sorted: 11 g 5 gh\n{0} {1}: input is not in sorted order\n",
ts.bin_path.to_string_lossy(),
ts.util_name
));
@@ -370,7 +374,7 @@ fn both_files_wrong_line_order() {
.fails()
.stdout_does_not_contain("5 e 3 ef")
.stderr_is(&format!(
- "{0}: fields_5.txt:4: is not sorted: 3",
+ "{0}: fields_5.txt:4: is not sorted: 3\n",
ts.util_name
));
}
@@ -453,7 +457,7 @@ fn non_unicode() {
.arg("non-unicode_2.bin")
.fails()
.stderr_is(
- "join: unprintable field separators are only supported on unix-like platforms",
+ "join: unprintable field separators are only supported on unix-like platforms\n",
);
}
}
diff --git a/tests/by-util/test_kill.rs b/tests/by-util/test_kill.rs
index 43e281155a48d0ac181b6344285b9fa5bb831b1f..3915a70908df3bbfc59f4757dce0e3a7577c28e5 100644
--- a/tests/by-util/test_kill.rs
+++ b/tests/by-util/test_kill.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
use regex::Regex;
use std::os::unix::process::ExitStatusExt;
use std::process::{Child, Command};
@@ -58,7 +62,8 @@ fn test_kill_list_all_signals() {
.succeeds()
.stdout_contains("KILL")
.stdout_contains("TERM")
- .stdout_contains("HUP");
+ .stdout_contains("HUP")
+ .stdout_does_not_contain("EXIT");
}
#[test]
@@ -78,6 +83,29 @@ fn test_kill_list_all_signals_as_table() {
.stdout_contains("HUP");
}
+#[test]
+fn test_kill_table_starts_at_1() {
+ new_ucmd!()
+ .arg("-t")
+ .succeeds()
+ .stdout_matches(&Regex::new("^\\s?1\\sHUP").unwrap());
+}
+
+#[test]
+fn test_kill_table_lists_all_vertically() {
+ // Check for a few signals. Do not try to be comprehensive.
+ let command = new_ucmd!().arg("-t").succeeds();
+ let signals = command
+ .stdout_str()
+ .split('\n')
+ .flat_map(|line| line.trim().split(' ').nth(1))
+ .collect::<Vec<&str>>();
+
+ assert!(signals.contains(&"KILL"));
+ assert!(signals.contains(&"TERM"));
+ assert!(signals.contains(&"HUP"));
+}
+
#[test]
fn test_kill_list_one_signal_from_name() {
// Use SIGKILL because it is 9 on all unixes.
@@ -88,9 +116,59 @@ fn test_kill_list_one_signal_from_name() {
.stdout_matches(&Regex::new("\\b9\\b").unwrap());
}
+#[test]
+fn test_kill_list_one_signal_ignore_case() {
+ // Use SIGKILL because it is 9 on all unixes.
+ new_ucmd!()
+ .arg("-l")
+ .arg("KiLl")
+ .succeeds()
+ .stdout_matches(&Regex::new("\\b9\\b").unwrap());
+}
+
+#[test]
+fn test_kill_list_unknown_must_match_input_case() {
+ new_ucmd!()
+ .arg("-l")
+ .arg("IaMnOtAsIgNaL")
+ .fails()
+ .stderr_contains("IaMnOtAsIgNaL");
+}
+
+#[test]
+fn test_kill_list_all_vertically() {
+ // Check for a few signals. Do not try to be comprehensive.
+ let command = new_ucmd!().arg("-l").succeeds();
+ let signals = command.stdout_str().split('\n').collect::<Vec<&str>>();
+ assert!(signals.contains(&"KILL"));
+ assert!(signals.contains(&"TERM"));
+ assert!(signals.contains(&"HUP"));
+}
+
+#[test]
+fn test_kill_list_two_signal_from_name() {
+ new_ucmd!()
+ .arg("-l")
+ .arg("INT")
+ .arg("KILL")
+ .succeeds()
+ .stdout_matches(&Regex::new("\\d\n\\d").unwrap());
+}
+
+#[test]
+fn test_kill_list_three_signal_first_unknown() {
+ new_ucmd!()
+ .arg("-l")
+ .arg("IAMNOTASIGNAL") // spell-checker:disable-line
+ .arg("INT")
+ .arg("KILL")
+ .fails()
+ .stderr_contains("unknown signal")
+ .stdout_matches(&Regex::new("\\d\n\\d").unwrap());
+}
+
#[test]
fn test_kill_set_bad_signal_name() {
- // spell-checker:disable-line
new_ucmd!()
.arg("-s")
.arg("IAMNOTASIGNAL") // spell-checker:disable-line
@@ -157,6 +235,17 @@ fn test_kill_with_signal_name_new_form() {
assert_eq!(target.wait_for_signal(), Some(libc::SIGKILL));
}
+#[test]
+fn test_kill_with_signal_name_new_form_ignore_case() {
+ let mut target = Target::new();
+ new_ucmd!()
+ .arg("-s")
+ .arg("KiLl")
+ .arg(format!("{}", target.pid()))
+ .succeeds();
+ assert_eq!(target.wait_for_signal(), Some(libc::SIGKILL));
+}
+
#[test]
fn test_kill_with_signal_prefixed_name_new_form() {
let mut target = Target::new();
@@ -167,3 +256,43 @@ fn test_kill_with_signal_prefixed_name_new_form() {
.succeeds();
assert_eq!(target.wait_for_signal(), Some(libc::SIGKILL));
}
+
+#[test]
+fn test_kill_with_signal_prefixed_name_new_form_ignore_case() {
+ let mut target = Target::new();
+ new_ucmd!()
+ .arg("-s")
+ .arg("SiGKiLl")
+ .arg(format!("{}", target.pid()))
+ .succeeds();
+ assert_eq!(target.wait_for_signal(), Some(libc::SIGKILL));
+}
+
+#[test]
+fn test_kill_with_signal_name_new_form_unknown_must_match_input_case() {
+ let target = Target::new();
+ new_ucmd!()
+ .arg("-s")
+ .arg("IaMnOtAsIgNaL")
+ .arg(format!("{}", target.pid()))
+ .fails()
+ .stderr_contains("unknown signal")
+ .stderr_contains("IaMnOtAsIgNaL");
+}
+
+#[test]
+fn test_kill_no_pid_provided() {
+ new_ucmd!()
+ .fails()
+ .stderr_contains("no process ID specified");
+}
+
+#[test]
+fn test_kill_with_signal_exit_new_form() {
+ let target = Target::new();
+ new_ucmd!()
+ .arg("-s")
+ .arg("EXIT")
+ .arg(format!("{}", target.pid()))
+ .succeeds();
+}
diff --git a/tests/by-util/test_link.rs b/tests/by-util/test_link.rs
index c65dc29d8c8e010287c35887e4d2dde1d252e0c0..8d48931c424b7e0b0273a75b0b42c87018410d4a 100644
--- a/tests/by-util/test_link.rs
+++ b/tests/by-util/test_link.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
@@ -29,7 +33,7 @@ fn test_link_no_circular() {
ucmd.args(&[link, link])
.fails()
- .stderr_is("link: cannot create link 'test_link_no_circular' to 'test_link_no_circular': No such file or directory");
+ .stderr_is("link: cannot create link 'test_link_no_circular' to 'test_link_no_circular': No such file or directory\n");
assert!(!at.file_exists(link));
}
@@ -41,7 +45,7 @@ fn test_link_nonexistent_file() {
ucmd.args(&[file, link])
.fails()
- .stderr_only("link: cannot create link 'test_link_nonexistent_file_link' to 'test_link_nonexistent_file': No such file or directory");
+ .stderr_only("link: cannot create link 'test_link_nonexistent_file_link' to 'test_link_nonexistent_file': No such file or directory\n");
assert!(!at.file_exists(file));
assert!(!at.file_exists(link));
}
@@ -52,18 +56,18 @@ fn test_link_one_argument() {
let file = "test_link_argument";
ucmd.args(&[file])
.fails()
- .stderr_contains("requires 2 values");
+ .stderr_contains("2 values required");
}
#[test]
fn test_link_three_arguments() {
let (_, mut ucmd) = at_and_ucmd!();
- let arguments = vec![
+ let arguments = [
"test_link_argument1",
"test_link_argument2",
"test_link_argument3",
];
ucmd.args(&arguments[..])
.fails()
- .stderr_contains("requires 2 values");
+ .stderr_contains("2 values required");
}
diff --git a/tests/by-util/test_ln.rs b/tests/by-util/test_ln.rs
index 07b82464983119f38c474229cbf927f7f749cd22..b315630ce4e3b8fc801d956bacab2e154c62fbbc 100644
--- a/tests/by-util/test_ln.rs
+++ b/tests/by-util/test_ln.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
use std::path::PathBuf;
#[test]
@@ -116,7 +120,7 @@ fn test_symlink_interactive() {
.ucmd()
.args(&["-i", "-s", file, link])
.pipe_in("n")
- .succeeds()
+ .fails()
.no_stdout();
assert!(at.file_exists(file));
@@ -153,7 +157,7 @@ fn test_symlink_simple_backup() {
assert!(at.is_symlink(link));
assert_eq!(at.resolve_link(link), file);
- let backup = &format!("{}~", link);
+ let backup = &format!("{link}~");
assert!(at.is_symlink(backup));
assert_eq!(at.resolve_link(backup), file);
}
@@ -171,7 +175,7 @@ fn test_symlink_custom_backup_suffix() {
assert!(at.is_symlink(link));
assert_eq!(at.resolve_link(link), file);
- let arg = &format!("--suffix={}", suffix);
+ let arg = &format!("--suffix={suffix}");
ucmd.args(&["-b", arg, "-s", file, link])
.succeeds()
.no_stderr();
@@ -180,7 +184,7 @@ fn test_symlink_custom_backup_suffix() {
assert!(at.is_symlink(link));
assert_eq!(at.resolve_link(link), file);
- let backup = &format!("{}{}", link, suffix);
+ let backup = &format!("{link}{suffix}");
assert!(at.is_symlink(backup));
assert_eq!(at.resolve_link(backup), file);
}
@@ -198,7 +202,7 @@ fn test_symlink_custom_backup_suffix_hyphen_value() {
assert!(at.is_symlink(link));
assert_eq!(at.resolve_link(link), file);
- let arg = &format!("--suffix={}", suffix);
+ let arg = &format!("--suffix={suffix}");
ucmd.args(&["-b", arg, "-s", file, link])
.succeeds()
.no_stderr();
@@ -207,7 +211,7 @@ fn test_symlink_custom_backup_suffix_hyphen_value() {
assert!(at.is_symlink(link));
assert_eq!(at.resolve_link(link), file);
- let backup = &format!("{}{}", link, suffix);
+ let backup = &format!("{link}{suffix}");
assert!(at.is_symlink(backup));
assert_eq!(at.resolve_link(backup), file);
}
@@ -232,7 +236,7 @@ fn test_symlink_backup_numbering() {
assert!(at.is_symlink(link));
assert_eq!(at.resolve_link(link), file);
- let backup = &format!("{}.~1~", link);
+ let backup = &format!("{link}.~1~");
assert!(at.is_symlink(backup));
assert_eq!(at.resolve_link(backup), file);
}
@@ -285,11 +289,11 @@ fn test_symlink_target_dir() {
.succeeds()
.no_stderr();
- let file_a_link = &format!("{}/{}", dir, file_a);
+ let file_a_link = &format!("{dir}/{file_a}");
assert!(at.is_symlink(file_a_link));
assert_eq!(at.resolve_link(file_a_link), file_a);
- let file_b_link = &format!("{}/{}", dir, file_b);
+ let file_b_link = &format!("{dir}/{file_b}");
assert!(at.is_symlink(file_b_link));
assert_eq!(at.resolve_link(file_b_link), file_b);
}
@@ -301,8 +305,8 @@ fn test_symlink_target_dir_from_dir() {
let from_dir = "test_ln_target_dir_from_dir";
let filename_a = "test_ln_target_dir_file_a";
let filename_b = "test_ln_target_dir_file_b";
- let file_a = &format!("{}/{}", from_dir, filename_a);
- let file_b = &format!("{}/{}", from_dir, filename_b);
+ let file_a = &format!("{from_dir}/{filename_a}");
+ let file_b = &format!("{from_dir}/{filename_b}");
at.mkdir(from_dir);
at.touch(file_a);
@@ -313,11 +317,11 @@ fn test_symlink_target_dir_from_dir() {
.succeeds()
.no_stderr();
- let file_a_link = &format!("{}/{}", dir, filename_a);
+ let file_a_link = &format!("{dir}/{filename_a}");
assert!(at.is_symlink(file_a_link));
assert_eq!(&at.resolve_link(file_a_link), file_a);
- let file_b_link = &format!("{}/{}", dir, filename_b);
+ let file_b_link = &format!("{dir}/{filename_b}");
assert!(at.is_symlink(file_b_link));
assert_eq!(&at.resolve_link(file_b_link), file_b);
}
@@ -367,7 +371,7 @@ fn test_symlink_verbose() {
.ucmd()
.args(&["-s", "-v", file_a, file_b])
.succeeds()
- .stdout_only(format!("'{}' -> '{}'\n", file_b, file_a));
+ .stdout_only(format!("'{file_b}' -> '{file_a}'\n"));
at.touch(file_b);
@@ -375,10 +379,7 @@ fn test_symlink_verbose() {
.ucmd()
.args(&["-s", "-v", "-b", file_a, file_b])
.succeeds()
- .stdout_only(format!(
- "'{}' -> '{}' (backup: '{}~')\n",
- file_b, file_a, file_b
- ));
+ .stdout_only(format!("'{file_b}' -> '{file_a}' (backup: '{file_b}~')\n"));
}
#[test]
@@ -406,7 +407,7 @@ fn test_symlink_implicit_target_dir() {
let file = &path.to_string_lossy();
at.mkdir(dir);
- at.touch(file);
+ at.touch(&path);
ucmd.args(&["-s", file]).succeeds().no_stderr();
@@ -421,7 +422,7 @@ fn test_symlink_to_dir_2args() {
let filename = "test_symlink_to_dir_2args_file";
let from_file = &format!("{}/{}", at.as_string(), filename);
let to_dir = "test_symlink_to_dir_2args_to_dir";
- let to_file = &format!("{}/{}", to_dir, filename);
+ let to_file = &format!("{to_dir}/{filename}");
at.mkdir(to_dir);
at.touch(from_file);
@@ -441,8 +442,7 @@ fn test_symlink_missing_destination() {
at.touch(file);
ucmd.args(&["-s", "-T", file]).fails().stderr_is(format!(
- "ln: missing destination file operand after '{}'",
- file
+ "ln: missing destination file operand after '{file}'\n"
));
}
@@ -475,7 +475,7 @@ fn test_symlink_relative_path() {
// Thanks to -r, all the ../ should be resolved to a single file
ucmd.args(&["-r", "-s", "-v", &p.to_string_lossy(), link])
.succeeds()
- .stdout_only(format!("'{}' -> '{}'\n", link, file_a));
+ .stdout_only(format!("'{link}' -> '{file_a}'\n"));
assert!(at.is_symlink(link));
assert_eq!(at.resolve_link(link), file_a);
@@ -719,3 +719,50 @@ fn test_symlink_remove_existing_same_src_and_dest() {
assert!(at.file_exists("a") && !at.symlink_exists("a"));
assert_eq!(at.read("a"), "sample");
}
+
+#[test]
+#[cfg(not(target_os = "android"))]
+fn test_ln_seen_file() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+
+ at.mkdir("a");
+ at.mkdir("b");
+ at.mkdir("c");
+ at.write("a/f", "a");
+ at.write("b/f", "b");
+
+ let result = ts.ucmd().arg("a/f").arg("b/f").arg("c").fails();
+
+ #[cfg(not(unix))]
+ assert!(result
+ .stderr_str()
+ .contains("will not overwrite just-created 'c\\f' with 'b/f'"));
+ #[cfg(unix)]
+ assert!(result
+ .stderr_str()
+ .contains("will not overwrite just-created 'c/f' with 'b/f'"));
+
+ assert!(at.plus("c").join("f").exists());
+ // b/f still exists
+ assert!(at.plus("b").join("f").exists());
+ // a/f still exists
+ assert!(at.plus("a").join("f").exists());
+ #[cfg(unix)]
+ {
+ use std::os::unix::fs::MetadataExt;
+ // Check inode numbers
+ let inode_a_f = at.plus("a").join("f").metadata().unwrap().ino();
+ let inode_b_f = at.plus("b").join("f").metadata().unwrap().ino();
+ let inode_c_f = at.plus("c").join("f").metadata().unwrap().ino();
+
+ assert_eq!(
+ inode_a_f, inode_c_f,
+ "Inode numbers of a/f and c/f should be equal"
+ );
+ assert_ne!(
+ inode_b_f, inode_c_f,
+ "Inode numbers of b/f and c/f should not be equal"
+ );
+ }
+}
diff --git a/tests/by-util/test_logname.rs b/tests/by-util/test_logname.rs
index 43fce68515fd926398ae7a17d93779a9ac3b8678..8833975556dc669514f8aee650e1dec4b1f9543b 100644
--- a/tests/by-util/test_logname.rs
+++ b/tests/by-util/test_logname.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::{is_ci, TestScenario};
use std::env;
#[test]
@@ -12,7 +16,7 @@ fn test_normal() {
println!("env::var(CI).is_ok() = {}", env::var("CI").is_ok());
for (key, value) in env::vars() {
- println!("{}: {}", key, value);
+ println!("{key}: {value}");
}
if (is_ci() || uucore::os::is_wsl_1()) && result.stderr_str().contains("no login name") {
// ToDO: investigate WSL failure
diff --git a/tests/by-util/test_ls.rs b/tests/by-util/test_ls.rs
index 159f21de3b8494d56a1b5244056860a123a18ffd..498d6284f6db73ed109cd55c1842c062c963235c 100644
--- a/tests/by-util/test_ls.rs
+++ b/tests/by-util/test_ls.rs
@@ -1,16 +1,20 @@
-// spell-checker:ignore (words) READMECAREFULLY birthtime doesntexist oneline somebackup lrwx somefile somegroup somehiddenbackup somehiddenfile tabsize aaaaaaaa bbbb cccc dddddddd ncccc
-
-#[cfg(not(windows))]
-extern crate libc;
-extern crate regex;
-#[cfg(not(windows))]
-extern crate tempfile;
-
-use self::regex::Regex;
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore (words) READMECAREFULLY birthtime doesntexist oneline somebackup lrwx somefile somegroup somehiddenbackup somehiddenfile tabsize aaaaaaaa bbbb cccc dddddddd ncccc neee naaaaa nbcdef nfffff dired subdired tmpfs mdir COLORTERM mexe bcdef mfoo
+
+#[cfg(any(unix, feature = "feat_selinux"))]
+use crate::common::util::expected_result;
+use crate::common::util::TestScenario;
#[cfg(all(unix, feature = "chmod"))]
use nix::unistd::{close, dup};
+use regex::Regex;
use std::collections::HashMap;
+#[cfg(target_os = "linux")]
+use std::ffi::OsStr;
+#[cfg(target_os = "linux")]
+use std::os::unix::ffi::OsStrExt;
#[cfg(all(unix, feature = "chmod"))]
use std::os::unix::io::IntoRawFd;
use std::path::Path;
@@ -22,8 +26,8 @@ use std::time::Duration;
const LONG_ARGS: &[&str] = &[
"-l",
"--long",
- "--l",
"--format=long",
+ "--format=lon",
"--for=long",
"--format=verbose",
"--for=verbose",
@@ -32,6 +36,7 @@ const LONG_ARGS: &[&str] = &[
const ACROSS_ARGS: &[&str] = &[
"-x",
"--format=across",
+ "--format=acr",
"--format=horizontal",
"--for=across",
"--for=horizontal",
@@ -41,11 +46,89 @@ const COMMA_ARGS: &[&str] = &["-m", "--format=commas", "--for=commas"];
const COLUMN_ARGS: &[&str] = &["-C", "--format=columns", "--for=columns"];
+#[test]
+fn test_invalid_flag() {
+ new_ucmd!()
+ .arg("--invalid-argument")
+ .fails()
+ .no_stdout()
+ .code_is(2);
+}
+
+#[test]
+fn test_invalid_value_returns_1() {
+ // Invalid values to flags *sometimes* result in error code 1:
+ for flag in [
+ "--classify",
+ "--color",
+ "--format",
+ "--hyperlink",
+ "--indicator-style",
+ "--quoting-style",
+ "--sort",
+ "--time",
+ ] {
+ new_ucmd!()
+ .arg(&format!("{flag}=definitely_invalid_value"))
+ .fails()
+ .no_stdout()
+ .code_is(1);
+ }
+}
+
+#[test]
+fn test_invalid_value_returns_2() {
+ // Invalid values to flags *sometimes* result in error code 2:
+ for flag in ["--block-size", "--width", "--tab-size"] {
+ new_ucmd!()
+ .arg(&format!("{flag}=definitely_invalid_value"))
+ .fails()
+ .no_stdout()
+ .code_is(2);
+ }
+}
+
+#[test]
+fn test_invalid_value_time_style() {
+ // This is the only flag which does not raise an error if it is invalid but not actually used:
+ new_ucmd!()
+ .arg("--time-style=definitely_invalid_value")
+ .succeeds()
+ .no_stderr()
+ .code_is(0);
+ // If it is used, error:
+ new_ucmd!()
+ .arg("-g")
+ .arg("--time-style=definitely_invalid_value")
+ .fails()
+ .no_stdout()
+ .code_is(2);
+ // If it only looks temporarily like it might be used, no error:
+ new_ucmd!()
+ .arg("-l")
+ .arg("--time-style=definitely_invalid_value")
+ .arg("--format=single-column")
+ .succeeds()
+ .no_stderr()
+ .code_is(0);
+}
+
#[test]
fn test_ls_ls() {
new_ucmd!().succeeds();
}
+#[test]
+fn test_ls_help() {
+ // Because we have to work around a lot of clap's error handling and
+ // modify the exit-code, this is actually non-trivial.
+ new_ucmd!()
+ .arg("--help")
+ .succeeds()
+ .stdout_contains("--version")
+ .no_stderr();
+}
+
#[test]
fn test_ls_i() {
new_ucmd!().arg("-i").succeeds();
@@ -70,6 +153,21 @@ fn test_ls_ordering() {
.stdout_matches(&Regex::new("some-dir1:\\ntotal 0").unwrap());
}
+#[cfg(all(unix, feature = "df", not(target_os = "freebsd")))]
+fn get_filesystem_type(scene: &TestScenario, path: &Path) -> String {
+ let mut cmd = scene.ccmd("df");
+ cmd.args(&["-PT"]).arg(path);
+ let output = cmd.succeeds();
+ let stdout_str = String::from_utf8_lossy(output.stdout());
+ println!("output of stat call ({cmd:?}):\n{stdout_str}");
+ let regex_str = r#"Filesystem\s+Type\s+.+[\r\n]+([^\s]+)\s+(?<fstype>[^\s]+)\s+"#;
+ let regex = Regex::new(regex_str).unwrap();
+ let m = regex.captures(&stdout_str).unwrap();
+ let fstype = m["fstype"].to_owned();
+ println!("detected fstype: {}", fstype);
+ fstype
+}
+
#[cfg(all(feature = "truncate", feature = "dd"))]
#[test] // FIXME: fix this test for FreeBSD
fn test_ls_allocation_size() {
@@ -78,7 +176,7 @@ fn test_ls_allocation_size() {
at.mkdir("some-dir1");
at.touch("some-dir1/empty-file");
- #[cfg(unix)]
+ #[cfg(all(unix, feature = "df"))]
{
scene
.ccmd("truncate")
@@ -112,13 +210,24 @@ fn test_ls_allocation_size() {
.succeeds()
.stdout_matches(&Regex::new("[^ ] 2 [^ ]").unwrap());
+ #[cfg(not(target_os = "freebsd"))]
+ let (zero_file_size_4k, zero_file_size_1k, zero_file_size_8k, zero_file_size_4m) =
+ match get_filesystem_type(&scene, &scene.fixtures.subdir).as_str() {
+ // apparently f2fs (flash friendly fs) accepts small overhead for better performance
+ "f2fs" => (4100, 1025, 8200, "4.1M"),
+ _ => (4096, 1024, 8192, "4.0M"),
+ };
+
#[cfg(not(target_os = "freebsd"))]
scene
.ucmd()
.arg("-s1")
.arg("some-dir1")
.succeeds()
- .stdout_is("total 4096\n 0 empty-file\n 0 file-with-holes\n4096 zero-file\n");
+ .stdout_is(format!(
+ "total {zero_file_size_4k}\n 0 empty-file\n 0 file-with-holes\n\
+ {zero_file_size_4k} zero-file\n"
+ ));
scene
.ucmd()
@@ -135,7 +244,7 @@ fn test_ls_allocation_size() {
.arg("some-dir1")
.succeeds()
.stdout_contains("0 empty-file")
- .stdout_contains("4096 zero-file");
+ .stdout_contains(format!("{zero_file_size_4k} zero-file"));
// Test alignment of different block sized files
let res = scene.ucmd().arg("-si1").arg("some-dir1").succeeds();
@@ -182,10 +291,10 @@ fn test_ls_allocation_size() {
.arg("-s1")
.arg("some-dir1")
.succeeds()
- .stdout_contains("total 1024")
+ .stdout_contains(format!("total {zero_file_size_1k}"))
.stdout_contains("0 empty-file")
.stdout_contains("0 file-with-holes")
- .stdout_contains("1024 zero-file");
+ .stdout_contains(format!("{zero_file_size_1k} zero-file"));
#[cfg(not(target_os = "freebsd"))]
scene
@@ -207,10 +316,10 @@ fn test_ls_allocation_size() {
.arg("-s1")
.arg("some-dir1")
.succeeds()
- .stdout_contains("total 1024")
+ .stdout_contains(format!("total {zero_file_size_1k}"))
.stdout_contains("0 empty-file")
.stdout_contains("0 file-with-holes")
- .stdout_contains("1024 zero-file");
+ .stdout_contains(format!("{zero_file_size_1k} zero-file"));
#[cfg(not(target_os = "freebsd"))]
scene
@@ -219,10 +328,10 @@ fn test_ls_allocation_size() {
.arg("-s1")
.arg("some-dir1")
.succeeds()
- .stdout_contains("total 8192")
+ .stdout_contains(format!("total {zero_file_size_8k}"))
.stdout_contains("0 empty-file")
.stdout_contains("0 file-with-holes")
- .stdout_contains("8192 zero-file");
+ .stdout_contains(format!("{zero_file_size_8k} zero-file"));
// -k should make 'ls' ignore the env var
#[cfg(not(target_os = "freebsd"))]
@@ -232,10 +341,10 @@ fn test_ls_allocation_size() {
.arg("-s1k")
.arg("some-dir1")
.succeeds()
- .stdout_contains("total 4096")
+ .stdout_contains(format!("total {zero_file_size_4k}"))
.stdout_contains("0 empty-file")
.stdout_contains("0 file-with-holes")
- .stdout_contains("4096 zero-file");
+ .stdout_contains(format!("{zero_file_size_4k} zero-file"));
// but manually specified blocksize overrides -k
#[cfg(not(target_os = "freebsd"))]
@@ -245,10 +354,10 @@ fn test_ls_allocation_size() {
.arg("--block-size=4K")
.arg("some-dir1")
.succeeds()
- .stdout_contains("total 1024")
+ .stdout_contains(format!("total {zero_file_size_1k}"))
.stdout_contains("0 empty-file")
.stdout_contains("0 file-with-holes")
- .stdout_contains("1024 zero-file");
+ .stdout_contains(format!("{zero_file_size_1k} zero-file"));
#[cfg(not(target_os = "freebsd"))]
scene
@@ -257,10 +366,10 @@ fn test_ls_allocation_size() {
.arg("--block-size=4K")
.arg("some-dir1")
.succeeds()
- .stdout_contains("total 1024")
+ .stdout_contains(format!("total {zero_file_size_1k}"))
.stdout_contains("0 empty-file")
.stdout_contains("0 file-with-holes")
- .stdout_contains("1024 zero-file");
+ .stdout_contains(format!("{zero_file_size_1k} zero-file"));
// si option should always trump the human-readable option
#[cfg(not(target_os = "freebsd"))]
@@ -282,10 +391,10 @@ fn test_ls_allocation_size() {
.arg("--block-size=human-readable")
.arg("some-dir1")
.succeeds()
- .stdout_contains("total 4.0M")
+ .stdout_contains(format!("total {zero_file_size_4m}"))
.stdout_contains("0 empty-file")
.stdout_contains("0 file-with-holes")
- .stdout_contains("4.0M zero-file");
+ .stdout_contains(format!("{zero_file_size_4m} zero-file"));
#[cfg(not(target_os = "freebsd"))]
scene
@@ -435,44 +544,43 @@ fn test_ls_io_errors() {
// on the mac and in certain Linux containers bad fds are typed as dirs,
// however sometimes bad fds are typed as links and directory entry on links won't fail
- if PathBuf::from(format!("/dev/fd/{fd}", fd = fd2)).is_dir() {
+ if PathBuf::from(format!("/dev/fd/{fd2}")).is_dir() {
scene
.ucmd()
.arg("-alR")
- .arg(format!("/dev/fd/{fd}", fd = fd2))
+ .arg(format!("/dev/fd/{fd2}"))
.fails()
.stderr_contains(format!(
- "cannot open directory '/dev/fd/{fd}': Bad file descriptor",
- fd = fd2
+ "cannot open directory '/dev/fd/{fd2}': Bad file descriptor"
))
- .stdout_does_not_contain(format!("{fd}:\n", fd = fd2));
+ .stdout_does_not_contain(format!("{fd2}:\n"));
scene
.ucmd()
.arg("-RiL")
- .arg(format!("/dev/fd/{fd}", fd = fd2))
+ .arg(format!("/dev/fd/{fd2}"))
.fails()
- .stderr_contains(format!("cannot open directory '/dev/fd/{fd}': Bad file descriptor", fd = fd2))
+ .stderr_contains(format!("cannot open directory '/dev/fd/{fd2}': Bad file descriptor"))
// don't double print bad fd errors
- .stderr_does_not_contain(format!("ls: cannot open directory '/dev/fd/{fd}': Bad file descriptor\nls: cannot open directory '/dev/fd/{fd}': Bad file descriptor", fd = fd2));
+ .stderr_does_not_contain(format!("ls: cannot open directory '/dev/fd/{fd2}': Bad file descriptor\nls: cannot open directory '/dev/fd/{fd2}': Bad file descriptor"));
} else {
scene
.ucmd()
.arg("-alR")
- .arg(format!("/dev/fd/{fd}", fd = fd2))
+ .arg(format!("/dev/fd/{fd2}"))
.succeeds();
scene
.ucmd()
.arg("-RiL")
- .arg(format!("/dev/fd/{fd}", fd = fd2))
+ .arg(format!("/dev/fd/{fd2}"))
.succeeds();
}
scene
.ucmd()
.arg("-alL")
- .arg(format!("/dev/fd/{fd}", fd = fd2))
+ .arg(format!("/dev/fd/{fd2}"))
.succeeds();
let _ = close(fd2);
@@ -610,10 +718,10 @@ fn test_ls_a() {
fn test_ls_width() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
- at.touch(&at.plus_as_string("test-width-1"));
- at.touch(&at.plus_as_string("test-width-2"));
- at.touch(&at.plus_as_string("test-width-3"));
- at.touch(&at.plus_as_string("test-width-4"));
+ at.touch(at.plus_as_string("test-width-1"));
+ at.touch(at.plus_as_string("test-width-2"));
+ at.touch(at.plus_as_string("test-width-3"));
+ at.touch(at.plus_as_string("test-width-4"));
for option in [
"-w 100",
@@ -672,6 +780,23 @@ fn test_ls_width() {
.stdout_only("test-width-1 test-width-3\ntest-width-2 test-width-4\n");
}
+ for option in [
+ "-w 100000000000000",
+ "-w=100000000000000",
+ "--width=100000000000000",
+ "--width 100000000000000",
+ "-w 07777777777777777777",
+ "-w=07777777777777777777",
+ "--width=07777777777777777777",
+ "--width 07777777777777777777",
+ ] {
+ scene
+ .ucmd()
+ .args(&option.split(' ').collect::<Vec<_>>())
+ .arg("-C")
+ .succeeds()
+ .stdout_only("test-width-1 test-width-2 test-width-3 test-width-4\n");
+ }
scene
.ucmd()
.arg("-w=bad")
@@ -685,7 +810,7 @@ fn test_ls_width() {
.args(&option.split(' ').collect::<Vec<_>>())
.arg("-C")
.fails()
- .stderr_only("ls: invalid line width: '1a'");
+ .stderr_only("ls: invalid line width: '1a'\n");
}
}
@@ -693,10 +818,10 @@ fn test_ls_width() {
fn test_ls_columns() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
- at.touch(&at.plus_as_string("test-columns-1"));
- at.touch(&at.plus_as_string("test-columns-2"));
- at.touch(&at.plus_as_string("test-columns-3"));
- at.touch(&at.plus_as_string("test-columns-4"));
+ at.touch(at.plus_as_string("test-columns-1"));
+ at.touch(at.plus_as_string("test-columns-2"));
+ at.touch(at.plus_as_string("test-columns-3"));
+ at.touch(at.plus_as_string("test-columns-4"));
// Columns is the default
let result = scene.ucmd().succeeds();
@@ -736,7 +861,7 @@ fn test_ls_columns() {
.arg("-C")
.succeeds()
.stdout_is("test-columns-1 test-columns-2 test-columns-3 test-columns-4\n")
- .stderr_is("ls: ignoring invalid width in environment variable COLUMNS: 'garbage'");
+ .stderr_is("ls: ignoring invalid width in environment variable COLUMNS: 'garbage'\n");
}
scene
.ucmd()
@@ -754,10 +879,10 @@ fn test_ls_columns() {
fn test_ls_across() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
- at.touch(&at.plus_as_string("test-across-1"));
- at.touch(&at.plus_as_string("test-across-2"));
- at.touch(&at.plus_as_string("test-across-3"));
- at.touch(&at.plus_as_string("test-across-4"));
+ at.touch(at.plus_as_string("test-across-1"));
+ at.touch(at.plus_as_string("test-across-2"));
+ at.touch(at.plus_as_string("test-across-3"));
+ at.touch(at.plus_as_string("test-across-4"));
for option in ACROSS_ARGS {
let result = scene.ucmd().arg(option).succeeds();
@@ -782,10 +907,10 @@ fn test_ls_across() {
fn test_ls_commas() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
- at.touch(&at.plus_as_string("test-commas-1"));
- at.touch(&at.plus_as_string("test-commas-2"));
- at.touch(&at.plus_as_string("test-commas-3"));
- at.touch(&at.plus_as_string("test-commas-4"));
+ at.touch(at.plus_as_string("test-commas-1"));
+ at.touch(at.plus_as_string("test-commas-2"));
+ at.touch(at.plus_as_string("test-commas-3"));
+ at.touch(at.plus_as_string("test-commas-4"));
for option in COMMA_ARGS {
let result = scene.ucmd().arg(option).succeeds();
@@ -815,8 +940,8 @@ fn test_ls_zero() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
at.mkdir("0-test-zero");
- at.touch(&at.plus_as_string("2-test-zero"));
- at.touch(&at.plus_as_string("3-test-zero"));
+ at.touch(at.plus_as_string("2-test-zero"));
+ at.touch(at.plus_as_string("3-test-zero"));
let ignored_opts = [
"--quoting-style=c",
@@ -845,11 +970,11 @@ fn test_ls_zero() {
.succeeds()
.stdout_only("\"0-test-zero\"\x00\"2-test-zero\"\x00\"3-test-zero\"\x00");
- scene
- .ucmd()
- .args(&["--zero", "--color=always"])
- .succeeds()
- .stdout_only("\x1b[1;34m0-test-zero\x1b[0m\x002-test-zero\x003-test-zero\x00");
+ let result = scene.ucmd().args(&["--zero", "--color=always"]).succeeds();
+ assert_eq!(
+ result.stdout_str(),
+ "\u{1b}[0m\u{1b}[01;34m0-test-zero\x1b[0m\x002-test-zero\x003-test-zero\x00"
+ );
scene
.ucmd()
@@ -871,11 +996,13 @@ fn test_ls_zero() {
#[cfg(unix)]
{
- at.touch(&at.plus_as_string("1\ntest-zero"));
+ at.touch(at.plus_as_string("1\ntest-zero"));
let ignored_opts = [
"--quoting-style=c",
"--color=always",
+ "--color=alway",
+ "--color=al",
"-m",
"--hide-control-chars",
];
@@ -902,12 +1029,9 @@ fn test_ls_zero() {
"\"0-test-zero\"\x00\"1\\ntest-zero\"\x00\"2-test-zero\"\x00\"3-test-zero\"\x00",
);
- scene
- .ucmd()
- .args(&["--zero", "--color=always"])
- .succeeds()
- .stdout_only(
- "\x1b[1;34m0-test-zero\x1b[0m\x001\ntest-zero\x002-test-zero\x003-test-zero\x00",
+ let result = scene.ucmd().args(&["--zero", "--color=always"]).succeeds();
+ assert_eq!(result.stdout_str(),
+ "\u{1b}[0m\u{1b}[01;34m0-test-zero\x1b[0m\x001\ntest-zero\x002-test-zero\x003-test-zero\x00",
);
scene
@@ -934,9 +1058,9 @@ fn test_ls_zero() {
fn test_ls_commas_trailing() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
- at.touch(&at.plus_as_string("test-commas-trailing-2"));
+ at.touch(at.plus_as_string("test-commas-trailing-2"));
- at.touch(&at.plus_as_string("test-commas-trailing-1"));
+ at.touch(at.plus_as_string("test-commas-trailing-1"));
at.append(
"test-commas-trailing-1",
&(0..2000)
@@ -951,14 +1075,14 @@ fn test_ls_commas_trailing() {
.arg("./test-commas-trailing-1")
.arg("./test-commas-trailing-2")
.succeeds()
- .stdout_matches(&Regex::new(r"\S$").unwrap()); // matches if there is no whitespace at the end of stdout.
+ .stdout_matches(&Regex::new(r"\S\n$").unwrap());
}
#[test]
fn test_ls_long() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
- at.touch(&at.plus_as_string("test-long"));
+ at.touch(at.plus_as_string("test-long"));
for arg in LONG_ARGS {
let result = scene.ucmd().arg(arg).arg("test-long").succeeds();
@@ -975,9 +1099,9 @@ fn test_ls_long() {
fn test_ls_long_format() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
- at.mkdir(&at.plus_as_string("test-long-dir"));
- at.touch(&at.plus_as_string("test-long-dir/test-long-file"));
- at.mkdir(&at.plus_as_string("test-long-dir/test-long-dir"));
+ at.mkdir(at.plus_as_string("test-long-dir"));
+ at.touch(at.plus_as_string("test-long-dir/test-long-file"));
+ at.mkdir(at.plus_as_string("test-long-dir/test-long-dir"));
for arg in LONG_ARGS {
// Assuming sane username do not have spaces within them.
@@ -1004,6 +1128,21 @@ fn test_ls_long_format() {
).unwrap());
}
+#[test]
+fn test_ls_long_padding_of_size_column_with_multiple_files() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ at.mkdir("dir");
+ at.touch("dir/a");
+ at.touch("dir/b");
+
+ ucmd.arg("-l")
+ .arg("dir")
+ .succeeds()
+ .stdout_contains(" 0 ")
+ .stdout_does_not_contain(" 0 ");
+}
+
/// This test tests `ls -laR --color`.
/// This test is mainly about coloring, but, the recursion, symlink `->` processing,
/// and `.` and `..` being present in `-a` all need to work for the test to pass.
@@ -1168,12 +1307,21 @@ fn test_ls_long_symlink_color() {
}
fn capture_colored_string(input: &str) -> (Color, Name) {
- let colored_name = Regex::new(r"\x1b\[([0-9;]+)m(.+)\x1b\[0m").unwrap();
+ // Input can be:
+ // \u{1b}[0m\u{1b}[01;36mln-dir3\u{1b}[0m
+ // \u{1b}[0m\u{1b}[01;34m./dir1/dir2/dir3\u{1b}[0m
+ // \u{1b}[0m\u{1b}[01;36mln-file-invalid\u{1b}[0m
+ // \u{1b}[01;36mdir1/invalid-target\u{1b}[0m
+ let colored_name = Regex::new(r"(?:\x1b\[0m\x1b)?\[([0-9;]+)m(.+)\x1b\[0m").unwrap();
match colored_name.captures(input) {
- Some(captures) => (
- captures.get(1).unwrap().as_str().to_string(),
- captures.get(2).unwrap().as_str().to_string(),
- ),
+ Some(captures) => {
+ dbg!(captures.get(1).unwrap().as_str().to_string());
+ dbg!(captures.get(2).unwrap().as_str().to_string());
+ return (
+ captures.get(1).unwrap().as_str().to_string(),
+ captures.get(2).unwrap().as_str().to_string(),
+ );
+ }
None => (String::new(), input.to_string()),
}
}
@@ -1228,13 +1376,51 @@ fn test_ls_long_symlink_color() {
}
}
+/// This test is for "ls -l --color=auto|--color=always"
+/// We use "--color=always" as the colors are the same regardless of the color option being "auto" or "always"
+/// tests whether the specific color of the target and the dangling_symlink are equal and checks
+/// whether checks whether ls outputs the correct path for the symlink and the file it points to and applies the color code to it.
+#[test]
+fn test_ls_long_dangling_symlink_color() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+
+ at.mkdir("dir1");
+ at.symlink_dir("foo", "dir1/dangling_symlink");
+ let result = ts
+ .ucmd()
+ .arg("-l")
+ .arg("--color=always")
+ .arg("dir1/dangling_symlink")
+ .succeeds();
+
+ let stdout = result.stdout_str();
+ // stdout contains output like in the below sequence. We match for the color i.e. 01;36
+ // \x1b[0m\x1b[01;36mdir1/dangling_symlink\x1b[0m -> \x1b[01;36mfoo\x1b[0m
+ let color_regex = Regex::new(r"(\d\d;)\d\dm").unwrap();
+ // colors_vec[0] contains the symlink color and style and colors_vec[1] contains the color and style of the file the
+ // symlink points to.
+ let colors_vec: Vec<_> = color_regex
+ .find_iter(stdout)
+ .map(|color| color.as_str())
+ .collect();
+
+ assert_eq!(colors_vec[0], colors_vec[1]);
+ // constructs the string of file path with the color code
+ let symlink_color_name = colors_vec[0].to_owned() + "dir1/dangling_symlink\x1b";
+ let target_color_name = colors_vec[1].to_owned() + at.plus_as_string("foo\x1b").as_str();
+
+ assert!(stdout.contains(&symlink_color_name));
+ assert!(stdout.contains(&target_color_name));
+}
+
#[test]
fn test_ls_long_total_size() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
- at.touch(&at.plus_as_string("test-long"));
+ at.touch(at.plus_as_string("test-long"));
at.append("test-long", "1");
- at.touch(&at.plus_as_string("test-long2"));
+ at.touch(at.plus_as_string("test-long2"));
at.append("test-long2", "2");
let expected_prints: HashMap<_, _> = if cfg!(unix) {
@@ -1244,7 +1430,7 @@ fn test_ls_long_total_size() {
("long_si", "total 8.2k"),
]
.iter()
- .cloned()
+ .copied()
.collect()
} else {
[
@@ -1253,7 +1439,7 @@ fn test_ls_long_total_size() {
("long_si", "total 2"),
]
.iter()
- .cloned()
+ .copied()
.collect()
};
@@ -1276,12 +1462,12 @@ fn test_ls_long_total_size() {
fn test_ls_long_formats() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
- at.touch(&at.plus_as_string("test-long-formats"));
+ at.touch(at.plus_as_string("test-long-formats"));
// Zero or one "." for indicating a file with security context
// Regex for three names, so all of author, group and owner
- let re_three = Regex::new(r"[xrw-]{9}\.? \d ([-0-9_a-z]+ ){3}0").unwrap();
+ let re_three = Regex::new(r"[xrw-]{9}\.? \d ([-0-9_a-z.A-Z]+ ){3}0").unwrap();
#[cfg(unix)]
let re_three_num = Regex::new(r"[xrw-]{9}\.? \d (\d+ ){3}0").unwrap();
@@ -1290,13 +1476,13 @@ fn test_ls_long_formats() {
// - group and owner
// - author and owner
// - author and group
- let re_two = Regex::new(r"[xrw-]{9}\.? \d ([-0-9_a-z]+ ){2}0").unwrap();
+ let re_two = Regex::new(r"[xrw-]{9}\.? \d ([-0-9_a-z.A-Z]+ ){2}0").unwrap();
#[cfg(unix)]
let re_two_num = Regex::new(r"[xrw-]{9}\.? \d (\d+ ){2}0").unwrap();
// Regex for one name: author, group or owner
- let re_one = Regex::new(r"[xrw-]{9}\.? \d [-0-9_a-z]+ 0").unwrap();
+ let re_one = Regex::new(r"[xrw-]{9}\.? \d [-0-9_a-z.A-Z]+ 0").unwrap();
#[cfg(unix)]
let re_one_num = Regex::new(r"[xrw-]{9}\.? \d \d+ 0").unwrap();
@@ -1423,8 +1609,8 @@ fn test_ls_long_formats() {
fn test_ls_oneline() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
- at.touch(&at.plus_as_string("test-oneline-1"));
- at.touch(&at.plus_as_string("test-oneline-2"));
+ at.touch(at.plus_as_string("test-oneline-1"));
+ at.touch(at.plus_as_string("test-oneline-2"));
// Bit of a weird situation: in the tests oneline and columns have the same output,
// except on Windows.
@@ -1444,7 +1630,7 @@ fn test_ls_deref() {
let path_regexp = r"(.*)test-long.link -> (.*)test-long(.*)";
let re = Regex::new(path_regexp).unwrap();
- at.touch(&at.plus_as_string("test-long"));
+ at.touch(at.plus_as_string("test-long"));
at.symlink_file("test-long", "test-long.link");
assert!(at.is_symlink("test-long.link"));
@@ -1457,6 +1643,24 @@ fn test_ls_deref() {
.succeeds();
assert!(re.is_match(result.stdout_str().trim()));
+ let result = scene
+ .ucmd()
+ .arg("-l")
+ .arg("--color=neve") // spell-checker:disable-line
+ .arg("test-long")
+ .arg("test-long.link")
+ .succeeds();
+ assert!(re.is_match(result.stdout_str().trim()));
+
+ let result = scene
+ .ucmd()
+ .arg("-l")
+ .arg("--color=n")
+ .arg("test-long")
+ .arg("test-long.link")
+ .succeeds();
+ assert!(re.is_match(result.stdout_str().trim()));
+
let result = scene
.ucmd()
.arg("-L")
@@ -1532,6 +1736,10 @@ fn test_ls_sort_none() {
// Order is not specified so we just check that it doesn't
// give any errors.
scene.ucmd().arg("--sort=none").succeeds();
+ scene.ucmd().arg("--sort=non").succeeds();
+ scene.ucmd().arg("--sort=no").succeeds();
+ // scene.ucmd().arg("--sort=n").succeeds();
+ // We refuse to accept "--sort=n", since this is too confusable with "--sort=name", which is our own extension.
scene.ucmd().arg("-U").succeeds();
}
@@ -1549,6 +1757,16 @@ fn test_ls_sort_name() {
.arg("--sort=name")
.succeeds()
.stdout_is("test-1\ntest-2\ntest-3\n");
+ scene
+ .ucmd()
+ .arg("--sort=nam")
+ .succeeds()
+ .stdout_is("test-1\ntest-2\ntest-3\n");
+ scene
+ .ucmd()
+ .arg("--sort=na")
+ .succeeds()
+ .stdout_is("test-1\ntest-2\ntest-3\n");
let scene_dot = TestScenario::new(util_name!());
let at = &scene_dot.fixtures;
@@ -1565,6 +1783,38 @@ fn test_ls_sort_name() {
.stdout_is(".a\n.b\na\nb\n");
}
+#[test]
+fn test_ls_sort_width() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("aaaaa");
+ at.touch("bbb");
+ at.touch("cccc");
+ at.touch("eee");
+ at.touch("d");
+ at.touch("fffff");
+ at.touch("abc");
+ at.touch("zz");
+ at.touch("bcdef");
+
+ scene
+ .ucmd()
+ .arg("--sort=width")
+ .succeeds()
+ .stdout_is("d\nzz\nabc\nbbb\neee\ncccc\naaaaa\nbcdef\nfffff\n");
+ scene
+ .ucmd()
+ .arg("--sort=widt") // spell-checker:disable-line
+ .succeeds()
+ .stdout_is("d\nzz\nabc\nbbb\neee\ncccc\naaaaa\nbcdef\nfffff\n");
+ scene
+ .ucmd()
+ .arg("--sort=w")
+ .succeeds()
+ .stdout_is("d\nzz\nabc\nbbb\neee\ncccc\naaaaa\nbcdef\nfffff\n");
+}
+
#[test]
fn test_ls_order_size() {
let scene = TestScenario::new(util_name!());
@@ -1591,6 +1841,12 @@ fn test_ls_order_size() {
let result = scene.ucmd().arg("--sort=size").succeeds();
result.stdout_only("test-4\ntest-3\ntest-2\ntest-1\n");
+ let result = scene.ucmd().arg("--sort=siz").succeeds();
+ result.stdout_only("test-4\ntest-3\ntest-2\ntest-1\n");
+
+ let result = scene.ucmd().arg("--sort=s").succeeds();
+ result.stdout_only("test-4\ntest-3\ntest-2\ntest-1\n");
+
let result = scene.ucmd().arg("--sort=size").arg("-r").succeeds();
result.stdout_only("test-1\ntest-2\ntest-3\ntest-4\n");
}
@@ -1645,88 +1901,108 @@ fn test_ls_styles() {
at.touch("test");
let re_full = Regex::new(
- r"[a-z-]* \d* \w* \w* \d* \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d* (\+|\-)\d{4} test\n",
+ r"[a-z-]* \d* [\w.]* [\w.]* \d* \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d* (\+|\-)\d{4} test\n",
)
.unwrap();
let re_long =
- Regex::new(r"[a-z-]* \d* \w* \w* \d* \d{4}-\d{2}-\d{2} \d{2}:\d{2} test\n").unwrap();
- let re_iso = Regex::new(r"[a-z-]* \d* \w* \w* \d* \d{2}-\d{2} \d{2}:\d{2} test\n").unwrap();
+ Regex::new(r"[a-z-]* \d* [\w.]* [\w.]* \d* \d{4}-\d{2}-\d{2} \d{2}:\d{2} test\n").unwrap();
+ let re_iso =
+ Regex::new(r"[a-z-]* \d* [\w.]* [\w.]* \d* \d{2}-\d{2} \d{2}:\d{2} test\n").unwrap();
let re_locale =
- Regex::new(r"[a-z-]* \d* \w* \w* \d* [A-Z][a-z]{2} ( |\d)\d \d{2}:\d{2} test\n").unwrap();
- let re_custom_format = Regex::new(r"[a-z-]* \d* \w* \w* \d* \d{4}__\d{2} test\n").unwrap();
+ Regex::new(r"[a-z-]* \d* [\w.]* [\w.]* \d* [A-Z][a-z]{2} ( |\d)\d \d{2}:\d{2} test\n")
+ .unwrap();
+ let re_custom_format =
+ Regex::new(r"[a-z-]* \d* [\w.]* [\w.]* \d* \d{4}__\d{2} test\n").unwrap();
//full-iso
- let result = scene
+ scene
.ucmd()
.arg("-l")
.arg("--time-style=full-iso")
- .succeeds();
- assert!(re_full.is_match(result.stdout_str()));
+ .succeeds()
+ .stdout_matches(&re_full);
//long-iso
- let result = scene
+ scene
.ucmd()
.arg("-l")
.arg("--time-style=long-iso")
- .succeeds();
- assert!(re_long.is_match(result.stdout_str()));
+ .succeeds()
+ .stdout_matches(&re_long);
//iso
- let result = scene.ucmd().arg("-l").arg("--time-style=iso").succeeds();
- assert!(re_iso.is_match(result.stdout_str()));
+ scene
+ .ucmd()
+ .arg("-l")
+ .arg("--time-style=iso")
+ .succeeds()
+ .stdout_matches(&re_iso);
//locale
- let result = scene.ucmd().arg("-l").arg("--time-style=locale").succeeds();
- assert!(re_locale.is_match(result.stdout_str()));
+ scene
+ .ucmd()
+ .arg("-l")
+ .arg("--time-style=locale")
+ .succeeds()
+ .stdout_matches(&re_locale);
//+FORMAT
- let result = scene
+ scene
.ucmd()
.arg("-l")
.arg("--time-style=+%Y__%M")
- .succeeds();
- assert!(re_custom_format.is_match(result.stdout_str()));
+ .succeeds()
+ .stdout_matches(&re_custom_format);
// Also fails due to not having full clap support for time_styles
- scene.ucmd().arg("-l").arg("-time-style=invalid").fails();
+ scene
+ .ucmd()
+ .arg("-l")
+ .arg("--time-style=invalid")
+ .fails()
+ .code_is(2);
//Overwrite options tests
- let result = scene
+ scene
.ucmd()
.arg("-l")
.arg("--time-style=long-iso")
.arg("--time-style=iso")
- .succeeds();
- assert!(re_iso.is_match(result.stdout_str()));
- let result = scene
+ .succeeds()
+ .stdout_matches(&re_iso);
+ scene
.ucmd()
.arg("--time-style=iso")
.arg("--full-time")
- .succeeds();
- assert!(re_full.is_match(result.stdout_str()));
- let result = scene
+ .succeeds()
+ .stdout_matches(&re_full);
+ scene
.ucmd()
.arg("--full-time")
.arg("--time-style=iso")
- .succeeds();
- assert!(re_iso.is_match(result.stdout_str()));
+ .succeeds()
+ .stdout_matches(&re_iso);
- let result = scene
+ scene
.ucmd()
.arg("--full-time")
.arg("--time-style=iso")
.arg("--full-time")
- .succeeds();
- assert!(re_full.is_match(result.stdout_str()));
+ .succeeds()
+ .stdout_matches(&re_full);
- let result = scene
+ scene
.ucmd()
.arg("--full-time")
.arg("-x")
.arg("-l")
- .succeeds();
- assert!(re_full.is_match(result.stdout_str()));
+ .succeeds()
+ .stdout_matches(&re_full);
at.touch("test2");
- let result = scene.ucmd().arg("--full-time").arg("-x").succeeds();
- assert_eq!(result.stdout_str(), "test test2\n");
+ scene
+ .ucmd()
+ .arg("--full-time")
+ .arg("-x")
+ .succeeds()
+ .stdout_is("test test2\n");
}
#[test]
@@ -1775,15 +2051,28 @@ fn test_ls_order_time() {
// 3 was accessed last in the read
// So the order should be 2 3 4 1
- for arg in ["-u", "--time=atime", "--time=access", "--time=use"] {
+ for arg in [
+ "-u",
+ "--time=atime",
+ "--time=atim", // spell-checker:disable-line
+ "--time=a",
+ "--time=access",
+ "--time=use",
+ ] {
let result = scene.ucmd().arg("-t").arg(arg).succeeds();
at.open("test-3").metadata().unwrap().accessed().unwrap();
at.open("test-4").metadata().unwrap().accessed().unwrap();
// It seems to be dependent on the platform whether the access time is actually set
- #[cfg(all(unix, not(target_os = "android")))]
- result.stdout_only("test-3\ntest-4\ntest-2\ntest-1\n");
- #[cfg(any(windows, target_os = "android"))]
+ #[cfg(unix)]
+ {
+ let expected = unwrap_or_return!(expected_result(&scene, &["-t", arg]));
+ at.open("test-3").metadata().unwrap().accessed().unwrap();
+ at.open("test-4").metadata().unwrap().accessed().unwrap();
+
+ result.stdout_only(expected.stdout_str());
+ }
+ #[cfg(windows)]
result.stdout_only("test-4\ntest-3\ntest-2\ntest-1\n");
}
@@ -1809,8 +2098,8 @@ fn test_ls_files_dirs() {
at.mkdir("a/b");
at.mkdir("a/b/c");
at.mkdir("z");
- at.touch(&at.plus_as_string("a/a"));
- at.touch(&at.plus_as_string("a/b/b"));
+ at.touch(at.plus_as_string("a/a"));
+ at.touch(at.plus_as_string("a/b/b"));
scene.ucmd().arg("a").succeeds();
scene.ucmd().arg("a/a").succeeds();
@@ -1841,8 +2130,8 @@ fn test_ls_recursive() {
at.mkdir("a/b");
at.mkdir("a/b/c");
at.mkdir("z");
- at.touch(&at.plus_as_string("a/a"));
- at.touch(&at.plus_as_string("a/b/b"));
+ at.touch(at.plus_as_string("a/a"));
+ at.touch(at.plus_as_string("a/b/b"));
scene.ucmd().arg("a").succeeds();
scene.ucmd().arg("a/a").succeeds();
@@ -1866,6 +2155,35 @@ fn test_ls_recursive() {
result.stdout_contains("a\\b:\nb");
}
+#[test]
+fn test_ls_recursive_1() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.mkdir("x");
+ at.mkdir("y");
+ at.mkdir("a");
+ at.mkdir("b");
+ at.mkdir("c");
+ at.mkdir("a/1");
+ at.mkdir("a/2");
+ at.mkdir("a/3");
+ at.touch("f");
+ at.touch("a/1/I");
+ at.touch("a/1/II");
+ #[cfg(unix)]
+ let out = "a:\n1\n2\n3\n\na/1:\nI\nII\n\na/2:\n\na/3:\n\nb:\n\nc:\n";
+ #[cfg(windows)]
+ let out = "a:\n1\n2\n3\n\na\\1:\nI\nII\n\na\\2:\n\na\\3:\n\nb:\n\nc:\n";
+ scene
+ .ucmd()
+ .arg("-R1")
+ .arg("a")
+ .arg("b")
+ .arg("c")
+ .succeeds()
+ .stdout_is(out);
+}
+
#[test]
fn test_ls_color() {
let scene = TestScenario::new(util_name!());
@@ -1875,18 +2193,18 @@ fn test_ls_color() {
.join("nested_dir")
.to_string_lossy()
.to_string();
- at.mkdir(&nested_dir);
+ at.mkdir(nested_dir);
at.mkdir("z");
let nested_file = Path::new("a")
.join("nested_file")
.to_string_lossy()
.to_string();
- at.touch(&nested_file);
+ at.touch(nested_file);
at.touch("test-color");
- let a_with_colors = "\x1b[1;34ma\x1b[0m";
- let z_with_colors = "\x1b[1;34mz\x1b[0m";
- let nested_dir_with_colors = "\x1b[1;34mnested_dir\x1b[0m"; // spell-checker:disable-line
+ let a_with_colors = "\x1b[0m\x1b[01;34ma\x1b[0m";
+ let z_with_colors = "\x1b[01;34mz\x1b[0m\n";
+ let nested_dir_with_colors = "\x1b[0m\x1b[01;34mnested_dir\x1b[0m\x0anested_file"; // spell-checker:disable-line
// Color is disabled by default
let result = scene.ucmd().succeeds();
@@ -1895,12 +2213,9 @@ fn test_ls_color() {
// Color should be enabled
for param in ["--color", "--col", "--color=always", "--col=always"] {
- scene
- .ucmd()
- .arg(param)
- .succeeds()
- .stdout_contains(a_with_colors)
- .stdout_contains(z_with_colors);
+ let result = scene.ucmd().arg(param).succeeds();
+ assert!(result.stdout_str().contains(a_with_colors));
+ assert!(result.stdout_str().contains(z_with_colors));
}
// Color should be disabled
@@ -1909,12 +2224,8 @@ fn test_ls_color() {
assert!(!result.stdout_str().contains(z_with_colors));
// Nested dir should be shown and colored
- scene
- .ucmd()
- .arg("--color")
- .arg("a")
- .succeeds()
- .stdout_contains(nested_dir_with_colors);
+ let result = scene.ucmd().arg("--color").arg("a").succeeds();
+ assert!(result.stdout_str().contains(nested_dir_with_colors));
// No output
scene
@@ -1926,16 +2237,18 @@ fn test_ls_color() {
// The colors must not mess up the grid layout
at.touch("b");
- scene
+ let result = scene
.ucmd()
.arg("--color")
.arg("-w=15")
.arg("-C")
- .succeeds()
- .stdout_only(format!(
- "{} test-color\nb {}\n",
- a_with_colors, z_with_colors
- ));
+ .succeeds();
+ let expected = format!("{a_with_colors} test-color\x0ab {z_with_colors}");
+ assert_eq!(
+ result.stdout_str().escape_default().to_string(),
+ expected.escape_default().to_string()
+ );
+ assert_eq!(result.stdout_str(), expected);
}
#[cfg(unix)]
@@ -1989,7 +2302,7 @@ fn test_ls_indicator_style() {
at.mkdir("directory");
assert!(at.dir_exists("directory"));
- at.touch(&at.plus_as_string("link-src"));
+ at.touch(at.plus_as_string("link-src"));
at.symlink_file("link-src", "link-dest.link");
assert!(at.is_symlink("link-dest.link"));
@@ -2000,12 +2313,16 @@ fn test_ls_indicator_style() {
for opt in [
"--indicator-style=classify",
"--ind=classify",
+ "--indicator-style=clas", // spell-checker:disable-line
+ "--indicator-style=c",
"--indicator-style=file-type",
"--ind=file-type",
"--indicator-style=slash",
"--ind=slash",
"--classify",
"--classify=always",
+ "--classify=alway",
+ "--classify=al",
"--classify=yes",
"--classify=force",
"--class",
@@ -2020,10 +2337,13 @@ fn test_ls_indicator_style() {
// Classify, Indicator options should not contain any indicators when value is none.
for opt in [
"--indicator-style=none",
+ "--indicator-style=n",
"--ind=none",
"--classify=none",
"--classify=never",
+ "--classify=non",
"--classify=no",
+ "--classify=n",
] {
// Verify that there are no indicators for any of the file types.
scene
@@ -2041,7 +2361,7 @@ fn test_ls_indicator_style() {
// Verify that classify and file-type both contain indicators for symlinks.
scene
.ucmd()
- .arg(format!("--indicator-style={}", opt))
+ .arg(format!("--indicator-style={opt}"))
.succeeds()
.stdout_contains("@")
.stdout_contains("|");
@@ -2081,7 +2401,7 @@ fn test_ls_indicator_style() {
at.mkdir("directory");
assert!(at.dir_exists("directory"));
- at.touch(&at.plus_as_string("link-src"));
+ at.touch(at.plus_as_string("link-src"));
at.symlink_file("link-src", "link-dest.link");
assert!(at.is_symlink("link-dest.link"));
@@ -2091,7 +2411,7 @@ fn test_ls_indicator_style() {
// Verify that classify and file-type both contain indicators for symlinks.
scene
.ucmd()
- .arg(format!("--indicator-style={}", opt))
+ .arg(format!("--indicator-style={opt}"))
.succeeds()
.stdout_contains("/");
}
@@ -2108,7 +2428,7 @@ fn test_ls_indicator_style() {
// Verify that classify and file-type both contain indicators for symlinks.
scene
.ucmd()
- .arg(format!("--indicator-style={}", opt))
+ .arg(format!("--indicator-style={opt}"))
.succeeds()
.stdout_contains("@");
}
@@ -2337,6 +2657,12 @@ fn test_ls_version_sort() {
expected
);
+ let result = scene.ucmd().arg("-1").arg("--sort=v").succeeds();
+ assert_eq!(
+ result.stdout_str().split('\n').collect::<Vec<_>>(),
+ expected
+ );
+
let result = scene.ucmd().arg("-a1v").succeeds();
expected.insert(expected.len() - 1, "..");
expected.insert(0, ".");
@@ -2360,28 +2686,48 @@ fn test_ls_quoting_style() {
{
at.touch("one\ntwo");
at.touch("one\\two");
- // Default is shell-escape
+
+ // Default is literal, when stdout is not a TTY...
+ scene
+ .ucmd()
+ .arg("--hide-control-chars")
+ .arg("one\ntwo")
+ .succeeds()
+ .stdout_only("one?two\n");
+
+ // ... Otherwise, it is shell-escape
+ #[cfg(unix)]
scene
.ucmd()
.arg("--hide-control-chars")
.arg("one\ntwo")
+ .terminal_simulation(true)
.succeeds()
- .stdout_only("'one'$'\\n''two'\n");
+ .stdout_only("'one'$'\\n''two'\r\n");
for (arg, correct) in [
("--quoting-style=literal", "one?two"),
+ ("--quoting-style=litera", "one?two"), // spell-checker:disable-line
+ ("--quoting-style=li", "one?two"),
("-N", "one?two"),
("--literal", "one?two"),
+ ("--l", "one?two"),
("--quoting-style=c", "\"one\\ntwo\""),
+ ("--quoting-style=c-", "\"one\\ntwo\""),
+ ("--quoting-style=c-maybe", "\"one\\ntwo\""),
("-Q", "\"one\\ntwo\""),
("--quote-name", "\"one\\ntwo\""),
("--quoting-style=escape", "one\\ntwo"),
+ ("--quoting-style=escap", "one\\ntwo"), // spell-checker:disable-line
("-b", "one\\ntwo"),
("--escape", "one\\ntwo"),
("--quoting-style=shell-escape", "'one'$'\\n''two'"),
("--quoting-style=shell-escape-always", "'one'$'\\n''two'"),
+ ("--quoting-style=shell-escape-alway", "'one'$'\\n''two'"),
+ ("--quoting-style=shell-escape-a", "'one'$'\\n''two'"),
("--quoting-style=shell", "one?two"),
("--quoting-style=shell-always", "'one?two'"),
+ ("--quoting-style=shell-a", "'one?two'"),
] {
scene
.ucmd()
@@ -2389,13 +2735,14 @@ fn test_ls_quoting_style() {
.arg(arg)
.arg("one\ntwo")
.succeeds()
- .stdout_only(format!("{}\n", correct));
+ .stdout_only(format!("{correct}\n"));
}
for (arg, correct) in [
("--quoting-style=literal", "one\ntwo"),
("-N", "one\ntwo"),
("--literal", "one\ntwo"),
+ ("--l", "one\ntwo"),
("--quoting-style=shell", "one\ntwo"), // FIXME: GNU ls quotes this case
("--quoting-style=shell-always", "'one\ntwo'"),
] {
@@ -2405,7 +2752,7 @@ fn test_ls_quoting_style() {
.arg("--show-control-chars")
.arg("one\ntwo")
.succeeds()
- .stdout_only(format!("{}\n", correct));
+ .stdout_only(format!("{correct}\n"));
}
for (arg, correct) in [
@@ -2427,7 +2774,7 @@ fn test_ls_quoting_style() {
.arg(arg)
.arg("one\\two")
.succeeds()
- .stdout_only(format!("{}\n", correct));
+ .stdout_only(format!("{correct}\n"));
}
// Tests for a character that forces quotation in shell-style escaping
@@ -2443,20 +2790,31 @@ fn test_ls_quoting_style() {
.arg(arg)
.arg("one\n&two")
.succeeds()
- .stdout_only(format!("{}\n", correct));
+ .stdout_only(format!("{correct}\n"));
}
}
+ // No-TTY
+ scene
+ .ucmd()
+ .arg("one two")
+ .succeeds()
+ .stdout_only("one two\n");
+
+ // TTY
+ #[cfg(unix)]
scene
.ucmd()
.arg("one two")
+ .terminal_simulation(true)
.succeeds()
- .stdout_only("'one two'\n");
+ .stdout_only("'one two'\r\n");
for (arg, correct) in [
("--quoting-style=literal", "one two"),
("-N", "one two"),
("--literal", "one two"),
+ ("--l", "one two"),
("--quoting-style=c", "\"one two\""),
("-Q", "\"one two\""),
("--quote-name", "\"one two\""),
@@ -2474,7 +2832,7 @@ fn test_ls_quoting_style() {
.arg(arg)
.arg("one two")
.succeeds()
- .stdout_only(format!("{}\n", correct));
+ .stdout_only(format!("{correct}\n"));
}
scene.ucmd().arg("one").succeeds().stdout_only("one\n");
@@ -2498,45 +2856,157 @@ fn test_ls_quoting_style() {
.arg(arg)
.arg("one")
.succeeds()
- .stdout_only(format!("{}\n", correct));
+ .stdout_only(format!("{correct}\n"));
}
}
#[test]
-fn test_ls_quoting_and_color() {
+fn test_ls_quoting_style_env_var_default() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
+ at.touch(at.plus_as_string("foo-1"));
+ at.touch(at.plus_as_string("bar-2"));
- at.touch("one two");
+ // If no quoting style argument is provided, the QUOTING_STYLE environment variable
+ // shall be used.
+
+ let correct_c = "\"bar-2\"\n\"foo-1\"";
scene
.ucmd()
- .arg("--color")
- .arg("one two")
+ .env("QUOTING_STYLE", "c")
.succeeds()
- .stdout_only("'one two'\n");
+ .stdout_only(format!("{correct_c}\n"));
}
#[test]
-fn test_ls_ignore_hide() {
+fn test_ls_quoting_style_arg_overrides_env_var() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
+ at.touch(at.plus_as_string("foo-1"));
+ at.touch(at.plus_as_string("bar-2"));
- at.touch("README.md");
- at.touch("CONTRIBUTING.md");
- at.touch("some_other_file");
- at.touch("READMECAREFULLY.md");
-
- scene
- .ucmd()
- .arg("--hide=*")
- .arg("-1")
- .succeeds()
- .stdout_only("");
+ // The quoting style given by the env variable should be
+ // overridden by any escape style provided by argument.
+ for (arg, correct) in [
+ ("--quoting-style=literal", "foo-1"),
+ ("-N", "foo-1"),
+ ("--quoting-style=escape", "foo-1"),
+ ("-b", "foo-1"),
+ ("--quoting-style=shell-escape", "foo-1"),
+ ("--quoting-style=shell-escape-always", "'foo-1'"),
+ ("--quoting-style=shell", "foo-1"),
+ ("--quoting-style=shell-always", "'foo-1'"),
+ ] {
+ scene
+ .ucmd()
+ .env("QUOTING_STYLE", "c")
+ .arg("--hide-control-chars")
+ .arg(arg)
+ .arg("foo-1")
+ .succeeds()
+ .stdout_only(format!("{correct}\n"));
+ }
- scene
- .ucmd()
- .arg("--ignore=*")
- .arg("-1")
+ // Another loop to check for the C quoting style that is used as a default above.
+ for (arg, correct) in [
+ ("--quoting-style=c", "\"foo-1\""),
+ ("-Q", "\"foo-1\""),
+ ("--quote-name", "\"foo-1\""),
+ ] {
+ scene
+ .ucmd()
+ .env("QUOTING_STYLE", "literal")
+ .arg("--hide-control-chars")
+ .arg(arg)
+ .arg("foo-1")
+ .succeeds()
+ .stdout_only(format!("{correct}\n"));
+ }
+}
+
+#[test]
+fn test_ls_quoting_and_color() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("one two");
+
+ // No-TTY
+ scene
+ .ucmd()
+ .arg("--color")
+ .arg("one two")
+ .succeeds()
+ .stdout_only("one two\n");
+
+ // TTY
+ #[cfg(unix)]
+ scene
+ .ucmd()
+ .arg("--color")
+ .arg("one two")
+ .terminal_simulation(true)
+ .succeeds()
+ .stdout_only("'one two'\r\n");
+}
+
+#[test]
+fn test_ls_align_unquoted() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("elf two");
+ at.touch("foobar");
+ at.touch("CAPS");
+ at.touch("'quoted'");
+
+ // In TTY
+ #[cfg(unix)]
+ scene
+ .ucmd()
+ .arg("--color")
+ .terminal_simulation(true)
+ .succeeds()
+ .stdout_only("\"'quoted'\" CAPS 'elf two' foobar\r\n");
+ // ^ ^ ^
+ // space no-space space
+
+ // The same should happen with format columns/across
+ // and shell quoting style, except for the `\r` at the end.
+ for format in &["--format=column", "--format=across"] {
+ scene
+ .ucmd()
+ .arg("--color")
+ .arg(format)
+ .arg("--quoting-style=shell")
+ .succeeds()
+ .stdout_only("\"'quoted'\" CAPS 'elf two' foobar\n");
+ // ^ ^ ^
+ // space no-space space
+ }
+}
+
+#[test]
+fn test_ls_ignore_hide() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.touch("README.md");
+ at.touch("CONTRIBUTING.md");
+ at.touch("some_other_file");
+ at.touch("READMECAREFULLY.md");
+
+ scene
+ .ucmd()
+ .arg("--hide=*")
+ .arg("-1")
+ .succeeds()
+ .stdout_only("");
+
+ scene
+ .ucmd()
+ .arg("--ignore=*")
+ .arg("-1")
.succeeds()
.stdout_only("");
@@ -3028,31 +3498,28 @@ fn test_ls_path() {
let file1 = "file1";
let file2 = "file2";
let dir = "dir";
- let path = &format!("{}/{}", dir, file2);
+ let path = &format!("{dir}/{file2}");
at.mkdir(dir);
at.touch(file1);
at.touch(path);
- let expected_stdout = &format!("{}\n", path);
+ let expected_stdout = &format!("{path}\n");
scene.ucmd().arg(path).run().stdout_is(expected_stdout);
- let expected_stdout = &format!("./{}\n", path);
+ let expected_stdout = &format!("./{path}\n");
scene
.ucmd()
- .arg(format!("./{}", path))
+ .arg(format!("./{path}"))
.run()
.stdout_is(expected_stdout);
let abs_path = format!("{}/{}", at.as_string(), path);
- let expected_stdout = if cfg!(windows) {
- format!("\'{}\'\n", abs_path)
- } else {
- format!("{}\n", abs_path)
- };
+ let expected_stdout = format!("{abs_path}\n");
+
scene.ucmd().arg(&abs_path).run().stdout_is(expected_stdout);
- let expected_stdout = format!("{}\n{}\n", path, file1);
+ let expected_stdout = format!("{path}\n{file1}\n");
scene
.ucmd()
.arg(file1)
@@ -3098,6 +3565,16 @@ fn test_ls_dangling_symlinks() {
.stderr_contains("No such file or directory")
.stdout_contains(if cfg!(windows) { "dangle" } else { "? dangle" });
+ scene
+ .ucmd()
+ .arg("-LZ")
+ .arg("temp_dir")
+ .fails()
+ .code_is(1)
+ .stderr_contains("cannot access")
+ .stderr_contains("No such file or directory")
+ .stdout_contains(if cfg!(windows) { "dangle" } else { "? dangle" });
+
scene
.ucmd()
.arg("-Ll")
@@ -3380,3 +3857,766 @@ fn test_tabsize_formatting() {
.succeeds()
.stdout_is("aaaaaaaa bbbb\ncccc dddddddd");
}
+
+#[cfg(any(
+ target_os = "linux",
+ target_os = "macos",
+ target_os = "ios",
+ target_os = "freebsd",
+ target_os = "dragonfly",
+ target_os = "netbsd",
+ target_os = "openbsd",
+ target_os = "illumos",
+ target_os = "solaris"
+))]
+#[test]
+fn test_device_number() {
+ use std::fs::{metadata, read_dir};
+ use std::os::unix::fs::{FileTypeExt, MetadataExt};
+ use uucore::libc::{dev_t, major, minor};
+
+ let dev_dir = read_dir("/dev").unwrap();
+ // let's use the first device for test
+ let blk_dev = dev_dir
+ .map(|res_entry| res_entry.unwrap())
+ .find(|entry| {
+ entry.file_type().unwrap().is_block_device()
+ || entry.file_type().unwrap().is_char_device()
+ })
+ .expect("Expect a block/char device");
+ let blk_dev_path = blk_dev.path();
+ let blk_dev_meta = metadata(blk_dev_path.as_path()).unwrap();
+ let blk_dev_number = blk_dev_meta.rdev() as dev_t;
+ let (major, minor) = unsafe { (major(blk_dev_number), minor(blk_dev_number)) };
+ let major_minor_str = format!("{major}, {minor}");
+
+ let scene = TestScenario::new(util_name!());
+ scene
+ .ucmd()
+ .arg("-l")
+ .arg(blk_dev_path.to_str().expect("should be UTF-8 encoded"))
+ .succeeds()
+ .stdout_contains(major_minor_str);
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_invalid_utf8() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let filename = OsStr::from_bytes(b"-\xE0-foo");
+ at.touch(filename);
+ ucmd.succeeds();
+}
+
+#[cfg(all(unix, feature = "chmod"))]
+#[test]
+fn test_ls_perm_io_errors() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.mkdir("d");
+ at.symlink_file("/", "d/s");
+
+ scene.ccmd("chmod").arg("600").arg("d").succeeds();
+
+ scene
+ .ucmd()
+ .arg("-l")
+ .arg("d")
+ .fails()
+ .code_is(1)
+ .stderr_contains("Permission denied");
+}
+
+#[test]
+fn test_ls_dired_incompatible() {
+ let scene = TestScenario::new(util_name!());
+
+ scene
+ .ucmd()
+ .arg("--dired")
+ .fails()
+ .code_is(1)
+ .stderr_contains("--dired requires --format=long");
+}
+
+#[test]
+fn test_ls_dired_and_zero_are_incompatible() {
+ let scene = TestScenario::new(util_name!());
+
+ scene
+ .ucmd()
+ .arg("--dired")
+ .arg("-l")
+ .arg("--zero")
+ .fails()
+ .code_is(2)
+ .stderr_contains("--dired and --zero are incompatible");
+}
+
+#[test]
+fn test_ls_dired_recursive() {
+ let scene = TestScenario::new(util_name!());
+
+ scene
+ .ucmd()
+ .arg("--dired")
+ .arg("-l")
+ .arg("-R")
+ .succeeds()
+ .stdout_does_not_contain("//DIRED//")
+ .stdout_contains(" total 0")
+ .stdout_contains("//SUBDIRED// 2 3")
+ .stdout_contains("//DIRED-OPTIONS// --quoting-style");
+}
+
+#[test]
+fn test_ls_dired_recursive_multiple() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.mkdir("d");
+ at.mkdir("d/d1");
+ at.mkdir("d/d2");
+ at.touch("d/d2/a");
+ at.touch("d/d2/c2");
+ at.touch("d/d1/f1");
+ at.touch("d/d1/file-long");
+
+ let mut cmd = scene.ucmd();
+ cmd.arg("--dired").arg("-l").arg("-R").arg("d");
+
+ let result = cmd.succeeds();
+
+ let output = result.stdout_str().to_string();
+ println!("Output:\n{}", output);
+
+ let dired_line = output
+ .lines()
+ .find(|&line| line.starts_with("//DIRED//"))
+ .unwrap();
+ let positions: Vec<usize> = dired_line
+ .split_whitespace()
+ .skip(1)
+ .map(|s| s.parse().unwrap())
+ .collect();
+ println!("Parsed byte positions: {positions:?}");
+ assert_eq!(positions.len() % 2, 0); // Ensure there's an even number of positions
+
+ let filenames: Vec<String> = positions
+ .chunks(2)
+ .map(|chunk| {
+ let start_pos = chunk[0];
+ let end_pos = chunk[1];
+ let filename = String::from_utf8(output.as_bytes()[start_pos..=end_pos].to_vec())
+ .unwrap()
+ .trim()
+ .to_string();
+ println!("Extracted filename: {}", filename);
+ filename
+ })
+ .collect();
+
+ println!("Extracted filenames: {filenames:?}");
+ assert_eq!(filenames, vec!["d1", "d2", "f1", "file-long", "a", "c2"]);
+}
+
+#[test]
+fn test_ls_dired_simple() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ scene
+ .ucmd()
+ .arg("--dired")
+ .arg("-l")
+ .succeeds()
+ .stdout_contains(" total 0");
+
+ at.mkdir("d");
+ at.touch("d/a1");
+ let mut cmd = scene.ucmd();
+ cmd.arg("--dired").arg("-l").arg("d");
+ let result = cmd.succeeds();
+ result.stdout_contains(" total 0");
+ println!(" result.stdout = {:#?}", result.stdout_str());
+
+ let dired_line = result
+ .stdout_str()
+ .lines()
+ .find(|&line| line.starts_with("//DIRED//"))
+ .unwrap();
+ let positions: Vec<usize> = dired_line
+ .split_whitespace()
+ .skip(1)
+ .map(|s| s.parse().unwrap())
+ .collect();
+
+ assert_eq!(positions.len(), 2);
+
+ let start_pos = positions[0];
+ let end_pos = positions[1];
+
+ // Extract the filename using the positions
+ let filename =
+ String::from_utf8(result.stdout_str().as_bytes()[start_pos..end_pos].to_vec()).unwrap();
+
+ assert_eq!(filename, "a1");
+}
+
+#[test]
+fn test_ls_dired_complex() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.mkdir("d");
+ at.mkdir("d/d");
+ at.touch("d/a1");
+ at.touch("d/a22");
+ at.touch("d/a333");
+ at.touch("d/a4444");
+
+ let mut cmd = scene.ucmd();
+ cmd.arg("--dired").arg("-l").arg("d");
+ let result = cmd.succeeds();
+
+ // Number of blocks. We run this test only if the default size of a newly created directory is
+ // 4096 bytes to prevent it from failing where this is not the case (e.g. using tmpfs for /tmp).
+ #[cfg(target_os = "linux")]
+ if at.metadata("d/d").len() == 4096 {
+ result.stdout_contains(" total 4");
+ }
+
+ let output = result.stdout_str().to_string();
+ println!("Output:\n{output}");
+
+ let dired_line = output
+ .lines()
+ .find(|&line| line.starts_with("//DIRED//"))
+ .unwrap();
+ let positions: Vec<usize> = dired_line
+ .split_whitespace()
+ .skip(1)
+ .map(|s| s.parse().unwrap())
+ .collect();
+ println!("{:?}", positions);
+ println!("Parsed byte positions: {:?}", positions);
+ assert_eq!(positions.len() % 2, 0); // Ensure there's an even number of positions
+
+ let filenames: Vec<String> = positions
+ .chunks(2)
+ .map(|chunk| {
+ let start_pos = chunk[0];
+ let end_pos = chunk[1];
+ let filename = String::from_utf8(output.as_bytes()[start_pos..=end_pos].to_vec())
+ .unwrap()
+ .trim()
+ .to_string();
+ println!("Extracted filename: {}", filename);
+ filename
+ })
+ .collect();
+
+ println!("Extracted filenames: {:?}", filenames);
+ assert_eq!(filenames, vec!["a1", "a22", "a333", "a4444", "d"]);
+}
+
+#[test]
+fn test_ls_subdired_complex() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.mkdir("dir1");
+ at.mkdir("dir1/d");
+ at.mkdir("dir1/c2");
+ at.touch("dir1/a1");
+ at.touch("dir1/a22");
+ at.touch("dir1/a333");
+ at.touch("dir1/c2/a4444");
+
+ let mut cmd = scene.ucmd();
+ cmd.arg("--dired").arg("-l").arg("-R").arg("dir1");
+ let result = cmd.succeeds();
+
+ let output = result.stdout_str().to_string();
+ println!("Output:\n{}", output);
+
+ let dired_line = output
+ .lines()
+ .find(|&line| line.starts_with("//SUBDIRED//"))
+ .unwrap();
+ let positions: Vec<usize> = dired_line
+ .split_whitespace()
+ .skip(1)
+ .map(|s| s.parse().unwrap())
+ .collect();
+ println!("Parsed byte positions: {:?}", positions);
+ assert_eq!(positions.len() % 2, 0); // Ensure there's an even number of positions
+
+ let dirnames: Vec<String> = positions
+ .chunks(2)
+ .map(|chunk| {
+ let start_pos = chunk[0];
+ let end_pos = chunk[1];
+ let dirname =
+ String::from_utf8(output.as_bytes()[start_pos..end_pos].to_vec()).unwrap();
+ println!("Extracted dirname: {}", dirname);
+ dirname
+ })
+ .collect();
+
+ println!("Extracted dirnames: {:?}", dirnames);
+ #[cfg(unix)]
+ assert_eq!(dirnames, vec!["dir1", "dir1/c2", "dir1/d"]);
+ #[cfg(windows)]
+ assert_eq!(dirnames, vec!["dir1", "dir1\\c2", "dir1\\d"]);
+}
+
+#[ignore = "issue #5396"]
+#[test]
+fn test_ls_cf_output_should_be_delimited_by_tab() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ at.mkdir("e");
+ at.mkdir("e/a2345");
+ at.mkdir("e/b");
+
+ ucmd.args(&["-CF", "e"])
+ .succeeds()
+ .stdout_is("a2345/\tb/\n");
+}
+
+#[cfg(all(unix, feature = "dd"))]
+#[test]
+fn test_posixly_correct_and_block_size_env_vars() {
+ let scene = TestScenario::new(util_name!());
+
+ scene
+ .ccmd("dd")
+ .arg("if=/dev/zero")
+ .arg("of=file")
+ .arg("bs=1024")
+ .arg("count=1")
+ .succeeds();
+
+ scene
+ .ucmd()
+ .arg("-l")
+ .succeeds()
+ .stdout_contains_line("total 4")
+ .stdout_contains(" 1024 ");
+
+ scene
+ .ucmd()
+ .arg("-l")
+ .env("POSIXLY_CORRECT", "some_value")
+ .succeeds()
+ .stdout_contains_line("total 8")
+ .stdout_contains(" 1024 ");
+
+ scene
+ .ucmd()
+ .arg("-l")
+ .env("LS_BLOCK_SIZE", "512")
+ .succeeds()
+ .stdout_contains_line("total 8")
+ .stdout_contains(" 2 ");
+
+ scene
+ .ucmd()
+ .arg("-l")
+ .env("BLOCK_SIZE", "512")
+ .succeeds()
+ .stdout_contains_line("total 8")
+ .stdout_contains(" 2 ");
+
+ scene
+ .ucmd()
+ .arg("-l")
+ .env("BLOCKSIZE", "512")
+ .succeeds()
+ .stdout_contains_line("total 8")
+ .stdout_contains(" 1024 ");
+}
+
+#[cfg(all(unix, feature = "dd"))]
+#[test]
+fn test_posixly_correct_and_block_size_env_vars_with_k() {
+ let scene = TestScenario::new(util_name!());
+
+ scene
+ .ccmd("dd")
+ .arg("if=/dev/zero")
+ .arg("of=file")
+ .arg("bs=1024")
+ .arg("count=1")
+ .succeeds();
+
+ scene
+ .ucmd()
+ .arg("-l")
+ .arg("-k")
+ .env("POSIXLY_CORRECT", "some_value")
+ .succeeds()
+ .stdout_contains_line("total 4")
+ .stdout_contains(" 1024 ");
+
+ scene
+ .ucmd()
+ .arg("-l")
+ .arg("-k")
+ .env("LS_BLOCK_SIZE", "512")
+ .succeeds()
+ .stdout_contains_line("total 4")
+ .stdout_contains(" 2 ");
+
+ scene
+ .ucmd()
+ .arg("-l")
+ .arg("-k")
+ .env("BLOCK_SIZE", "512")
+ .succeeds()
+ .stdout_contains_line("total 4")
+ .stdout_contains(" 2 ");
+
+ scene
+ .ucmd()
+ .arg("-l")
+ .arg("-k")
+ .env("BLOCKSIZE", "512")
+ .succeeds()
+ .stdout_contains_line("total 4")
+ .stdout_contains(" 1024 ");
+}
+
+#[test]
+fn test_ls_invalid_block_size() {
+ new_ucmd!()
+ .arg("--block-size=invalid")
+ .fails()
+ .code_is(2)
+ .no_stdout()
+ .stderr_is("ls: invalid --block-size argument 'invalid'\n");
+}
+
+#[cfg(all(unix, feature = "dd"))]
+#[test]
+fn test_ls_invalid_block_size_in_env_var() {
+ let scene = TestScenario::new(util_name!());
+
+ scene
+ .ccmd("dd")
+ .arg("if=/dev/zero")
+ .arg("of=file")
+ .arg("bs=1024")
+ .arg("count=1")
+ .succeeds();
+
+ scene
+ .ucmd()
+ .arg("-og")
+ .env("LS_BLOCK_SIZE", "invalid")
+ .succeeds()
+ .stdout_contains_line("total 4")
+ .stdout_contains(" 1 1 "); // hardlink count + file size
+
+ scene
+ .ucmd()
+ .arg("-og")
+ .env("BLOCK_SIZE", "invalid")
+ .succeeds()
+ .stdout_contains_line("total 4")
+ .stdout_contains(" 1 1 "); // hardlink count + file size
+
+ scene
+ .ucmd()
+ .arg("-og")
+ .env("BLOCKSIZE", "invalid")
+ .succeeds()
+ .stdout_contains_line("total 4")
+ .stdout_contains(" 1024 ");
+}
+
+#[cfg(all(unix, feature = "dd"))]
+#[test]
+fn test_ls_block_size_override() {
+ let scene = TestScenario::new(util_name!());
+
+ scene
+ .ccmd("dd")
+ .arg("if=/dev/zero")
+ .arg("of=file")
+ .arg("bs=1024")
+ .arg("count=1")
+ .succeeds();
+
+ // --si "wins"
+ scene
+ .ucmd()
+ .arg("-s")
+ .arg("--block-size=512")
+ .arg("--si")
+ .succeeds()
+ .stdout_contains_line("total 4.1k");
+
+ // --block-size "wins"
+ scene
+ .ucmd()
+ .arg("-s")
+ .arg("--si")
+ .arg("--block-size=512")
+ .succeeds()
+ .stdout_contains_line("total 8");
+
+ // --human-readable "wins"
+ scene
+ .ucmd()
+ .arg("-s")
+ .arg("--block-size=512")
+ .arg("--human-readable")
+ .succeeds()
+ .stdout_contains_line("total 4.0K");
+
+ // --block-size "wins"
+ scene
+ .ucmd()
+ .arg("-s")
+ .arg("--human-readable")
+ .arg("--block-size=512")
+ .succeeds()
+ .stdout_contains_line("total 8");
+}
+
+#[test]
+fn test_ls_block_size_override_self() {
+ new_ucmd!()
+ .arg("--block-size=512")
+ .arg("--block-size=512")
+ .succeeds();
+
+ new_ucmd!()
+ .arg("--human-readable")
+ .arg("--human-readable")
+ .succeeds();
+
+ new_ucmd!().arg("--si").arg("--si").succeeds();
+}
+
+#[test]
+fn test_ls_hyperlink() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let file = "a.txt";
+
+ at.touch(file);
+
+ let path = at.root_dir_resolved();
+ let separator = std::path::MAIN_SEPARATOR_STR;
+
+ let result = scene.ucmd().arg("--hyperlink").succeeds();
+ assert!(result.stdout_str().contains("\x1b]8;;file://"));
+ assert!(result
+ .stdout_str()
+ .contains(&format!("{path}{separator}{file}\x07{file}\x1b]8;;\x07")));
+
+ let result = scene.ucmd().arg("--hyperlink=always").succeeds();
+ assert!(result.stdout_str().contains("\x1b]8;;file://"));
+ assert!(result
+ .stdout_str()
+ .contains(&format!("{path}{separator}{file}\x07{file}\x1b]8;;\x07")));
+
+ for argument in [
+ "--hyperlink=never",
+ "--hyperlink=neve", // spell-checker:disable-line
+ "--hyperlink=ne",
+ "--hyperlink=n",
+ ] {
+ scene
+ .ucmd()
+ .arg(argument)
+ .succeeds()
+ .stdout_is(format!("{file}\n"));
+ }
+}
+
+// spell-checker: disable
+#[test]
+fn test_ls_hyperlink_encode_link() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ #[cfg(not(target_os = "windows"))]
+ {
+ at.touch("back\\slash");
+ at.touch("ques?tion");
+ }
+ at.touch("encoded%3Fquestion");
+ at.touch("sp ace");
+
+ let result = ucmd.arg("--hyperlink").succeeds();
+ #[cfg(not(target_os = "windows"))]
+ {
+ assert!(result
+ .stdout_str()
+ .contains("back%5cslash\x07back\\slash\x1b]8;;\x07"));
+ assert!(result
+ .stdout_str()
+ .contains("ques%3ftion\x07ques?tion\x1b]8;;\x07"));
+ }
+ assert!(result
+ .stdout_str()
+ .contains("encoded%253Fquestion\x07encoded%3Fquestion\x1b]8;;\x07"));
+ assert!(result
+ .stdout_str()
+ .contains("sp%20ace\x07sp ace\x1b]8;;\x07"));
+}
+// spell-checker: enable
+
+#[test]
+fn test_ls_hyperlink_dirs() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let dir_a = "a";
+ let dir_b = "b";
+
+ at.mkdir(dir_a);
+ at.mkdir(dir_b);
+
+ let path = at.root_dir_resolved();
+ let separator = std::path::MAIN_SEPARATOR_STR;
+
+ let result = scene
+ .ucmd()
+ .arg("--hyperlink")
+ .arg(dir_a)
+ .arg(dir_b)
+ .succeeds();
+
+ assert!(result.stdout_str().contains("\x1b]8;;file://"));
+ assert!(result
+ .stdout_str()
+ .lines()
+ .next()
+ .unwrap()
+ .contains(&format!("{path}{separator}{dir_a}\x07{dir_a}\x1b]8;;\x07:")));
+ assert_eq!(result.stdout_str().lines().nth(1).unwrap(), "");
+ assert!(result
+ .stdout_str()
+ .lines()
+ .nth(2)
+ .unwrap()
+ .contains(&format!("{path}{separator}{dir_b}\x07{dir_b}\x1b]8;;\x07:")));
+}
+
+#[test]
+fn test_ls_color_do_not_reset() {
+ let scene: TestScenario = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.mkdir("example");
+ at.mkdir("example/a");
+ at.mkdir("example/b");
+
+ let result = scene
+ .ucmd()
+ .arg("--color=always")
+ .arg("example/")
+ .succeeds();
+ // the second color code should not have a reset
+ assert_eq!(
+ result.stdout_str().escape_default().to_string(),
+ "\\u{1b}[0m\\u{1b}[01;34ma\\u{1b}[0m\\n\\u{1b}[01;34mb\\u{1b}[0m\\n"
+ );
+}
+
+#[cfg(all(unix, feature = "chmod"))]
+#[test]
+fn test_term_colorterm() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.touch("exe");
+ scene.ccmd("chmod").arg("+x").arg("exe").succeeds();
+
+ // Should show colors
+ let result = scene
+ .ucmd()
+ .arg("--color=always")
+ .env("LS_COLORS", "")
+ .env("TERM", "")
+ .succeeds();
+ assert_eq!(
+ result.stdout_str().trim().escape_default().to_string(),
+ "\\u{1b}[0m\\u{1b}[01;32mexe\\u{1b}[0m"
+ );
+
+ // Should show colors
+ let result = scene
+ .ucmd()
+ .arg("--color=always")
+ .env("LS_COLORS", "")
+ .env("COLORTERM", "")
+ .succeeds();
+ assert_eq!(
+ result.stdout_str().trim().escape_default().to_string(),
+ "\\u{1b}[0m\\u{1b}[01;32mexe\\u{1b}[0m"
+ );
+
+ // No colors
+ let result = scene
+ .ucmd()
+ .arg("--color=always")
+ .env("LS_COLORS", "")
+ .env("TERM", "")
+ .env("COLORTERM", "")
+ .succeeds();
+ assert_eq!(
+ result.stdout_str().trim().escape_default().to_string(),
+ "exe"
+ );
+
+ // No colors
+ let result = scene
+ .ucmd()
+ .arg("--color=always")
+ .env("LS_COLORS", "")
+ .env("TERM", "dumb")
+ .env("COLORTERM", "")
+ .succeeds();
+ assert_eq!(
+ result.stdout_str().trim().escape_default().to_string(),
+ "exe"
+ );
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_acl_display() {
+ use std::process::Command;
+
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let path = "a42";
+ at.mkdir(path);
+
+ let path = at.plus_as_string(path);
+ // calling the command directly. xattr requires some dev packages to be installed
+ // and it adds a complex dependency just for a test
+ match Command::new("setfacl")
+ .args(["-d", "-m", "group::rwx", &path])
+ .status()
+ .map(|status| status.code())
+ {
+ Ok(Some(0)) => {}
+ Ok(_) => {
+ println!("test skipped: setfacl failed");
+ return;
+ }
+ Err(e) => {
+ println!("test skipped: setfacl failed with {}", e);
+ return;
+ }
+ }
+
+ scene
+ .ucmd()
+ .args(&["-lda", &path])
+ .succeeds()
+ .stdout_contains("+");
+}
diff --git a/tests/by-util/test_mkdir.rs b/tests/by-util/test_mkdir.rs
index 59546b847b72f28dc0aaf7a9f25cf1bcb13f5c3e..04d3922206eecf636299c9b7a81f9dc008444524 100644
--- a/tests/by-util/test_mkdir.rs
+++ b/tests/by-util/test_mkdir.rs
@@ -1,24 +1,12 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
#[cfg(not(windows))]
-use std::os::unix::fs::PermissionsExt;
-#[cfg(not(windows))]
-extern crate libc;
-#[cfg(not(windows))]
-use self::libc::{mode_t, umask};
-
-static TEST_DIR1: &str = "mkdir_test1";
-static TEST_DIR2: &str = "mkdir_test2";
-static TEST_DIR3: &str = "mkdir_test3";
-static TEST_DIR4: &str = "mkdir_test4/mkdir_test4_1";
-static TEST_DIR5: &str = "mkdir_test5/mkdir_test5_1";
-static TEST_DIR6: &str = "mkdir_test6";
-static TEST_FILE7: &str = "mkdir_test7";
-static TEST_DIR8: &str = "mkdir_test8/mkdir_test8_1/mkdir_test8_2";
-static TEST_DIR9: &str = "mkdir_test9/../mkdir_test9_1/../mkdir_test9_2";
-static TEST_DIR10: &str = "mkdir_test10/.";
-static TEST_DIR11: &str = "mkdir_test11/..";
+use libc::mode_t;
#[cfg(not(windows))]
-static TEST_DIR12: &str = "mkdir_test12";
+use std::os::unix::fs::PermissionsExt;
#[test]
fn test_invalid_arg() {
@@ -27,14 +15,14 @@ fn test_invalid_arg() {
#[test]
fn test_mkdir_mkdir() {
- new_ucmd!().arg(TEST_DIR1).succeeds();
+ new_ucmd!().arg("test_dir").succeeds();
}
#[test]
fn test_mkdir_verbose() {
- let expected = "mkdir: created directory 'mkdir_test1'\n";
+ let expected = "mkdir: created directory 'test_dir'\n";
new_ucmd!()
- .arg(TEST_DIR1)
+ .arg("test_dir")
.arg("-v")
.run()
.stdout_is(expected);
@@ -43,53 +31,123 @@ fn test_mkdir_verbose() {
#[test]
fn test_mkdir_dup_dir() {
let scene = TestScenario::new(util_name!());
- scene.ucmd().arg(TEST_DIR2).succeeds();
- scene.ucmd().arg(TEST_DIR2).fails();
+ let test_dir = "test_dir";
+
+ scene.ucmd().arg(test_dir).succeeds();
+ scene.ucmd().arg(test_dir).fails();
}
#[test]
fn test_mkdir_mode() {
- new_ucmd!().arg("-m").arg("755").arg(TEST_DIR3).succeeds();
+ new_ucmd!().arg("-m").arg("755").arg("test_dir").succeeds();
}
#[test]
fn test_mkdir_parent() {
let scene = TestScenario::new(util_name!());
- scene.ucmd().arg("-p").arg(TEST_DIR4).succeeds();
- scene.ucmd().arg("-p").arg(TEST_DIR4).succeeds();
- scene.ucmd().arg("--parent").arg(TEST_DIR4).succeeds();
- scene.ucmd().arg("--parents").arg(TEST_DIR4).succeeds();
+ let test_dir = "parent_dir/child_dir";
+
+ scene.ucmd().arg("-p").arg(test_dir).succeeds();
+ scene.ucmd().arg("-p").arg(test_dir).succeeds();
+ scene.ucmd().arg("--parent").arg(test_dir).succeeds();
+ scene.ucmd().arg("--parents").arg(test_dir).succeeds();
}
#[test]
fn test_mkdir_no_parent() {
- new_ucmd!().arg(TEST_DIR5).fails();
+ new_ucmd!().arg("parent_dir/child_dir").fails();
}
#[test]
fn test_mkdir_dup_dir_parent() {
let scene = TestScenario::new(util_name!());
- scene.ucmd().arg(TEST_DIR6).succeeds();
- scene.ucmd().arg("-p").arg(TEST_DIR6).succeeds();
+ let test_dir = "test_dir";
+
+ scene.ucmd().arg(test_dir).succeeds();
+ scene.ucmd().arg("-p").arg(test_dir).succeeds();
+}
+
+#[cfg(not(windows))]
+#[test]
+fn test_mkdir_parent_mode() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let default_umask: mode_t = 0o160;
+
+ ucmd.arg("-p")
+ .arg("a/b")
+ .umask(default_umask)
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+
+ assert!(at.dir_exists("a"));
+ // parents created by -p have permissions set to "=rwx,u+wx"
+ assert_eq!(
+ at.metadata("a").permissions().mode() as mode_t,
+ ((!default_umask & 0o777) | 0o300) + 0o40000
+ );
+ assert!(at.dir_exists("a/b"));
+ // sub directory's permission is determined only by the umask
+ assert_eq!(
+ at.metadata("a/b").permissions().mode() as mode_t,
+ (!default_umask & 0o777) + 0o40000
+ );
+}
+
+#[cfg(not(windows))]
+#[test]
+fn test_mkdir_parent_mode_check_existing_parent() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ at.mkdir("a");
+ let parent_a_perms = at.metadata("a").permissions().mode();
+
+ let default_umask: mode_t = 0o160;
+
+ ucmd.arg("-p")
+ .arg("a/b/c")
+ .umask(default_umask)
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+
+ assert!(at.dir_exists("a"));
+ // parent dirs that already exist do not get their permissions modified
+ assert_eq!(at.metadata("a").permissions().mode(), parent_a_perms);
+ assert!(at.dir_exists("a/b"));
+ assert_eq!(
+ at.metadata("a/b").permissions().mode() as mode_t,
+ ((!default_umask & 0o777) | 0o300) + 0o40000
+ );
+ assert!(at.dir_exists("a/b/c"));
+ assert_eq!(
+ at.metadata("a/b/c").permissions().mode() as mode_t,
+ (!default_umask & 0o777) + 0o40000
+ );
}
#[test]
fn test_mkdir_dup_file() {
let scene = TestScenario::new(util_name!());
- scene.fixtures.touch(TEST_FILE7);
- scene.ucmd().arg(TEST_FILE7).fails();
+ let test_file = "test_file.txt";
+
+ scene.fixtures.touch(test_file);
+
+ scene.ucmd().arg(test_file).fails();
// mkdir should fail for a file even if -p is specified.
- scene.ucmd().arg("-p").arg(TEST_FILE7).fails();
+ scene.ucmd().arg("-p").arg(test_file).fails();
}
#[test]
#[cfg(not(windows))]
fn test_symbolic_mode() {
let (at, mut ucmd) = at_and_ucmd!();
+ let test_dir = "test_dir";
- ucmd.arg("-m").arg("a=rwx").arg(TEST_DIR1).succeeds();
- let perms = at.metadata(TEST_DIR1).permissions().mode();
+ ucmd.arg("-m").arg("a=rwx").arg(test_dir).succeeds();
+ let perms = at.metadata(test_dir).permissions().mode();
assert_eq!(perms, 0o40777);
}
@@ -97,69 +155,76 @@ fn test_symbolic_mode() {
#[cfg(not(windows))]
fn test_symbolic_alteration() {
let (at, mut ucmd) = at_and_ucmd!();
+ let test_dir = "test_dir";
+
+ let default_umask = 0o022;
- ucmd.arg("-m").arg("-w").arg(TEST_DIR1).succeeds();
- let perms = at.metadata(TEST_DIR1).permissions().mode();
- assert_eq!(perms, 0o40555);
+ ucmd.arg("-m")
+ .arg("-w")
+ .arg(test_dir)
+ .umask(default_umask)
+ .succeeds();
+ let perms = at.metadata(test_dir).permissions().mode();
+ assert_eq!(perms, 0o40577);
}
#[test]
#[cfg(not(windows))]
fn test_multi_symbolic() {
let (at, mut ucmd) = at_and_ucmd!();
+ let test_dir = "test_dir";
- ucmd.arg("-m")
- .arg("u=rwx,g=rx,o=")
- .arg(TEST_DIR1)
- .succeeds();
- let perms = at.metadata(TEST_DIR1).permissions().mode();
+ ucmd.arg("-m").arg("u=rwx,g=rx,o=").arg(test_dir).succeeds();
+ let perms = at.metadata(test_dir).permissions().mode();
assert_eq!(perms, 0o40750);
}
#[test]
fn test_recursive_reporting() {
+ let test_dir = "test_dir/test_dir_a/test_dir_b";
+
new_ucmd!()
.arg("-p")
.arg("-v")
- .arg(TEST_DIR8)
+ .arg(test_dir)
.succeeds()
- .stdout_contains("created directory 'mkdir_test8'")
- .stdout_contains("created directory 'mkdir_test8/mkdir_test8_1'")
- .stdout_contains("created directory 'mkdir_test8/mkdir_test8_1/mkdir_test8_2'");
- new_ucmd!().arg("-v").arg(TEST_DIR8).fails().no_stdout();
+ .stdout_contains("created directory 'test_dir'")
+ .stdout_contains("created directory 'test_dir/test_dir_a'")
+ .stdout_contains("created directory 'test_dir/test_dir_a/test_dir_b'");
+ new_ucmd!().arg("-v").arg(test_dir).fails().no_stdout();
+
+ let test_dir = "test_dir/../test_dir_a/../test_dir_b";
+
new_ucmd!()
.arg("-p")
.arg("-v")
- .arg(TEST_DIR9)
+ .arg(test_dir)
.succeeds()
- .stdout_contains("created directory 'mkdir_test9'")
- .stdout_contains("created directory 'mkdir_test9/../mkdir_test9_1'")
- .stdout_contains("created directory 'mkdir_test9/../mkdir_test9_1/../mkdir_test9_2'");
+ .stdout_contains("created directory 'test_dir'")
+ .stdout_contains("created directory 'test_dir/../test_dir_a'")
+ .stdout_contains("created directory 'test_dir/../test_dir_a/../test_dir_b'");
}
#[test]
fn test_mkdir_trailing_dot() {
- let scene2 = TestScenario::new("ls");
- new_ucmd!()
- .arg("-p")
- .arg("-v")
- .arg("mkdir_test10-2")
- .succeeds();
+ new_ucmd!().arg("-p").arg("-v").arg("test_dir").succeeds();
new_ucmd!()
.arg("-p")
.arg("-v")
- .arg(TEST_DIR10)
+ .arg("test_dir_a/.")
.succeeds()
- .stdout_contains("created directory 'mkdir_test10'");
+ .stdout_contains("created directory 'test_dir_a'");
new_ucmd!()
.arg("-p")
.arg("-v")
- .arg(TEST_DIR11)
+ .arg("test_dir_b/..")
.succeeds()
- .stdout_contains("created directory 'mkdir_test11'");
- let result = scene2.ucmd().arg("-al").run();
+ .stdout_contains("created directory 'test_dir_b'");
+
+ let scene = TestScenario::new("ls");
+ let result = scene.ucmd().arg("-al").run();
println!("ls dest {}", result.stdout_str());
}
@@ -167,17 +232,13 @@ fn test_mkdir_trailing_dot() {
#[cfg(not(windows))]
fn test_umask_compliance() {
fn test_single_case(umask_set: mode_t) {
+ let test_dir = "test_dir";
let (at, mut ucmd) = at_and_ucmd!();
- let original_umask = unsafe { umask(umask_set) };
-
- ucmd.arg(TEST_DIR12).succeeds();
- let perms = at.metadata(TEST_DIR12).permissions().mode() as mode_t;
+ ucmd.arg(test_dir).umask(umask_set).succeeds();
+ let perms = at.metadata(test_dir).permissions().mode() as mode_t;
assert_eq!(perms, (!umask_set & 0o0777) + 0o40000); // before compare, add the set GUID, UID bits
- unsafe {
- umask(original_umask);
- } // set umask back to original
}
for i in 0o0..0o027 {
diff --git a/tests/by-util/test_mkfifo.rs b/tests/by-util/test_mkfifo.rs
index 18d1d53d18634b7db57a9fe54ba6c4e0e5b7e6cf..731b6c1d5cd7404fdbec0c829e69ad26924236f2 100644
--- a/tests/by-util/test_mkfifo.rs
+++ b/tests/by-util/test_mkfifo.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
@@ -7,7 +11,7 @@ fn test_invalid_arg() {
#[test]
fn test_create_fifo_missing_operand() {
- new_ucmd!().fails().stderr_is("mkfifo: missing operand");
+ new_ucmd!().fails().stderr_is("mkfifo: missing operand\n");
}
#[test]
@@ -46,5 +50,5 @@ fn test_create_one_fifo_already_exists() {
.arg("abcdef")
.arg("abcdef")
.fails()
- .stderr_is("mkfifo: cannot create fifo 'abcdef': File exists");
+ .stderr_is("mkfifo: cannot create fifo 'abcdef': File exists\n");
}
diff --git a/tests/by-util/test_mknod.rs b/tests/by-util/test_mknod.rs
index c6d15e2046a458d8cab8e9b4e24613824a351209..2d83d250d8464307cd947e4fab66779045cd92d7 100644
--- a/tests/by-util/test_mknod.rs
+++ b/tests/by-util/test_mknod.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
#[test]
#[cfg(not(windows))]
@@ -92,14 +96,14 @@ fn test_mknod_character_device_requires_major_and_minor() {
.arg("1")
.arg("c")
.fails()
- .stderr_contains("Invalid value 'c'");
+ .stderr_contains("invalid value 'c'");
new_ucmd!()
.arg("test_file")
.arg("c")
.arg("c")
.arg("1")
.fails()
- .stderr_contains("Invalid value 'c'");
+ .stderr_contains("invalid value 'c'");
}
#[test]
@@ -109,7 +113,7 @@ fn test_mknod_invalid_arg() {
.arg("--foo")
.fails()
.no_stdout()
- .stderr_contains("Found argument '--foo' which wasn't expected");
+ .stderr_contains("unexpected argument '--foo' found");
}
#[test]
diff --git a/tests/by-util/test_mktemp.rs b/tests/by-util/test_mktemp.rs
index 4650eb2fdddcbf101a668f56c1ee714289eb5f7a..272769ad9790bd461a5923193e85f762051588e4 100644
--- a/tests/by-util/test_mktemp.rs
+++ b/tests/by-util/test_mktemp.rs
@@ -1,6 +1,10 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (words) gpghome
-use crate::common::util::*;
+use crate::common::util::TestScenario;
use uucore::display::Quotable;
@@ -17,8 +21,8 @@ static TEST_TEMPLATE2: &str = "temp";
static TEST_TEMPLATE3: &str = "tempX";
static TEST_TEMPLATE4: &str = "tempXX";
static TEST_TEMPLATE5: &str = "tempXXX";
-static TEST_TEMPLATE6: &str = "tempXXXlate"; // spell-checker:disable-line
-static TEST_TEMPLATE7: &str = "XXXtemplate"; // spell-checker:disable-line
+static TEST_TEMPLATE6: &str = "tempXXXlate";
+static TEST_TEMPLATE7: &str = "XXXtemplate";
#[cfg(unix)]
static TEST_TEMPLATE8: &str = "tempXXXl/ate";
#[cfg(windows)]
@@ -425,7 +429,7 @@ fn test_mktemp_tmpdir_one_arg() {
let scene = TestScenario::new(util_name!());
let result = scene
- .ucmd_keepenv()
+ .ucmd()
.arg("--tmpdir")
.arg("apt-key-gpghome.XXXXXXXXXX")
.succeeds();
@@ -438,7 +442,7 @@ fn test_mktemp_directory_tmpdir() {
let scene = TestScenario::new(util_name!());
let result = scene
- .ucmd_keepenv()
+ .ucmd()
.arg("--directory")
.arg("--tmpdir")
.arg("apt-key-gpghome.XXXXXXXXXX")
@@ -473,8 +477,7 @@ fn test_tmpdir_absolute_path() {
.args(&["--tmpdir=a", path])
.fails()
.stderr_only(format!(
- "mktemp: invalid template, '{}'; with --tmpdir, it may not be absolute\n",
- path
+ "mktemp: invalid template, '{path}'; with --tmpdir, it may not be absolute\n"
));
}
@@ -570,6 +573,32 @@ fn test_template_path_separator() {
));
}
+/// Test that a prefix with a point is valid.
+#[test]
+fn test_prefix_template_separator() {
+ new_ucmd!().args(&["-p", ".", "-t", "a.XXXX"]).succeeds();
+}
+
+#[test]
+fn test_prefix_template_with_path_separator() {
+ #[cfg(not(windows))]
+ new_ucmd!()
+ .args(&["-t", "a/XXX"])
+ .fails()
+ .stderr_only(format!(
+ "mktemp: invalid template, {}, contains directory separator\n",
+ "a/XXX".quote()
+ ));
+ #[cfg(windows)]
+ new_ucmd!()
+ .args(&["-t", r"a\XXX"])
+ .fails()
+ .stderr_only(format!(
+ "mktemp: invalid template, {}, contains directory separator\n",
+ r"a\XXX".quote()
+ ));
+}
+
/// Test that a suffix with a path separator is invalid.
#[test]
fn test_suffix_path_separator() {
@@ -600,7 +629,7 @@ fn test_too_few_xs_suffix() {
new_ucmd!()
.args(&["--suffix=X", "aXX"])
.fails()
- .stderr_only("mktemp: too few X's in template 'aXXX'\n");
+ .stderr_only("mktemp: too few X's in template 'aXX'\n");
}
#[test]
@@ -608,7 +637,7 @@ fn test_too_few_xs_suffix_directory() {
new_ucmd!()
.args(&["-d", "--suffix=X", "aXX"])
.fails()
- .stderr_only("mktemp: too few X's in template 'aXXX'\n");
+ .stderr_only("mktemp: too few X's in template 'aXX'\n");
}
#[test]
@@ -691,7 +720,7 @@ fn test_tmpdir_env_var() {
let filename = result.no_stderr().stdout_str().trim_end();
#[cfg(not(windows))]
{
- let template = format!(".{}tmp.XXXXXXXXXX", MAIN_SEPARATOR);
+ let template = format!(".{MAIN_SEPARATOR}tmp.XXXXXXXXXX");
assert_matches_template!(&template, filename);
}
// On Windows, `env::temp_dir()` seems to give an absolute path
@@ -703,16 +732,18 @@ fn test_tmpdir_env_var() {
assert_suffix_matches_template!("tmp.XXXXXXXXXX", filename);
assert!(at.file_exists(filename));
- // FIXME This is not working because --tmpdir is configured to
- // require a value.
- //
- // // `TMPDIR=. mktemp --tmpdir`
- // let (at, mut ucmd) = at_and_ucmd!();
- // let result = ucmd.env(TMPDIR, ".").arg("--tmpdir").succeeds();
- // let filename = result.no_stderr().stdout_str().trim_end();
- // let template = format!(".{}tmp.XXXXXXXXXX", MAIN_SEPARATOR);
- // assert_matches_template!(&template, filename);
- // assert!(at.file_exists(filename));
+ // `TMPDIR=. mktemp --tmpdir`
+ let (at, mut ucmd) = at_and_ucmd!();
+ let result = ucmd.env(TMPDIR, ".").arg("--tmpdir").succeeds();
+ let filename = result.no_stderr().stdout_str().trim_end();
+ #[cfg(not(windows))]
+ {
+ let template = format!(".{MAIN_SEPARATOR}tmp.XXXXXXXXXX");
+ assert_matches_template!(&template, filename);
+ }
+ #[cfg(windows)]
+ assert_suffix_matches_template!("tmp.XXXXXXXXXX", filename);
+ assert!(at.file_exists(filename));
// `TMPDIR=. mktemp --tmpdir XXX`
let (at, mut ucmd) = at_and_ucmd!();
@@ -720,7 +751,7 @@ fn test_tmpdir_env_var() {
let filename = result.no_stderr().stdout_str().trim_end();
#[cfg(not(windows))]
{
- let template = format!(".{}XXX", MAIN_SEPARATOR);
+ let template = format!(".{MAIN_SEPARATOR}XXX");
assert_matches_template!(&template, filename);
}
#[cfg(windows)]
@@ -824,6 +855,132 @@ fn test_nonexistent_dir_prefix() {
#[test]
fn test_default_missing_value() {
+ new_ucmd!().arg("-d").arg("--tmpdir").succeeds();
+}
+
+#[test]
+fn test_default_issue_4821_t_tmpdir() {
+ let scene = TestScenario::new(util_name!());
+ let pathname = scene.fixtures.as_string();
+ let result = scene
+ .ucmd()
+ .env(TMPDIR, &pathname)
+ .arg("-t")
+ .arg("foo.XXXX")
+ .succeeds();
+ let stdout = result.stdout_str();
+ println!("stdout = {stdout}");
+ assert!(stdout.contains(&pathname));
+}
+
+#[test]
+fn test_default_issue_4821_t_tmpdir_p() {
+ let scene = TestScenario::new(util_name!());
+ let pathname = scene.fixtures.as_string();
+ let result = scene
+ .ucmd()
+ .arg("-t")
+ .arg("-p")
+ .arg(&pathname)
+ .arg("foo.XXXX")
+ .succeeds();
+ let stdout = result.stdout_str();
+ println!("stdout = {stdout}");
+ assert!(stdout.contains(&pathname));
+}
+
+#[test]
+fn test_t_ensure_tmpdir_has_higher_priority_than_p() {
+ let scene = TestScenario::new(util_name!());
+ let pathname = scene.fixtures.as_string();
+ let result = scene
+ .ucmd()
+ .env(TMPDIR, &pathname)
+ .arg("-t")
+ .arg("-p")
+ .arg("should_not_attempt_to_write_in_this_nonexisting_dir")
+ .arg("foo.XXXX")
+ .succeeds();
+ let stdout = result.stdout_str();
+ println!("stdout = {stdout}");
+ assert!(stdout.contains(&pathname));
+}
+
+#[test]
+fn test_missing_xs_tmpdir_template() {
+ let scene = TestScenario::new(util_name!());
+ scene
+ .ucmd()
+ .arg("--tmpdir")
+ .arg(TEST_TEMPLATE3)
+ .fails()
+ .no_stdout()
+ .stderr_contains("too few X's in template");
+ scene
+ .ucmd()
+ .arg("--tmpdir=foobar")
+ .fails()
+ .no_stdout()
+ .stderr_contains("failed to create file via template");
+}
+
+#[test]
+fn test_both_tmpdir_flags_present() {
+ let scene = TestScenario::new(util_name!());
+
+ #[cfg(not(windows))]
+ let template = format!(".{MAIN_SEPARATOR}foobarXXXX");
+
+ let (at, mut ucmd) = at_and_ucmd!();
+ let result = ucmd
+ .env(TMPDIR, ".")
+ .arg("-p")
+ .arg("nonsense")
+ .arg("--tmpdir")
+ .arg("foobarXXXX")
+ .succeeds();
+ let filename = result.no_stderr().stdout_str().trim_end();
+
+ #[cfg(not(windows))]
+ assert_matches_template!(&template, filename);
+ #[cfg(windows)]
+ assert_suffix_matches_template!("foobarXXXX", filename);
+
+ assert!(at.file_exists(filename));
+
+ scene
+ .ucmd()
+ .arg("-p")
+ .arg(".")
+ .arg("--tmpdir=does_not_exist")
+ .fails()
+ .no_stdout()
+ .stderr_contains("failed to create file via template");
+
+ let (at, mut ucmd) = at_and_ucmd!();
+ let result = ucmd
+ .arg("--tmpdir")
+ .arg("foobarXXXX")
+ .arg("-p")
+ .arg(".")
+ .succeeds();
+ let filename = result.no_stderr().stdout_str().trim_end();
+
+ #[cfg(not(windows))]
+ assert_matches_template!(&template, filename);
+ #[cfg(windows)]
+ assert_suffix_matches_template!("foobarXXXX", filename);
+
+ assert!(at.file_exists(filename));
+}
+
+#[test]
+fn test_missing_short_tmpdir_flag() {
let scene = TestScenario::new(util_name!());
- scene.ucmd().arg("-d").arg("--tmpdir").succeeds();
+ scene
+ .ucmd()
+ .arg("-p")
+ .fails()
+ .no_stdout()
+ .stderr_contains("a value is required for '-p <DIR>' but none was supplied");
}
diff --git a/tests/by-util/test_more.rs b/tests/by-util/test_more.rs
index 5c2b3c0f6b3997c0ec56aa2178b7a39e3b862b1b..3941dc1dad905b9b3750553da9c76946b6acd465 100644
--- a/tests/by-util/test_more.rs
+++ b/tests/by-util/test_more.rs
@@ -1,11 +1,98 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
+use std::io::IsTerminal;
#[test]
fn test_more_no_arg() {
- // Reading from stdin is now supported, so this must succeed
- if atty::is(atty::Stream::Stdout) {
- new_ucmd!().succeeds();
- } else {
+ if std::io::stdout().is_terminal() {
+ new_ucmd!().fails().stderr_contains("more: bad usage");
+ }
+}
+
+#[test]
+fn test_valid_arg() {
+ if std::io::stdout().is_terminal() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ let file = "test_file";
+ at.touch(file);
+
+ scene.ucmd().arg(file).arg("-c").succeeds();
+ scene.ucmd().arg(file).arg("--print-over").succeeds();
+
+ scene.ucmd().arg(file).arg("-p").succeeds();
+ scene.ucmd().arg(file).arg("--clean-print").succeeds();
+
+ scene.ucmd().arg(file).arg("-s").succeeds();
+ scene.ucmd().arg(file).arg("--squeeze").succeeds();
+
+ scene.ucmd().arg(file).arg("-u").succeeds();
+ scene.ucmd().arg(file).arg("--plain").succeeds();
+
+ scene.ucmd().arg(file).arg("-n").arg("10").succeeds();
+ scene.ucmd().arg(file).arg("--lines").arg("0").succeeds();
+ scene.ucmd().arg(file).arg("--number").arg("0").succeeds();
+
+ scene.ucmd().arg(file).arg("-F").arg("10").succeeds();
+ scene
+ .ucmd()
+ .arg(file)
+ .arg("--from-line")
+ .arg("0")
+ .succeeds();
+
+ scene.ucmd().arg(file).arg("-P").arg("something").succeeds();
+ scene.ucmd().arg(file).arg("--pattern").arg("-1").succeeds();
+ }
+}
+
+#[test]
+fn test_invalid_arg() {
+ if std::io::stdout().is_terminal() {
+ new_ucmd!().arg("--invalid").fails();
+
+ new_ucmd!().arg("--lines").arg("-10").fails();
+ new_ucmd!().arg("--number").arg("-10").fails();
+
+ new_ucmd!().arg("--from-line").arg("-10").fails();
+ }
+}
+
+#[test]
+fn test_argument_from_file() {
+ if std::io::stdout().is_terminal() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ let file = "test_file";
+
+ at.write(file, "1\n2");
+
+ // output all lines
+ scene
+ .ucmd()
+ .arg("-F")
+ .arg("0")
+ .arg(file)
+ .succeeds()
+ .no_stderr()
+ .stdout_contains("1")
+ .stdout_contains("2");
+
+ // output only the second line
+ scene
+ .ucmd()
+ .arg("-F")
+ .arg("2")
+ .arg(file)
+ .succeeds()
+ .no_stderr()
+ .stdout_contains("2")
+ .stdout_does_not_contain("1");
}
}
@@ -14,11 +101,113 @@ fn test_more_dir_arg() {
// Run the test only if there's a valid terminal, else do nothing
// Maybe we could capture the error, i.e. "Device not found" in that case
// but I am leaving this for later
- if atty::is(atty::Stream::Stdout) {
+ if std::io::stdout().is_terminal() {
new_ucmd!()
.arg(".")
- .fails()
- .usage_error("'.' is a directory.");
- } else {
+ .succeeds()
+ .stderr_contains("'.' is a directory.");
+ }
+}
+
+#[test]
+#[cfg(target_family = "unix")]
+fn test_more_invalid_file_perms() {
+ use std::fs::{set_permissions, Permissions};
+ use std::os::unix::fs::PermissionsExt;
+
+ if std::io::stdout().is_terminal() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let permissions = Permissions::from_mode(0o244);
+ at.make_file("invalid-perms.txt");
+ set_permissions(at.plus("invalid-perms.txt"), permissions).unwrap();
+ ucmd.arg("invalid-perms.txt")
+ .succeeds()
+ .stderr_contains("permission denied");
+ }
+}
+
+#[test]
+fn test_more_error_on_single_arg() {
+ if std::io::stdout().is_terminal() {
+ let ts = TestScenario::new("more");
+ ts.fixtures.mkdir_all("folder");
+ ts.ucmd()
+ .arg("folder")
+ .succeeds()
+ .stderr_contains("is a directory");
+ ts.ucmd()
+ .arg("file1")
+ .succeeds()
+ .stderr_contains("No such file or directory");
+ }
+}
+
+#[test]
+fn test_more_error_on_multiple_files() {
+ if std::io::stdout().is_terminal() {
+ let ts = TestScenario::new("more");
+ ts.fixtures.mkdir_all("folder");
+ ts.fixtures.make_file("file1");
+ ts.ucmd()
+ .arg("folder")
+ .arg("file2")
+ .arg("file1")
+ .succeeds()
+ .stderr_contains("folder")
+ .stderr_contains("file2")
+ .stdout_contains("file1");
+ ts.ucmd()
+ .arg("file2")
+ .arg("file3")
+ .succeeds()
+ .stderr_contains("file2")
+ .stderr_contains("file3");
+ }
+}
+
+#[test]
+fn test_more_pattern_found() {
+ if std::io::stdout().is_terminal() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ let file = "test_file";
+
+ at.write(file, "line1\nline2");
+
+ // output only the second line "line2"
+ scene
+ .ucmd()
+ .arg("-P")
+ .arg("line2")
+ .arg(file)
+ .succeeds()
+ .no_stderr()
+ .stdout_does_not_contain("line1")
+ .stdout_contains("line2");
+ }
+}
+
+#[test]
+fn test_more_pattern_not_found() {
+ if std::io::stdout().is_terminal() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ let file = "test_file";
+
+ let file_content = "line1\nline2";
+ at.write(file, file_content);
+
+ scene
+ .ucmd()
+ .arg("-P")
+ .arg("something")
+ .arg(file)
+ .succeeds()
+ .no_stderr()
+ .stdout_contains("Pattern not found")
+ .stdout_contains("line1")
+ .stdout_contains("line2");
}
}
diff --git a/tests/by-util/test_mv.rs b/tests/by-util/test_mv.rs
index b4470ccea5203a3d797ad6d5b1ec6f274e2e9bd3..9ff335138490f054b3e9ce3ae762740678afb91d 100644
--- a/tests/by-util/test_mv.rs
+++ b/tests/by-util/test_mv.rs
@@ -1,35 +1,40 @@
-extern crate filetime;
-extern crate time;
-
-use self::filetime::*;
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+//
+// spell-checker:ignore mydir
+use crate::common::util::TestScenario;
+use filetime::FileTime;
+use std::thread::sleep;
+use std::time::Duration;
#[test]
-fn test_invalid_arg() {
+fn test_mv_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
}
#[test]
-fn test_mv_rename_dir() {
+fn test_mv_missing_dest() {
let (at, mut ucmd) = at_and_ucmd!();
- let dir1 = "test_mv_rename_dir";
- let dir2 = "test_mv_rename_dir2";
-
- at.mkdir(dir1);
+ let dir = "dir";
- ucmd.arg(dir1).arg(dir2).succeeds().no_stderr();
+ at.mkdir(dir);
- assert!(at.dir_exists(dir2));
+ ucmd.arg(dir).fails();
}
#[test]
-fn test_mv_fail() {
+fn test_mv_rename_dir() {
let (at, mut ucmd) = at_and_ucmd!();
let dir1 = "test_mv_rename_dir";
+ let dir2 = "test_mv_rename_dir2";
at.mkdir(dir1);
- ucmd.arg(dir1).fails();
+ ucmd.arg(dir1).arg(dir2).succeeds().no_stderr();
+
+ assert!(at.dir_exists(dir2));
}
#[test]
@@ -55,7 +60,64 @@ fn test_mv_move_file_into_dir() {
ucmd.arg(file).arg(dir).succeeds().no_stderr();
- assert!(at.file_exists(&format!("{}/{}", dir, file)));
+ assert!(at.file_exists(format!("{dir}/{file}")));
+}
+
+#[test]
+fn test_mv_move_file_into_dir_with_target_arg() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let dir = "test_mv_move_file_into_dir_with_target_arg_dir";
+ let file = "test_mv_move_file_into_dir_with_target_arg_file";
+
+ at.mkdir(dir);
+ at.touch(file);
+
+ ucmd.arg("--target")
+ .arg(dir)
+ .arg(file)
+ .succeeds()
+ .no_stderr();
+
+ assert!(at.file_exists(format!("{dir}/{file}")));
+}
+
+#[test]
+fn test_mv_move_file_into_file_with_target_arg() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let file1 = "test_mv_move_file_into_file_with_target_arg_file1";
+ let file2 = "test_mv_move_file_into_file_with_target_arg_file2";
+
+ at.touch(file1);
+ at.touch(file2);
+
+ ucmd.arg("--target")
+ .arg(file1)
+ .arg(file2)
+ .fails()
+ .stderr_is(format!("mv: target directory '{file1}': Not a directory\n"));
+
+ assert!(at.file_exists(file1));
+}
+
+#[test]
+fn test_mv_move_multiple_files_into_file() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let file1 = "test_mv_move_multiple_files_into_file1";
+ let file2 = "test_mv_move_multiple_files_into_file2";
+ let file3 = "test_mv_move_multiple_files_into_file3";
+
+ at.touch(file1);
+ at.touch(file2);
+ at.touch(file3);
+
+ ucmd.arg(file1)
+ .arg(file2)
+ .arg(file3)
+ .fails()
+ .stderr_is(format!("mv: target '{file3}': Not a directory\n"));
+
+ assert!(at.file_exists(file1));
+ assert!(at.file_exists(file2));
}
#[test]
@@ -67,17 +129,17 @@ fn test_mv_move_file_between_dirs() {
at.mkdir(dir1);
at.mkdir(dir2);
- at.touch(&format!("{}/{}", dir1, file));
+ at.touch(format!("{dir1}/{file}"));
- assert!(at.file_exists(&format!("{}/{}", dir1, file)));
+ assert!(at.file_exists(format!("{dir1}/{file}")));
- ucmd.arg(&format!("{}/{}", dir1, file))
+ ucmd.arg(&format!("{dir1}/{file}"))
.arg(dir2)
.succeeds()
.no_stderr();
- assert!(!at.file_exists(&format!("{}/{}", dir1, file)));
- assert!(at.file_exists(&format!("{}/{}", dir2, file)));
+ assert!(!at.file_exists(format!("{dir1}/{file}")));
+ assert!(at.file_exists(format!("{dir2}/{file}")));
}
#[test]
@@ -94,7 +156,7 @@ fn test_mv_strip_slashes() {
scene.ucmd().arg(&source).arg(dir).fails();
- assert!(!at.file_exists(&format!("{}/{}", dir, file)));
+ assert!(!at.file_exists(format!("{dir}/{file}")));
scene
.ucmd()
@@ -104,7 +166,7 @@ fn test_mv_strip_slashes() {
.succeeds()
.no_stderr();
- assert!(at.file_exists(&format!("{}/{}", dir, file)));
+ assert!(at.file_exists(format!("{dir}/{file}")));
}
#[test]
@@ -124,8 +186,8 @@ fn test_mv_multiple_files() {
.succeeds()
.no_stderr();
- assert!(at.file_exists(&format!("{}/{}", target_dir, file_a)));
- assert!(at.file_exists(&format!("{}/{}", target_dir, file_b)));
+ assert!(at.file_exists(format!("{target_dir}/{file_a}")));
+ assert!(at.file_exists(format!("{target_dir}/{file_b}")));
}
#[test]
@@ -145,8 +207,8 @@ fn test_mv_multiple_folders() {
.succeeds()
.no_stderr();
- assert!(at.dir_exists(&format!("{}/{}", target_dir, dir_a)));
- assert!(at.dir_exists(&format!("{}/{}", target_dir, dir_b)));
+ assert!(at.dir_exists(&format!("{target_dir}/{dir_a}")));
+ assert!(at.dir_exists(&format!("{target_dir}/{dir_b}")));
}
#[test]
@@ -165,7 +227,7 @@ fn test_mv_interactive() {
.arg(file_a)
.arg(file_b)
.pipe_in("n")
- .succeeds()
+ .fails()
.no_stdout();
assert!(at.file_exists(file_a));
@@ -184,6 +246,81 @@ fn test_mv_interactive() {
assert!(at.file_exists(file_b));
}
+#[test]
+fn test_mv_interactive_with_dir_as_target() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let file = "test_mv_interactive_file";
+ let target_dir = "target";
+
+ at.mkdir(target_dir);
+ at.touch(file);
+ at.touch(format!("{target_dir}/{file}"));
+
+ ucmd.arg(file)
+ .arg(target_dir)
+ .arg("-i")
+ .pipe_in("n")
+ .fails()
+ .stderr_does_not_contain("cannot move")
+ .no_stdout();
+}
+
+#[test]
+fn test_mv_interactive_dir_to_file_not_affirmative() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let dir = "test_mv_interactive_dir_to_file_not_affirmative_dir";
+ let file = "test_mv_interactive_dir_to_file_not_affirmative_file";
+
+ at.mkdir(dir);
+ at.touch(file);
+
+ ucmd.arg(dir)
+ .arg(file)
+ .arg("-i")
+ .pipe_in("n")
+ .fails()
+ .no_stdout();
+
+ assert!(at.dir_exists(dir));
+}
+
+#[test]
+fn test_mv_interactive_no_clobber_force_last_arg_wins() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ let file_a = "a.txt";
+ let file_b = "b.txt";
+
+ at.touch(file_a);
+ at.touch(file_b);
+
+ scene
+ .ucmd()
+ .args(&[file_a, file_b, "-f", "-i", "-n"])
+ .fails()
+ .stderr_is(format!("mv: not replacing '{file_b}'\n"));
+
+ scene
+ .ucmd()
+ .args(&[file_a, file_b, "-n", "-f", "-i"])
+ .fails()
+ .stderr_is(format!("mv: overwrite '{file_b}'? "));
+
+ at.write(file_a, "aa");
+
+ scene
+ .ucmd()
+ .args(&[file_a, file_b, "-i", "-n", "-f"])
+ .succeeds()
+ .no_output();
+
+ assert!(!at.file_exists(file_a));
+ assert_eq!("aa", at.read(file_b));
+}
+
#[test]
fn test_mv_arg_update_interactive() {
let (at, mut ucmd) = at_and_ucmd!();
@@ -215,8 +352,9 @@ fn test_mv_no_clobber() {
ucmd.arg("-n")
.arg(file_a)
.arg(file_b)
- .succeeds()
- .no_stderr();
+ .fails()
+ .code_is(1)
+ .stderr_only(format!("mv: not replacing '{file_b}'\n"));
assert!(at.file_exists(file_a));
assert!(at.file_exists(file_b));
@@ -262,10 +400,136 @@ fn test_mv_same_file() {
let file_a = "test_mv_same_file_a";
at.touch(file_a);
- ucmd.arg(file_a).arg(file_a).fails().stderr_is(format!(
- "mv: '{f}' and '{f}' are the same file\n",
- f = file_a,
- ));
+ ucmd.arg(file_a)
+ .arg(file_a)
+ .fails()
+ .stderr_is(format!("mv: '{file_a}' and '{file_a}' are the same file\n",));
+}
+
+#[test]
+#[cfg(all(unix, not(target_os = "android")))]
+fn test_mv_same_hardlink() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let file_a = "test_mv_same_file_a";
+ let file_b = "test_mv_same_file_b";
+ at.touch(file_a);
+
+ at.hard_link(file_a, file_b);
+
+ at.touch(file_a);
+ ucmd.arg(file_a)
+ .arg(file_b)
+ .fails()
+ .stderr_is(format!("mv: '{file_a}' and '{file_b}' are the same file\n",));
+}
+
+#[test]
+#[cfg(all(unix, not(target_os = "android")))]
+fn test_mv_same_symlink() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let file_a = "test_mv_same_file_a";
+ let file_b = "test_mv_same_file_b";
+ let file_c = "test_mv_same_file_c";
+
+ at.touch(file_a);
+
+ at.symlink_file(file_a, file_b);
+
+ ucmd.arg(file_b)
+ .arg(file_a)
+ .fails()
+ .stderr_is(format!("mv: '{file_b}' and '{file_a}' are the same file\n",));
+
+ let (at2, mut ucmd2) = at_and_ucmd!();
+ at2.touch(file_a);
+
+ at2.symlink_file(file_a, file_b);
+ ucmd2.arg(file_a).arg(file_b).succeeds();
+ assert!(at2.file_exists(file_b));
+ assert!(!at2.file_exists(file_a));
+
+ let (at3, mut ucmd3) = at_and_ucmd!();
+ at3.touch(file_a);
+
+ at3.symlink_file(file_a, file_b);
+ at3.symlink_file(file_b, file_c);
+
+ ucmd3.arg(file_c).arg(file_b).succeeds();
+ assert!(!at3.symlink_exists(file_c));
+ assert!(at3.symlink_exists(file_b));
+
+ let (at4, mut ucmd4) = at_and_ucmd!();
+ at4.touch(file_a);
+
+ at4.symlink_file(file_a, file_b);
+ at4.symlink_file(file_b, file_c);
+
+ ucmd4
+ .arg(file_c)
+ .arg(file_a)
+ .fails()
+ .stderr_is(format!("mv: '{file_c}' and '{file_a}' are the same file\n",));
+}
+
+#[test]
+#[cfg(all(unix, not(target_os = "android")))]
+fn test_mv_hardlink_to_symlink() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let file = "file";
+ let symlink_file = "symlink";
+ let hardlink_to_symlink_file = "hardlink_to_symlink";
+
+ at.touch(file);
+ at.symlink_file(file, symlink_file);
+ at.hard_link(symlink_file, hardlink_to_symlink_file);
+
+ ucmd.arg(symlink_file).arg(hardlink_to_symlink_file).fails();
+
+ let (at2, mut ucmd2) = at_and_ucmd!();
+
+ at2.touch(file);
+ at2.symlink_file(file, symlink_file);
+ at2.hard_link(symlink_file, hardlink_to_symlink_file);
+
+ ucmd2
+ .arg("--backup")
+ .arg(symlink_file)
+ .arg(hardlink_to_symlink_file)
+ .succeeds();
+ assert!(!at2.symlink_exists(symlink_file));
+ assert!(at2.symlink_exists(&format!("{hardlink_to_symlink_file}~")));
+}
+
+#[test]
+#[cfg(all(unix, not(target_os = "android")))]
+fn test_mv_same_hardlink_backup_simple() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let file_a = "test_mv_same_file_a";
+ let file_b = "test_mv_same_file_b";
+ at.touch(file_a);
+
+ at.hard_link(file_a, file_b);
+
+ ucmd.arg(file_a)
+ .arg(file_b)
+ .arg("--backup=simple")
+ .succeeds();
+}
+
+#[test]
+#[cfg(all(unix, not(target_os = "android")))]
+fn test_mv_same_hardlink_backup_simple_destroy() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let file_a = "test_mv_same_file_a~";
+ let file_b = "test_mv_same_file_a";
+ at.touch(file_a);
+ at.touch(file_b);
+
+ ucmd.arg(file_a)
+ .arg(file_b)
+ .arg("--b=simple")
+ .fails()
+ .stderr_contains("backing up 'test_mv_same_file_a' might destroy source");
}
#[test]
@@ -275,8 +539,7 @@ fn test_mv_same_file_not_dot_dir() {
at.mkdir(dir);
ucmd.arg(dir).arg(dir).fails().stderr_is(format!(
- "mv: cannot move '{d}' to a subdirectory of itself, '{d}/{d}'",
- d = dir,
+ "mv: cannot move '{dir}' to a subdirectory of itself, '{dir}/{dir}'\n",
));
}
@@ -306,7 +569,7 @@ fn test_mv_simple_backup() {
assert!(!at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}~", file_b)));
+ assert!(at.file_exists(format!("{file_b}~")));
}
#[test]
@@ -325,7 +588,7 @@ fn test_mv_simple_backup_with_file_extension() {
assert!(!at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}~", file_b)));
+ assert!(at.file_exists(format!("{file_b}~")));
}
#[test]
@@ -340,7 +603,7 @@ fn test_mv_arg_backup_arg_first() {
assert!(!at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}~", file_b)));
+ assert!(at.file_exists(format!("{file_b}~")));
}
#[test]
@@ -353,7 +616,7 @@ fn test_mv_custom_backup_suffix() {
at.touch(file_a);
at.touch(file_b);
ucmd.arg("-b")
- .arg(format!("--suffix={}", suffix))
+ .arg(format!("--suffix={suffix}"))
.arg(file_a)
.arg(file_b)
.succeeds()
@@ -361,7 +624,7 @@ fn test_mv_custom_backup_suffix() {
assert!(!at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}{}", file_b, suffix)));
+ assert!(at.file_exists(format!("{file_b}{suffix}")));
}
#[test]
@@ -374,7 +637,7 @@ fn test_mv_custom_backup_suffix_hyphen_value() {
at.touch(file_a);
at.touch(file_b);
ucmd.arg("-b")
- .arg(format!("--suffix={}", suffix))
+ .arg(format!("--suffix={suffix}"))
.arg(file_a)
.arg(file_b)
.succeeds()
@@ -382,7 +645,7 @@ fn test_mv_custom_backup_suffix_hyphen_value() {
assert!(!at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}{}", file_b, suffix)));
+ assert!(at.file_exists(format!("{file_b}{suffix}")));
}
#[test]
@@ -402,7 +665,7 @@ fn test_mv_custom_backup_suffix_via_env() {
assert!(!at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}{}", file_b, suffix)));
+ assert!(at.file_exists(format!("{file_b}{suffix}")));
}
#[test]
@@ -421,7 +684,7 @@ fn test_mv_backup_numbered_with_t() {
assert!(!at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}.~1~", file_b)));
+ assert!(at.file_exists(format!("{file_b}.~1~")));
}
#[test]
@@ -440,7 +703,7 @@ fn test_mv_backup_numbered() {
assert!(!at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}.~1~", file_b)));
+ assert!(at.file_exists(format!("{file_b}.~1~")));
}
#[test]
@@ -459,7 +722,7 @@ fn test_mv_backup_existing() {
assert!(!at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}~", file_b)));
+ assert!(at.file_exists(format!("{file_b}~")));
}
#[test]
@@ -478,7 +741,7 @@ fn test_mv_backup_nil() {
assert!(!at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}~", file_b)));
+ assert!(at.file_exists(format!("{file_b}~")));
}
#[test]
@@ -499,7 +762,7 @@ fn test_mv_numbered_if_existing_backup_existing() {
assert!(at.file_exists(file_b));
assert!(at.file_exists(file_b_backup));
- assert!(at.file_exists(&format!("{}.~2~", file_b)));
+ assert!(at.file_exists(format!("{file_b}.~2~")));
}
#[test]
@@ -520,7 +783,7 @@ fn test_mv_numbered_if_existing_backup_nil() {
assert!(at.file_exists(file_b));
assert!(at.file_exists(file_b_backup));
- assert!(at.file_exists(&format!("{}.~2~", file_b)));
+ assert!(at.file_exists(format!("{file_b}.~2~")));
}
#[test]
@@ -539,7 +802,7 @@ fn test_mv_backup_simple() {
assert!(!at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}~", file_b)));
+ assert!(at.file_exists(format!("{file_b}~")));
}
#[test]
@@ -558,7 +821,7 @@ fn test_mv_backup_never() {
assert!(!at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}~", file_b)));
+ assert!(at.file_exists(format!("{file_b}~")));
}
#[test]
@@ -577,7 +840,7 @@ fn test_mv_backup_none() {
assert!(!at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(!at.file_exists(&format!("{}~", file_b)));
+ assert!(!at.file_exists(format!("{file_b}~")));
}
#[test]
@@ -596,7 +859,7 @@ fn test_mv_backup_off() {
assert!(!at.file_exists(file_a));
assert!(at.file_exists(file_b));
- assert!(!at.file_exists(&format!("{}~", file_b)));
+ assert!(!at.file_exists(format!("{file_b}~")));
}
#[test]
@@ -619,7 +882,7 @@ fn test_mv_update_option() {
at.touch(file_a);
at.touch(file_b);
- let ts = time::OffsetDateTime::now_local().unwrap();
+ let ts = time::OffsetDateTime::now_utc();
let now = FileTime::from_unix_time(ts.unix_timestamp(), ts.nanosecond());
let later = FileTime::from_unix_time(ts.unix_timestamp() + 3600, ts.nanosecond());
filetime::set_file_times(at.plus_as_string(file_a), now, now).unwrap();
@@ -642,6 +905,222 @@ fn test_mv_update_option() {
assert!(!at.file_exists(file_b));
}
+#[test]
+fn test_mv_update_with_dest_ending_with_slash() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let source = "source";
+ let dest = "destination/";
+
+ at.mkdir("source");
+
+ ucmd.arg("--update").arg(source).arg(dest).succeeds();
+
+ assert!(!at.dir_exists(source));
+ assert!(at.dir_exists(dest));
+}
+
+#[test]
+fn test_mv_arg_update_none() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let file1 = "test_mv_arg_update_none_file1";
+ let file2 = "test_mv_arg_update_none_file2";
+ let file1_content = "file1 content\n";
+ let file2_content = "file2 content\n";
+
+ at.write(file1, file1_content);
+ at.write(file2, file2_content);
+
+ ucmd.arg(file1)
+ .arg(file2)
+ .arg("--update=none")
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+
+ assert_eq!(at.read(file2), file2_content);
+}
+
+#[test]
+fn test_mv_arg_update_all() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let file1 = "test_mv_arg_update_none_file1";
+ let file2 = "test_mv_arg_update_none_file2";
+ let file1_content = "file1 content\n";
+ let file2_content = "file2 content\n";
+
+ at.write(file1, file1_content);
+ at.write(file2, file2_content);
+
+ ucmd.arg(file1)
+ .arg(file2)
+ .arg("--update=all")
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+
+ assert_eq!(at.read(file2), file1_content);
+}
+
+#[test]
+fn test_mv_arg_update_older_dest_not_older() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let old = "test_mv_arg_update_none_file1";
+ let new = "test_mv_arg_update_none_file2";
+ let old_content = "file1 content\n";
+ let new_content = "file2 content\n";
+
+ at.write(old, old_content);
+
+ sleep(Duration::from_secs(1));
+
+ at.write(new, new_content);
+
+ ucmd.arg(old)
+ .arg(new)
+ .arg("--update=older")
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+
+ assert_eq!(at.read(new), new_content);
+}
+
+#[test]
+fn test_mv_arg_update_none_then_all() {
+ // take last if multiple update args are supplied,
+ // update=all wins in this case
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let old = "test_mv_arg_update_none_then_all_file1";
+ let new = "test_mv_arg_update_none_then_all_file2";
+ let old_content = "old content\n";
+ let new_content = "new content\n";
+
+ at.write(old, old_content);
+
+ sleep(Duration::from_secs(1));
+
+ at.write(new, new_content);
+
+ ucmd.arg(old)
+ .arg(new)
+ .arg("--update=none")
+ .arg("--update=all")
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+
+ assert_eq!(at.read(new), "old content\n");
+}
+
+#[test]
+fn test_mv_arg_update_all_then_none() {
+ // take last if multiple update args are supplied,
+ // update=none wins in this case
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let old = "test_mv_arg_update_all_then_none_file1";
+ let new = "test_mv_arg_update_all_then_none_file2";
+ let old_content = "old content\n";
+ let new_content = "new content\n";
+
+ at.write(old, old_content);
+
+ sleep(Duration::from_secs(1));
+
+ at.write(new, new_content);
+
+ ucmd.arg(old)
+ .arg(new)
+ .arg("--update=all")
+ .arg("--update=none")
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+
+ assert_eq!(at.read(new), "new content\n");
+}
+
+#[test]
+fn test_mv_arg_update_older_dest_older() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let old = "test_mv_arg_update_none_file1";
+ let new = "test_mv_arg_update_none_file2";
+ let old_content = "file1 content\n";
+ let new_content = "file2 content\n";
+
+ at.write(old, old_content);
+
+ sleep(Duration::from_secs(1));
+
+ at.write(new, new_content);
+
+ ucmd.arg(new)
+ .arg(old)
+ .arg("--update=all")
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+
+ assert_eq!(at.read(old), new_content);
+}
+
+#[test]
+fn test_mv_arg_update_short_overwrite() {
+ // same as --update=older
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let old = "test_mv_arg_update_none_file1";
+ let new = "test_mv_arg_update_none_file2";
+ let old_content = "file1 content\n";
+ let new_content = "file2 content\n";
+
+ at.write(old, old_content);
+
+ sleep(Duration::from_secs(1));
+
+ at.write(new, new_content);
+
+ ucmd.arg(new)
+ .arg(old)
+ .arg("-u")
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+
+ assert_eq!(at.read(old), new_content);
+}
+
+#[test]
+fn test_mv_arg_update_short_no_overwrite() {
+ // same as --update=older
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let old = "test_mv_arg_update_none_file1";
+ let new = "test_mv_arg_update_none_file2";
+ let old_content = "file1 content\n";
+ let new_content = "file2 content\n";
+
+ at.write(old, old_content);
+
+ sleep(Duration::from_secs(1));
+
+ at.write(new, new_content);
+
+ ucmd.arg(old)
+ .arg(new)
+ .arg("-u")
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+
+ assert_eq!(at.read(new), new_content);
+}
+
#[test]
fn test_mv_target_dir() {
let (at, mut ucmd) = at_and_ucmd!();
@@ -661,8 +1140,8 @@ fn test_mv_target_dir() {
assert!(!at.file_exists(file_a));
assert!(!at.file_exists(file_b));
- assert!(at.file_exists(&format!("{}/{}", dir, file_a)));
- assert!(at.file_exists(&format!("{}/{}", dir, file_b)));
+ assert!(at.file_exists(format!("{dir}/{file_a}")));
+ assert!(at.file_exists(format!("{dir}/{file_b}")));
}
#[test]
@@ -676,7 +1155,7 @@ fn test_mv_target_dir_single_source() {
ucmd.arg("-t").arg(dir).arg(file).succeeds().no_stderr();
assert!(!at.file_exists(file));
- assert!(at.file_exists(&format!("{}/{}", dir, file)));
+ assert!(at.file_exists(format!("{dir}/{file}")));
}
#[test]
@@ -693,6 +1172,32 @@ fn test_mv_overwrite_dir() {
assert!(at.dir_exists(dir_b));
}
+#[test]
+fn test_mv_no_target_dir_with_dest_not_existing() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let dir_a = "a";
+ let dir_b = "b";
+
+ at.mkdir(dir_a);
+ ucmd.arg("-T").arg(dir_a).arg(dir_b).succeeds().no_output();
+
+ assert!(!at.dir_exists(dir_a));
+ assert!(at.dir_exists(dir_b));
+}
+
+#[test]
+fn test_mv_no_target_dir_with_dest_not_existing_and_ending_with_slash() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let dir_a = "a";
+ let dir_b = "b/";
+
+ at.mkdir(dir_a);
+ ucmd.arg("-T").arg(dir_a).arg(dir_b).succeeds().no_output();
+
+ assert!(!at.dir_exists(dir_a));
+ assert!(at.dir_exists(dir_b));
+}
+
#[test]
fn test_mv_overwrite_nonempty_dir() {
let (at, mut ucmd) = at_and_ucmd!();
@@ -730,13 +1235,12 @@ fn test_mv_backup_dir() {
.arg(dir_b)
.succeeds()
.stdout_only(format!(
- "'{}' -> '{}' (backup: '{}~')\n",
- dir_a, dir_b, dir_b
+ "renamed '{dir_a}' -> '{dir_b}' (backup: '{dir_b}~')\n"
));
assert!(!at.dir_exists(dir_a));
assert!(at.dir_exists(dir_b));
- assert!(at.dir_exists(&format!("{}~", dir_b)));
+ assert!(at.dir_exists(&format!("{dir_b}~")));
}
#[test]
@@ -772,8 +1276,7 @@ fn test_mv_errors() {
.arg(dir)
.fails()
.stderr_is(format!(
- "mv: cannot overwrite directory '{}' with non-directory\n",
- dir
+ "mv: cannot overwrite directory '{dir}' with non-directory\n"
));
// $ at.mkdir dir && at.touch file
@@ -805,7 +1308,7 @@ fn test_mv_verbose() {
.arg(file_a)
.arg(file_b)
.succeeds()
- .stdout_only(format!("'{}' -> '{}'\n", file_a, file_b));
+ .stdout_only(format!("renamed '{file_a}' -> '{file_b}'\n"));
at.touch(file_a);
scene
@@ -815,14 +1318,13 @@ fn test_mv_verbose() {
.arg(file_b)
.succeeds()
.stdout_only(format!(
- "'{}' -> '{}' (backup: '{}~')\n",
- file_a, file_b, file_b
+ "renamed '{file_a}' -> '{file_b}' (backup: '{file_b}~')\n"
));
}
#[test]
#[cfg(any(target_os = "linux", target_os = "android"))] // mkdir does not support -m on windows. Freebsd doesn't return a permission error either.
-#[cfg(features = "mkdir")]
+#[cfg(feature = "mkdir")]
fn test_mv_permission_error() {
let scene = TestScenario::new("mkdir");
let folder1 = "bar";
@@ -863,7 +1365,7 @@ fn test_mv_interactive_error() {
}
#[test]
-fn test_mv_info_self() {
+fn test_mv_into_self() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
let dir1 = "dir1";
@@ -880,6 +1382,30 @@ fn test_mv_info_self() {
.stderr_contains("mv: cannot move 'dir2' to a subdirectory of itself, 'dir2/dir2'");
}
+#[test]
+fn test_mv_arg_interactive_skipped() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.touch("a");
+ at.touch("b");
+ ucmd.args(&["-vi", "a", "b"])
+ .pipe_in("N\n")
+ .ignore_stdin_write_error()
+ .fails()
+ .stderr_is("mv: overwrite 'b'? ")
+ .no_stdout();
+}
+
+#[test]
+fn test_mv_arg_interactive_skipped_vin() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.touch("a");
+ at.touch("b");
+ ucmd.args(&["-vin", "a", "b"])
+ .fails()
+ .stderr_is("mv: not replacing 'b'\n")
+ .no_stdout();
+}
+
#[test]
fn test_mv_into_self_data() {
let scene = TestScenario::new(util_name!());
@@ -905,6 +1431,185 @@ fn test_mv_into_self_data() {
assert!(at.file_exists(file2));
assert!(!at.file_exists(file1));
}
+
+#[test]
+fn test_mv_directory_into_subdirectory_of_itself_fails() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let dir1 = "mydir";
+ let dir2 = "mydir/mydir_2";
+ at.mkdir(dir1);
+ at.mkdir(dir2);
+ scene.ucmd().arg(dir1).arg(dir2).fails().stderr_contains(
+ "mv: cannot move 'mydir' to a subdirectory of itself, 'mydir/mydir_2/mydir'",
+ );
+
+ // check that it also errors out with /
+ scene
+ .ucmd()
+ .arg(format!("{}/", dir1))
+ .arg(dir2)
+ .fails()
+ .stderr_contains(
+ "mv: cannot move 'mydir/' to a subdirectory of itself, 'mydir/mydir_2/mydir/'",
+ );
+}
+
+#[test]
+fn test_mv_dir_into_dir_with_source_name_a_prefix_of_target_name() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let source = "test";
+ let target = "test2";
+
+ at.mkdir(source);
+ at.mkdir(target);
+
+ ucmd.arg(source).arg(target).succeeds().no_output();
+
+ assert!(at.dir_exists(&format!("{target}/{source}")));
+}
+
+#[test]
+fn test_mv_file_into_dir_where_both_are_files() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.touch("a");
+ at.touch("b");
+ scene
+ .ucmd()
+ .arg("a")
+ .arg("b/")
+ .fails()
+ .stderr_contains("mv: failed to access 'b/': Not a directory");
+}
+
+#[test]
+fn test_mv_seen_file() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+
+ at.mkdir("a");
+ at.mkdir("b");
+ at.mkdir("c");
+ at.write("a/f", "a");
+ at.write("b/f", "b");
+
+ let result = ts.ucmd().arg("a/f").arg("b/f").arg("c").fails();
+
+ #[cfg(not(unix))]
+ assert!(result
+ .stderr_str()
+ .contains("will not overwrite just-created 'c\\f' with 'b/f'"));
+ #[cfg(unix)]
+ assert!(result
+ .stderr_str()
+ .contains("will not overwrite just-created 'c/f' with 'b/f'"));
+
+ // a/f has been moved into c/f
+ assert!(at.plus("c").join("f").exists());
+ // b/f still exists
+ assert!(at.plus("b").join("f").exists());
+ // a/f no longer exists
+ assert!(!at.plus("a").join("f").exists());
+}
+
+#[test]
+fn test_mv_seen_multiple_files_to_directory() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+
+ at.mkdir("a");
+ at.mkdir("b");
+ at.mkdir("c");
+ at.write("a/f", "a");
+ at.write("b/f", "b");
+ at.write("b/g", "g");
+
+ let result = ts.ucmd().arg("a/f").arg("b/f").arg("b/g").arg("c").fails();
+ #[cfg(not(unix))]
+ assert!(result
+ .stderr_str()
+ .contains("will not overwrite just-created 'c\\f' with 'b/f'"));
+ #[cfg(unix)]
+ assert!(result
+ .stderr_str()
+ .contains("will not overwrite just-created 'c/f' with 'b/f'"));
+
+ assert!(!at.plus("a").join("f").exists());
+ assert!(at.plus("b").join("f").exists());
+ assert!(!at.plus("b").join("g").exists());
+ assert!(at.plus("c").join("f").exists());
+ assert!(at.plus("c").join("g").exists());
+}
+
+#[test]
+fn test_mv_dir_into_file_where_both_are_files() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.touch("a");
+ at.touch("b");
+ scene
+ .ucmd()
+ .arg("a/")
+ .arg("b")
+ .fails()
+ .stderr_contains("mv: cannot stat 'a/': Not a directory");
+}
+
+#[test]
+fn test_mv_dir_into_path_slash() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.mkdir("a");
+ scene.ucmd().arg("a").arg("e/").succeeds();
+ assert!(at.dir_exists("e"));
+ at.mkdir("b");
+ at.mkdir("f");
+ scene.ucmd().arg("b").arg("f/").succeeds();
+ assert!(at.dir_exists("f/b"));
+}
+
+#[cfg(all(unix, not(any(target_os = "macos", target_os = "openbsd"))))]
+#[test]
+fn test_acl() {
+ use std::process::Command;
+
+ use crate::common::util::compare_xattrs;
+
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let path1 = "a";
+ let path2 = "b";
+ let file = "a/file";
+ let file_target = "b/file";
+ at.mkdir(path1);
+ at.mkdir(path2);
+ at.touch(file);
+
+ let path = at.plus_as_string(file);
+ // calling the command directly. xattr requires some dev packages to be installed
+ // and it adds a complex dependency just for a test
+ match Command::new("setfacl")
+ .args(["-m", "group::rwx", path1])
+ .status()
+ .map(|status| status.code())
+ {
+ Ok(Some(0)) => {}
+ Ok(_) => {
+ println!("test skipped: setfacl failed");
+ return;
+ }
+ Err(e) => {
+ println!("test skipped: setfacl failed with {}", e);
+ return;
+ }
+ }
+
+ scene.ucmd().arg(&path).arg(path2).succeeds();
+
+ assert!(compare_xattrs(&file, &file_target));
+}
+
// Todo:
// $ at.touch a b
diff --git a/tests/by-util/test_nice.rs b/tests/by-util/test_nice.rs
index 036723cdefa0d3ed6a0ed24caf5014dfada5ad43..994b0e85660571dce083ce05f67dbec94c0d7bca 100644
--- a/tests/by-util/test_nice.rs
+++ b/tests/by-util/test_nice.rs
@@ -1,11 +1,18 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore libc's
+use crate::common::util::TestScenario;
#[test]
#[cfg(not(target_os = "android"))]
fn test_get_current_niceness() {
- // NOTE: this assumes the test suite is being run with a default niceness
- // of 0, which may not necessarily be true
- new_ucmd!().run().stdout_is("0\n");
+ // Test that the nice command with no arguments returns the default nice
+ // value, which we determine by querying libc's `nice` in our own process.
+ new_ucmd!()
+ .run()
+ .stdout_is(format!("{}\n", unsafe { libc::nice(0) }));
}
#[test]
@@ -63,3 +70,22 @@ fn test_command_where_command_takes_n_flag() {
fn test_invalid_argument() {
new_ucmd!().arg("--invalid").fails().code_is(125);
}
+
+#[test]
+fn test_bare_adjustment() {
+ new_ucmd!()
+ .args(&["-1", "echo", "-n", "a"])
+ .run()
+ .stdout_is("a");
+}
+
+#[test]
+fn test_trailing_empty_adjustment() {
+ new_ucmd!()
+ .args(&["-n", "1", "-n"])
+ .fails()
+ .stderr_str()
+ .starts_with(
+ "error: The argument '--adjustment <adjustment>' requires a value but none was supplied",
+ );
+}
diff --git a/tests/by-util/test_nl.rs b/tests/by-util/test_nl.rs
index cd59a745c69c8e44aa1953dd2362ad0474acdd4d..78d18bcb41fe0c37c70fa7a5d31ca6fa5a5ed29b 100644
--- a/tests/by-util/test_nl.rs
+++ b/tests/by-util/test_nl.rs
@@ -1,4 +1,10 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+//
+// spell-checker:ignore binvalid finvalid hinvalid iinvalid linvalid nabcabc nabcabcabc ninvalid vinvalid winvalid dabc näää
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
@@ -12,6 +18,7 @@ fn test_stdin_no_newline() {
.run()
.stdout_is(" 1\tNo Newline\n");
}
+
#[test]
fn test_stdin_newline() {
new_ucmd!()
@@ -50,15 +57,15 @@ fn test_sections_and_styles() {
for (fixture, output) in [
(
"section.txt",
- "\nHEADER1\nHEADER2\n\n1 |BODY1\n2 \
- |BODY2\n\nFOOTER1\nFOOTER2\n\nNEXTHEADER1\nNEXTHEADER2\n\n1 \
- |NEXTBODY1\n2 |NEXTBODY2\n\nNEXTFOOTER1\nNEXTFOOTER2\n",
+ "\n HEADER1\n HEADER2\n\n1 |BODY1\n2 \
+ |BODY2\n\n FOOTER1\n FOOTER2\n\n NEXTHEADER1\n NEXTHEADER2\n\n1 \
+ |NEXTBODY1\n2 |NEXTBODY2\n\n NEXTFOOTER1\n NEXTFOOTER2\n",
),
(
"joinblanklines.txt",
- "1 |Nonempty\n2 |Nonempty\n3 |Followed by 10x empty\n\n\n\n\n4 \
- |\n\n\n\n\n5 |\n6 |Followed by 5x empty\n\n\n\n\n7 |\n8 \
- |Followed by 4x empty\n\n\n\n\n9 |Nonempty\n10 |Nonempty\n11 \
+ "1 |Nonempty\n2 |Nonempty\n3 |Followed by 10x empty\n \n \n \n \n4 \
+ |\n \n \n \n \n5 |\n6 |Followed by 5x empty\n \n \n \n \n7 |\n8 \
+ |Followed by 4x empty\n \n \n \n \n9 |Nonempty\n10 |Nonempty\n11 \
|Nonempty.\n",
),
] {
@@ -71,3 +78,576 @@ fn test_sections_and_styles() {
}
// spell-checker:enable
}
+
+#[test]
+fn test_no_renumber() {
+ for arg in ["-p", "--no-renumber"] {
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("a\n\\:\\:\nb")
+ .succeeds()
+ .stdout_is(" 1\ta\n\n 2\tb\n");
+ }
+}
+
+#[test]
+fn test_number_format_ln() {
+ for arg in ["-nln", "--number-format=ln"] {
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("test")
+ .succeeds()
+ .stdout_is("1 \ttest\n");
+ }
+}
+
+#[test]
+fn test_number_format_rn() {
+ for arg in ["-nrn", "--number-format=rn"] {
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("test")
+ .succeeds()
+ .stdout_is(" 1\ttest\n");
+ }
+}
+
+#[test]
+fn test_number_format_rz() {
+ for arg in ["-nrz", "--number-format=rz"] {
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("test")
+ .succeeds()
+ .stdout_is("000001\ttest\n");
+ }
+}
+
+#[test]
+fn test_number_format_rz_with_negative_line_number() {
+ for arg in ["-nrz", "--number-format=rz"] {
+ new_ucmd!()
+ .arg(arg)
+ .arg("-v-12")
+ .pipe_in("test")
+ .succeeds()
+ .stdout_is("-00012\ttest\n");
+ }
+}
+
+#[test]
+fn test_invalid_number_format() {
+ for arg in ["-ninvalid", "--number-format=invalid"] {
+ new_ucmd!()
+ .arg(arg)
+ .fails()
+ .stderr_contains("invalid value 'invalid'");
+ }
+}
+
+#[test]
+fn test_number_width() {
+ for width in 1..10 {
+ for arg in [format!("-w{width}"), format!("--number-width={width}")] {
+ let spaces = " ".repeat(width - 1);
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("test")
+ .succeeds()
+ .stdout_is(format!("{spaces}1\ttest\n"));
+ }
+ }
+}
+
+#[test]
+fn test_number_width_zero() {
+ for arg in ["-w0", "--number-width=0"] {
+ new_ucmd!()
+ .arg(arg)
+ .fails()
+ .stderr_contains("Invalid line number field width: ‘0’: Numerical result out of range");
+ }
+}
+
+#[test]
+fn test_invalid_number_width() {
+ for arg in ["-winvalid", "--number-width=invalid"] {
+ new_ucmd!()
+ .arg(arg)
+ .fails()
+ .stderr_contains("invalid value 'invalid'");
+ }
+}
+
+#[test]
+fn test_number_separator() {
+ for arg in ["-s:-:", "--number-separator=:-:"] {
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("test")
+ .succeeds()
+ .stdout_is(" 1:-:test\n");
+ }
+}
+
+#[test]
+fn test_starting_line_number() {
+ for arg in ["-v10", "--starting-line-number=10"] {
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("test")
+ .succeeds()
+ .stdout_is(" 10\ttest\n");
+ }
+}
+
+#[test]
+fn test_negative_starting_line_number() {
+ for arg in ["-v-10", "--starting-line-number=-10"] {
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("test")
+ .succeeds()
+ .stdout_is(" -10\ttest\n");
+ }
+}
+
+#[test]
+fn test_invalid_starting_line_number() {
+ for arg in ["-vinvalid", "--starting-line-number=invalid"] {
+ new_ucmd!()
+ .arg(arg)
+ .fails()
+ .stderr_contains("invalid value 'invalid'");
+ }
+}
+
+#[test]
+fn test_line_increment() {
+ for arg in ["-i10", "--line-increment=10"] {
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("a\nb")
+ .succeeds()
+ .stdout_is(" 1\ta\n 11\tb\n");
+ }
+}
+
+#[test]
+fn test_line_increment_from_negative_starting_line() {
+ for arg in ["-i10", "--line-increment=10"] {
+ new_ucmd!()
+ .arg(arg)
+ .arg("-v-19")
+ .pipe_in("a\nb\nc")
+ .succeeds()
+ .stdout_is(" -19\ta\n -9\tb\n 1\tc\n");
+ }
+}
+
+#[test]
+fn test_negative_line_increment() {
+ for arg in ["-i-10", "--line-increment=-10"] {
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("a\nb\nc")
+ .succeeds()
+ .stdout_is(" 1\ta\n -9\tb\n -19\tc\n");
+ }
+}
+
+#[test]
+fn test_invalid_line_increment() {
+ for arg in ["-iinvalid", "--line-increment=invalid"] {
+ new_ucmd!()
+ .arg(arg)
+ .fails()
+ .stderr_contains("invalid value 'invalid'");
+ }
+}
+
+#[test]
+fn test_join_blank_lines() {
+ for arg in ["-l3", "--join-blank-lines=3"] {
+ new_ucmd!()
+ .arg(arg)
+ .arg("--body-numbering=a")
+ .pipe_in("\n\n\n\n\n\n")
+ .succeeds()
+ .stdout_is(concat!(
+ " \n",
+ " \n",
+ " 1\t\n",
+ " \n",
+ " \n",
+ " 2\t\n",
+ ));
+ }
+}
+
+#[test]
+fn test_join_blank_lines_multiple_files() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ at.write("a.txt", "\n\n");
+ at.write("b.txt", "\n\n");
+ at.write("c.txt", "\n\n");
+
+ for arg in ["-l3", "--join-blank-lines=3"] {
+ scene
+ .ucmd()
+ .args(&[arg, "--body-numbering=a", "a.txt", "b.txt", "c.txt"])
+ .succeeds()
+ .stdout_is(concat!(
+ " \n",
+ " \n",
+ " 1\t\n",
+ " \n",
+ " \n",
+ " 2\t\n",
+ ));
+ }
+}
+
+#[test]
+fn test_join_blank_lines_zero() {
+ for arg in ["-l0", "--join-blank-lines=0"] {
+ new_ucmd!().arg(arg).fails().stderr_contains(
+ "Invalid line number of blank lines: ‘0’: Numerical result out of range",
+ );
+ }
+}
+
+#[test]
+fn test_invalid_join_blank_lines() {
+ for arg in ["-linvalid", "--join-blank-lines=invalid"] {
+ new_ucmd!()
+ .arg(arg)
+ .fails()
+ .stderr_contains("invalid value 'invalid'");
+ }
+}
+
+#[test]
+fn test_default_body_numbering() {
+ new_ucmd!()
+ .pipe_in("a\n\nb")
+ .succeeds()
+ .stdout_is(" 1\ta\n \n 2\tb\n");
+}
+
+#[test]
+fn test_default_body_numbering_multiple_files() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ at.write("a.txt", "a");
+ at.write("b.txt", "b");
+ at.write("c.txt", "c");
+
+ ucmd.args(&["a.txt", "b.txt", "c.txt"])
+ .succeeds()
+ .stdout_is(" 1\ta\n 2\tb\n 3\tc\n");
+}
+
+#[test]
+fn test_default_body_numbering_multiple_files_and_stdin() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ at.write("a.txt", "a");
+ at.write("c.txt", "c");
+
+ ucmd.args(&["a.txt", "-", "c.txt"])
+ .pipe_in("b")
+ .succeeds()
+ .stdout_is(" 1\ta\n 2\tb\n 3\tc\n");
+}
+
+#[test]
+fn test_body_numbering_all_lines_without_delimiter() {
+ for arg in ["-ba", "--body-numbering=a"] {
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("a\n\nb")
+ .succeeds()
+ .stdout_is(" 1\ta\n 2\t\n 3\tb\n");
+ }
+}
+
+#[test]
+fn test_body_numbering_no_lines_without_delimiter() {
+ for arg in ["-bn", "--body-numbering=n"] {
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("a\n\nb")
+ .succeeds()
+ .stdout_is(" a\n \n b\n");
+ }
+}
+
+#[test]
+fn test_body_numbering_non_empty_lines_without_delimiter() {
+ for arg in ["-bt", "--body-numbering=t"] {
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("a\n\nb")
+ .succeeds()
+ .stdout_is(" 1\ta\n \n 2\tb\n");
+ }
+}
+
+#[test]
+fn test_body_numbering_matched_lines_without_delimiter() {
+ for arg in ["-bp^[ac]", "--body-numbering=p^[ac]"] {
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("a\nb\nc")
+ .succeeds()
+ .stdout_is(" 1\ta\n b\n 2\tc\n");
+ }
+}
+
+#[test]
+fn test_numbering_all_lines() {
+ let delimiters_and_args = [
+ ("\\:\\:\\:\n", ["-ha", "--header-numbering=a"]),
+ ("\\:\\:\n", ["-ba", "--body-numbering=a"]),
+ ("\\:\n", ["-fa", "--footer-numbering=a"]),
+ ];
+
+ for (delimiter, args) in delimiters_and_args {
+ for arg in args {
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in(format!("{delimiter}a\n\nb"))
+ .succeeds()
+ .stdout_is("\n 1\ta\n 2\t\n 3\tb\n");
+ }
+ }
+}
+
+#[test]
+fn test_numbering_no_lines() {
+ let delimiters_and_args = [
+ ("\\:\\:\\:\n", ["-hn", "--header-numbering=n"]),
+ ("\\:\\:\n", ["-bn", "--body-numbering=n"]),
+ ("\\:\n", ["-fn", "--footer-numbering=n"]),
+ ];
+
+ for (delimiter, args) in delimiters_and_args {
+ for arg in args {
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in(format!("{delimiter}a\n\nb"))
+ .succeeds()
+ .stdout_is("\n a\n \n b\n");
+ }
+ }
+}
+
+#[test]
+fn test_numbering_non_empty_lines() {
+ let delimiters_and_args = [
+ ("\\:\\:\\:\n", ["-ht", "--header-numbering=t"]),
+ ("\\:\\:\n", ["-bt", "--body-numbering=t"]),
+ ("\\:\n", ["-ft", "--footer-numbering=t"]),
+ ];
+
+ for (delimiter, args) in delimiters_and_args {
+ for arg in args {
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in(format!("{delimiter}a\n\nb"))
+ .succeeds()
+ .stdout_is("\n 1\ta\n \n 2\tb\n");
+ }
+ }
+}
+
+#[test]
+fn test_numbering_matched_lines() {
+ let delimiters_and_args = [
+ ("\\:\\:\\:\n", ["-hp^[ac]", "--header-numbering=p^[ac]"]),
+ ("\\:\\:\n", ["-bp^[ac]", "--body-numbering=p^[ac]"]),
+ ("\\:\n", ["-fp^[ac]", "--footer-numbering=p^[ac]"]),
+ ];
+
+ for (delimiter, args) in delimiters_and_args {
+ for arg in args {
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in(format!("{delimiter}a\nb\nc"))
+ .succeeds()
+ .stdout_is("\n 1\ta\n b\n 2\tc\n");
+ }
+ }
+}
+
+#[test]
+fn test_invalid_numbering() {
+ let invalid_args = [
+ "-hinvalid",
+ "--header-numbering=invalid",
+ "-binvalid",
+ "--body-numbering=invalid",
+ "-finvalid",
+ "--footer-numbering=invalid",
+ ];
+
+ for invalid_arg in invalid_args {
+ new_ucmd!()
+ .arg(invalid_arg)
+ .fails()
+ .stderr_contains("invalid numbering style: 'invalid'");
+ }
+}
+
+#[test]
+fn test_invalid_regex_numbering() {
+ let invalid_args = [
+ "-hp[",
+ "--header-numbering=p[",
+ "-bp[",
+ "--body-numbering=p[",
+ "-fp[",
+ "--footer-numbering=p[",
+ ];
+
+ for invalid_arg in invalid_args {
+ new_ucmd!()
+ .arg(invalid_arg)
+ .fails()
+ .stderr_contains("invalid regular expression");
+ }
+}
+
+#[test]
+fn test_line_number_overflow() {
+ new_ucmd!()
+ .arg(format!("--starting-line-number={}", i64::MAX))
+ .pipe_in("a\nb")
+ .fails()
+ .stdout_is(format!("{}\ta\n", i64::MAX))
+ .stderr_is("nl: line number overflow\n");
+
+ new_ucmd!()
+ .arg(format!("--starting-line-number={}", i64::MIN))
+ .arg("--line-increment=-1")
+ .pipe_in("a\nb")
+ .fails()
+ .stdout_is(format!("{}\ta\n", i64::MIN))
+ .stderr_is("nl: line number overflow\n");
+}
+
+#[test]
+fn test_line_number_no_overflow() {
+ new_ucmd!()
+ .arg(format!("--starting-line-number={}", i64::MAX))
+ .pipe_in("a\n\\:\\:\nb")
+ .succeeds()
+ .stdout_is(format!("{0}\ta\n\n{0}\tb\n", i64::MAX));
+
+ new_ucmd!()
+ .arg(format!("--starting-line-number={}", i64::MIN))
+ .arg("--line-increment=-1")
+ .pipe_in("a\n\\:\\:\nb")
+ .succeeds()
+ .stdout_is(format!("{0}\ta\n\n{0}\tb\n", i64::MIN));
+}
+
+#[test]
+fn test_section_delimiter() {
+ for arg in ["-dabc", "--section-delimiter=abc"] {
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("a\nabcabcabc\nb") // header section
+ .succeeds()
+ .stdout_is(" 1\ta\n\n b\n");
+
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("a\nabcabc\nb") // body section
+ .succeeds()
+ .stdout_is(" 1\ta\n\n 1\tb\n");
+
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("a\nabc\nb") // footer section
+ .succeeds()
+ .stdout_is(" 1\ta\n\n b\n");
+ }
+}
+
+#[test]
+fn test_one_char_section_delimiter_expansion() {
+ for arg in ["-da", "--section-delimiter=a"] {
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("a\na:a:a:\nb") // header section
+ .succeeds()
+ .stdout_is(" 1\ta\n\n b\n");
+
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("a\na:a:\nb") // body section
+ .succeeds()
+ .stdout_is(" 1\ta\n\n 1\tb\n");
+
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("a\na:\nb") // footer section
+ .succeeds()
+ .stdout_is(" 1\ta\n\n b\n");
+ }
+}
+
+#[test]
+fn test_non_ascii_one_char_section_delimiter() {
+ for arg in ["-dä", "--section-delimiter=ä"] {
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("a\näää\nb") // header section
+ .succeeds()
+ .stdout_is(" 1\ta\n\n b\n");
+
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("a\nää\nb") // body section
+ .succeeds()
+ .stdout_is(" 1\ta\n\n 1\tb\n");
+
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("a\nä\nb") // footer section
+ .succeeds()
+ .stdout_is(" 1\ta\n\n b\n");
+ }
+}
+
+#[test]
+fn test_empty_section_delimiter() {
+ for arg in ["-d ''", "--section-delimiter=''"] {
+ new_ucmd!()
+ .arg(arg)
+ .pipe_in("a\n\nb")
+ .succeeds()
+ .stdout_is(" 1\ta\n \n 2\tb\n");
+ }
+}
+
+#[test]
+fn test_directory_as_input() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let dir = "dir";
+ let file = "file";
+ let content = "aaa";
+
+ at.mkdir(dir);
+ at.write(file, content);
+
+ ucmd.arg(dir)
+ .arg(file)
+ .fails()
+ .stderr_is(format!("nl: {dir}: Is a directory\n"))
+ .stdout_contains(content);
+}
diff --git a/tests/by-util/test_nohup.rs b/tests/by-util/test_nohup.rs
index 8ef0bc9c9aac35783204091447a8f3b1be6fd595..db19114b6630258e3fac1f0de8912e58115adc5d 100644
--- a/tests/by-util/test_nohup.rs
+++ b/tests/by-util/test_nohup.rs
@@ -1,4 +1,9 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore winsize Openpty openpty xpixel ypixel ptyprocess
+use crate::common::util::TestScenario;
use std::thread::sleep;
// General observation: nohup.out will not be created in tests run by cargo test
@@ -27,3 +32,32 @@ fn test_nohup_multiple_args_and_flags() {
assert!(at.file_exists("file1"));
assert!(at.file_exists("file2"));
}
+
+#[test]
+#[cfg(any(
+ target_os = "linux",
+ target_os = "android",
+ target_os = "freebsd",
+ target_vendor = "apple"
+))]
+fn test_nohup_with_pseudo_terminal_emulation_on_stdin_stdout_stderr_get_replaced() {
+ let ts = TestScenario::new(util_name!());
+ let result = ts
+ .ucmd()
+ .terminal_simulation(true)
+ .args(&["sh", "is_a_tty.sh"])
+ .succeeds();
+
+ assert_eq!(
+ String::from_utf8_lossy(result.stderr()).trim(),
+ "nohup: ignoring input and appending output to 'nohup.out'"
+ );
+
+ sleep(std::time::Duration::from_millis(10));
+
+ // this proves that nohup was exchanging the stdio file descriptors
+ assert_eq!(
+ std::fs::read_to_string(ts.fixtures.plus_as_string("nohup.out")).unwrap(),
+ "stdin is not a tty\nstdout is not a tty\nstderr is not a tty\n"
+ );
+}
diff --git a/tests/by-util/test_nproc.rs b/tests/by-util/test_nproc.rs
index 3260e46e7c772a09aed013447255246c7ab46f53..22523352b5f38a4a06c237b51ed7912f5168e92f 100644
--- a/tests/by-util/test_nproc.rs
+++ b/tests/by-util/test_nproc.rs
@@ -1,5 +1,9 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore incorrectnumber
-use crate::common::util::*;
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
@@ -20,7 +24,7 @@ fn test_nproc_all_omp() {
assert!(nproc > 0);
let result = TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.env("OMP_NUM_THREADS", "60")
.succeeds();
@@ -28,7 +32,7 @@ fn test_nproc_all_omp() {
assert_eq!(nproc_omp, 60);
let result = TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.env("OMP_NUM_THREADS", "1") // Has no effect
.arg("--all")
.succeeds();
@@ -37,7 +41,7 @@ fn test_nproc_all_omp() {
// If the parsing fails, returns the number of CPU
let result = TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.env("OMP_NUM_THREADS", "incorrectnumber") // returns the number CPU
.succeeds();
let nproc_omp: u8 = result.stdout_str().trim().parse().unwrap();
@@ -51,7 +55,7 @@ fn test_nproc_ignore() {
if nproc_total > 1 {
// Ignore all CPU but one
let result = TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.arg("--ignore")
.arg((nproc_total - 1).to_string())
.succeeds();
@@ -59,7 +63,7 @@ fn test_nproc_ignore() {
assert_eq!(nproc, 1);
// Ignore all CPU but one with a string
let result = TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.arg("--ignore= 1")
.succeeds();
let nproc: u8 = result.stdout_str().trim().parse().unwrap();
@@ -70,7 +74,7 @@ fn test_nproc_ignore() {
#[test]
fn test_nproc_ignore_all_omp() {
let result = TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.env("OMP_NUM_THREADS", "42")
.arg("--ignore=40")
.succeeds();
@@ -81,7 +85,7 @@ fn test_nproc_ignore_all_omp() {
#[test]
fn test_nproc_omp_limit() {
let result = TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.env("OMP_NUM_THREADS", "42")
.env("OMP_THREAD_LIMIT", "0")
.succeeds();
@@ -89,7 +93,7 @@ fn test_nproc_omp_limit() {
assert_eq!(nproc, 42);
let result = TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.env("OMP_NUM_THREADS", "42")
.env("OMP_THREAD_LIMIT", "2")
.succeeds();
@@ -97,7 +101,7 @@ fn test_nproc_omp_limit() {
assert_eq!(nproc, 2);
let result = TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.env("OMP_NUM_THREADS", "42")
.env("OMP_THREAD_LIMIT", "2bad")
.succeeds();
@@ -109,14 +113,14 @@ fn test_nproc_omp_limit() {
assert!(nproc_system > 0);
let result = TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.env("OMP_THREAD_LIMIT", "1")
.succeeds();
let nproc: u8 = result.stdout_str().trim().parse().unwrap();
assert_eq!(nproc, 1);
let result = TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.env("OMP_NUM_THREADS", "0")
.env("OMP_THREAD_LIMIT", "")
.succeeds();
@@ -124,7 +128,7 @@ fn test_nproc_omp_limit() {
assert_eq!(nproc, nproc_system);
let result = TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.env("OMP_NUM_THREADS", "")
.env("OMP_THREAD_LIMIT", "")
.succeeds();
@@ -132,7 +136,7 @@ fn test_nproc_omp_limit() {
assert_eq!(nproc, nproc_system);
let result = TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.env("OMP_NUM_THREADS", "2,2,1")
.env("OMP_THREAD_LIMIT", "")
.succeeds();
@@ -140,7 +144,7 @@ fn test_nproc_omp_limit() {
assert_eq!(2, nproc);
let result = TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.env("OMP_NUM_THREADS", "2,ignored")
.env("OMP_THREAD_LIMIT", "")
.succeeds();
@@ -148,7 +152,7 @@ fn test_nproc_omp_limit() {
assert_eq!(2, nproc);
let result = TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.env("OMP_NUM_THREADS", "2,2,1")
.env("OMP_THREAD_LIMIT", "0")
.succeeds();
@@ -156,7 +160,7 @@ fn test_nproc_omp_limit() {
assert_eq!(2, nproc);
let result = TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.env("OMP_NUM_THREADS", "2,2,1")
.env("OMP_THREAD_LIMIT", "1bad")
.succeeds();
@@ -164,7 +168,7 @@ fn test_nproc_omp_limit() {
assert_eq!(2, nproc);
let result = TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.env("OMP_NUM_THREADS", "29,2,1")
.env("OMP_THREAD_LIMIT", "1bad")
.succeeds();
diff --git a/tests/by-util/test_numfmt.rs b/tests/by-util/test_numfmt.rs
index 108c26fd06d1f2c5dd540982dc959b9e33528c02..1ef588f26a9a961ee55193df3851bf8645266887 100644
--- a/tests/by-util/test_numfmt.rs
+++ b/tests/by-util/test_numfmt.rs
@@ -1,6 +1,10 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (paths) gnutest
-use crate::common::util::*;
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
@@ -60,8 +64,7 @@ fn test_from_iec_i_requires_suffix() {
.fails()
.code_is(2)
.stderr_is(format!(
- "numfmt: missing 'i' suffix in input: '{}' (e.g Ki/Mi/Gi)",
- number
+ "numfmt: missing 'i' suffix in input: '{number}' (e.g Ki/Mi/Gi)\n"
));
}
}
@@ -151,7 +154,7 @@ fn test_header_error_if_non_numeric() {
new_ucmd!()
.args(&["--header=two"])
.run()
- .stderr_is("numfmt: invalid header value 'two'");
+ .stderr_is("numfmt: invalid header value 'two'\n");
}
#[test]
@@ -159,7 +162,7 @@ fn test_header_error_if_0() {
new_ucmd!()
.args(&["--header=0"])
.run()
- .stderr_is("numfmt: invalid header value '0'");
+ .stderr_is("numfmt: invalid header value '0'\n");
}
#[test]
@@ -167,7 +170,7 @@ fn test_header_error_if_negative() {
new_ucmd!()
.args(&["--header=-3"])
.run()
- .stderr_is("numfmt: invalid header value '-3'");
+ .stderr_is("numfmt: invalid header value '-3'\n");
}
#[test]
@@ -458,7 +461,7 @@ fn test_delimiter_must_not_be_more_than_one_character() {
new_ucmd!()
.args(&["--delimiter", "sad"])
.fails()
- .stderr_is("numfmt: the delimiter must be a single character");
+ .stderr_is("numfmt: the delimiter must be a single character\n");
}
#[test]
@@ -547,10 +550,14 @@ fn test_delimiter_with_padding_and_fields() {
fn test_round() {
for (method, exp) in [
("from-zero", ["9.1K", "-9.1K", "9.1K", "-9.1K"]),
+ ("from-zer", ["9.1K", "-9.1K", "9.1K", "-9.1K"]),
+ ("f", ["9.1K", "-9.1K", "9.1K", "-9.1K"]),
("towards-zero", ["9.0K", "-9.0K", "9.0K", "-9.0K"]),
("up", ["9.1K", "-9.0K", "9.1K", "-9.0K"]),
("down", ["9.0K", "-9.1K", "9.0K", "-9.1K"]),
("nearest", ["9.0K", "-9.0K", "9.1K", "-9.1K"]),
+ ("near", ["9.0K", "-9.0K", "9.1K", "-9.1K"]),
+ ("n", ["9.0K", "-9.0K", "9.1K", "-9.1K"]),
] {
new_ucmd!()
.args(&[
@@ -663,12 +670,88 @@ fn test_invalid_stdin_number_returns_status_2() {
#[test]
fn test_invalid_stdin_number_in_middle_of_input() {
- new_ucmd!().pipe_in("100\nhello\n200").fails().code_is(2);
+ new_ucmd!()
+ .pipe_in("100\nhello\n200")
+ .ignore_stdin_write_error()
+ .fails()
+ .stdout_is("100\n")
+ .code_is(2);
+}
+
+#[test]
+fn test_invalid_stdin_number_with_warn_returns_status_0() {
+ new_ucmd!()
+ .args(&["--invalid=warn"])
+ .pipe_in("4Q")
+ .succeeds()
+ .stdout_is("4Q\n")
+ .stderr_is("numfmt: invalid suffix in input: '4Q'\n");
+}
+
+#[test]
+fn test_invalid_stdin_number_with_ignore_returns_status_0() {
+ new_ucmd!()
+ .args(&["--invalid=ignore"])
+ .pipe_in("4Q")
+ .succeeds()
+ .stdout_only("4Q\n");
+}
+
+#[test]
+fn test_invalid_stdin_number_with_abort_returns_status_2() {
+ new_ucmd!()
+ .args(&["--invalid=abort"])
+ .pipe_in("4Q")
+ .fails()
+ .code_is(2)
+ .stderr_only("numfmt: invalid suffix in input: '4Q'\n");
+}
+
+#[test]
+fn test_invalid_stdin_number_with_fail_returns_status_2() {
+ new_ucmd!()
+ .args(&["--invalid=fail"])
+ .pipe_in("4Q")
+ .fails()
+ .code_is(2)
+ .stdout_is("4Q\n")
+ .stderr_is("numfmt: invalid suffix in input: '4Q'\n");
+}
+
+#[test]
+fn test_invalid_arg_number_with_warn_returns_status_0() {
+ new_ucmd!()
+ .args(&["--invalid=warn", "4Q"])
+ .succeeds()
+ .stdout_is("4Q\n")
+ .stderr_is("numfmt: invalid suffix in input: '4Q'\n");
+}
+
+#[test]
+fn test_invalid_arg_number_with_ignore_returns_status_0() {
+ new_ucmd!()
+ .args(&["--invalid=ignore", "4Q"])
+ .succeeds()
+ .stdout_only("4Q\n");
+}
+
+#[test]
+fn test_invalid_arg_number_with_abort_returns_status_2() {
+ new_ucmd!()
+ .args(&["--invalid=abort", "4Q"])
+ .fails()
+ .code_is(2)
+ .stderr_only("numfmt: invalid suffix in input: '4Q'\n");
}
#[test]
-fn test_invalid_argument_number_returns_status_2() {
- new_ucmd!().args(&["hello"]).fails().code_is(2);
+fn test_invalid_arg_number_with_fail_returns_status_2() {
+ new_ucmd!()
+ .args(&["--invalid=fail", "4Q"])
+ .fails()
+ .code_is(2)
+ .stdout_is("4Q\n")
+ .stderr_is("numfmt: invalid suffix in input: '4Q'\n");
}
#[test]
@@ -687,11 +770,11 @@ fn test_invalid_padding_value() {
for padding_value in padding_values {
new_ucmd!()
- .arg(format!("--padding={}", padding_value))
+ .arg(format!("--padding={padding_value}"))
.arg("5")
.fails()
.code_is(1)
- .stderr_contains(format!("invalid padding value '{}'", padding_value));
+ .stderr_contains(format!("invalid padding value '{padding_value}'"));
}
}
@@ -719,10 +802,10 @@ fn test_invalid_unit_size() {
for command in commands {
for invalid_size in &invalid_sizes {
new_ucmd!()
- .arg(format!("--{}-unit={}", command, invalid_size))
+ .arg(format!("--{command}-unit={invalid_size}"))
.fails()
.code_is(1)
- .stderr_contains(format!("invalid unit size: '{}'", invalid_size));
+ .stderr_contains(format!("invalid unit size: '{invalid_size}'"));
}
}
}
@@ -737,8 +820,7 @@ fn test_valid_but_forbidden_suffix() {
.fails()
.code_is(2)
.stderr_contains(format!(
- "rejecting suffix in input: '{}' (consider using --from)",
- number
+ "rejecting suffix in input: '{number}' (consider using --from)"
));
}
}
@@ -805,7 +887,7 @@ fn test_format_with_zero_padding() {
for format in formats {
new_ucmd!()
- .args(&[format!("--format={}", format), String::from("1234")])
+ .args(&[format!("--format={format}"), String::from("1234")])
.succeeds()
.stdout_is("001234\n");
}
@@ -851,7 +933,7 @@ fn test_format_with_precision() {
new_ucmd!()
.args(&["--format=%.1f", input])
.succeeds()
- .stdout_is(format!("{}\n", expected));
+ .stdout_is(format!("{expected}\n"));
}
let values = vec![("0.99", "0.99"), ("1", "1.00"), ("1.01", "1.01")];
@@ -860,7 +942,7 @@ fn test_format_with_precision() {
new_ucmd!()
.args(&["--format=%.2f", input])
.succeeds()
- .stdout_is(format!("{}\n", expected));
+ .stdout_is(format!("{expected}\n"));
}
}
@@ -872,7 +954,7 @@ fn test_format_with_precision_and_down_rounding() {
new_ucmd!()
.args(&["--format=%.1f", input, "--round=down"])
.succeeds()
- .stdout_is(format!("{}\n", expected));
+ .stdout_is(format!("{expected}\n"));
}
}
@@ -883,12 +965,12 @@ fn test_format_with_precision_and_to_arg() {
for (format, expected) in values {
new_ucmd!()
.args(&[
- format!("--format={}", format),
+ format!("--format={format}"),
"9991239123".to_string(),
"--to=si".to_string(),
])
.succeeds()
- .stdout_is(format!("{}\n", expected));
+ .stdout_is(format!("{expected}\n"));
}
}
@@ -900,7 +982,7 @@ fn test_format_preserve_trailing_zeros_if_no_precision_is_specified() {
new_ucmd!()
.args(&["--format=%f", value])
.succeeds()
- .stdout_is(format!("{}\n", value));
+ .stdout_is(format!("{value}\n"));
}
}
@@ -910,10 +992,10 @@ fn test_format_without_percentage_directive() {
for invalid_format in invalid_formats {
new_ucmd!()
- .arg(format!("--format={}", invalid_format))
+ .arg(format!("--format={invalid_format}"))
.fails()
.code_is(1)
- .stderr_contains(format!("format '{}' has no % directive", invalid_format));
+ .stderr_contains(format!("format '{invalid_format}' has no % directive"));
}
}
@@ -922,10 +1004,10 @@ fn test_format_with_percentage_directive_at_end() {
let invalid_format = "hello%";
new_ucmd!()
- .arg(format!("--format={}", invalid_format))
+ .arg(format!("--format={invalid_format}"))
.fails()
.code_is(1)
- .stderr_contains(format!("format '{}' ends in %", invalid_format));
+ .stderr_contains(format!("format '{invalid_format}' ends in %"));
}
#[test]
@@ -933,12 +1015,11 @@ fn test_format_with_too_many_percentage_directives() {
let invalid_format = "%f %f";
new_ucmd!()
- .arg(format!("--format={}", invalid_format))
+ .arg(format!("--format={invalid_format}"))
.fails()
.code_is(1)
.stderr_contains(format!(
- "format '{}' has too many % directives",
- invalid_format
+ "format '{invalid_format}' has too many % directives"
));
}
@@ -948,12 +1029,11 @@ fn test_format_with_invalid_format() {
for invalid_format in invalid_formats {
new_ucmd!()
- .arg(format!("--format={}", invalid_format))
+ .arg(format!("--format={invalid_format}"))
.fails()
.code_is(1)
.stderr_contains(format!(
- "invalid format '{}', directive must be %[0]['][-][N][.][N]f",
- invalid_format
+ "invalid format '{invalid_format}', directive must be %[0]['][-][N][.][N]f"
));
}
}
@@ -962,12 +1042,11 @@ fn test_format_with_invalid_format() {
fn test_format_with_width_overflow() {
let invalid_format = "%18446744073709551616f";
new_ucmd!()
- .arg(format!("--format={}", invalid_format))
+ .arg(format!("--format={invalid_format}"))
.fails()
.code_is(1)
.stderr_contains(format!(
- "invalid format '{}' (width overflow)",
- invalid_format
+ "invalid format '{invalid_format}' (width overflow)"
));
}
@@ -977,10 +1056,10 @@ fn test_format_with_invalid_precision() {
for invalid_format in invalid_formats {
new_ucmd!()
- .arg(format!("--format={}", invalid_format))
+ .arg(format!("--format={invalid_format}"))
.fails()
.code_is(1)
- .stderr_contains(format!("invalid precision in format '{}'", invalid_format));
+ .stderr_contains(format!("invalid precision in format '{invalid_format}'"));
}
}
diff --git a/tests/by-util/test_od.rs b/tests/by-util/test_od.rs
index 00a408d5657d5f6e2fb8a2f3a84f39b6b60cd5a5..20a23bb6ebb7b6187b78fea60491580187129a71 100644
--- a/tests/by-util/test_od.rs
+++ b/tests/by-util/test_od.rs
@@ -1,29 +1,20 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
// spell-checker:ignore abcdefghijklmnopqrstuvwxyz
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
-
-extern crate unindent;
-
-use self::unindent::*;
-use crate::common::util::*;
-use std::env;
-use std::fs::remove_file;
-use std::fs::File;
-use std::io::Write;
-use std::path::Path;
-
-// octal dump of 'abcdefghijklmnopqrstuvwxyz\n' // spell-checker:disable-line
+
+use crate::common::util::TestScenario;
+use unindent::unindent;
+
+// octal dump of 'abcdefghijklmnopqrstuvwxyz\n'
static ALPHA_OUT: &str = "
0000000 061141 062143 063145 064147 065151 066153 067155 070157
0000020 071161 072163 073165 074167 075171 000012
0000033
";
-// XXX We could do a better job of ensuring that we have a fresh temp dir to ourselves,
-// not a general one full of other process leftovers.
-
#[test]
fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
@@ -32,88 +23,64 @@ fn test_invalid_arg() {
// Test that od can read one file and dump with default format
#[test]
fn test_file() {
- // TODO: Can this be replaced by AtPath?
- use std::env;
- let temp = env::temp_dir();
- let tmpdir = Path::new(&temp);
- let file = tmpdir.join("test");
-
- {
- let mut f = File::create(&file).unwrap();
- // spell-checker:disable-next-line
- assert!(
- f.write_all(b"abcdefghijklmnopqrstuvwxyz\n").is_ok(),
- "Test setup failed - could not write file"
- );
- }
-
- new_ucmd!()
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.write("test", "abcdefghijklmnopqrstuvwxyz\n");
+ scene
+ .ucmd()
.arg("--endian=little")
- .arg(file.as_os_str())
+ .arg("test")
+ .succeeds()
+ .no_stderr()
+ .stdout_is(unindent(ALPHA_OUT));
+ scene
+ .ucmd()
+ .arg("--endian=littl") // spell-checker:disable-line
+ .arg("test")
+ .succeeds()
+ .no_stderr()
+ .stdout_is(unindent(ALPHA_OUT));
+ scene
+ .ucmd()
+ .arg("--endian=l")
+ .arg("test")
.succeeds()
.no_stderr()
.stdout_is(unindent(ALPHA_OUT));
-
// Ensure that default format matches `-t o2`, and that `-t` does not absorb file argument
- new_ucmd!()
+ scene
+ .ucmd()
.arg("--endian=little")
.arg("-t")
.arg("o2")
- .arg(file.as_os_str())
- .succeeds()
- .no_stderr()
- .stdout_is(unindent(ALPHA_OUT));
-
- let _ = remove_file(file);
+ .arg("test");
}
// Test that od can read 2 files and concatenate the contents
#[test]
fn test_2files() {
- let temp = env::temp_dir();
- let tmpdir = Path::new(&temp);
- let file1 = tmpdir.join("test1");
- let file2 = tmpdir.join("test2");
-
- for (n, a) in [(1, "a"), (2, "b")] {
- println!("number: {} letter:{}", n, a);
- }
-
- // spell-checker:disable-next-line
- for (path, data) in [(&file1, "abcdefghijklmnop"), (&file2, "qrstuvwxyz\n")] {
- let mut f = File::create(path).unwrap();
- assert!(
- f.write_all(data.as_bytes()).is_ok(),
- "Test setup failed - could not write file"
- );
- }
-
- new_ucmd!()
- .arg("--endian=little")
- .arg(file1.as_os_str())
- .arg(file2.as_os_str())
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.write("test1", "abcdefghijklmnop");
+ at.write("test2", "qrstuvwxyz\n"); // spell-checker:disable-line
+ ucmd.arg("--endian=little")
+ .arg("test1")
+ .arg("test2")
.succeeds()
.no_stderr()
.stdout_is(unindent(ALPHA_OUT));
- // TODO: Handle errors?
- let _ = remove_file(file1);
- let _ = remove_file(file2);
}
// Test that od gives non-0 exit val for filename that doesn't exist.
#[test]
fn test_no_file() {
- let temp = env::temp_dir();
- let tmpdir = Path::new(&temp);
- let file = tmpdir.join("}surely'none'would'thus'a'file'name"); // spell-checker:disable-line
-
- new_ucmd!().arg(file.as_os_str()).fails();
+ let (_at, mut ucmd) = at_and_ucmd!();
+ ucmd.arg("}surely'none'would'thus'a'file'name").fails();
}
// Test that od reads from stdin instead of a file
#[test]
fn test_from_stdin() {
- let input = "abcdefghijklmnopqrstuvwxyz\n"; // spell-checker:disable-line
+ let input = "abcdefghijklmnopqrstuvwxyz\n";
new_ucmd!()
.arg("--endian=little")
.run_piped_stdin(input.as_bytes())
@@ -125,26 +92,16 @@ fn test_from_stdin() {
// Test that od reads from stdin and also from files
#[test]
fn test_from_mixed() {
- let temp = env::temp_dir();
- let tmpdir = Path::new(&temp);
- let file1 = tmpdir.join("test-1");
- let file3 = tmpdir.join("test-3");
-
+ let (at, mut ucmd) = at_and_ucmd!();
// spell-checker:disable-next-line
let (data1, data2, data3) = ("abcdefg", "hijklmnop", "qrstuvwxyz\n");
- for (path, data) in [(&file1, data1), (&file3, data3)] {
- let mut f = File::create(path).unwrap();
- assert!(
- f.write_all(data.as_bytes()).is_ok(),
- "Test setup failed - could not write file"
- );
- }
+ at.write("test-1", data1);
+ at.write("test-3", data3);
- new_ucmd!()
- .arg("--endian=little")
- .arg(file1.as_os_str())
+ ucmd.arg("--endian=little")
+ .arg("test-1")
.arg("-")
- .arg(file3.as_os_str())
+ .arg("test-3")
.run_piped_stdin(data2.as_bytes())
.success()
.no_stderr()
@@ -153,7 +110,7 @@ fn test_from_mixed() {
#[test]
fn test_multiple_formats() {
- let input = "abcdefghijklmnopqrstuvwxyz\n"; // spell-checker:disable-line
+ let input = "abcdefghijklmnopqrstuvwxyz\n";
new_ucmd!()
.arg("-c")
.arg("-b")
@@ -464,6 +421,16 @@ fn test_big_endian() {
.run_piped_stdin(&input[..])
.no_stderr()
.success()
+ .stdout_is(&expected_output);
+ new_ucmd!()
+ .arg("--endian=b")
+ .arg("-F")
+ .arg("-f")
+ .arg("-X")
+ .arg("-x")
+ .run_piped_stdin(&input[..])
+ .no_stderr()
+ .success()
.stdout_is(expected_output);
}
@@ -614,7 +581,7 @@ fn test_invalid_offset() {
#[test]
fn test_skip_bytes() {
- let input = "abcdefghijklmnopq"; // spell-checker:disable-line
+ let input = "abcdefghijklmnopq";
new_ucmd!()
.arg("-c")
.arg("--skip-bytes=5")
@@ -629,6 +596,35 @@ fn test_skip_bytes() {
));
}
+#[test]
+fn test_skip_bytes_hex() {
+ let input = "abcdefghijklmnopq";
+ new_ucmd!()
+ .arg("-c")
+ .arg("--skip-bytes=0xB")
+ .run_piped_stdin(input.as_bytes())
+ .no_stderr()
+ .success()
+ .stdout_is(unindent(
+ "
+ 0000013 l m n o p q
+ 0000021
+ ",
+ ));
+ new_ucmd!()
+ .arg("-c")
+ .arg("--skip-bytes=0xE")
+ .run_piped_stdin(input.as_bytes())
+ .no_stderr()
+ .success()
+ .stdout_is(unindent(
+ "
+ 0000016 o p q
+ 0000021
+ ",
+ ));
+}
+
#[test]
fn test_skip_bytes_error() {
let input = "12345";
@@ -640,7 +636,7 @@ fn test_skip_bytes_error() {
#[test]
fn test_read_bytes() {
- let input = "abcdefghijklmnopqrstuvwxyz\n12345678"; // spell-checker:disable-line
+ let input = "abcdefghijklmnopqrstuvwxyz\n12345678";
new_ucmd!()
.arg("--endian=little")
.arg("--read-bytes=27")
@@ -699,7 +695,7 @@ fn test_filename_parsing() {
#[test]
fn test_stdin_offset() {
- let input = "abcdefghijklmnopq"; // spell-checker:disable-line
+ let input = "abcdefghijklmnopq";
new_ucmd!()
.arg("-c")
.arg("+5")
@@ -734,7 +730,7 @@ fn test_file_offset() {
#[test]
fn test_traditional() {
// note gnu od does not align both lines
- let input = "abcdefghijklmnopq"; // spell-checker:disable-line
+ let input = "abcdefghijklmnopq";
new_ucmd!()
.arg("--traditional")
.arg("-a")
@@ -757,7 +753,7 @@ fn test_traditional() {
#[test]
fn test_traditional_with_skip_bytes_override() {
// --skip-bytes is ignored in this case
- let input = "abcdefghijklmnop"; // spell-checker:disable-line
+ let input = "abcdefghijklmnop";
new_ucmd!()
.arg("--traditional")
.arg("--skip-bytes=10")
@@ -777,7 +773,7 @@ fn test_traditional_with_skip_bytes_override() {
#[test]
fn test_traditional_with_skip_bytes_non_override() {
// no offset specified in the traditional way, so --skip-bytes is used
- let input = "abcdefghijklmnop"; // spell-checker:disable-line
+ let input = "abcdefghijklmnop";
new_ucmd!()
.arg("--traditional")
.arg("--skip-bytes=10")
@@ -807,7 +803,7 @@ fn test_traditional_error() {
#[test]
fn test_traditional_only_label() {
- let input = "abcdefghijklmnopqrstuvwxyz"; // spell-checker:disable-line
+ let input = "abcdefghijklmnopqrstuvwxyz";
new_ucmd!()
.arg("-An")
.arg("--traditional")
@@ -849,31 +845,26 @@ fn test_od_invalid_bytes() {
];
for option in &options {
new_ucmd!()
- .arg(format!("{}={}", option, INVALID_SIZE))
+ .arg(format!("{option}={INVALID_SIZE}"))
.arg("file")
.fails()
.code_is(1)
- .stderr_only(format!(
- "od: invalid {} argument '{}'",
- option, INVALID_SIZE
- ));
+ .stderr_only(format!("od: invalid {option} argument '{INVALID_SIZE}'\n"));
new_ucmd!()
- .arg(format!("{}={}", option, INVALID_SUFFIX))
+ .arg(format!("{option}={INVALID_SUFFIX}"))
.arg("file")
.fails()
.code_is(1)
.stderr_only(format!(
- "od: invalid suffix in {} argument '{}'",
- option, INVALID_SUFFIX
+ "od: invalid suffix in {option} argument '{INVALID_SUFFIX}'\n"
));
- #[cfg(not(target_pointer_width = "128"))]
new_ucmd!()
- .arg(format!("{}={}", option, BIG_SIZE))
+ .arg(format!("{option}={BIG_SIZE}"))
.arg("file")
.fails()
.code_is(1)
- .stderr_only(format!("od: {} argument '{}' too large", option, BIG_SIZE));
+ .stderr_only(format!("od: {option} argument '{BIG_SIZE}' too large\n"));
}
}
diff --git a/tests/by-util/test_paste.rs b/tests/by-util/test_paste.rs
index 088a27eae90c9af31843890e812021a244640c80..0fbdb75d2683f28c367fbb197ed24e118a5ba82e 100644
--- a/tests/by-util/test_paste.rs
+++ b/tests/by-util/test_paste.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
struct TestData<'b> {
name: &'b str,
@@ -156,13 +160,46 @@ fn test_multi_stdin() {
}
}
+#[test]
+// TODO: make this test work on Windows
+#[cfg(not(windows))]
+fn test_delimiter_list_ending_with_escaped_backslash() {
+ for d in ["-d", "--delimiters"] {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let mut ins = vec![];
+ for (i, _in) in ["a\n", "b\n"].iter().enumerate() {
+ let file = format!("in{}", i);
+ at.write(&file, _in);
+ ins.push(file);
+ }
+ ucmd.args(&[d, "\\\\"])
+ .args(&ins)
+ .succeeds()
+ .stdout_is("a\\b\n");
+ }
+}
+
+#[test]
+fn test_delimiter_list_ending_with_unescaped_backslash() {
+ for d in ["-d", "--delimiters"] {
+ new_ucmd!()
+ .args(&[d, "\\"])
+ .fails()
+ .stderr_contains("delimiter list ends with an unescaped backslash: \\");
+ new_ucmd!()
+ .args(&[d, "_\\"])
+ .fails()
+ .stderr_contains("delimiter list ends with an unescaped backslash: _\\");
+ }
+}
+
#[test]
fn test_data() {
for example in EXAMPLE_DATA {
let (at, mut ucmd) = at_and_ucmd!();
let mut ins = vec![];
for (i, _in) in example.ins.iter().enumerate() {
- let file = format!("in{}", i);
+ let file = format!("in{i}");
at.write(&file, _in);
ins.push(file);
}
diff --git a/tests/by-util/test_pathchk.rs b/tests/by-util/test_pathchk.rs
index 9b16fe7384409a25e79f9cd176dca7be844fdb1f..d09c8a2e1e48429406b1491f8ff47d40baf4348c 100644
--- a/tests/by-util/test_pathchk.rs
+++ b/tests/by-util/test_pathchk.rs
@@ -1,4 +1,16 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
+
+#[test]
+fn test_no_args() {
+ new_ucmd!()
+ .fails()
+ .no_stdout()
+ .stderr_contains("pathchk: missing operand");
+}
#[test]
fn test_invalid_arg() {
@@ -7,16 +19,22 @@ fn test_invalid_arg() {
#[test]
fn test_default_mode() {
- // test the default mode
-
// accept some reasonable default
new_ucmd!().args(&["dir/file"]).succeeds().no_stdout();
// accept non-portable chars
new_ucmd!().args(&["dir#/$file"]).succeeds().no_stdout();
- // accept empty path
- new_ucmd!().args(&[""]).succeeds().no_stdout();
+ // fail on empty path
+ new_ucmd!()
+ .args(&[""])
+ .fails()
+ .stderr_only("pathchk: '': No such file or directory\n");
+
+ new_ucmd!().args(&["", ""]).fails().stderr_only(
+ "pathchk: '': No such file or directory\n\
+ pathchk: '': No such file or directory\n",
+ );
// fail on long path
new_ucmd!()
@@ -36,8 +54,6 @@ fn test_default_mode() {
#[test]
fn test_posix_mode() {
- // test the posix mode
-
// accept some reasonable default
new_ucmd!().args(&["-p", "dir/file"]).succeeds().no_stdout();
@@ -62,8 +78,6 @@ fn test_posix_mode() {
#[test]
fn test_posix_special() {
- // test the posix special mode
-
// accept some reasonable default
new_ucmd!().args(&["-P", "dir/file"]).succeeds().no_stdout();
@@ -103,8 +117,6 @@ fn test_posix_special() {
#[test]
fn test_posix_all() {
- // test the posix special mode
-
// accept some reasonable default
new_ucmd!()
.args(&["-p", "-P", "dir/file"])
@@ -152,10 +164,3 @@ fn test_posix_all() {
// fail on empty path
new_ucmd!().args(&["-p", "-P", ""]).fails().no_stdout();
}
-
-#[test]
-fn test_args_parsing() {
- // fail on no args
- let empty_args: [String; 0] = [];
- new_ucmd!().args(&empty_args).fails().no_stdout();
-}
diff --git a/tests/by-util/test_pinky.rs b/tests/by-util/test_pinky.rs
index 6dd85b6beb0a94a954b9902da57f47ab538b368e..0fff402df9616cef158c78c837ea9621e6c2a1f3 100644
--- a/tests/by-util/test_pinky.rs
+++ b/tests/by-util/test_pinky.rs
@@ -1,16 +1,11 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-extern crate uucore;
-
-use crate::common::util::*;
-
-use self::uucore::entries::{Locate, Passwd};
-
-extern crate pinky;
-pub use self::pinky::*;
+use crate::common::util::{expected_result, TestScenario};
+use pinky::Capitalize;
+use uucore::entries::{Locate, Passwd};
#[test]
fn test_invalid_arg() {
@@ -26,6 +21,7 @@ fn test_capitalize() {
}
#[test]
+#[cfg(not(target_os = "openbsd"))]
fn test_long_format() {
let login = "root";
let pw: Passwd = Passwd::locate(login).unwrap();
@@ -35,8 +31,7 @@ fn test_long_format() {
let real_name = user_info.replace('&', &pw.name.capitalize());
let ts = TestScenario::new(util_name!());
ts.ucmd().arg("-l").arg(login).succeeds().stdout_is(format!(
- "Login name: {:<28}In real life: {}\nDirectory: {:<29}Shell: {}\n\n",
- login, real_name, user_dir, user_shell
+ "Login name: {login:<28}In real life: {real_name}\nDirectory: {user_dir:<29}Shell: {user_shell}\n\n"
));
ts.ucmd()
@@ -44,13 +39,13 @@ fn test_long_format() {
.arg(login)
.succeeds()
.stdout_is(format!(
- "Login name: {:<28}In real life: {1}\n\n",
- login, real_name
+ "Login name: {login:<28}In real life: {real_name}\n\n"
));
}
#[cfg(unix)]
#[test]
+#[cfg(not(target_os = "openbsd"))]
fn test_long_format_multiple_users() {
// multiple instances of one account we know exists,
// the account of the test runner,
@@ -78,6 +73,7 @@ fn test_long_format_wo_user() {
#[cfg(unix)]
#[test]
+#[cfg(not(target_os = "openbsd"))]
fn test_short_format_i() {
// allow whitespace variation
// * minor whitespace differences occur between platform built-in outputs; specifically, the number of trailing TABs may be variant
@@ -92,6 +88,7 @@ fn test_short_format_i() {
#[cfg(unix)]
#[test]
+#[cfg(not(target_os = "openbsd"))]
fn test_short_format_q() {
// allow whitespace variation
// * minor whitespace differences occur between platform built-in outputs; specifically, the number of trailing TABs may be variant
@@ -106,6 +103,7 @@ fn test_short_format_q() {
#[cfg(unix)]
#[test]
+#[cfg(not(target_os = "openbsd"))]
fn test_no_flag() {
let ts = TestScenario::new(util_name!());
let actual = ts.ucmd().succeeds().stdout_move_str();
diff --git a/tests/by-util/test_pr.rs b/tests/by-util/test_pr.rs
index 20abd1a24fcb9ec00a958d475fa9ee87a3c02f98..c886b6452e219f1c9d8d451a70f476c5b8c470b5 100644
--- a/tests/by-util/test_pr.rs
+++ b/tests/by-util/test_pr.rs
@@ -1,14 +1,14 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) Sdivide
-extern crate time;
-use crate::common::util::*;
+use crate::common::util::{TestScenario, UCommand};
+use chrono::{DateTime, Duration, Utc};
use std::fs::metadata;
-use time::macros::format_description;
-use time::Duration;
-use time::OffsetDateTime;
-const DATE_TIME_FORMAT: &[time::format_description::FormatItem] =
- format_description!("[month repr:short] [day] [hour]:[minute] [year]");
+const DATE_TIME_FORMAT: &str = "%b %d %H:%M %Y";
fn file_last_modified_time(ucmd: &UCommand, path: &str) -> String {
let tmp_dir_path = ucmd.get_full_fixture_path(path);
@@ -17,37 +17,41 @@ fn file_last_modified_time(ucmd: &UCommand, path: &str) -> String {
.map(|i| {
i.modified()
.map(|x| {
- let date_time: OffsetDateTime = x.into();
- let offset = OffsetDateTime::now_local().unwrap().offset();
- date_time
- .to_offset(offset)
- .format(&DATE_TIME_FORMAT)
- .unwrap()
+ let date_time: DateTime<Utc> = x.into();
+ date_time.format(DATE_TIME_FORMAT).to_string()
})
.unwrap_or_default()
})
.unwrap_or_default()
}
-fn all_minutes(from: OffsetDateTime, to: OffsetDateTime) -> Vec<String> {
- let to = to + Duration::minutes(1);
- // const FORMAT: &str = "%b %d %H:%M %Y";
+fn all_minutes(from: DateTime<Utc>, to: DateTime<Utc>) -> Vec<String> {
+ let to = to + Duration::try_minutes(1).unwrap();
let mut vec = vec![];
let mut current = from;
while current < to {
- vec.push(current.format(&DATE_TIME_FORMAT).unwrap());
- current += Duration::minutes(1);
+ vec.push(current.format(DATE_TIME_FORMAT).to_string());
+ current += Duration::try_minutes(1).unwrap();
}
vec
}
-fn valid_last_modified_template_vars(from: OffsetDateTime) -> Vec<Vec<(String, String)>> {
- all_minutes(from, OffsetDateTime::now_local().unwrap())
+fn valid_last_modified_template_vars(from: DateTime<Utc>) -> Vec<Vec<(String, String)>> {
+ all_minutes(from, Utc::now())
.into_iter()
.map(|time| vec![("{last_modified_time}".to_string(), time)])
.collect()
}
+#[test]
+fn test_invalid_flag() {
+ new_ucmd!()
+ .arg("--invalid-argument")
+ .fails()
+ .no_stdout()
+ .code_is(1);
+}
+
#[test]
fn test_without_any_options() {
let test_file_path = "test_one_page.log";
@@ -163,7 +167,7 @@ fn test_with_valid_page_ranges() {
scenario
.args(&["--pages=20:5", test_file_path])
.fails()
- .stderr_is("pr: invalid --pages argument '20:5'")
+ .stderr_is("pr: invalid --pages argument '20:5'\n")
.stdout_is("");
new_ucmd!()
.args(&["--pages=1:5", test_file_path])
@@ -172,17 +176,17 @@ fn test_with_valid_page_ranges() {
new_ucmd!()
.args(&["--pages=-1:5", test_file_path])
.fails()
- .stderr_is("pr: invalid --pages argument '-1:5'")
+ .stderr_is("pr: invalid --pages argument '-1:5'\n")
.stdout_is("");
new_ucmd!()
.args(&["--pages=1:-5", test_file_path])
.fails()
- .stderr_is("pr: invalid --pages argument '1:-5'")
+ .stderr_is("pr: invalid --pages argument '1:-5'\n")
.stdout_is("");
new_ucmd!()
.args(&["--pages=5:1", test_file_path])
.fails()
- .stderr_is("pr: invalid --pages argument '5:1'")
+ .stderr_is("pr: invalid --pages argument '5:1'\n")
.stdout_is("");
}
@@ -258,7 +262,7 @@ fn test_with_suppress_error_option() {
fn test_with_stdin() {
let expected_file_path = "stdin.log.expected";
let mut scenario = new_ucmd!();
- let start = OffsetDateTime::now_local().unwrap();
+ let start = Utc::now();
scenario
.pipe_in_fixture("stdin.log")
.args(&["--pages=1:2", "-n", "-"])
@@ -321,7 +325,7 @@ fn test_with_mpr() {
let expected_test_file_path = "mpr.log.expected";
let expected_test_file_path1 = "mpr1.log.expected";
let expected_test_file_path2 = "mpr2.log.expected";
- let start = OffsetDateTime::now_local().unwrap();
+ let start = Utc::now();
new_ucmd!()
.args(&["--pages=1:2", "-m", "-n", test_file_path, test_file_path1])
.succeeds()
@@ -330,7 +334,7 @@ fn test_with_mpr() {
&valid_last_modified_template_vars(start),
);
- let start = OffsetDateTime::now_local().unwrap();
+ let start = Utc::now();
new_ucmd!()
.args(&["--pages=2:4", "-m", "-n", test_file_path, test_file_path1])
.succeeds()
@@ -339,7 +343,7 @@ fn test_with_mpr() {
&valid_last_modified_template_vars(start),
);
- let start = OffsetDateTime::now_local().unwrap();
+ let start = Utc::now();
new_ucmd!()
.args(&[
"--pages=1:2",
@@ -364,13 +368,13 @@ fn test_with_mpr_and_column_options() {
new_ucmd!()
.args(&["--column=2", "-m", "-n", test_file_path])
.fails()
- .stderr_is("pr: cannot specify number of columns when printing in parallel")
+ .stderr_is("pr: cannot specify number of columns when printing in parallel\n")
.stdout_is("");
new_ucmd!()
.args(&["-a", "-m", "-n", test_file_path])
.fails()
- .stderr_is("pr: cannot specify both printing across and printing in parallel")
+ .stderr_is("pr: cannot specify both printing across and printing in parallel\n")
.stdout_is("");
}
@@ -414,10 +418,9 @@ fn test_with_pr_core_utils_tests() {
let mut scenario = new_ucmd!();
let input_file_path = input_file.first().unwrap();
let test_file_path = expected_file.first().unwrap();
- let value = file_last_modified_time(&scenario, test_file_path);
+ let value = file_last_modified_time(&scenario, input_file_path);
let mut arguments: Vec<&str> = flags
.split(' ')
- .into_iter()
.filter(|i| i.trim() != "")
.collect::<Vec<&str>>();
@@ -447,7 +450,7 @@ fn test_with_join_lines_option() {
let test_file_2 = "test.log";
let expected_file_path = "joined.log.expected";
let mut scenario = new_ucmd!();
- let start = OffsetDateTime::now_local().unwrap();
+ let start = Utc::now();
scenario
.args(&["+1:2", "-J", "-m", test_file_1, test_file_2])
.run()
diff --git a/tests/by-util/test_printenv.rs b/tests/by-util/test_printenv.rs
index 29ca24857e829d4eb3a78dd7584980aa270b7064..c9eb3c60eed642aa04339854eb578d25e4e9cd0c 100644
--- a/tests/by-util/test_printenv.rs
+++ b/tests/by-util/test_printenv.rs
@@ -1,27 +1,25 @@
-use crate::common::util::*;
-use std::env;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
#[test]
fn test_get_all() {
- let key = "KEY";
- env::set_var(key, "VALUE");
- assert_eq!(env::var(key), Ok("VALUE".to_string()));
-
TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
+ .env("HOME", "FOO")
+ .env("KEY", "VALUE")
.succeeds()
- .stdout_contains("HOME=")
+ .stdout_contains("HOME=FOO")
.stdout_contains("KEY=VALUE");
}
#[test]
fn test_get_var() {
- let key = "KEY";
- env::set_var(key, "VALUE");
- assert_eq!(env::var(key), Ok("VALUE".to_string()));
-
let result = TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
+ .env("KEY", "VALUE")
.arg("KEY")
.succeeds();
diff --git a/tests/by-util/test_printf.rs b/tests/by-util/test_printf.rs
index 77f64750cbba7cb3800ca34d6cc1295dac45dda0..7bf1fcfe5bf293775caed33333f1de69702f41c0 100644
--- a/tests/by-util/test_printf.rs
+++ b/tests/by-util/test_printf.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
#[test]
fn basic_literal() {
@@ -32,6 +36,11 @@ fn escaped_slash() {
.stdout_only("hello\\ world");
}
+#[test]
+fn unescaped_double_quote() {
+ new_ucmd!().args(&["\\\""]).succeeds().stdout_only("\"");
+}
+
#[test]
fn escaped_hex() {
new_ucmd!().args(&["\\x41"]).succeeds().stdout_only("A");
@@ -108,6 +117,15 @@ fn sub_b_string_handle_escapes() {
.stdout_only("hello \tworld");
}
+#[test]
+fn sub_b_string_validate_field_params() {
+ new_ucmd!()
+ .args(&["hello %7b", "world"])
+ .run()
+ .stdout_is("hello ")
+ .stderr_is("printf: %7b: invalid conversion specification\n");
+}
+
#[test]
fn sub_b_string_ignore_subs() {
new_ucmd!()
@@ -116,6 +134,31 @@ fn sub_b_string_ignore_subs() {
.stdout_only("hello world %% %i");
}
+#[test]
+fn sub_q_string_non_printable() {
+ new_ucmd!()
+ .args(&["non-printable: %q", "\"$test\""])
+ .succeeds()
+ .stdout_only("non-printable: '\"$test\"'");
+}
+
+#[test]
+fn sub_q_string_validate_field_params() {
+ new_ucmd!()
+ .args(&["hello %7q", "world"])
+ .run()
+ .stdout_is("hello ")
+ .stderr_is("printf: %7q: invalid conversion specification\n");
+}
+
+#[test]
+fn sub_q_string_special_non_printable() {
+ new_ucmd!()
+ .args(&["non-printable: %q", "test~"])
+ .succeeds()
+ .stdout_only("non-printable: test~");
+}
+
#[test]
fn sub_char() {
new_ucmd!()
@@ -124,6 +167,14 @@ fn sub_char() {
.stdout_only("the letter A");
}
+#[test]
+fn sub_char_from_string() {
+ new_ucmd!()
+ .args(&["%c%c%c", "five", "%", "oval"])
+ .succeeds()
+ .stdout_only("f%o");
+}
+
#[test]
fn sub_num_int() {
new_ucmd!()
@@ -186,6 +237,11 @@ fn sub_num_int_char_const_in() {
.args(&["ninety seven is %i", "'a"])
.succeeds()
.stdout_only("ninety seven is 97");
+
+ new_ucmd!()
+ .args(&["emoji is %i", "'🙃"])
+ .succeeds()
+ .stdout_only("emoji is 128579");
}
#[test]
@@ -220,6 +276,14 @@ fn sub_num_hex_upper() {
.stdout_only("thirty in hex is 1E");
}
+#[test]
+fn sub_num_hex_non_numerical() {
+ new_ucmd!()
+ .args(&["parameters need to be numbers %X", "%194"])
+ .fails()
+ .code_is(1);
+}
+
#[test]
fn sub_num_float() {
new_ucmd!()
@@ -245,7 +309,16 @@ fn sub_num_float_e_no_round() {
}
#[test]
-fn sub_num_float_round() {
+fn sub_num_float_round_to_one() {
+ new_ucmd!()
+ .args(&["one is %f", "0.9999995"])
+ .succeeds()
+ .stdout_only("one is 1.000000");
+}
+
+#[test]
+#[ignore = "Requires 'long double' precision floats to be used internally"]
+fn sub_num_float_round_to_two() {
new_ucmd!()
.args(&["two is %f", "1.9999995"])
.succeeds()
@@ -448,10 +521,7 @@ fn sub_any_specifiers_after_period() {
#[test]
fn unspecified_left_justify_is_1_width() {
- new_ucmd!()
- .args(&["%-o"]) //spell-checker:disable-line
- .succeeds()
- .stdout_only("0");
+ new_ucmd!().args(&["%-o"]).succeeds().stdout_only("0");
}
#[test]
@@ -465,7 +535,7 @@ fn sub_any_specifiers_after_second_param() {
#[test]
fn stop_after_additional_escape() {
new_ucmd!()
- .args(&["A%sC\\cD%sF", "B", "E"]) //spell-checker:disable-line
+ .args(&["A%sC\\cD%sF", "B", "E"])
.succeeds()
.stdout_only("ABC");
}
@@ -530,3 +600,177 @@ fn sub_general_round_float_leading_zeroes() {
.succeeds()
.stdout_only("1.00001");
}
+
+#[test]
+fn partial_float() {
+ new_ucmd!()
+ .args(&["%.2f is %s", "42.03x", "a lot"])
+ .fails()
+ .code_is(1)
+ .stdout_is("42.03 is a lot")
+ .stderr_is("printf: '42.03x': value not completely converted\n");
+}
+
+#[test]
+fn partial_integer() {
+ new_ucmd!()
+ .args(&["%d is %s", "42x23", "a lot"])
+ .fails()
+ .code_is(1)
+ .stdout_is("42 is a lot")
+ .stderr_is("printf: '42x23': value not completely converted\n");
+}
+
+#[test]
+fn test_overflow() {
+ new_ucmd!()
+ .args(&["%d", "36893488147419103232"])
+ .fails()
+ .code_is(1)
+ .stderr_is("printf: '36893488147419103232': Numerical result out of range\n");
+}
+
+#[test]
+fn partial_char() {
+ new_ucmd!()
+ .args(&["%d", "'abc"])
+ .fails()
+ .code_is(1)
+ .stdout_is("97")
+ .stderr_is(
+ "printf: warning: bc: character(s) following character constant have been ignored\n",
+ );
+}
+
+#[test]
+fn sub_alternative_lower_hex_0() {
+ new_ucmd!().args(&["%#x", "0"]).succeeds().stdout_only("0");
+}
+
+#[test]
+fn sub_alternative_lower_hex() {
+ new_ucmd!()
+ .args(&["%#x", "42"])
+ .succeeds()
+ .stdout_only("0x2a");
+}
+
+#[test]
+fn sub_alternative_upper_hex_0() {
+ new_ucmd!().args(&["%#X", "0"]).succeeds().stdout_only("0");
+}
+
+#[test]
+fn sub_alternative_upper_hex() {
+ new_ucmd!()
+ .args(&["%#X", "42"])
+ .succeeds()
+ .stdout_only("0X2A");
+}
+
+#[test]
+fn char_as_byte() {
+ new_ucmd!()
+ .args(&["%c", "🙃"])
+ .succeeds()
+ .no_stderr()
+ .stdout_is_bytes(b"\xf0");
+}
+
+#[test]
+fn no_infinite_loop() {
+ new_ucmd!().args(&["a", "b"]).succeeds().stdout_only("a");
+}
+
+#[test]
+fn pad_octal_with_prefix() {
+ new_ucmd!()
+ .args(&[">%#15.6o<", "0"])
+ .succeeds()
+ .stdout_only("> 000000<");
+
+ new_ucmd!()
+ .args(&[">%#15.6o<", "01"])
+ .succeeds()
+ .stdout_only("> 000001<");
+
+ new_ucmd!()
+ .args(&[">%#15.6o<", "01234"])
+ .succeeds()
+ .stdout_only("> 001234<");
+
+ new_ucmd!()
+ .args(&[">%#15.6o<", "012345"])
+ .succeeds()
+ .stdout_only("> 012345<");
+
+ new_ucmd!()
+ .args(&[">%#15.6o<", "0123456"])
+ .succeeds()
+ .stdout_only("> 0123456<");
+}
+
+#[test]
+fn pad_unsigned_zeroes() {
+ for format in ["%.3u", "%.3x", "%.3X", "%.3o"] {
+ new_ucmd!()
+ .args(&[format, "0"])
+ .succeeds()
+ .stdout_only("000");
+ }
+}
+
+#[test]
+fn pad_unsigned_three() {
+ for (format, expected) in [
+ ("%.3u", "003"),
+ ("%.3x", "003"),
+ ("%.3X", "003"),
+ ("%.3o", "003"),
+ ("%#.3x", "0x003"),
+ ("%#.3X", "0X003"),
+ ("%#.3o", "003"),
+ ] {
+ new_ucmd!()
+ .args(&[format, "3"])
+ .succeeds()
+ .stdout_only(expected);
+ }
+}
+
+#[test]
+fn pad_char() {
+ for (format, expected) in [("%3c", " X"), ("%1c", "X"), ("%-1c", "X"), ("%-3c", "X ")] {
+ new_ucmd!()
+ .args(&[format, "X"])
+ .succeeds()
+ .stdout_only(expected);
+ }
+}
+
+#[test]
+fn pad_string() {
+ for (format, expected) in [
+ ("%8s", " bottle"),
+ ("%-8s", "bottle "),
+ ("%6s", "bottle"),
+ ("%-6s", "bottle"),
+ ] {
+ new_ucmd!()
+ .args(&[format, "bottle"])
+ .succeeds()
+ .stdout_only(expected);
+ }
+}
+
+#[test]
+fn format_spec_zero_char_fails() {
+ // It is invalid to have the format spec '%0c'
+ new_ucmd!().args(&["%0c", "3"]).fails().code_is(1);
+}
+
+#[test]
+fn format_spec_zero_string_fails() {
+ // It is invalid to have the format spec '%0s'
+ new_ucmd!().args(&["%0s", "3"]).fails().code_is(1);
+}
diff --git a/tests/by-util/test_ptx.rs b/tests/by-util/test_ptx.rs
index 7372bb5cc8e7dd925ade6c860378d0360151e251..a106972ac295addcdfe3049f60ba2fea31e18a5a 100644
--- a/tests/by-util/test_ptx.rs
+++ b/tests/by-util/test_ptx.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
diff --git a/tests/by-util/test_pwd.rs b/tests/by-util/test_pwd.rs
index 0ae0cc909fa9a07d69368cb427016fab4c52be29..89341c0c33da150af513d6a93728ce871c923f96 100644
--- a/tests/by-util/test_pwd.rs
+++ b/tests/by-util/test_pwd.rs
@@ -1,8 +1,12 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (words) symdir somefakedir
use std::path::PathBuf;
-use crate::common::util::*;
+use crate::common::util::{TestScenario, UCommand};
#[test]
fn test_invalid_arg() {
@@ -27,7 +31,7 @@ fn test_deleted_dir() {
use std::process::Command;
let ts = TestScenario::new(util_name!());
- let at = ts.fixtures.clone();
+ let at = ts.fixtures;
let output = Command::new("sh")
.arg("-c")
.arg(format!(
@@ -60,7 +64,7 @@ fn symlinked_env() -> Env {
// Note: on Windows this requires admin permissions
at.symlink_dir("subdir", "symdir");
let root = PathBuf::from(at.root_dir_resolved());
- ucmd.raw.current_dir(root.join("symdir"));
+ ucmd.current_dir(root.join("symdir"));
#[cfg(not(windows))]
ucmd.env("PWD", root.join("symdir"));
Env {
@@ -116,7 +120,7 @@ fn test_symlinked_default_posix_p() {
.env("POSIXLY_CORRECT", "1")
.arg("-P")
.succeeds()
- .stdout_is(env.symdir + "\n");
+ .stdout_is(env.subdir + "\n");
}
#[cfg(not(windows))]
diff --git a/tests/by-util/test_readlink.rs b/tests/by-util/test_readlink.rs
index 2bc983b02908f2ab5e3702994afb1e7f0608aea6..973e30a35972aeaa24aa3367cbe6ccadc175e316 100644
--- a/tests/by-util/test_readlink.rs
+++ b/tests/by-util/test_readlink.rs
@@ -1,5 +1,9 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore regfile
-use crate::common::util::*;
+use crate::common::util::{get_root_path, TestScenario};
static GIBBERISH: &str = "supercalifragilisticexpialidocious";
@@ -29,8 +33,8 @@ fn test_canonicalize() {
let (at, mut ucmd) = at_and_ucmd!();
let actual = ucmd.arg("-f").arg(".").run().stdout_move_str();
let expect = at.root_dir_resolved() + "\n";
- println!("actual: {:?}", actual);
- println!("expect: {:?}", expect);
+ println!("actual: {actual:?}");
+ println!("expect: {expect:?}");
assert_eq!(actual, expect);
}
@@ -39,8 +43,8 @@ fn test_canonicalize_existing() {
let (at, mut ucmd) = at_and_ucmd!();
let actual = ucmd.arg("-e").arg(".").run().stdout_move_str();
let expect = at.root_dir_resolved() + "\n";
- println!("actual: {:?}", actual);
- println!("expect: {:?}", expect);
+ println!("actual: {actual:?}");
+ println!("expect: {expect:?}");
assert_eq!(actual, expect);
}
@@ -49,8 +53,8 @@ fn test_canonicalize_missing() {
let (at, mut ucmd) = at_and_ucmd!();
let actual = ucmd.arg("-m").arg(GIBBERISH).run().stdout_move_str();
let expect = path_concat!(at.root_dir_resolved(), GIBBERISH) + "\n";
- println!("actual: {:?}", actual);
- println!("expect: {:?}", expect);
+ println!("actual: {actual:?}");
+ println!("expect: {expect:?}");
assert_eq!(actual, expect);
}
@@ -61,8 +65,8 @@ fn test_long_redirection_to_current_dir() {
let dir = path_concat!(".", ..128);
let actual = ucmd.arg("-n").arg("-m").arg(dir).run().stdout_move_str();
let expect = at.root_dir_resolved();
- println!("actual: {:?}", actual);
- println!("expect: {:?}", expect);
+ println!("actual: {actual:?}");
+ println!("expect: {expect:?}");
assert_eq!(actual, expect);
}
@@ -77,8 +81,8 @@ fn test_long_redirection_to_root() {
.run()
.stdout_move_str();
let expect = get_root_path();
- println!("actual: {:?}", actual);
- println!("expect: {:?}", expect);
+ println!("actual: {actual:?}");
+ println!("expect: {expect:?}");
assert_eq!(actual, expect);
}
@@ -214,21 +218,21 @@ fn test_canonicalize_trailing_slash_regfile() {
.stdout_contains("regfile");
scene
.ucmd()
- .args(&["-fv", &format!("./{}/", name)])
+ .args(&["-fv", &format!("./{name}/")])
.fails()
.code_is(1)
.stderr_contains(NOT_A_DIRECTORY)
.no_stdout();
scene
.ucmd()
- .args(&["-fv", &format!("{}/more", name)])
+ .args(&["-fv", &format!("{name}/more")])
.fails()
.code_is(1)
.stderr_contains(NOT_A_DIRECTORY)
.no_stdout();
scene
.ucmd()
- .args(&["-fv", &format!("./{}/more/", name)])
+ .args(&["-fv", &format!("./{name}/more/")])
.fails()
.code_is(1)
.stderr_contains(NOT_A_DIRECTORY)
@@ -250,28 +254,28 @@ fn test_canonicalize_trailing_slash_subdir() {
.stdout_contains("subdir");
scene
.ucmd()
- .args(&["-f", &format!("./{}/", name)])
+ .args(&["-f", &format!("./{name}/")])
.succeeds()
.stdout_contains("subdir");
scene
.ucmd()
- .args(&["-f", &format!("{}/more", name)])
+ .args(&["-f", &format!("{name}/more")])
.succeeds()
.stdout_contains(path_concat!("subdir", "more"));
scene
.ucmd()
- .args(&["-f", &format!("./{}/more/", name)])
+ .args(&["-f", &format!("./{name}/more/")])
.succeeds()
.stdout_contains(path_concat!("subdir", "more"));
scene
.ucmd()
- .args(&["-f", &format!("{}/more/more2", name)])
+ .args(&["-f", &format!("{name}/more/more2")])
.fails()
.code_is(1)
.no_stdout();
scene
.ucmd()
- .args(&["-f", &format!("./{}/more/more2/", name)])
+ .args(&["-f", &format!("./{name}/more/more2/")])
.fails()
.code_is(1)
.no_stdout();
@@ -291,18 +295,18 @@ fn test_canonicalize_trailing_slash_missing() {
.stdout_contains("missing");
scene
.ucmd()
- .args(&["-f", &format!("./{}/", name)])
+ .args(&["-f", &format!("./{name}/")])
.succeeds()
.stdout_contains("missing");
scene
.ucmd()
- .args(&["-f", &format!("{}/more", name)])
+ .args(&["-f", &format!("{name}/more")])
.fails()
.code_is(1)
.no_stdout();
scene
.ucmd()
- .args(&["-f", &format!("./{}/more/", name)])
+ .args(&["-f", &format!("./{name}/more/")])
.fails()
.code_is(1)
.no_stdout();
diff --git a/tests/by-util/test_realpath.rs b/tests/by-util/test_realpath.rs
index fdbead59fa6ae2204deb36a7a7b29cf935ccae51..02ee76c6f40346bafde9e5f9dbbbf204d0ffaeb6 100644
--- a/tests/by-util/test_realpath.rs
+++ b/tests/by-util/test_realpath.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::{get_root_path, TestScenario};
#[cfg(windows)]
use regex::Regex;
@@ -192,7 +196,7 @@ fn test_realpath_existing() {
ucmd.arg("-e")
.arg(".")
.succeeds()
- .stdout_only(at.plus_as_string(&format!("{}\n", at.root_dir_resolved())));
+ .stdout_only(at.plus_as_string(format!("{}\n", at.root_dir_resolved())));
}
#[test]
@@ -239,7 +243,7 @@ fn test_realpath_when_symlink_is_absolute_and_enoent() {
.run()
.stdout_contains("\\dir2\\bar\n")
.stdout_contains("\\dir2\\baz\n")
- .stderr_is("realpath: dir1/foo2: No such file or directory");
+ .stderr_is("realpath: dir1/foo2: No such file or directory\n");
}
#[test]
@@ -255,8 +259,8 @@ fn test_realpath_when_symlink_part_is_missing() {
at.relative_symlink_file("../dir2/baz", "dir1/foo3");
at.symlink_file("dir3/bar", "dir1/foo4");
- let expect1 = format!("dir2{}bar", MAIN_SEPARATOR);
- let expect2 = format!("dir2{}baz", MAIN_SEPARATOR);
+ let expect1 = format!("dir2{MAIN_SEPARATOR}bar");
+ let expect2 = format!("dir2{MAIN_SEPARATOR}baz");
ucmd.args(&["dir1/foo1", "dir1/foo2", "dir1/foo3", "dir1/foo4"])
.run()
@@ -300,7 +304,7 @@ fn test_relative_base_not_prefix_of_relative_to() {
.succeeds();
#[cfg(windows)]
- result.stdout_matches(&Regex::new(r"^.*:\\usr\n.*:\\usr\\local$").unwrap());
+ result.stdout_matches(&Regex::new(r"^.*:\\usr\n.*:\\usr\\local\n$").unwrap());
#[cfg(not(windows))]
result.stdout_is("/usr\n/usr/local\n");
@@ -344,12 +348,12 @@ fn test_relative() {
#[cfg(not(windows))]
result.stdout_is("/tmp\n.\n");
#[cfg(windows)]
- result.stdout_matches(&Regex::new(r"^.*:\\tmp\n\.$").unwrap());
+ result.stdout_matches(&Regex::new(r"^.*:\\tmp\n\.\n$").unwrap());
new_ucmd!()
.args(&["-sm", "--relative-base=/", "--relative-to=/", "/", "/usr"])
.succeeds()
- .stdout_is(".\nusr\n"); // spell-checker:disable-line
+ .stdout_is(".\nusr\n");
let result = new_ucmd!()
.args(&["-sm", "--relative-base=/usr", "/tmp", "/usr"])
@@ -357,12 +361,12 @@ fn test_relative() {
#[cfg(not(windows))]
result.stdout_is("/tmp\n.\n");
#[cfg(windows)]
- result.stdout_matches(&Regex::new(r"^.*:\\tmp\n\.$").unwrap());
+ result.stdout_matches(&Regex::new(r"^.*:\\tmp\n\.\n$").unwrap());
new_ucmd!()
.args(&["-sm", "--relative-base=/", "/", "/usr"])
.succeeds()
- .stdout_is(".\nusr\n"); // spell-checker:disable-line
+ .stdout_is(".\nusr\n");
}
#[test]
diff --git a/tests/by-util/test_relpath.rs b/tests/by-util/test_relpath.rs
deleted file mode 100644
index 52b829fdf00d3ebdc0585c881f5bde25401a29e0..0000000000000000000000000000000000000000
--- a/tests/by-util/test_relpath.rs
+++ /dev/null
@@ -1,178 +0,0 @@
-use crate::common::util::*;
-use std::borrow::Cow;
-use std::path::Path;
-
-struct TestCase<'a> {
- from: &'a str,
- to: &'a str,
- expected: &'a str,
-}
-
-const TESTS: [TestCase; 10] = [
- TestCase {
- from: "A/B/C",
- to: "A",
- expected: "../..",
- },
- TestCase {
- from: "A/B/C",
- to: "A/B",
- expected: "..",
- },
- TestCase {
- from: "A/B/C",
- to: "A/B/C",
- expected: "",
- },
- TestCase {
- from: "A/B/C",
- to: "A/B/C/D",
- expected: "D",
- },
- TestCase {
- from: "A/B/C",
- to: "A/B/C/D/E",
- expected: "D/E",
- },
- TestCase {
- from: "A/B/C",
- to: "A/B/D",
- expected: "../D",
- },
- TestCase {
- from: "A/B/C",
- to: "A/B/D/E",
- expected: "../D/E",
- },
- TestCase {
- from: "A/B/C",
- to: "A/D",
- expected: "../../D",
- },
- TestCase {
- from: "A/B/C",
- to: "D/E/F",
- expected: "../../../D/E/F",
- },
- TestCase {
- from: "A/B/C",
- to: "A/D/E",
- expected: "../../D/E",
- },
-];
-
-#[allow(clippy::needless_lifetimes)]
-fn convert_path<'a>(path: &'a str) -> Cow<'a, str> {
- #[cfg(windows)]
- return path.replace('/', "\\").into();
- #[cfg(not(windows))]
- return path.into();
-}
-
-#[test]
-fn test_relpath_with_from_no_d() {
- let scene = TestScenario::new(util_name!());
- let at = &scene.fixtures;
-
- for test in &TESTS {
- let from: &str = &convert_path(test.from);
- let to: &str = &convert_path(test.to);
- let expected: &str = &convert_path(test.expected);
-
- at.mkdir_all(to);
- at.mkdir_all(from);
-
- scene
- .ucmd()
- .arg(to)
- .arg(from)
- .succeeds()
- .stdout_only(&format!("{}\n", expected));
- }
-}
-
-#[test]
-fn test_relpath_with_from_with_d() {
- let scene = TestScenario::new(util_name!());
- let at = &scene.fixtures;
-
- for test in &TESTS {
- let from: &str = &convert_path(test.from);
- let to: &str = &convert_path(test.to);
- let pwd = at.as_string();
- at.mkdir_all(to);
- at.mkdir_all(from);
-
- // d is part of subpath -> expect relative path
- let mut _result_stdout = scene
- .ucmd()
- .arg(to)
- .arg(from)
- .arg(&format!("-d{}", pwd))
- .succeeds()
- .stdout_move_str();
- // relax rules for windows test environment
- #[cfg(not(windows))]
- assert!(Path::new(&_result_stdout).is_relative());
-
- // d is not part of subpath -> expect absolute path
- _result_stdout = scene
- .ucmd()
- .arg(to)
- .arg(from)
- .arg("-dnon_existing") // spell-checker:disable-line
- .succeeds()
- .stdout_move_str();
- assert!(Path::new(&_result_stdout).is_absolute());
- }
-}
-
-#[test]
-fn test_relpath_no_from_no_d() {
- let scene = TestScenario::new(util_name!());
- let at = &scene.fixtures;
-
- for test in &TESTS {
- let to: &str = &convert_path(test.to);
- at.mkdir_all(to);
-
- let _result_stdout = scene.ucmd().arg(to).succeeds().stdout_move_str();
- #[cfg(not(windows))]
- assert_eq!(_result_stdout, format!("{}\n", to));
- // relax rules for windows test environment
- #[cfg(windows)]
- assert!(_result_stdout.ends_with(&format!("{}\n", to)));
- }
-}
-
-#[test]
-fn test_relpath_no_from_with_d() {
- let scene = TestScenario::new(util_name!());
- let at = &scene.fixtures;
-
- for test in &TESTS {
- let to: &str = &convert_path(test.to);
- let pwd = at.as_string();
- at.mkdir_all(to);
-
- // d is part of subpath -> expect relative path
- let _result_stdout = scene
- .ucmd()
- .arg(to)
- .arg(&format!("-d{}", pwd))
- .succeeds()
- .stdout_move_str();
- // relax rules for windows test environment
- #[cfg(not(windows))]
- assert!(Path::new(&_result_stdout).is_relative());
-
- // d is not part of subpath -> expect absolute path
- let result_stdout = scene
- .ucmd()
- .arg(to)
- .arg("-dnon_existing") // spell-checker:disable-line
- .succeeds()
- .stdout_move_str();
- assert!(Path::new(&result_stdout).is_absolute());
- }
-}
diff --git a/tests/by-util/test_rm.rs b/tests/by-util/test_rm.rs
index d11a6e37904f1e9dfe3a5b3ac17bbc2d378a8f82..65d631e4cd881dbe56ac346fcbd518de95d22b1c 100644
--- a/tests/by-util/test_rm.rs
+++ b/tests/by-util/test_rm.rs
@@ -1,6 +1,10 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::process::Stdio;
-use crate::common::util::*;
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
@@ -25,8 +29,7 @@ fn test_rm_failed() {
let file = "test_rm_one_file"; // Doesn't exist
ucmd.arg(file).fails().stderr_contains(&format!(
- "cannot remove '{}': No such file or directory",
- file
+ "cannot remove '{file}': No such file or directory"
));
}
@@ -55,6 +58,8 @@ fn test_rm_interactive() {
at.touch(file_a);
at.touch(file_b);
+ assert!(at.file_exists(file_a));
+ assert!(at.file_exists(file_b));
scene
.ucmd()
@@ -85,6 +90,11 @@ fn test_rm_force() {
let file_a = "test_rm_force_a";
let file_b = "test_rm_force_b";
+ at.touch(file_a);
+ at.touch(file_b);
+ assert!(at.file_exists(file_a));
+ assert!(at.file_exists(file_b));
+
ucmd.arg("-f")
.arg(file_a)
.arg(file_b)
@@ -101,6 +111,11 @@ fn test_rm_force_multiple() {
let file_a = "test_rm_force_a";
let file_b = "test_rm_force_b";
+ at.touch(file_a);
+ at.touch(file_b);
+ assert!(at.file_exists(file_a));
+ assert!(at.file_exists(file_b));
+
ucmd.arg("-f")
.arg("-f")
.arg("-f")
@@ -136,7 +151,7 @@ fn test_rm_empty_directory_verbose() {
.arg("-v")
.arg(dir)
.succeeds()
- .stdout_only(format!("removed directory '{}'\n", dir));
+ .stdout_only(format!("removed directory '{dir}'\n"));
assert!(!at.dir_exists(dir));
}
@@ -145,7 +160,7 @@ fn test_rm_empty_directory_verbose() {
fn test_rm_non_empty_directory() {
let (at, mut ucmd) = at_and_ucmd!();
let dir = "test_rm_non_empty_dir";
- let file_a = &format!("{}/test_rm_non_empty_file_a", dir);
+ let file_a = &format!("{dir}/test_rm_non_empty_file_a");
at.mkdir(dir);
at.touch(file_a);
@@ -153,7 +168,7 @@ fn test_rm_non_empty_directory() {
ucmd.arg("-d")
.arg(dir)
.fails()
- .stderr_contains(&format!("cannot remove '{}': Directory not empty", dir));
+ .stderr_contains(&format!("cannot remove '{dir}': Directory not empty"));
assert!(at.file_exists(file_a));
assert!(at.dir_exists(dir));
}
@@ -208,7 +223,20 @@ fn test_rm_directory_without_flag() {
ucmd.arg(dir)
.fails()
- .stderr_contains(&format!("cannot remove '{}': Is a directory", dir));
+ .stderr_contains(&format!("cannot remove '{dir}': Is a directory"));
+}
+
+#[test]
+#[cfg(windows)]
+// https://github.com/uutils/coreutils/issues/3200
+fn test_rm_directory_with_trailing_backslash() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let dir = "dir";
+
+ at.mkdir(dir);
+
+ ucmd.arg(".\\dir\\").arg("-rf").succeeds();
+ assert!(!at.dir_exists(dir));
}
#[test]
@@ -224,7 +252,7 @@ fn test_rm_verbose() {
.arg(file_a)
.arg(file_b)
.succeeds()
- .stdout_only(format!("removed '{}'\nremoved '{}'\n", file_a, file_b));
+ .stdout_only(format!("removed '{file_a}'\nremoved '{file_b}'\n"));
}
#[test]
@@ -259,7 +287,7 @@ fn test_rm_symlink_dir() {
.ucmd()
.arg(link)
.fails()
- .stderr_contains(&format!("cannot remove '{}': Is a directory", link));
+ .stderr_contains(&format!("cannot remove '{link}': Is a directory"));
assert!(at.dir_exists(link));
@@ -293,7 +321,7 @@ fn test_rm_no_operand() {
fn test_rm_verbose_slash() {
let (at, mut ucmd) = at_and_ucmd!();
let dir = "test_rm_verbose_slash_directory";
- let file_a = &format!("{}/test_rm_verbose_slash_file_a", dir);
+ let file_a = &format!("{dir}/test_rm_verbose_slash_file_a");
at.mkdir(dir);
at.touch(file_a);
@@ -307,11 +335,10 @@ fn test_rm_verbose_slash() {
ucmd.arg("-r")
.arg("-f")
.arg("-v")
- .arg(&format!("{}///", dir))
+ .arg(&format!("{dir}///"))
.succeeds()
.stdout_only(format!(
- "removed '{}'\nremoved directory '{}'\n",
- file_a_normalized, dir
+ "removed '{file_a_normalized}'\nremoved directory '{dir}'\n"
));
assert!(!at.dir_exists(dir));
@@ -351,6 +378,74 @@ fn test_rm_interactive_never() {
assert!(!at.file_exists(file_2));
}
+#[test]
+fn test_rm_interactive_missing_value() {
+ // `--interactive` is equivalent to `--interactive=always` or `-i`
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let file1 = "test_rm_interactive_missing_value_file1";
+ let file2 = "test_rm_interactive_missing_value_file2";
+
+ at.touch(file1);
+ at.touch(file2);
+
+ ucmd.arg("--interactive")
+ .arg(file1)
+ .arg(file2)
+ .pipe_in("y\ny")
+ .succeeds();
+
+ assert!(!at.file_exists(file1));
+ assert!(!at.file_exists(file2));
+}
+
+#[test]
+fn test_rm_interactive_once_prompt() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let file1 = "test_rm_interactive_once_recursive_prompt_file1";
+ let file2 = "test_rm_interactive_once_recursive_prompt_file2";
+ let file3 = "test_rm_interactive_once_recursive_prompt_file3";
+ let file4 = "test_rm_interactive_once_recursive_prompt_file4";
+
+ at.touch(file1);
+ at.touch(file2);
+ at.touch(file3);
+ at.touch(file4);
+
+ ucmd.arg("--interactive=once")
+ .arg(file1)
+ .arg(file2)
+ .arg(file3)
+ .arg(file4)
+ .pipe_in("y")
+ .succeeds()
+ .stderr_contains("remove 4 arguments?");
+
+ assert!(!at.file_exists(file1));
+ assert!(!at.file_exists(file2));
+ assert!(!at.file_exists(file3));
+ assert!(!at.file_exists(file4));
+}
+
+#[test]
+fn test_rm_interactive_once_recursive_prompt() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let file1 = "test_rm_interactive_once_recursive_prompt_file1";
+
+ at.touch(file1);
+
+ ucmd.arg("--interactive=once")
+ .arg("-r")
+ .arg(file1)
+ .pipe_in("y")
+ .succeeds()
+ .stderr_contains("remove 1 argument recursively?");
+
+ assert!(!at.file_exists(file1));
+}
+
#[test]
fn test_rm_descend_directory() {
// This test descends into each directory and deletes the files and folders inside of them
@@ -359,7 +454,7 @@ fn test_rm_descend_directory() {
// Needed for talking with stdin on platforms where CRLF or LF matters
const END_OF_LINE: &str = if cfg!(windows) { "\r\n" } else { "\n" };
- let yes = format!("y{}", END_OF_LINE);
+ let yes = format!("y{END_OF_LINE}");
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
@@ -400,7 +495,7 @@ fn test_rm_prompts() {
// Needed for talking with stdin on platforms where CRLF or LF matters
const END_OF_LINE: &str = if cfg!(windows) { "\r\n" } else { "\n" };
- let mut answers = vec![
+ let mut answers = [
"rm: descend into directory 'a'?",
"rm: remove write-protected regular empty file 'a/empty-no-write'?",
"rm: remove symbolic link 'a/slink'?",
@@ -414,7 +509,7 @@ fn test_rm_prompts() {
answers.sort();
- let yes = format!("y{}", END_OF_LINE);
+ let yes = format!("y{END_OF_LINE}");
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
@@ -463,7 +558,7 @@ fn test_rm_prompts() {
let mut trimmed_output = Vec::new();
for string in result.stderr_str().split("rm: ") {
if !string.is_empty() {
- let trimmed_string = format!("rm: {}", string).trim().to_string();
+ let trimmed_string = format!("rm: {string}").trim().to_string();
trimmed_output.push(trimmed_string);
}
}
@@ -484,7 +579,7 @@ fn test_rm_force_prompts_order() {
// Needed for talking with stdin on platforms where CRLF or LF matters
const END_OF_LINE: &str = if cfg!(windows) { "\r\n" } else { "\n" };
- let yes = format!("y{}", END_OF_LINE);
+ let yes = format!("y{END_OF_LINE}");
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
@@ -503,11 +598,8 @@ fn test_rm_force_prompts_order() {
child.try_write_in(yes.as_bytes()).unwrap();
let result = child.wait().unwrap();
- let string_output = result.stderr_str();
- assert_eq!(
- string_output.trim(),
- "rm: remove regular empty file 'empty'?"
- );
+ result.stderr_only("rm: remove regular empty file 'empty'? ");
+
assert!(!at.file_exists(empty_file));
at.touch(empty_file);
@@ -568,6 +660,21 @@ fn test_prompt_write_protected_no() {
assert!(at.file_exists(file_2));
}
+#[cfg(feature = "chmod")]
+#[test]
+fn test_remove_inaccessible_dir() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let dir_1 = "test_rm_protected";
+
+ at.mkdir(dir_1);
+
+ scene.ccmd("chmod").arg("0").arg(dir_1).succeeds();
+
+ scene.ucmd().arg("-rf").arg(dir_1).succeeds();
+ assert!(!at.dir_exists(dir_1));
+}
+
#[test]
#[cfg(not(windows))]
fn test_fifo_removal() {
@@ -583,3 +690,24 @@ fn test_fifo_removal() {
.timeout(Duration::from_secs(2))
.succeeds();
}
+
+#[test]
+#[cfg(any(unix, target_os = "wasi"))]
+#[cfg(not(target_os = "macos"))]
+fn test_non_utf8() {
+ use std::ffi::OsStr;
+ #[cfg(unix)]
+ use std::os::unix::ffi::OsStrExt;
+ #[cfg(target_os = "wasi")]
+ use std::os::wasi::ffi::OsStrExt;
+
+ let file = OsStr::from_bytes(b"not\xffutf8"); // spell-checker:disable-line
+
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ at.touch(file);
+ assert!(at.file_exists(file));
+
+ ucmd.arg(file).succeeds();
+ assert!(!at.file_exists(file));
+}
diff --git a/tests/by-util/test_rmdir.rs b/tests/by-util/test_rmdir.rs
index 4cee34bf8f6eae1866d53c3e9f487888c2aa6f86..086d43748ab20dcf5799a34487fd0edae0388683 100644
--- a/tests/by-util/test_rmdir.rs
+++ b/tests/by-util/test_rmdir.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
const DIR: &str = "dir";
const DIR_FILE: &str = "dir/file";
@@ -57,7 +61,7 @@ fn test_rmdir_nonempty_directory_no_parents() {
ucmd.arg(DIR)
.fails()
- .stderr_is(format!("rmdir: failed to remove 'dir': {}", NOT_EMPTY));
+ .stderr_is(format!("rmdir: failed to remove 'dir': {NOT_EMPTY}\n"));
assert!(at.dir_exists(DIR));
}
@@ -70,8 +74,7 @@ fn test_rmdir_nonempty_directory_with_parents() {
at.touch(NESTED_DIR_FILE);
ucmd.arg("-p").arg(NESTED_DIR).fails().stderr_is(format!(
- "rmdir: failed to remove 'dir/ect/ory': {}",
- NOT_EMPTY
+ "rmdir: failed to remove 'dir/ect/ory': {NOT_EMPTY}\n"
));
assert!(at.dir_exists(NESTED_DIR));
@@ -119,8 +122,7 @@ fn test_rmdir_not_a_directory() {
.fails()
.no_stdout()
.stderr_is(format!(
- "rmdir: failed to remove 'file': {}",
- NOT_A_DIRECTORY
+ "rmdir: failed to remove 'file': {NOT_A_DIRECTORY}\n"
));
}
@@ -152,8 +154,7 @@ fn test_verbose_multi() {
rmdir: removing directory, 'dir'\n",
)
.stderr_is(format!(
- "rmdir: failed to remove 'does_not_exist': {}",
- NOT_FOUND
+ "rmdir: failed to remove 'does_not_exist': {NOT_FOUND}\n"
));
}
@@ -171,23 +172,18 @@ fn test_verbose_nested_failure() {
"rmdir: removing directory, 'dir/ect/ory'\n\
rmdir: removing directory, 'dir/ect'\n",
)
- .stderr_is(format!("rmdir: failed to remove 'dir/ect': {}", NOT_EMPTY));
+ .stderr_is(format!("rmdir: failed to remove 'dir/ect': {NOT_EMPTY}\n"));
}
#[cfg(unix)]
#[test]
fn test_rmdir_ignore_nonempty_no_permissions() {
- use std::fs;
-
let (at, mut ucmd) = at_and_ucmd!();
// We make the *parent* dir read-only to prevent deleting the dir in it.
at.mkdir_all("dir/ect/ory");
at.touch("dir/ect/ory/file");
- let dir_ect = at.plus("dir/ect");
- let mut perms = fs::metadata(&dir_ect).unwrap().permissions();
- perms.set_readonly(true);
- fs::set_permissions(&dir_ect, perms.clone()).unwrap();
+ at.set_mode("dir/ect", 0o555);
// rmdir should now get a permissions error that it interprets as
// a non-empty error.
@@ -199,8 +195,7 @@ fn test_rmdir_ignore_nonempty_no_permissions() {
assert!(at.dir_exists("dir/ect/ory"));
// Politely restore permissions for cleanup
- perms.set_readonly(false);
- fs::set_permissions(&dir_ect, perms).unwrap();
+ at.set_mode("dir/ect", 0o755);
}
#[test]
@@ -211,8 +206,7 @@ fn test_rmdir_remove_symlink_file() {
at.symlink_file("file", "fl");
ucmd.arg("fl/").fails().stderr_is(format!(
- "rmdir: failed to remove 'fl/': {}",
- NOT_A_DIRECTORY
+ "rmdir: failed to remove 'fl/': {NOT_A_DIRECTORY}\n"
));
}
@@ -227,7 +221,7 @@ fn test_rmdir_remove_symlink_dir() {
ucmd.arg("dl/")
.fails()
- .stderr_is("rmdir: failed to remove 'dl/': Symbolic link not followed");
+ .stderr_is("rmdir: failed to remove 'dl/': Symbolic link not followed\n");
}
#[cfg(any(target_os = "linux", target_os = "android"))]
@@ -239,5 +233,5 @@ fn test_rmdir_remove_symlink_dangling() {
ucmd.arg("dl/")
.fails()
- .stderr_is("rmdir: failed to remove 'dl/': Symbolic link not followed");
+ .stderr_is("rmdir: failed to remove 'dl/': Symbolic link not followed\n");
}
diff --git a/tests/by-util/test_runcon.rs b/tests/by-util/test_runcon.rs
index dd4445625bc5a4ba07534273d90d786aa9d19c8f..8e8b9b6b56254c2dec441cdd4456fcc9d0d9fb64 100644
--- a/tests/by-util/test_runcon.rs
+++ b/tests/by-util/test_runcon.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (jargon) xattributes
#![cfg(feature = "feat_selinux")]
@@ -133,7 +137,7 @@ fn custom_context() {
}
fn get_sestatus_context(output: &[u8]) -> &str {
- let re = regex::bytes::Regex::new(r#"Current context:\s*(\S+)\s*"#)
+ let re = regex::bytes::Regex::new(r"Current context:\s*(\S+)\s*")
.expect("Invalid regular expression");
output
diff --git a/tests/by-util/test_seq.rs b/tests/by-util/test_seq.rs
index fa73b29373c2972f011cc1835638ed6f882c9b80..a8bd1fb8359640430e43029de9e840859e232b13 100644
--- a/tests/by-util/test_seq.rs
+++ b/tests/by-util/test_seq.rs
@@ -1,5 +1,9 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore lmnop xlmnop
-use crate::common::util::*;
+use crate::common::util::TestScenario;
use std::process::Stdio;
#[test]
@@ -7,6 +11,14 @@ fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
}
+#[test]
+fn test_no_args() {
+ new_ucmd!()
+ .fails()
+ .code_is(1)
+ .stderr_contains("missing operand");
+}
+
#[test]
fn test_hex_rejects_sign_after_identifier() {
new_ucmd!()
@@ -36,18 +48,12 @@ fn test_hex_rejects_sign_after_identifier() {
.args(&["-0x-123ABC"])
.fails()
.no_stdout()
- .stderr_contains(
- "Found argument '-0' which wasn't expected, or isn't valid in this context",
- )
- .stderr_contains("For more information try '--help'");
+ .stderr_contains("unexpected argument '-0' found");
new_ucmd!()
.args(&["-0x+123ABC"])
.fails()
.no_stdout()
- .stderr_contains(
- "Found argument '-0' which wasn't expected, or isn't valid in this context",
- )
- .stderr_contains("For more information try '--help'");
+ .stderr_contains("unexpected argument '-0' found");
}
#[test]
@@ -214,10 +220,13 @@ fn test_separator_and_terminator() {
#[test]
fn test_equalize_widths() {
- new_ucmd!()
- .args(&["-w", "5", "10"])
- .run()
- .stdout_is("05\n06\n07\n08\n09\n10\n");
+ let args = ["-w", "--equal-width"];
+ for arg in args {
+ new_ucmd!()
+ .args(&[arg, "5", "10"])
+ .run()
+ .stdout_is("05\n06\n07\n08\n09\n10\n");
+ }
}
#[test]
@@ -614,11 +623,21 @@ fn test_neg_inf() {
run(&["--", "-inf", "0"], b"-inf\n-inf\n-inf\n");
}
+#[test]
+fn test_neg_infinity() {
+ run(&["--", "-infinity", "0"], b"-inf\n-inf\n-inf\n");
+}
+
#[test]
fn test_inf() {
run(&["inf"], b"1\n2\n3\n");
}
+#[test]
+fn test_infinity() {
+ run(&["infinity"], b"1\n2\n3\n");
+}
+
#[test]
fn test_inf_width() {
run(
@@ -739,6 +758,33 @@ fn test_format_option() {
.stdout_only("0.00\n0.10\n0.20\n0.30\n0.40\n0.50\n");
}
+#[test]
+#[ignore = "Need issue #6233 to be fixed"]
+fn test_auto_precision() {
+ new_ucmd!()
+ .args(&["1", "0x1p-1", "2"])
+ .succeeds()
+ .stdout_only("1\n1.5\n2\n");
+}
+
+#[test]
+#[ignore = "Need issue #6234 to be fixed"]
+fn test_undefined() {
+ new_ucmd!()
+ .args(&["1e-9223372036854775808"])
+ .succeeds()
+ .no_output();
+}
+
+#[test]
+#[ignore = "Need issue #6235 to be fixed"]
+fn test_invalid_float_point_fail_properly() {
+ new_ucmd!()
+ .args(&["66000e000000000000000000000000000000000000000000000000000009223372036854775807"])
+ .fails()
+ .stdout_only(""); // might need to be updated
+}
+
#[test]
fn test_invalid_zero_increment_value() {
new_ucmd!()
@@ -747,3 +793,37 @@ fn test_invalid_zero_increment_value() {
.no_stdout()
.usage_error("invalid Zero increment value: '0'");
}
+
+#[test]
+fn test_power_of_ten_display() {
+ new_ucmd!()
+ .args(&["-f", "%.2g", "10", "10"])
+ .succeeds()
+ .stdout_only("10\n");
+}
+
+#[test]
+fn test_default_g_precision() {
+ new_ucmd!()
+ .args(&["-f", "%010g", "1e5", "1e5"])
+ .succeeds()
+ .stdout_only("0000100000\n");
+ new_ucmd!()
+ .args(&["-f", "%010g", "1e6", "1e6"])
+ .succeeds()
+ .stdout_only("000001e+06\n");
+}
+
+#[test]
+fn test_invalid_format() {
+ new_ucmd!()
+ .args(&["-f", "%%g", "1"])
+ .fails()
+ .no_stdout()
+ .stderr_contains("format '%%g' has no % directive");
+ new_ucmd!()
+ .args(&["-f", "%g%g", "1"])
+ .fails()
+ .no_stdout()
+ .stderr_contains("format '%g%g' has too many % directives");
+}
diff --git a/tests/by-util/test_shred.rs b/tests/by-util/test_shred.rs
index 0780411f670dd87ba7503389e2947b3e1b30d5aa..82e421839aea0644bedc5409f5f64816f57408e1 100644
--- a/tests/by-util/test_shred.rs
+++ b/tests/by-util/test_shred.rs
@@ -1,12 +1,98 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore wipesync
+
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
}
+#[test]
+fn test_invalid_remove_arg() {
+ new_ucmd!().arg("--remove=unknown").fails().code_is(1);
+}
+
+#[test]
+fn test_ambiguous_remove_arg() {
+ new_ucmd!().arg("--remove=wip").fails().code_is(1);
+}
+
+#[test]
+fn test_shred() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let file = "test_shred";
+ let file_original_content = "test_shred file content";
+
+ at.write(file, file_original_content);
+
+ ucmd.arg(file).succeeds();
+
+ // File exists
+ assert!(at.file_exists(file));
+ // File is obfuscated
+ assert!(at.read_bytes(file) != file_original_content.as_bytes());
+}
+
#[test]
fn test_shred_remove() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let file = "test_shred_remove";
+ at.touch(file);
+
+ ucmd.arg("--remove").arg(file).succeeds();
+
+ // File was deleted
+ assert!(!at.file_exists(file));
+}
+
+#[test]
+fn test_shred_remove_unlink() {
+ // spell-checker:disable-next-line
+ for argument in ["--remove=unlink", "--remove=unlin", "--remove=u"] {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let file = "test_shred_remove_unlink";
+ at.touch(file);
+ ucmd.arg(argument).arg(file).succeeds();
+ // File was deleted
+ assert!(!at.file_exists(file));
+ }
+}
+
+#[test]
+fn test_shred_remove_wipe() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let file = "test_shred_remove_wipe";
+ at.touch(file);
+
+ ucmd.arg("--remove=wipe").arg(file).succeeds();
+
+ // File was deleted
+ assert!(!at.file_exists(file));
+}
+
+#[test]
+fn test_shred_remove_wipesync() {
+ // spell-checker:disable-next-line
+ for argument in ["--remove=wipesync", "--remove=wipesyn", "--remove=wipes"] {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let file = "test_shred_remove_wipesync";
+ at.touch(file);
+ ucmd.arg(argument).arg(file).succeeds();
+ // File was deleted
+ assert!(!at.file_exists(file));
+ }
+}
+
+#[test]
+fn test_shred_u() {
let scene = TestScenario::new(util_name!());
let at = &scene.fixtures;
@@ -18,14 +104,13 @@ fn test_shred_remove() {
at.touch(file_b);
// Shred file_a.
- scene.ucmd().arg("-u").arg(file_a).run();
+ scene.ucmd().arg("-u").arg(file_a).succeeds();
// file_a was deleted, file_b exists.
assert!(!at.file_exists(file_a));
assert!(at.file_exists(file_b));
}
-#[cfg(not(target_os = "freebsd"))]
#[test]
fn test_shred_force() {
let scene = TestScenario::new(util_name!());
@@ -52,3 +137,71 @@ fn test_shred_force() {
// file_a was deleted.
assert!(!at.file_exists(file));
}
+
+#[test]
+fn test_hex() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let file = "test_hex";
+
+ at.touch(file);
+
+ ucmd.arg("--size=0x10").arg(file).succeeds();
+}
+
+#[test]
+fn test_shred_empty() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ let file_a = "test_shred_remove_a";
+
+ at.touch(file_a);
+
+ // Shred file_a and verify that, as it is empty, it doesn't have "pass 1/3 (random)"
+ scene
+ .ucmd()
+ .arg("-uv")
+ .arg(file_a)
+ .succeeds()
+ .stderr_does_not_contain("1/3 (random)");
+
+ assert!(!at.file_exists(file_a));
+
+ // if the file isn't empty, we should have random
+ at.touch(file_a);
+ at.write(file_a, "1");
+ scene
+ .ucmd()
+ .arg("-uv")
+ .arg(file_a)
+ .succeeds()
+ .stderr_contains("1/3 (random)");
+
+ assert!(!at.file_exists(file_a));
+}
+
+#[test]
+#[cfg(all(unix, feature = "chmod"))]
+fn test_shred_fail_no_perm() {
+ use std::path::Path;
+
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let dir = "dir";
+
+ let file = "test_shred_remove_a";
+
+ let binding = Path::new("dir").join(file);
+ let path = binding.to_str().unwrap();
+ at.mkdir(dir);
+ at.touch(path);
+ scene.ccmd("chmod").arg("a-w").arg(dir).succeeds();
+
+ scene
+ .ucmd()
+ .arg("-uv")
+ .arg(path)
+ .fails()
+ .stderr_contains("Couldn't rename to");
+}
diff --git a/tests/by-util/test_shuf.rs b/tests/by-util/test_shuf.rs
index 39a7a640b6d90a22b1e4a97f652a29e2fc4df358..3208eadb4e10db0d3515192b1600e366c08e360e 100644
--- a/tests/by-util/test_shuf.rs
+++ b/tests/by-util/test_shuf.rs
@@ -1,4 +1,10 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+// spell-checker:ignore (ToDO) unwritable
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
@@ -10,7 +16,7 @@ fn test_output_is_random_permutation() {
let input_seq = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let input = input_seq
.iter()
- .map(|x| x.to_string())
+ .map(ToString::to_string)
.collect::<Vec<String>>()
.join("\n");
@@ -28,6 +34,28 @@ fn test_output_is_random_permutation() {
assert_eq!(result_seq, input_seq, "Output is not a permutation");
}
+#[test]
+fn test_explicit_stdin_file() {
+ let input_seq = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+ let input = input_seq
+ .iter()
+ .map(ToString::to_string)
+ .collect::<Vec<String>>()
+ .join("\n");
+
+ let result = new_ucmd!().arg("-").pipe_in(input.as_bytes()).succeeds();
+ result.no_stderr();
+
+ let mut result_seq: Vec<i32> = result
+ .stdout_str()
+ .split('\n')
+ .filter(|x| !x.is_empty())
+ .map(|x| x.parse().unwrap())
+ .collect();
+ result_seq.sort_unstable();
+ assert_eq!(result_seq, input_seq, "Output is not a permutation");
+}
+
#[test]
fn test_zero_termination() {
let input_seq = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
@@ -44,6 +72,215 @@ fn test_zero_termination() {
assert_eq!(result_seq, input_seq, "Output is not a permutation");
}
+#[test]
+fn test_zero_termination_multi() {
+ let input_seq = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+ let result = new_ucmd!().arg("-z").arg("-z").arg("-i1-10").succeeds();
+ result.no_stderr();
+
+ let mut result_seq: Vec<i32> = result
+ .stdout_str()
+ .split('\0')
+ .filter(|x| !x.is_empty())
+ .map(|x| x.parse().unwrap())
+ .collect();
+ result_seq.sort_unstable();
+ assert_eq!(result_seq, input_seq, "Output is not a permutation");
+}
+
+#[test]
+fn test_very_large_range() {
+ let num_samples = 10;
+ let result = new_ucmd!()
+ .arg("-n")
+ .arg(num_samples.to_string())
+ .arg("-i0-1234567890")
+ .succeeds();
+ result.no_stderr();
+
+ let result_seq: Vec<isize> = result
+ .stdout_str()
+ .split('\n')
+ .filter(|x| !x.is_empty())
+ .map(|x| x.parse().unwrap())
+ .collect();
+ assert_eq!(result_seq.len(), num_samples, "Miscounted output length!");
+ assert!(
+ result_seq.iter().all(|x| (0..=1234567890).contains(x)),
+ "Output includes element not from range: {}",
+ result.stdout_str()
+ );
+}
+
+#[test]
+fn test_very_large_range_offset() {
+ let num_samples = 10;
+ let result = new_ucmd!()
+ .arg("-n")
+ .arg(num_samples.to_string())
+ .arg("-i1234567890-2147483647")
+ .succeeds();
+ result.no_stderr();
+
+ let result_seq: Vec<isize> = result
+ .stdout_str()
+ .split('\n')
+ .filter(|x| !x.is_empty())
+ .map(|x| x.parse().unwrap())
+ .collect();
+ assert_eq!(result_seq.len(), num_samples, "Miscounted output length!");
+ assert!(
+ result_seq
+ .iter()
+ .all(|x| (1234567890..=2147483647).contains(x)),
+ "Output includes element not from range: {}",
+ result.stdout_str()
+ );
+}
+
+#[test]
+fn test_range_repeat_no_overflow_1_max() {
+ let upper_bound = usize::MAX;
+ let result = new_ucmd!()
+ .arg("-rn1")
+ .arg(&format!("-i1-{upper_bound}"))
+ .succeeds();
+ result.no_stderr();
+
+ let result_seq: Vec<usize> = result
+ .stdout_str()
+ .split('\n')
+ .filter(|x| !x.is_empty())
+ .map(|x| x.parse().unwrap())
+ .collect();
+ assert_eq!(result_seq.len(), 1, "Miscounted output length!");
+}
+
+#[test]
+fn test_range_repeat_no_overflow_0_max_minus_1() {
+ let upper_bound = usize::MAX - 1;
+ let result = new_ucmd!()
+ .arg("-rn1")
+ .arg(&format!("-i0-{upper_bound}"))
+ .succeeds();
+ result.no_stderr();
+
+ let result_seq: Vec<usize> = result
+ .stdout_str()
+ .split('\n')
+ .filter(|x| !x.is_empty())
+ .map(|x| x.parse().unwrap())
+ .collect();
+ assert_eq!(result_seq.len(), 1, "Miscounted output length!");
+}
+
+#[test]
+fn test_range_permute_no_overflow_1_max() {
+ let upper_bound = usize::MAX;
+ let result = new_ucmd!()
+ .arg("-n1")
+ .arg(&format!("-i1-{upper_bound}"))
+ .succeeds();
+ result.no_stderr();
+
+ let result_seq: Vec<usize> = result
+ .stdout_str()
+ .split('\n')
+ .filter(|x| !x.is_empty())
+ .map(|x| x.parse().unwrap())
+ .collect();
+ assert_eq!(result_seq.len(), 1, "Miscounted output length!");
+}
+
+#[test]
+fn test_range_permute_no_overflow_0_max_minus_1() {
+ let upper_bound = usize::MAX - 1;
+ let result = new_ucmd!()
+ .arg("-n1")
+ .arg(&format!("-i0-{upper_bound}"))
+ .succeeds();
+ result.no_stderr();
+
+ let result_seq: Vec<usize> = result
+ .stdout_str()
+ .split('\n')
+ .filter(|x| !x.is_empty())
+ .map(|x| x.parse().unwrap())
+ .collect();
+ assert_eq!(result_seq.len(), 1, "Miscounted output length!");
+}
+
+#[test]
+fn test_range_permute_no_overflow_0_max() {
+ // NOTE: This is different from GNU shuf!
+ // GNU shuf accepts -i0-MAX-1 and -i1-MAX, but not -i0-MAX.
+ // This feels like a bug in GNU shuf.
+ let upper_bound = usize::MAX;
+ let result = new_ucmd!()
+ .arg("-n1")
+ .arg(&format!("-i0-{upper_bound}"))
+ .succeeds();
+ result.no_stderr();
+
+ let result_seq: Vec<usize> = result
+ .stdout_str()
+ .split('\n')
+ .filter(|x| !x.is_empty())
+ .map(|x| x.parse().unwrap())
+ .collect();
+ assert_eq!(result_seq.len(), 1, "Miscounted output length!");
+}
+
+#[test]
+fn test_very_high_range_full() {
+ let input_seq = vec![
+ 2147483641, 2147483642, 2147483643, 2147483644, 2147483645, 2147483646, 2147483647,
+ ];
+ let result = new_ucmd!().arg("-i2147483641-2147483647").succeeds();
+ result.no_stderr();
+
+ let mut result_seq: Vec<isize> = result
+ .stdout_str()
+ .split('\n')
+ .filter(|x| !x.is_empty())
+ .map(|x| x.parse().unwrap())
+ .collect();
+ result_seq.sort_unstable();
+ assert_eq!(result_seq, input_seq, "Output is not a permutation");
+}
+
+#[test]
+fn test_range_repeat() {
+ let num_samples = 500;
+ let result = new_ucmd!()
+ .arg("-r")
+ .arg("-n")
+ .arg(num_samples.to_string())
+ .arg("-i12-34")
+ .succeeds();
+ result.no_stderr();
+
+ let result_seq: Vec<isize> = result
+ .stdout_str()
+ .split('\n')
+ .filter(|x| !x.is_empty())
+ .map(|x| x.parse().unwrap())
+ .collect();
+ assert_eq!(result_seq.len(), num_samples, "Miscounted output length!");
+ assert!(
+ result_seq.iter().all(|x| (12..=34).contains(x)),
+ "Output includes element not from range: {}",
+ result.stdout_str()
+ );
+}
+
+#[test]
+fn test_empty_input() {
+ let result = new_ucmd!().pipe_in(vec![]).succeeds();
+ result.no_stderr();
+ result.no_stdout();
+}
+
#[test]
fn test_echo() {
let input_seq = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
@@ -52,7 +289,7 @@ fn test_echo() {
.args(
&input_seq
.iter()
- .map(|x| x.to_string())
+ .map(ToString::to_string)
.collect::<Vec<String>>(),
)
.succeeds();
@@ -68,13 +305,64 @@ fn test_echo() {
assert_eq!(result_seq, input_seq, "Output is not a permutation");
}
+#[test]
+fn test_echo_multi() {
+ let result = new_ucmd!()
+ .arg("-e")
+ .arg("a")
+ .arg("b")
+ .arg("-e")
+ .arg("c")
+ .succeeds();
+ result.no_stderr();
+
+ let mut result_seq: Vec<String> = result
+ .stdout_str()
+ .split('\n')
+ .filter(|x| !x.is_empty())
+ .map(|x| x.into())
+ .collect();
+ result_seq.sort_unstable();
+ assert_eq!(result_seq, ["a", "b", "c"], "Output is not a permutation");
+}
+
+#[test]
+fn test_echo_postfix() {
+ let result = new_ucmd!().arg("a").arg("b").arg("c").arg("-e").succeeds();
+ result.no_stderr();
+
+ let mut result_seq: Vec<String> = result
+ .stdout_str()
+ .split('\n')
+ .filter(|x| !x.is_empty())
+ .map(|x| x.into())
+ .collect();
+ result_seq.sort_unstable();
+ assert_eq!(result_seq, ["a", "b", "c"], "Output is not a permutation");
+}
+
+#[test]
+fn test_echo_short_collapsed_zero() {
+ let result = new_ucmd!().arg("-ez").arg("a").arg("b").arg("c").succeeds();
+ result.no_stderr();
+
+ let mut result_seq: Vec<String> = result
+ .stdout_str()
+ .split('\0')
+ .filter(|x| !x.is_empty())
+ .map(|x| x.parse().unwrap())
+ .collect();
+ result_seq.sort_unstable();
+ assert_eq!(result_seq, ["a", "b", "c"], "Output is not a permutation");
+}
+
#[test]
fn test_head_count() {
let repeat_limit = 5;
- let input_seq = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+ let input_seq = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let input = input_seq
.iter()
- .map(|x| x.to_string())
+ .map(ToString::to_string)
.collect::<Vec<String>>()
.join("\n");
@@ -99,18 +387,196 @@ fn test_head_count() {
);
}
+#[test]
+fn test_zero_head_count_pipe() {
+ let result = new_ucmd!().arg("-n0").pipe_in(vec![]).succeeds();
+ // Output must be completely empty, not even a newline!
+ result.no_output();
+}
+
+#[test]
+fn test_zero_head_count_pipe_explicit() {
+ let result = new_ucmd!().arg("-n0").arg("-").pipe_in(vec![]).succeeds();
+ result.no_output();
+}
+
+#[test]
+fn test_zero_head_count_file_unreadable() {
+ new_ucmd!()
+ .arg("-n0")
+ .arg("/invalid/unreadable")
+ .pipe_in(vec![])
+ .succeeds()
+ .no_output();
+}
+
+#[test]
+fn test_zero_head_count_file_touch_output_negative() {
+ new_ucmd!()
+ .arg("-n0")
+ .arg("-o")
+ .arg("/invalid/unwritable")
+ .pipe_in(vec![])
+ .fails()
+ .stderr_contains("failed to open '/invalid/unwritable' for writing:");
+}
+
+#[test]
+fn test_zero_head_count_file_touch_output_positive_new() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-n0", "-o", "file"]).succeeds().no_output();
+ assert_eq!(
+ at.read_bytes("file"),
+ Vec::new(),
+ "Output file must exist and be completely empty"
+ );
+}
+
+#[test]
+fn test_zero_head_count_file_touch_output_positive_existing() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.touch("file");
+ ucmd.args(&["-n0", "-o", "file"]).succeeds().no_output();
+ assert_eq!(
+ at.read_bytes("file"),
+ Vec::new(),
+ "Output file must exist and be completely empty"
+ );
+}
+
+#[test]
+fn test_zero_head_count_echo() {
+ new_ucmd!()
+ .arg("-n0")
+ .arg("-e")
+ .arg("hello")
+ .pipe_in(vec![])
+ .succeeds()
+ .no_output();
+}
+
+#[test]
+fn test_zero_head_count_range() {
+ new_ucmd!().arg("-n0").arg("-i4-8").succeeds().no_output();
+}
+
+#[test]
+fn test_head_count_multi_big_then_small() {
+ let repeat_limit = 5;
+ let input_seq = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+ let input = input_seq
+ .iter()
+ .map(ToString::to_string)
+ .collect::<Vec<String>>()
+ .join("\n");
+
+ let result = new_ucmd!()
+ .arg("-n")
+ .arg((repeat_limit + 1).to_string())
+ .arg("-n")
+ .arg(repeat_limit.to_string())
+ .pipe_in(input.as_bytes())
+ .succeeds();
+ result.no_stderr();
+
+ let result_seq: Vec<i32> = result
+ .stdout_str()
+ .split('\n')
+ .filter(|x| !x.is_empty())
+ .map(|x| x.parse().unwrap())
+ .collect();
+ assert_eq!(result_seq.len(), repeat_limit, "Output is not limited");
+ assert!(
+ result_seq.iter().all(|x| input_seq.contains(x)),
+ "Output includes element not from input: {}",
+ result.stdout_str()
+ );
+}
+
+#[test]
+fn test_head_count_multi_small_then_big() {
+ let repeat_limit = 5;
+ let input_seq = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+ let input = input_seq
+ .iter()
+ .map(ToString::to_string)
+ .collect::<Vec<String>>()
+ .join("\n");
+
+ let result = new_ucmd!()
+ .arg("-n")
+ .arg(repeat_limit.to_string())
+ .arg("-n")
+ .arg((repeat_limit + 1).to_string())
+ .pipe_in(input.as_bytes())
+ .succeeds();
+ result.no_stderr();
+
+ let result_seq: Vec<i32> = result
+ .stdout_str()
+ .split('\n')
+ .filter(|x| !x.is_empty())
+ .map(|x| x.parse().unwrap())
+ .collect();
+ assert_eq!(result_seq.len(), repeat_limit, "Output is not limited");
+ assert!(
+ result_seq.iter().all(|x| input_seq.contains(x)),
+ "Output includes element not from input: {}",
+ result.stdout_str()
+ );
+}
+
#[test]
fn test_repeat() {
let repeat_limit = 15000;
- let input_seq = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+ let input_seq = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+ let input = input_seq
+ .iter()
+ .map(ToString::to_string)
+ .collect::<Vec<String>>()
+ .join("\n");
+
+ let result = new_ucmd!()
+ .arg("-r")
+ .args(&["-n", &repeat_limit.to_string()])
+ .pipe_in(input.as_bytes())
+ .succeeds();
+ result.no_stderr();
+
+ let result_seq: Vec<i32> = result
+ .stdout_str()
+ .split('\n')
+ .filter(|x| !x.is_empty())
+ .map(|x| x.parse().unwrap())
+ .collect();
+ assert_eq!(
+ result_seq.len(),
+ repeat_limit,
+ "Output is not repeating forever"
+ );
+ assert!(
+ result_seq.iter().all(|x| input_seq.contains(x)),
+ "Output includes element not from input: {:?}",
+ result_seq
+ .iter()
+ .filter(|x| !input_seq.contains(x))
+ .collect::<Vec<&i32>>()
+ );
+}
+
+#[test]
+fn test_repeat_multi() {
+ let repeat_limit = 15000;
+ let input_seq = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let input = input_seq
.iter()
- .map(|x| x.to_string())
+ .map(ToString::to_string)
.collect::<Vec<String>>()
.join("\n");
let result = new_ucmd!()
.arg("-r")
+ .arg("-r") // The only difference to test_repeat()
.args(&["-n", &repeat_limit.to_string()])
.pipe_in(input.as_bytes())
.succeeds();
@@ -194,6 +660,40 @@ fn test_shuf_invalid_input_range_three() {
.stderr_contains("invalid input range: 'b'");
}
+#[test]
+fn test_shuf_multiple_input_ranges() {
+ new_ucmd!()
+ .args(&["-i", "2-9", "-i", "2-9"])
+ .fails()
+ .stderr_contains("--input-range")
+ .stderr_contains("cannot be used multiple times");
+}
+
+#[test]
+fn test_shuf_multiple_outputs() {
+ new_ucmd!()
+ .args(&["-o", "file_a", "-o", "file_b"])
+ .fails()
+ .stderr_contains("--output")
+ .stderr_contains("cannot be used multiple times");
+}
+
+#[test]
+fn test_shuf_two_input_files() {
+ new_ucmd!()
+ .args(&["file_a", "file_b"])
+ .fails()
+ .stderr_contains("unexpected argument 'file_b' found");
+}
+
+#[test]
+fn test_shuf_three_input_files() {
+ new_ucmd!()
+ .args(&["file_a", "file_b", "file_c"])
+ .fails()
+ .stderr_contains("unexpected argument 'file_b' found");
+}
+
#[test]
fn test_shuf_invalid_input_line_count() {
new_ucmd!()
@@ -217,3 +717,84 @@ fn test_shuf_multiple_input_line_count() {
.count();
assert_eq!(result_count, 5, "Output should have 5 items");
}
+
+#[test]
+fn test_shuf_repeat_empty_range() {
+ new_ucmd!()
+ .arg("-ri4-3")
+ .fails()
+ .no_stdout()
+ .stderr_only("shuf: no lines to repeat\n");
+}
+
+#[test]
+fn test_shuf_repeat_empty_echo() {
+ new_ucmd!()
+ .arg("-re")
+ .fails()
+ .no_stdout()
+ .stderr_only("shuf: no lines to repeat\n");
+}
+
+#[test]
+fn test_shuf_repeat_empty_input() {
+ new_ucmd!()
+ .arg("-r")
+ .pipe_in("")
+ .fails()
+ .no_stdout()
+ .stderr_only("shuf: no lines to repeat\n");
+}
+
+#[test]
+fn test_range_one_elem() {
+ new_ucmd!()
+ .arg("-i5-5")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("5\n");
+}
+
+#[test]
+fn test_range_empty() {
+ new_ucmd!().arg("-i5-4").succeeds().no_output();
+}
+
+#[test]
+fn test_range_empty_minus_one() {
+ new_ucmd!()
+ .arg("-i5-3")
+ .fails()
+ .no_stdout()
+ .stderr_only("shuf: invalid input range: '5-3'\n");
+}
+
+#[test]
+fn test_range_repeat_one_elem() {
+ new_ucmd!()
+ .arg("-n1")
+ .arg("-ri5-5")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("5\n");
+}
+
+#[test]
+fn test_range_repeat_empty() {
+ new_ucmd!()
+ .arg("-n1")
+ .arg("-ri5-4")
+ .fails()
+ .no_stdout()
+ .stderr_only("shuf: no lines to repeat\n");
+}
+
+#[test]
+fn test_range_repeat_empty_minus_one() {
+ new_ucmd!()
+ .arg("-n1")
+ .arg("-ri5-3")
+ .fails()
+ .no_stdout()
+ .stderr_only("shuf: invalid input range: '5-3'\n");
+}
diff --git a/tests/by-util/test_sleep.rs b/tests/by-util/test_sleep.rs
index b6b573508c963bc17dc844020f8f748cef71f531..dd99c74060b80ac06da4d641922b32210bf7858f 100644
--- a/tests/by-util/test_sleep.rs
+++ b/tests/by-util/test_sleep.rs
@@ -1,5 +1,11 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use rstest::rstest;
+
// spell-checker:ignore dont
-use crate::common::util::*;
+use crate::common::util::TestScenario;
use std::time::{Duration, Instant};
@@ -8,11 +14,11 @@ fn test_invalid_time_interval() {
new_ucmd!()
.arg("xyz")
.fails()
- .usage_error("invalid time interval 'xyz'");
+ .usage_error("invalid time interval 'xyz': Invalid input: xyz");
new_ucmd!()
.args(&["--", "-1"])
.fails()
- .usage_error("invalid time interval '-1'");
+ .usage_error("invalid time interval '-1': Number was negative");
}
#[test]
@@ -129,29 +135,98 @@ fn test_sleep_wrong_time() {
new_ucmd!().args(&["0.1s", "abc"]).fails();
}
-// TODO These tests would obviously block for a very long time. We
-// only want to verify that there is no error here, so we could just
-// figure out a way to terminate the child process after a short
-// period of time.
+#[test]
+fn test_sleep_when_single_input_exceeds_max_duration_then_no_error() {
+ let mut child = new_ucmd!()
+ .arg(format!("{}", u64::MAX as u128 + 1))
+ .timeout(Duration::from_secs(10))
+ .run_no_wait();
+
+ #[cfg(unix)]
+ child
+ .delay(100)
+ .kill()
+ .make_assertion()
+ .with_current_output()
+ .signal_is(9) // make sure it was us who terminated the process
+ .no_output();
+ #[cfg(windows)]
+ child
+ .delay(100)
+ .kill()
+ .make_assertion()
+ .with_current_output()
+ .failure()
+ .no_output();
+}
-// #[test]
-#[allow(dead_code)]
-fn test_dont_overflow() {
+#[test]
+fn test_sleep_when_multiple_inputs_exceed_max_duration_then_no_error() {
+ let mut child = new_ucmd!()
+ .arg(format!("{}", u64::MAX))
+ .arg("1")
+ .timeout(Duration::from_secs(10))
+ .run_no_wait();
+
+ #[cfg(unix)]
+ child
+ .delay(100)
+ .kill()
+ .make_assertion()
+ .with_current_output()
+ .signal_is(9) // make sure it was us who terminated the process
+ .no_output();
+ #[cfg(windows)]
+ child
+ .delay(100)
+ .kill()
+ .make_assertion()
+ .with_current_output()
+ .failure()
+ .no_output();
+}
+
+#[rstest]
+#[case::whitespace_prefix(" 0.1s")]
+#[case::multiple_whitespace_prefix(" 0.1s")]
+#[case::whitespace_suffix("0.1s ")]
+#[case::mixed_newlines_spaces_tabs("\n\t0.1s \n ")]
+fn test_sleep_when_input_has_whitespace_then_no_error(#[case] input: &str) {
new_ucmd!()
- .arg("9223372036854775808d")
+ .arg(input)
+ .timeout(Duration::from_secs(10))
.succeeds()
- .no_stderr()
- .no_stdout();
+ .no_output();
}
-// #[test]
-#[allow(dead_code)]
-fn test_sum_overflow() {
+#[rstest]
+#[case::only_space(" ")]
+#[case::only_tab("\t")]
+#[case::only_newline("\n")]
+fn test_sleep_when_input_has_only_whitespace_then_error(#[case] input: &str) {
new_ucmd!()
- .args(&["100000000000000d", "100000000000000d", "100000000000000d"])
- .succeeds()
- .no_stderr()
- .no_stdout();
+ .arg(input)
+ .timeout(Duration::from_secs(10))
+ .fails()
+ .usage_error(format!(
+ "invalid time interval '{input}': Found only whitespace in input"
+ ));
+}
+
+#[test]
+fn test_sleep_when_multiple_input_some_with_error_then_shows_all_errors() {
+ let expected = "invalid time interval 'abc': Invalid input: abc\n\
+ sleep: invalid time interval '1years': Invalid time unit: 'years' at position 2\n\
+ sleep: invalid time interval ' ': Found only whitespace in input";
+
+ // Even if one of the arguments is valid, but the rest isn't, we should still fail and exit early.
+ // So, the timeout of 10 seconds ensures we haven't executed `thread::sleep` with the only valid
+ // interval of `100000.0` seconds.
+ new_ucmd!()
+ .args(&["abc", "100000.0", "1years", " "])
+ .timeout(Duration::from_secs(10))
+ .fails()
+ .usage_error(expected);
}
#[test]
@@ -159,5 +234,5 @@ fn test_negative_interval() {
new_ucmd!()
.args(&["--", "-1"])
.fails()
- .usage_error("invalid time interval '-1'");
+ .usage_error("invalid time interval '-1': Number was negative");
}
diff --git a/tests/by-util/test_sort.rs b/tests/by-util/test_sort.rs
index ce05634fbdb4c4a54bc59f8ac74387ca9f6dbd46..a37a01ec60be04c63ab430029a488020b1b80215 100644
--- a/tests/by-util/test_sort.rs
+++ b/tests/by-util/test_sort.rs
@@ -1,28 +1,28 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (words) ints
use std::time::Duration;
-use crate::common::util::*;
+use crate::common::util::TestScenario;
fn test_helper(file_name: &str, possible_args: &[&str]) {
for args in possible_args {
new_ucmd!()
- .arg(format!("{}.txt", file_name))
+ .arg(format!("{file_name}.txt"))
.args(&args.split_whitespace().collect::<Vec<&str>>())
.succeeds()
- .stdout_is_fixture(format!("{}.expected", file_name));
+ .stdout_is_fixture(format!("{file_name}.expected"));
new_ucmd!()
- .arg(format!("{}.txt", file_name))
+ .arg(format!("{file_name}.txt"))
.arg("--debug")
.args(&args.split_whitespace().collect::<Vec<&str>>())
.succeeds()
- .stdout_is_fixture(format!("{}.expected.debug", file_name));
+ .stdout_is_fixture(format!("{file_name}.expected.debug"));
}
}
@@ -31,27 +31,27 @@ fn test_buffer_sizes() {
let buffer_sizes = ["0", "50K", "50k", "1M", "100M"];
for buffer_size in &buffer_sizes {
TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.arg("-n")
.arg("-S")
.arg(buffer_size)
.arg("ext_sort.txt")
.succeeds()
.stdout_is_fixture("ext_sort.expected");
+ }
- #[cfg(not(target_pointer_width = "32"))]
- {
- let buffer_sizes = ["1000G", "10T"];
- for buffer_size in &buffer_sizes {
- TestScenario::new(util_name!())
- .ucmd_keepenv()
- .arg("-n")
- .arg("-S")
- .arg(buffer_size)
- .arg("ext_sort.txt")
- .succeeds()
- .stdout_is_fixture("ext_sort.expected");
- }
+ #[cfg(not(target_pointer_width = "32"))]
+ {
+ let buffer_sizes = ["1000G", "10T"];
+ for buffer_size in &buffer_sizes {
+ TestScenario::new(util_name!())
+ .ucmd()
+ .arg("-n")
+ .arg("-S")
+ .arg(buffer_size)
+ .arg("ext_sort.txt")
+ .succeeds()
+ .stdout_is_fixture("ext_sort.expected");
}
}
}
@@ -63,16 +63,15 @@ fn test_invalid_buffer_size() {
.arg("asd")
.fails()
.code_is(2)
- .stderr_only("sort: invalid --buffer-size argument 'asd'");
+ .stderr_only("sort: invalid --buffer-size argument 'asd'\n");
new_ucmd!()
.arg("-S")
.arg("100f")
.fails()
.code_is(2)
- .stderr_only("sort: invalid suffix in --buffer-size argument '100f'");
+ .stderr_only("sort: invalid suffix in --buffer-size argument '100f'\n");
- #[cfg(not(target_pointer_width = "128"))]
new_ucmd!()
.arg("-n")
.arg("-S")
@@ -80,7 +79,7 @@ fn test_invalid_buffer_size() {
.arg("ext_sort.txt")
.fails()
.code_is(2)
- .stderr_only("sort: --buffer-size argument '1Y' too large");
+ .stderr_only("sort: --buffer-size argument '1Y' too large\n");
#[cfg(target_pointer_width = "32")]
{
@@ -94,7 +93,7 @@ fn test_invalid_buffer_size() {
.fails()
.code_is(2)
.stderr_only(format!(
- "sort: --buffer-size argument '{}' too large",
+ "sort: --buffer-size argument '{}' too large\n",
buffer_size
));
}
@@ -126,7 +125,16 @@ fn test_ext_sort_zero_terminated() {
#[test]
fn test_months_whitespace() {
- test_helper("months-whitespace", &["-M", "--month-sort", "--sort=month"]);
+ test_helper(
+ "months-whitespace",
+ &[
+ "-M",
+ "--month-sort",
+ "--sort=month",
+ "--sort=mont",
+ "--sort=m",
+ ],
+ );
}
#[test]
@@ -134,11 +142,47 @@ fn test_version_empty_lines() {
test_helper("version-empty-lines", &["-V", "--version-sort"]);
}
+#[test]
+fn test_version_sort_unstable() {
+ new_ucmd!()
+ .arg("--sort=version")
+ .pipe_in("0.1\n0.02\n0.2\n0.002\n0.3\n")
+ .succeeds()
+ .stdout_is("0.1\n0.002\n0.02\n0.2\n0.3\n");
+ new_ucmd!()
+ .arg("--sort=versio") // spell-checker:disable-line
+ .pipe_in("0.1\n0.02\n0.2\n0.002\n0.3\n")
+ .succeeds()
+ .stdout_is("0.1\n0.002\n0.02\n0.2\n0.3\n");
+ new_ucmd!()
+ .arg("--sort=v")
+ .pipe_in("0.1\n0.02\n0.2\n0.002\n0.3\n")
+ .succeeds()
+ .stdout_is("0.1\n0.002\n0.02\n0.2\n0.3\n");
+}
+
+#[test]
+fn test_version_sort_stable() {
+ new_ucmd!()
+ .arg("--stable")
+ .arg("--sort=version")
+ .pipe_in("0.1\n0.02\n0.2\n0.002\n0.3\n")
+ .succeeds()
+ .stdout_is("0.1\n0.02\n0.2\n0.002\n0.3\n");
+}
+
#[test]
fn test_human_numeric_whitespace() {
test_helper(
"human-numeric-whitespace",
- &["-h", "--human-numeric-sort", "--sort=human-numeric"],
+ &[
+ "-h",
+ "--human-numeric-sort",
+ "--sort=human-numeric",
+ "--sort=human-numeri", // spell-checker:disable-line
+ "--sort=human",
+ "--sort=h",
+ ],
);
}
@@ -158,7 +202,14 @@ fn test_ext_sort_as64_bailout() {
fn test_multiple_decimals_general() {
test_helper(
"multiple_decimals_general",
- &["-g", "--general-numeric-sort", "--sort=general-numeric"],
+ &[
+ "-g",
+ "--general-numeric-sort",
+ "--sort=general-numeric",
+ "--sort=general-numeri", // spell-checker:disable-line
+ "--sort=general",
+ "--sort=g",
+ ],
);
}
@@ -166,7 +217,7 @@ fn test_multiple_decimals_general() {
fn test_multiple_decimals_numeric() {
test_helper(
"multiple_decimals_numeric",
- &["-n", "--numeric-sort", "--sort=numeric"],
+ &["-n", "--numeric-sort", "--sort=numeric", "--sort=n"],
);
}
@@ -529,7 +580,7 @@ fn test_keys_invalid_field() {
new_ucmd!()
.args(&["-k", "1."])
.fails()
- .stderr_only("sort: failed to parse key '1.': failed to parse character index '': cannot parse integer from empty string");
+ .stderr_only("sort: failed to parse key '1.': failed to parse character index '': cannot parse integer from empty string\n");
}
#[test]
@@ -537,7 +588,7 @@ fn test_keys_invalid_field_option() {
new_ucmd!()
.args(&["-k", "1.1x"])
.fails()
- .stderr_only("sort: failed to parse key '1.1x': invalid option: 'x'");
+ .stderr_only("sort: failed to parse key '1.1x': invalid option: 'x'\n");
}
#[test]
@@ -545,7 +596,7 @@ fn test_keys_invalid_field_zero() {
new_ucmd!()
.args(&["-k", "0.1"])
.fails()
- .stderr_only("sort: failed to parse key '0.1': field index can not be 0");
+ .stderr_only("sort: failed to parse key '0.1': field index can not be 0\n");
}
#[test]
@@ -553,7 +604,7 @@ fn test_keys_invalid_char_zero() {
new_ucmd!()
.args(&["-k", "1.0"])
.fails()
- .stderr_only("sort: failed to parse key '1.0': invalid character index 0 for the start position of a field");
+ .stderr_only("sort: failed to parse key '1.0': invalid character index 0 for the start position of a field\n");
}
#[test]
@@ -765,7 +816,13 @@ fn test_pipe() {
#[test]
fn test_check() {
- for diagnose_arg in ["-c", "--check", "--check=diagnose-first"] {
+ for diagnose_arg in [
+ "-c",
+ "--check",
+ "--check=diagnose-first",
+ "--check=diagnose",
+ "--check=d",
+ ] {
new_ucmd!()
.arg(diagnose_arg)
.arg("check_fail.txt")
@@ -783,25 +840,46 @@ fn test_check() {
#[test]
fn test_check_silent() {
- for silent_arg in ["-C", "--check=silent", "--check=quiet"] {
+ for silent_arg in [
+ "-C",
+ "--check=silent",
+ "--check=quiet",
+ "--check=silen", // spell-checker:disable-line
+ "--check=quie", // spell-checker:disable-line
+ "--check=s",
+ "--check=q",
+ ] {
new_ucmd!()
.arg(silent_arg)
.arg("check_fail.txt")
.fails()
.stdout_is("");
+ new_ucmd!()
+ .arg(silent_arg)
+ .arg("empty.txt")
+ .succeeds()
+ .no_output();
}
}
#[test]
fn test_check_unique() {
- // Due to a clap bug the combination "-cu" does not work. "-c -u" works.
- // See https://github.com/clap-rs/clap/issues/2624
new_ucmd!()
.args(&["-c", "-u"])
.pipe_in("A\nA\n")
.fails()
.code_is(1)
- .stderr_only("sort: -:2: disorder: A");
+ .stderr_only("sort: -:2: disorder: A\n");
+}
+
+#[test]
+fn test_check_unique_combined() {
+ new_ucmd!()
+ .args(&["-cu"])
+ .pipe_in("A\nA\n")
+ .fails()
+ .code_is(1)
+ .stderr_only("sort: -:2: disorder: A\n");
}
#[test]
@@ -810,21 +888,21 @@ fn test_dictionary_and_nonprinting_conflicts() {
for restricted_arg in ["d", "i"] {
for conflicting_arg in &conflicting_args {
new_ucmd!()
- .arg(&format!("-{}{}", restricted_arg, conflicting_arg))
+ .arg(&format!("-{restricted_arg}{conflicting_arg}"))
.fails();
}
for conflicting_arg in &conflicting_args {
new_ucmd!()
.args(&[
- format!("-{}", restricted_arg).as_str(),
+ format!("-{restricted_arg}").as_str(),
"-k",
- &format!("1,1{}", conflicting_arg),
+ &format!("1,1{conflicting_arg}"),
])
.succeeds();
}
for conflicting_arg in &conflicting_args {
new_ucmd!()
- .args(&["-k", &format!("1{},1{}", restricted_arg, conflicting_arg)])
+ .args(&["-k", &format!("1{restricted_arg},1{conflicting_arg}")])
.fails();
}
}
@@ -847,9 +925,9 @@ fn test_nonexistent_file() {
.code_is(2)
.stderr_only(
#[cfg(not(windows))]
- "sort: cannot read: nonexistent.txt: No such file or directory",
+ "sort: cannot read: nonexistent.txt: No such file or directory\n",
#[cfg(windows)]
- "sort: cannot read: nonexistent.txt: The system cannot find the file specified.",
+ "sort: cannot read: nonexistent.txt: The system cannot find the file specified.\n",
);
}
@@ -915,10 +993,11 @@ fn test_compress_merge() {
}
#[test]
+#[cfg(not(target_os = "android"))]
fn test_compress_fail() {
#[cfg(not(windows))]
TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.args(&[
"ext_sort.txt",
"-n",
@@ -928,13 +1007,13 @@ fn test_compress_fail() {
"10",
])
.fails()
- .stderr_only("sort: couldn't execute compress program: errno 2");
+ .stderr_only("sort: couldn't execute compress program: errno 2\n");
// With coverage, it fails with a different error:
// "thread 'main' panicked at 'called `Option::unwrap()` on ...
// So, don't check the output
#[cfg(windows)]
TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.args(&[
"ext_sort.txt",
"-n",
@@ -949,7 +1028,7 @@ fn test_compress_fail() {
#[test]
fn test_merge_batches() {
TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.timeout(Duration::from_secs(120))
.args(&["ext_sort.txt", "-n", "-S", "150b"])
.succeeds()
@@ -959,7 +1038,7 @@ fn test_merge_batches() {
#[test]
fn test_merge_batch_size() {
TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.arg("--batch-size=2")
.arg("-m")
.arg("--unique")
@@ -993,7 +1072,7 @@ fn test_conflict_check_out() {
.fails()
.stderr_contains(
// the rest of the message might be subject to change
- "error: The argument",
+ "error: the argument",
);
}
}
@@ -1018,9 +1097,9 @@ fn test_verifies_out_file() {
.code_is(2)
.stderr_only(
#[cfg(not(windows))]
- "sort: open failed: nonexistent_dir/nonexistent_file: No such file or directory",
+ "sort: open failed: nonexistent_dir/nonexistent_file: No such file or directory\n",
#[cfg(windows)]
- "sort: open failed: nonexistent_dir/nonexistent_file: The system cannot find the path specified.",
+ "sort: open failed: nonexistent_dir/nonexistent_file: The system cannot find the path specified.\n",
);
}
}
@@ -1047,7 +1126,7 @@ fn test_verifies_input_files() {
.args(&["/dev/random", "nonexistent_file"])
.fails()
.code_is(2)
- .stderr_is("sort: cannot read: nonexistent_file: No such file or directory");
+ .stderr_is("sort: cannot read: nonexistent_file: No such file or directory\n");
}
#[test]
@@ -1067,7 +1146,7 @@ fn test_output_is_input() {
at.touch("file");
at.append("file", input);
scene
- .ucmd_keepenv()
+ .ucmd()
.args(&["-m", "-u", "-o", "file", "file", "file", "file"])
.succeeds();
assert_eq!(at.read("file"), input);
@@ -1126,7 +1205,7 @@ fn test_tmp_files_deleted_on_sigint() {
for _ in 0..40 {
let lines = rand_pcg::Pcg32::seed_from_u64(123)
.sample_iter(rand::distributions::uniform::Uniform::new(0, 10000))
- .take(100000)
+ .take(100_000)
.map(|x| x.to_string() + "\n")
.collect::<String>();
file.write_all(lines.as_bytes()).unwrap();
@@ -1161,3 +1240,8 @@ fn test_tmp_files_deleted_on_sigint() {
fn test_same_sort_mode_twice() {
new_ucmd!().args(&["-k", "2n,2n", "empty.txt"]).succeeds();
}
+
+#[test]
+fn test_args_override() {
+ new_ucmd!().args(&["-f", "-f"]).pipe_in("foo").succeeds();
+}
diff --git a/tests/by-util/test_split.rs b/tests/by-util/test_split.rs
index 2ff448a79637b9b798ed9a8fde17c79a0cd00746..79c5151724c321f1d37821b31d1b112591051cde 100644
--- a/tests/by-util/test_split.rs
+++ b/tests/by-util/test_split.rs
@@ -1,15 +1,14 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
-// spell-checker:ignore xzaaa sixhundredfiftyonebytes ninetyonebytes threebytes asciilowercase fghij klmno pqrst uvwxyz fivelines twohundredfortyonebytes onehundredlines nbbbb
-extern crate rand;
-extern crate regex;
-
-use self::rand::{thread_rng, Rng};
-use self::regex::Regex;
-use crate::common::util::*;
-use rand::SeedableRng;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore xzaaa sixhundredfiftyonebytes ninetyonebytes threebytes asciilowercase ghijkl mnopq rstuv wxyz fivelines twohundredfortyonebytes onehundredlines nbbbb dxen ncccc rlimit NOFILE
+
+use crate::common::util::{AtPath, TestScenario};
+use rand::{thread_rng, Rng, SeedableRng};
+use regex::Regex;
+#[cfg(any(target_os = "linux", target_os = "android"))]
+use rlimit::Resource;
#[cfg(not(windows))]
use std::env;
use std::path::Path;
@@ -124,6 +123,15 @@ fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
}
+#[test]
+fn test_split_non_existing_file() {
+ new_ucmd!()
+ .arg("non-existing")
+ .fails()
+ .code_is(1)
+ .stderr_is("split: cannot open 'non-existing' for reading: No such file or directory\n");
+}
+
#[test]
fn test_split_default() {
let (at, mut ucmd) = at_and_ucmd!();
@@ -173,6 +181,22 @@ fn test_split_str_prefixed_chunks_by_bytes() {
assert_eq!(glob.collate(), at.read_bytes(name));
}
+/// Test short bytes option concatenated with value
+#[test]
+fn test_split_by_bytes_short_concatenated_with_value() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let name = "split_by_bytes_short_concatenated_with_value";
+ RandomFile::new(&at, name).add_bytes(10000);
+ ucmd.args(&["-b1000", name]).succeeds();
+
+ let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]$");
+ assert_eq!(glob.count(), 10);
+ for filename in glob.collect() {
+ assert_eq!(glob.directory.metadata(&filename).len(), 1000);
+ }
+ assert_eq!(glob.collate(), at.read_bytes(name));
+}
+
// This is designed to test what happens when the desired part size is not a
// multiple of the buffer size and we hopefully don't overshoot the desired part
// size.
@@ -234,11 +258,30 @@ fn test_split_additional_suffix() {
}
#[test]
-fn test_additional_suffix_no_slash() {
+fn test_additional_suffix_dir_separator() {
+ #[cfg(unix)]
new_ucmd!()
.args(&["--additional-suffix", "a/b"])
.fails()
.usage_error("invalid suffix 'a/b', contains directory separator");
+
+ #[cfg(windows)]
+ new_ucmd!()
+ .args(&["--additional-suffix", "a\\b"])
+ .fails()
+ .usage_error("invalid suffix 'a\\b', contains directory separator");
+}
+
+#[test]
+fn test_split_additional_suffix_hyphen_value() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let name = "split_additional_suffix";
+ RandomFile::new(&at, name).add_lines(2000);
+ ucmd.args(&["--additional-suffix", "-300", name]).succeeds();
+
+ let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]-300$");
+ assert_eq!(glob.count(), 2);
+ assert_eq!(glob.collate(), at.read_bytes(name));
}
// note: the test_filter* tests below are unix-only
@@ -302,6 +345,47 @@ fn test_filter_command_fails() {
.fails();
}
+#[test]
+#[cfg(unix)]
+fn test_filter_broken_pipe() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let name = "filter-big-input";
+
+ RandomFile::new(&at, name).add_lines(1024 * 10);
+ ucmd.args(&["--filter=head -c1 > /dev/null", "-n", "r/1", name])
+ .succeeds();
+}
+
+#[test]
+#[cfg(unix)]
+fn test_filter_with_kth_chunk() {
+ let scene = TestScenario::new(util_name!());
+ scene
+ .ucmd()
+ .args(&["--filter='some'", "--number=1/2"])
+ .ignore_stdin_write_error()
+ .pipe_in("a\n")
+ .fails()
+ .no_stdout()
+ .stderr_contains("--filter does not process a chunk extracted to stdout");
+ scene
+ .ucmd()
+ .args(&["--filter='some'", "--number=l/1/2"])
+ .ignore_stdin_write_error()
+ .pipe_in("a\n")
+ .fails()
+ .no_stdout()
+ .stderr_contains("--filter does not process a chunk extracted to stdout");
+ scene
+ .ucmd()
+ .args(&["--filter='some'", "--number=r/1/2"])
+ .ignore_stdin_write_error()
+ .pipe_in("a\n")
+ .fails()
+ .no_stdout()
+ .stderr_contains("--filter does not process a chunk extracted to stdout");
+}
+
#[test]
fn test_split_lines_number() {
// Test if stdout/stderr for '--lines' option is correct
@@ -317,445 +401,1574 @@ fn test_split_lines_number() {
.no_stdout();
scene
.ucmd()
- .args(&["--lines", "2fb", "file"])
+ .args(&["--lines", "0", "file"])
.fails()
.code_is(1)
- .stderr_only("split: invalid number of lines: '2fb'");
-}
-
-#[test]
-fn test_split_invalid_bytes_size() {
- new_ucmd!()
- .args(&["-b", "1024R"])
+ .stderr_only("split: invalid number of lines: 0\n");
+ scene
+ .ucmd()
+ .args(&["-0", "file"])
.fails()
.code_is(1)
- .stderr_only("split: invalid number of bytes: '1024R'");
- #[cfg(not(target_pointer_width = "128"))]
- new_ucmd!()
- .args(&["-b", "1Y"])
+ .stderr_only("split: invalid number of lines: 0\n");
+ scene
+ .ucmd()
+ .args(&["--lines", "2fb", "file"])
.fails()
.code_is(1)
- .stderr_only("split: invalid number of bytes: '1Y': Value too large for defined data type");
- #[cfg(target_pointer_width = "32")]
- {
- let sizes = ["1000G", "10T"];
- for size in &sizes {
- new_ucmd!().args(&["-b", size]).succeeds();
- }
- }
-}
-
-#[test]
-fn test_split_chunks_num_chunks_oversized_32() {
- #[cfg(target_pointer_width = "32")]
- {
- let scene = TestScenario::new(util_name!());
- let at = &scene.fixtures;
- at.touch("file");
- scene
- .ucmd()
- .args(&["--number", "5000000000", "file"])
- .fails()
- .code_is(1)
- .stderr_only("split: Number of chunks too big");
- }
-}
-
-#[test]
-fn test_split_stdin_num_chunks() {
- new_ucmd!()
- .args(&["--number=1"])
+ .stderr_only("split: invalid number of lines: '2fb'\n");
+ scene
+ .ucmd()
+ .args(&["--lines", "file"])
.fails()
.code_is(1)
- .stderr_only("split: -: cannot determine file size");
-}
-
-fn file_read(at: &AtPath, filename: &str) -> String {
- let mut s = String::new();
- at.open(filename).read_to_string(&mut s).unwrap();
- s
-}
-
-// TODO Use char::from_digit() in Rust v1.51.0 or later.
-fn char_from_digit(n: usize) -> char {
- (b'a' + n as u8) as char
+ .stderr_only("split: invalid number of lines: 'file'\n");
}
-/// Test for the default suffix length behavior: dynamically increasing size.
+/// Test short lines option with value concatenated
#[test]
-fn test_alphabetic_dynamic_suffix_length() {
+fn test_split_lines_short_concatenated_with_value() {
let (at, mut ucmd) = at_and_ucmd!();
- // Split into chunks of one byte each.
- //
- // The input file has (26^2) - 26 + 1 = 651 bytes. This is just
- // enough to force `split` to dynamically increase the length of
- // the filename for the very last chunk.
- //
- // We expect the output files to be named
- //
- // xaa, xab, xac, ..., xyx, xyy, xyz, xzaaa
- //
- ucmd.args(&["-b", "1", "sixhundredfiftyonebytes.txt"])
- .succeeds();
- for i in 0..25 {
- for j in 0..26 {
- let filename = format!("x{}{}", char_from_digit(i), char_from_digit(j),);
- let contents = file_read(&at, &filename);
- assert_eq!(contents, "a");
- }
- }
- assert_eq!(file_read(&at, "xzaaa"), "a");
+ let name = "split_num_prefixed_chunks_by_lines";
+ RandomFile::new(&at, name).add_lines(10000);
+ ucmd.args(&["-l1000", name]).succeeds();
+
+ let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]$");
+ assert_eq!(glob.count(), 10);
+ assert_eq!(glob.collate(), at.read_bytes(name));
}
-/// Test for the default suffix length behavior: dynamically increasing size.
+/// Test for obsolete lines option standalone
#[test]
-fn test_numeric_dynamic_suffix_length() {
+fn test_split_obs_lines_standalone() {
let (at, mut ucmd) = at_and_ucmd!();
- // Split into chunks of one byte each, use numbers instead of
- // letters as file suffixes.
- //
- // The input file has (10^2) - 10 + 1 = 91 bytes. This is just
- // enough to force `split` to dynamically increase the length of
- // the filename for the very last chunk.
- //
- // x00, x01, x02, ..., x87, x88, x89, x9000
- //
- ucmd.args(&["-d", "-b", "1", "ninetyonebytes.txt"])
- .succeeds();
- for i in 0..90 {
- let filename = format!("x{:02}", i);
- let contents = file_read(&at, &filename);
- assert_eq!(contents, "a");
- }
- assert_eq!(file_read(&at, "x9000"), "a");
+ let name = "obs-lines-standalone";
+ RandomFile::new(&at, name).add_lines(4);
+ ucmd.args(&["-2", name]).succeeds().no_stderr().no_stdout();
+ let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]$");
+ assert_eq!(glob.count(), 2);
+ assert_eq!(glob.collate(), at.read_bytes(name));
}
+/// Test for obsolete lines option standalone overflow
#[test]
-fn test_hex_dynamic_suffix_length() {
+fn test_split_obs_lines_standalone_overflow() {
let (at, mut ucmd) = at_and_ucmd!();
- // Split into chunks of one byte each, use hexadecimal digits
- // instead of letters as file suffixes.
- //
- // The input file has (16^2) - 16 + 1 = 241 bytes. This is just
- // enough to force `split` to dynamically increase the length of
- // the filename for the very last chunk.
- //
- // x00, x01, x02, ..., xed, xee, xef, xf000
- //
- ucmd.args(&["-x", "-b", "1", "twohundredfortyonebytes.txt"])
- .succeeds();
- for i in 0..240 {
- let filename = format!("x{:02x}", i);
- let contents = file_read(&at, &filename);
- assert_eq!(contents, "a");
- }
- assert_eq!(file_read(&at, "xf000"), "a");
+ let name = "obs-lines-standalone";
+ RandomFile::new(&at, name).add_lines(4);
+ ucmd.args(&["-99999999999999999991", name])
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+ let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]$");
+ assert_eq!(glob.count(), 1);
+ assert_eq!(glob.collate(), at.read_bytes(name));
}
+/// Test for obsolete lines option as part of invalid combined short options
#[test]
-fn test_suffixes_exhausted() {
- new_ucmd!()
- .args(&["-b", "1", "-a", "1", "asciilowercase.txt"])
+fn test_split_obs_lines_within_invalid_combined_shorts() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.touch("file");
+
+ scene
+ .ucmd()
+ .args(&["-2fb", "file"])
.fails()
- .stderr_only("split: output file suffixes exhausted");
+ .code_is(1)
+ .stderr_contains("error: unexpected argument '-f' found\n");
}
+/// Test for obsolete lines option as part of combined short options
#[test]
-fn test_verbose() {
- new_ucmd!()
- .args(&["-b", "5", "--verbose", "asciilowercase.txt"])
+fn test_split_obs_lines_within_combined_shorts() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let name = "obs-lines-within-shorts";
+ RandomFile::new(at, name).add_lines(400);
+
+ scene
+ .ucmd()
+ .args(&["-x200de", name])
.succeeds()
- .stdout_only(
- "creating file 'xaa'
-creating file 'xab'
-creating file 'xac'
-creating file 'xad'
-creating file 'xae'
-creating file 'xaf'
-",
- );
+ .no_stderr()
+ .no_stdout();
+ let glob = Glob::new(at, ".", r"x\d\d$");
+ assert_eq!(glob.count(), 2);
+ assert_eq!(glob.collate(), at.read_bytes(name));
}
+/// Test for obsolete lines option as part of combined short options with tailing suffix length with value
#[test]
-fn test_number() {
+fn test_split_obs_lines_within_combined_shorts_tailing_suffix_length() {
let (at, mut ucmd) = at_and_ucmd!();
- let file_read = |f| {
- let mut s = String::new();
- at.open(f).read_to_string(&mut s).unwrap();
- s
- };
- ucmd.args(&["-n", "5", "asciilowercase.txt"]).succeeds();
- assert_eq!(file_read("xaa"), "abcde");
- assert_eq!(file_read("xab"), "fghij");
- assert_eq!(file_read("xac"), "klmno");
- assert_eq!(file_read("xad"), "pqrst");
- assert_eq!(file_read("xae"), "uvwxyz\n");
-}
+ let name = "obs-lines-combined-shorts-tailing-suffix-length";
+ RandomFile::new(&at, name).add_lines(1000);
+ ucmd.args(&["-d200a4", name]).succeeds();
-#[test]
-fn test_split_number_with_io_blksize() {
- let (at, mut ucmd) = at_and_ucmd!();
- let file_read = |f| {
- let mut s = String::new();
- at.open(f).read_to_string(&mut s).unwrap();
- s
- };
- ucmd.args(&["-n", "5", "asciilowercase.txt", "---io-blksize", "1024"])
- .succeeds();
- assert_eq!(file_read("xaa"), "abcde");
- assert_eq!(file_read("xab"), "fghij");
- assert_eq!(file_read("xac"), "klmno");
- assert_eq!(file_read("xad"), "pqrst");
- assert_eq!(file_read("xae"), "uvwxyz\n");
+ let glob = Glob::new(&at, ".", r"x\d\d\d\d$");
+ assert_eq!(glob.count(), 5);
+ assert_eq!(glob.collate(), at.read_bytes(name));
}
+/// Test for obsolete lines option starts as part of combined short options
#[test]
-fn test_split_default_with_io_blksize() {
- let (at, mut ucmd) = at_and_ucmd!();
- let name = "split_default_with_io_blksize";
- RandomFile::new(&at, name).add_lines(2000);
- ucmd.args(&[name, "---io-blksize", "2M"]).succeeds();
+fn test_split_obs_lines_starts_combined_shorts() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let name = "obs-lines-starts-shorts";
+ RandomFile::new(at, name).add_lines(400);
- let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]$");
+ scene
+ .ucmd()
+ .args(&["-200xd", name])
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+ let glob = Glob::new(at, ".", r"x\d\d$");
assert_eq!(glob.count(), 2);
assert_eq!(glob.collate(), at.read_bytes(name));
}
+/// Test for using both obsolete lines (standalone) option and short/long lines option simultaneously
#[test]
-fn test_invalid_suffix_length() {
- new_ucmd!()
- .args(&["-a", "xyz"])
- .fails()
- .no_stdout()
- .stderr_contains("invalid suffix length: 'xyz'");
-}
-
-#[test]
-fn test_include_newlines() {
- let (at, mut ucmd) = at_and_ucmd!();
- ucmd.args(&["-l", "2", "fivelines.txt"]).succeeds();
-
- let mut s = String::new();
- at.open("xaa").read_to_string(&mut s).unwrap();
- assert_eq!(s, "1\n2\n");
-
- let mut s = String::new();
- at.open("xab").read_to_string(&mut s).unwrap();
- assert_eq!(s, "3\n4\n");
+fn test_split_both_lines_and_obs_lines_standalone() {
+ // This test will ensure that:
+ // if both lines option '-l' or '--lines' (with value) and obsolete lines option '-100' are used - it fails
+ // if standalone lines option is used incorrectly and treated as a hyphen prefixed value of other option - it fails
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.touch("file");
- let mut s = String::new();
- at.open("xac").read_to_string(&mut s).unwrap();
- assert_eq!(s, "5\n");
+ scene
+ .ucmd()
+ .args(&["-l", "2", "-2", "file"])
+ .fails()
+ .code_is(1)
+ .stderr_contains("split: cannot split in more than one way\n");
+ scene
+ .ucmd()
+ .args(&["--lines", "2", "-2", "file"])
+ .fails()
+ .code_is(1)
+ .stderr_contains("split: cannot split in more than one way\n");
}
+/// Test for using obsolete lines option incorrectly, so it is treated as a hyphen prefixed value of other option
#[test]
-fn test_allow_empty_files() {
- let (at, mut ucmd) = at_and_ucmd!();
- ucmd.args(&["-n", "4", "threebytes.txt"])
- .succeeds()
- .no_stdout()
- .no_stderr();
- assert_eq!(at.read("xaa"), "a");
- assert_eq!(at.read("xab"), "b");
- assert_eq!(at.read("xac"), "c");
- assert_eq!(at.read("xad"), "");
-}
+fn test_split_obs_lines_as_other_option_value() {
+ // This test will ensure that:
+ // if obsolete lines option is used incorrectly and treated as a hyphen prefixed value of other option - it fails
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.touch("file");
-#[test]
-fn test_elide_empty_files() {
+ scene
+ .ucmd()
+ .args(&["--lines", "-200", "file"])
+ .fails()
+ .code_is(1)
+ .stderr_contains("split: invalid number of lines: '-200'\n");
+ scene
+ .ucmd()
+ .args(&["-l", "-200", "file"])
+ .fails()
+ .code_is(1)
+ .stderr_contains("split: invalid number of lines: '-200'\n");
+ scene
+ .ucmd()
+ .args(&["-a", "-200", "file"])
+ .fails()
+ .code_is(1)
+ .stderr_contains("split: invalid suffix length: '-200'\n");
+ scene
+ .ucmd()
+ .args(&["--suffix-length", "-d200e", "file"])
+ .fails()
+ .code_is(1)
+ .stderr_contains("split: invalid suffix length: '-d200e'\n");
+ scene
+ .ucmd()
+ .args(&["-C", "-200", "file"])
+ .fails()
+ .code_is(1)
+ .stderr_contains("split: invalid number of bytes: '-200'\n");
+ scene
+ .ucmd()
+ .args(&["--line-bytes", "-x200a4", "file"])
+ .fails()
+ .code_is(1)
+ .stderr_contains("split: invalid number of bytes: '-x200a4'\n");
+ scene
+ .ucmd()
+ .args(&["-b", "-200", "file"])
+ .fails()
+ .code_is(1)
+ .stderr_contains("split: invalid number of bytes: '-200'\n");
+ scene
+ .ucmd()
+ .args(&["--bytes", "-200xd", "file"])
+ .fails()
+ .code_is(1)
+ .stderr_contains("split: invalid number of bytes: '-200xd'\n");
+ scene
+ .ucmd()
+ .args(&["-n", "-200", "file"])
+ .fails()
+ .code_is(1)
+ .stderr_contains("split: invalid number of chunks: '-200'\n");
+ scene
+ .ucmd()
+ .args(&["--number", "-e200", "file"])
+ .fails()
+ .code_is(1)
+ .stderr_contains("split: invalid number of chunks: '-e200'\n");
+}
+
+/// Test for using more than one obsolete lines option (standalone)
+/// last one wins
+#[test]
+fn test_split_multiple_obs_lines_standalone() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let name = "multiple-obs-lines";
+ RandomFile::new(at, name).add_lines(400);
+
+ scene
+ .ucmd()
+ .args(&["-3000", "-200", name])
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+ let glob = Glob::new(at, ".", r"x[[:alpha:]][[:alpha:]]$");
+ assert_eq!(glob.count(), 2);
+ assert_eq!(glob.collate(), at.read_bytes(name));
+}
+
+/// Test for using more than one obsolete lines option within combined shorts
+/// last one wins
+#[test]
+fn test_split_multiple_obs_lines_within_combined() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ let name = "multiple-obs-lines";
+ RandomFile::new(at, name).add_lines(400);
+
+ scene
+ .ucmd()
+ .args(&["-d5000x", "-e200d", name])
+ .succeeds()
+ .no_stderr()
+ .no_stdout();
+ let glob = Glob::new(at, ".", r"x\d\d$");
+ assert_eq!(glob.count(), 2);
+ assert_eq!(glob.collate(), at.read_bytes(name));
+}
+
+/// Test for using both obsolete lines option within combined shorts with conflicting -n option simultaneously
+#[test]
+fn test_split_obs_lines_within_combined_with_number() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.touch("file");
+
+ scene
+ .ucmd()
+ .args(&["-3dxen", "4", "file"])
+ .fails()
+ .code_is(1)
+ .stderr_contains("split: cannot split in more than one way\n");
+ scene
+ .ucmd()
+ .args(&["-dxe30n", "4", "file"])
+ .fails()
+ .code_is(1)
+ .stderr_contains("split: cannot split in more than one way\n");
+}
+
+#[test]
+fn test_split_invalid_bytes_size() {
+ new_ucmd!()
+ .args(&["-b", "1024W"])
+ .fails()
+ .code_is(1)
+ .stderr_only("split: invalid number of bytes: '1024W'\n");
+ #[cfg(target_pointer_width = "32")]
+ {
+ let sizes = ["1000G", "10T"];
+ for size in &sizes {
+ new_ucmd!().args(&["-b", size]).succeeds();
+ }
+ }
+}
+
+#[test]
+fn test_split_overflow_bytes_size() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let name = "test_split_overflow_bytes_size";
+ RandomFile::new(&at, name).add_bytes(1000);
+ ucmd.args(&["-b", "1Y", name]).succeeds();
+ let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]$");
+ assert_eq!(glob.count(), 1);
+ assert_eq!(glob.collate(), at.read_bytes(name));
+}
+
+#[test]
+fn test_split_stdin_num_chunks() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["--number=1"]).pipe_in("").succeeds();
+ assert_eq!(at.read("xaa"), "");
+ assert!(!at.plus("xab").exists());
+}
+
+#[test]
+fn test_split_stdin_num_kth_chunk() {
+ new_ucmd!()
+ .args(&["--number=1/2"])
+ .pipe_in("1\n2\n3\n4\n5\n")
+ .succeeds()
+ .stdout_only("1\n2\n3");
+}
+
+#[test]
+fn test_split_stdin_num_line_chunks() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["--number=l/2"])
+ .pipe_in("1\n2\n3\n4\n5\n")
+ .succeeds();
+ assert_eq!(at.read("xaa"), "1\n2\n3\n");
+ assert_eq!(at.read("xab"), "4\n5\n");
+ assert!(!at.plus("xac").exists());
+}
+
+#[test]
+fn test_split_stdin_num_kth_line_chunk() {
+ new_ucmd!()
+ .args(&["--number=l/2/5"])
+ .pipe_in("1\n2\n3\n4\n5\n")
+ .succeeds()
+ .stdout_only("2\n");
+}
+
+/// Test for the default suffix length behavior: dynamically increasing size.
+#[test]
+fn test_alphabetic_dynamic_suffix_length() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ // Split into chunks of one byte each.
+ //
+ // The input file has (26^2) - 26 + 1 = 651 bytes. This is just
+ // enough to force `split` to dynamically increase the length of
+ // the filename for the very last chunk.
+ //
+ // We expect the output files to be named
+ //
+ // xaa, xab, xac, ..., xyx, xyy, xyz, xzaaa
+ //
+ ucmd.args(&["-b", "1", "sixhundredfiftyonebytes.txt"])
+ .succeeds();
+ for i in b'a'..=b'y' {
+ for j in b'a'..=b'z' {
+ let filename = format!("x{}{}", i as char, j as char);
+ let contents = at.read(&filename);
+ assert_eq!(contents, "a");
+ }
+ }
+ assert_eq!(at.read("xzaaa"), "a");
+}
+
+/// Test for the default suffix length behavior: dynamically increasing size.
+#[test]
+fn test_numeric_dynamic_suffix_length() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ // Split into chunks of one byte each, use numbers instead of
+ // letters as file suffixes.
+ //
+ // The input file has (10^2) - 10 + 1 = 91 bytes. This is just
+ // enough to force `split` to dynamically increase the length of
+ // the filename for the very last chunk.
+ //
+ // x00, x01, x02, ..., x87, x88, x89, x9000
+ //
+ ucmd.args(&["-d", "-b", "1", "ninetyonebytes.txt"])
+ .succeeds();
+ for i in 0..90 {
+ let filename = format!("x{i:02}");
+ let contents = at.read(&filename);
+ assert_eq!(contents, "a");
+ }
+ assert_eq!(at.read("x9000"), "a");
+}
+
+#[test]
+fn test_hex_dynamic_suffix_length() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ // Split into chunks of one byte each, use hexadecimal digits
+ // instead of letters as file suffixes.
+ //
+ // The input file has (16^2) - 16 + 1 = 241 bytes. This is just
+ // enough to force `split` to dynamically increase the length of
+ // the filename for the very last chunk.
+ //
+ // x00, x01, x02, ..., xed, xee, xef, xf000
+ //
+ ucmd.args(&["-x", "-b", "1", "twohundredfortyonebytes.txt"])
+ .succeeds();
+ for i in 0..240 {
+ let filename = format!("x{i:02x}");
+ let contents = at.read(&filename);
+ assert_eq!(contents, "a");
+ }
+ assert_eq!(at.read("xf000"), "a");
+}
+
+/// Test for dynamic suffix length (auto-widening) disabled when suffix start number is specified
+#[test]
+fn test_dynamic_suffix_length_off_with_suffix_start() {
+ new_ucmd!()
+ .args(&["-b", "1", "--numeric-suffixes=89", "ninetyonebytes.txt"])
+ .fails()
+ .stderr_only("split: output file suffixes exhausted\n");
+}
+
+/// Test for dynamic suffix length (auto-widening) enabled when suffix start number is NOT specified
+#[test]
+fn test_dynamic_suffix_length_on_with_suffix_start_no_value() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-b", "1", "--numeric-suffixes", "ninetyonebytes.txt"])
+ .succeeds();
+ assert_eq!(at.read("x9000"), "a");
+}
+
+/// Test for suffix auto-width with --number strategy and suffix start number
+#[test]
+fn test_suffix_auto_width_with_number() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["--numeric-suffixes=1", "--number=r/100", "fivelines.txt"])
+ .succeeds();
+ let glob = Glob::new(&at, ".", r"x\d\d\d$");
+ assert_eq!(glob.count(), 100);
+ assert_eq!(glob.collate(), at.read_bytes("fivelines.txt"));
+ assert_eq!(at.read("x001"), "1\n");
+ assert_eq!(at.read("x100"), "");
+
+ new_ucmd!()
+ .args(&["--numeric-suffixes=100", "--number=r/100", "fivelines.txt"])
+ .fails();
+}
+
+/// Test for edge case of specifying 0 for suffix length
+#[test]
+fn test_suffix_length_zero() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&[
+ "--numeric-suffixes=1",
+ "--number=r/100",
+ "-a",
+ "0",
+ "fivelines.txt",
+ ])
+ .succeeds();
+ let glob = Glob::new(&at, ".", r"x\d\d\d$");
+ assert_eq!(glob.count(), 100);
+
+ new_ucmd!()
+ .args(&[
+ "--numeric-suffixes=100",
+ "--number=r/100",
+ "-a",
+ "0",
+ "fivelines.txt",
+ ])
+ .fails();
+
+ new_ucmd!()
+ .args(&[
+ "-b",
+ "1",
+ "--numeric-suffixes=89",
+ "-a",
+ "0",
+ "ninetyonebytes.txt",
+ ])
+ .fails()
+ .stderr_only("split: output file suffixes exhausted\n");
+}
+
+#[test]
+fn test_suffixes_exhausted() {
+ new_ucmd!()
+ .args(&["-b", "1", "-a", "1", "asciilowercase.txt"])
+ .fails()
+ .stderr_only("split: output file suffixes exhausted\n");
+}
+
+#[test]
+fn test_suffix_length_req() {
+ new_ucmd!()
+ .args(&["-n", "100", "-a", "1", "asciilowercase.txt"])
+ .fails()
+ .stderr_only("split: the suffix length needs to be at least 2\n");
+}
+
+#[test]
+fn test_verbose() {
+ new_ucmd!()
+ .args(&["-b", "5", "--verbose", "asciilowercase.txt"])
+ .succeeds()
+ .stdout_only(
+ "creating file 'xaa'
+creating file 'xab'
+creating file 'xac'
+creating file 'xad'
+creating file 'xae'
+creating file 'xaf'
+",
+ );
+}
+
+#[test]
+fn test_number_n() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-n", "5", "asciilowercase.txt"]).succeeds();
+ assert_eq!(at.read("xaa"), "abcdef");
+ assert_eq!(at.read("xab"), "ghijkl");
+ assert_eq!(at.read("xac"), "mnopq");
+ assert_eq!(at.read("xad"), "rstuv");
+ assert_eq!(at.read("xae"), "wxyz\n");
+ #[cfg(unix)]
+ new_ucmd!()
+ .args(&["--number=100", "/dev/null"])
+ .succeeds()
+ .stdout_only("");
+}
+
+#[test]
+fn test_number_kth_of_n() {
+ new_ucmd!()
+ .args(&["--number=3/5", "asciilowercase.txt"])
+ .succeeds()
+ .stdout_only("mnopq");
+ new_ucmd!()
+ .args(&["--number=5/5", "asciilowercase.txt"])
+ .succeeds()
+ .stdout_only("wxyz\n");
+ new_ucmd!()
+ .args(&["-e", "--number=99/100", "asciilowercase.txt"])
+ .succeeds()
+ .stdout_only("");
+ #[cfg(unix)]
+ new_ucmd!()
+ .args(&["--number=3/10", "/dev/null"])
+ .succeeds()
+ .stdout_only("");
+ #[cfg(target_pointer_width = "64")]
+ new_ucmd!()
+ .args(&[
+ "--number=r/9223372036854775807/18446744073709551615",
+ "asciilowercase.txt",
+ ])
+ .succeeds()
+ .stdout_only("");
+ new_ucmd!()
+ .args(&["--number=0/5", "asciilowercase.txt"])
+ .fails()
+ .stderr_contains("split: invalid chunk number: '0'");
+ new_ucmd!()
+ .args(&["--number=10/5", "asciilowercase.txt"])
+ .fails()
+ .stderr_contains("split: invalid chunk number: '10'");
+ #[cfg(target_pointer_width = "64")]
+ new_ucmd!()
+ .args(&[
+ "--number=9223372036854775807/18446744073709551616",
+ "asciilowercase.txt",
+ ])
+ .fails()
+ .stderr_contains("split: invalid number of chunks: '18446744073709551616'");
+}
+
+#[test]
+fn test_number_kth_of_n_round_robin() {
+ new_ucmd!()
+ .args(&["--number", "r/2/3", "fivelines.txt"])
+ .succeeds()
+ .stdout_only("2\n5\n");
+ new_ucmd!()
+ .args(&["--number", "r/1/4", "fivelines.txt"])
+ .succeeds()
+ .stdout_only("1\n5\n");
+ new_ucmd!()
+ .args(&["-e", "--number", "r/7/7", "fivelines.txt"])
+ .succeeds()
+ .stdout_only("");
+ #[cfg(target_pointer_width = "64")]
+ new_ucmd!()
+ .args(&[
+ "--number",
+ "r/9223372036854775807/18446744073709551615",
+ "fivelines.txt",
+ ])
+ .succeeds()
+ .stdout_only("");
+ #[cfg(target_pointer_width = "64")]
+ new_ucmd!()
+ .args(&[
+ "--number",
+ "r/9223372036854775807/18446744073709551616",
+ "fivelines.txt",
+ ])
+ .fails()
+ .stderr_contains("split: invalid number of chunks: '18446744073709551616'");
+ new_ucmd!()
+ .args(&["--number", "r/0/3", "fivelines.txt"])
+ .fails()
+ .stderr_contains("split: invalid chunk number: '0'");
+ new_ucmd!()
+ .args(&["--number", "r/10/3", "fivelines.txt"])
+ .fails()
+ .stderr_contains("split: invalid chunk number: '10'");
+}
+
+#[test]
+fn test_split_number_with_io_blksize() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-n", "5", "asciilowercase.txt", "---io-blksize", "1024"])
+ .succeeds();
+ assert_eq!(at.read("xaa"), "abcdef");
+ assert_eq!(at.read("xab"), "ghijkl");
+ assert_eq!(at.read("xac"), "mnopq");
+ assert_eq!(at.read("xad"), "rstuv");
+ assert_eq!(at.read("xae"), "wxyz\n");
+}
+
+#[test]
+fn test_split_default_with_io_blksize() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let name = "split_default_with_io_blksize";
+ RandomFile::new(&at, name).add_lines(2000);
+ ucmd.args(&[name, "---io-blksize", "2M"]).succeeds();
+
+ let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]$");
+ assert_eq!(glob.count(), 2);
+ assert_eq!(glob.collate(), at.read_bytes(name));
+}
+
+#[test]
+fn test_split_invalid_io_blksize() {
+ new_ucmd!()
+ .args(&["---io-blksize=XYZ", "threebytes.txt"])
+ .fails()
+ .stderr_only("split: invalid IO block size: 'XYZ'\n");
+ new_ucmd!()
+ .args(&["---io-blksize=5000000000", "threebytes.txt"])
+ .fails()
+ .stderr_only("split: invalid IO block size: '5000000000'\n");
+ #[cfg(target_pointer_width = "32")]
+ new_ucmd!()
+ .args(&["---io-blksize=2146435072", "threebytes.txt"])
+ .fails()
+ .stderr_only("split: invalid IO block size: '2146435072'\n");
+}
+
+#[test]
+fn test_split_number_oversized_stdin() {
+ new_ucmd!()
+ .args(&["--number=3", "---io-blksize=600"])
+ .pipe_in_fixture("sixhundredfiftyonebytes.txt")
+ .ignore_stdin_write_error()
+ .fails()
+ .stderr_only("split: -: cannot determine input size\n");
+}
+
+#[test]
+fn test_invalid_suffix_length() {
+ new_ucmd!()
+ .args(&["-a", "xyz"])
+ .fails()
+ .no_stdout()
+ .stderr_contains("invalid suffix length: 'xyz'");
+}
+
+/// Test short suffix length option with value concatenated
+#[test]
+fn test_split_suffix_length_short_concatenated_with_value() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let name = "split_num_prefixed_chunks_by_lines";
+ RandomFile::new(&at, name).add_lines(10000);
+ ucmd.args(&["-a4", name]).succeeds();
+
+ let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]][[:alpha:]][[:alpha:]]$");
+ assert_eq!(glob.count(), 10);
+ assert_eq!(glob.collate(), at.read_bytes(name));
+}
+
+#[test]
+fn test_include_newlines() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-l", "2", "fivelines.txt"]).succeeds();
+
+ let mut s = String::new();
+ at.open("xaa").read_to_string(&mut s).unwrap();
+ assert_eq!(s, "1\n2\n");
+
+ let mut s = String::new();
+ at.open("xab").read_to_string(&mut s).unwrap();
+ assert_eq!(s, "3\n4\n");
+
+ let mut s = String::new();
+ at.open("xac").read_to_string(&mut s).unwrap();
+ assert_eq!(s, "5\n");
+}
+
+/// Test short number of chunks option concatenated with value
+#[test]
+fn test_split_number_chunks_short_concatenated_with_value() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-n3", "threebytes.txt"])
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert_eq!(at.read("xaa"), "a");
+ assert_eq!(at.read("xab"), "b");
+ assert_eq!(at.read("xac"), "c");
+}
+
+#[test]
+fn test_allow_empty_files() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-n", "4", "threebytes.txt"])
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert_eq!(at.read("xaa"), "a");
+ assert_eq!(at.read("xab"), "b");
+ assert_eq!(at.read("xac"), "c");
+ assert_eq!(at.read("xad"), "");
+}
+
+#[test]
+fn test_elide_empty_files_n_chunks() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-e", "-n", "4", "threebytes.txt"])
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert_eq!(at.read("xaa"), "a");
+ assert_eq!(at.read("xab"), "b");
+ assert_eq!(at.read("xac"), "c");
+ assert!(!at.plus("xad").exists());
+}
+
+#[test]
+#[cfg(unix)]
+fn test_elide_dev_null_n_chunks() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-e", "-n", "3", "/dev/null"])
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert!(!at.plus("xaa").exists());
+ assert!(!at.plus("xab").exists());
+ assert!(!at.plus("xac").exists());
+}
+
+#[test]
+#[cfg(unix)]
+fn test_dev_zero() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-n", "3", "/dev/zero"])
+ .fails()
+ .stderr_only("split: /dev/zero: cannot determine file size\n");
+ assert!(!at.plus("xaa").exists());
+ assert!(!at.plus("xab").exists());
+ assert!(!at.plus("xac").exists());
+}
+
+#[test]
+fn test_elide_empty_files_l_chunks() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-e", "-n", "l/7", "fivelines.txt"])
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert_eq!(at.read("xaa"), "1\n");
+ assert_eq!(at.read("xab"), "2\n");
+ assert_eq!(at.read("xac"), "3\n");
+ assert_eq!(at.read("xad"), "4\n");
+ assert_eq!(at.read("xae"), "5\n");
+ assert!(!at.plus("xaf").exists());
+ assert!(!at.plus("xag").exists());
+}
+
+#[test]
+#[cfg(unix)]
+fn test_elide_dev_null_l_chunks() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-e", "-n", "l/3", "/dev/null"])
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert!(!at.plus("xaa").exists());
+ assert!(!at.plus("xab").exists());
+ assert!(!at.plus("xac").exists());
+}
+
+#[test]
+#[cfg(unix)]
+fn test_number_by_bytes_dev_zero() {
let (at, mut ucmd) = at_and_ucmd!();
- ucmd.args(&["-e", "-n", "4", "threebytes.txt"])
+ ucmd.args(&["-n", "3", "/dev/zero"])
+ .fails()
+ .stderr_only("split: /dev/zero: cannot determine file size\n");
+ assert!(!at.plus("xaa").exists());
+ assert!(!at.plus("xab").exists());
+ assert!(!at.plus("xac").exists());
+}
+
+#[test]
+fn test_number_by_lines() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ // Split into two files without splitting up lines.
+ ucmd.args(&["-n", "l/2", "fivelines.txt"]).succeeds();
+
+ assert_eq!(at.read("xaa"), "1\n2\n3\n");
+ assert_eq!(at.read("xab"), "4\n5\n");
+}
+
+#[test]
+fn test_number_by_lines_kth() {
+ new_ucmd!()
+ .args(&["-n", "l/3/10", "onehundredlines.txt"])
+ .succeeds()
+ .stdout_only("20\n21\n22\n23\n24\n25\n26\n27\n28\n29\n");
+}
+
+#[test]
+#[cfg(unix)]
+fn test_number_by_lines_kth_dev_null() {
+ new_ucmd!()
+ .args(&["-n", "l/3/10", "/dev/null"])
+ .succeeds()
+ .stdout_only("");
+}
+
+#[test]
+fn test_number_by_lines_kth_no_end_sep() {
+ new_ucmd!()
+ .args(&["-n", "l/3/10"])
+ .pipe_in("1\n2222\n3\n4")
+ .succeeds()
+ .stdout_only("2222\n");
+ new_ucmd!()
+ .args(&["-e", "-n", "l/2/2"])
+ .pipe_in("1\n2222\n3\n4")
+ .succeeds()
+ .stdout_only("3\n4");
+}
+
+#[test]
+fn test_number_by_lines_rr_kth_no_end_sep() {
+ new_ucmd!()
+ .args(&["-n", "r/2/3"])
+ .pipe_in("1\n2\n3\n4\n5")
+ .succeeds()
+ .stdout_only("2\n5");
+}
+
+#[test]
+fn test_line_bytes() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-C", "8", "letters.txt"]).succeeds();
+ assert_eq!(at.read("xaa"), "aaaaaaaa");
+ assert_eq!(at.read("xab"), "a\nbbbb\n");
+ assert_eq!(at.read("xac"), "cccc\ndd\n");
+ assert_eq!(at.read("xad"), "ee\n");
+}
+
+#[test]
+#[cfg(target_pointer_width = "64")]
+fn test_line_bytes_overflow() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-C", "18446744073709551616", "letters.txt"])
+ .succeeds();
+ assert_eq!(at.read("xaa"), "aaaaaaaaa\nbbbb\ncccc\ndd\nee\n");
+}
+
+#[test]
+fn test_line_bytes_concatenated_with_value() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-C8", "letters.txt"]).succeeds();
+ assert_eq!(at.read("xaa"), "aaaaaaaa");
+ assert_eq!(at.read("xab"), "a\nbbbb\n");
+ assert_eq!(at.read("xac"), "cccc\ndd\n");
+ assert_eq!(at.read("xad"), "ee\n");
+}
+
+#[test]
+fn test_line_bytes_no_final_newline() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-C", "2"])
+ .pipe_in("1\n2222\n3\n4")
.succeeds()
.no_stdout()
.no_stderr();
- assert_eq!(at.read("xaa"), "a");
- assert_eq!(at.read("xab"), "b");
- assert_eq!(at.read("xac"), "c");
- assert!(!at.plus("xad").exists());
+ assert_eq!(at.read("xaa"), "1\n");
+ assert_eq!(at.read("xab"), "22");
+ assert_eq!(at.read("xac"), "22");
+ assert_eq!(at.read("xad"), "\n");
+ assert_eq!(at.read("xae"), "3\n");
+ assert_eq!(at.read("xaf"), "4");
+}
+
+#[test]
+fn test_line_bytes_no_empty_file() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-C", "1"])
+ .pipe_in("1\n2222\n3\n4")
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert_eq!(at.read("xaa"), "1");
+ assert_eq!(at.read("xab"), "\n");
+ assert_eq!(at.read("xac"), "2");
+ assert_eq!(at.read("xad"), "2");
+ assert_eq!(at.read("xae"), "2");
+ assert_eq!(at.read("xaf"), "2");
+ assert_eq!(at.read("xag"), "\n");
+ assert_eq!(at.read("xah"), "3");
+ assert_eq!(at.read("xai"), "\n");
+ assert_eq!(at.read("xaj"), "4");
+ assert!(!at.plus("xak").exists());
+}
+
+#[test]
+fn test_line_bytes_no_eof() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-C", "3"])
+ .pipe_in("1\n2222\n3\n4")
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert_eq!(at.read("xaa"), "1\n");
+ assert_eq!(at.read("xab"), "222");
+ assert_eq!(at.read("xac"), "2\n");
+ assert_eq!(at.read("xad"), "3\n");
+ assert_eq!(at.read("xae"), "4");
+ assert!(!at.plus("xaf").exists());
+}
+
+#[test]
+fn test_guard_input() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+
+ ts.ucmd()
+ .args(&["-C", "6"])
+ .pipe_in("1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n")
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert_eq!(at.read("xaa"), "1\n2\n3\n");
+
+ ts.ucmd()
+ .args(&["-C", "6"])
+ .pipe_in("1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n")
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert_eq!(at.read("xaa"), "1\n2\n3\n");
+
+ ts.ucmd()
+ .args(&["-C", "6", "xaa"])
+ .fails()
+ .stderr_only("split: 'xaa' would overwrite input; aborting\n");
+ assert_eq!(at.read("xaa"), "1\n2\n3\n");
+}
+
+#[test]
+fn test_multiple_of_input_chunk() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let name = "multiple_of_input_chunk";
+ RandomFile::new(&at, name).add_bytes(16 * 1024);
+ ucmd.args(&["-b", "8K", name, "b"]).succeeds();
+
+ let glob = Glob::new(&at, ".", r"b[[:alpha:]][[:alpha:]]$");
+ assert_eq!(glob.count(), 2);
+ for filename in glob.collect() {
+ assert_eq!(glob.directory.metadata(&filename).len(), 8 * 1024);
+ }
+ assert_eq!(glob.collate(), at.read_bytes(name));
+}
+
+#[test]
+fn test_numeric_suffix() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-n", "4", "--numeric-suffixes=9", "threebytes.txt"])
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert_eq!(at.read("x09"), "a");
+ assert_eq!(at.read("x10"), "b");
+ assert_eq!(at.read("x11"), "c");
+ assert_eq!(at.read("x12"), "");
+}
+
+#[test]
+fn test_numeric_suffix_inferred() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-n", "4", "--numeric=9", "threebytes.txt"])
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert_eq!(at.read("x09"), "a");
+ assert_eq!(at.read("x10"), "b");
+ assert_eq!(at.read("x11"), "c");
+ assert_eq!(at.read("x12"), "");
+}
+
+#[test]
+fn test_hex_suffix() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-n", "4", "--hex-suffixes=9", "threebytes.txt"])
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert_eq!(at.read("x09"), "a");
+ assert_eq!(at.read("x0a"), "b");
+ assert_eq!(at.read("x0b"), "c");
+ assert_eq!(at.read("x0c"), "");
+}
+
+#[test]
+fn test_hex_suffix_alias() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-n", "4", "--hex=9", "threebytes.txt"])
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert_eq!(at.read("x09"), "a");
+ assert_eq!(at.read("x0a"), "b");
+ assert_eq!(at.read("x0b"), "c");
+ assert_eq!(at.read("x0c"), "");
+}
+
+#[test]
+fn test_numeric_suffix_no_equal() {
+ new_ucmd!()
+ .args(&["-n", "4", "--numeric-suffixes", "9", "threebytes.txt"])
+ .fails()
+ .stderr_contains("split: cannot open '9' for reading: No such file or directory");
+}
+
+#[test]
+fn test_hex_suffix_no_equal() {
+ new_ucmd!()
+ .args(&["-n", "4", "--hex-suffixes", "9", "threebytes.txt"])
+ .fails()
+ .stderr_contains("split: cannot open '9' for reading: No such file or directory");
+}
+
+/// Test for short numeric suffix not having any value
+#[test]
+fn test_short_numeric_suffix_no_value() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-l", "9", "-d", "onehundredlines.txt"])
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert_eq!(at.read("x00"), "00\n01\n02\n03\n04\n05\n06\n07\n08\n");
+ assert_eq!(at.read("x01"), "09\n10\n11\n12\n13\n14\n15\n16\n17\n");
+ assert_eq!(at.read("x02"), "18\n19\n20\n21\n22\n23\n24\n25\n26\n");
+ assert_eq!(at.read("x03"), "27\n28\n29\n30\n31\n32\n33\n34\n35\n");
+ assert_eq!(at.read("x04"), "36\n37\n38\n39\n40\n41\n42\n43\n44\n");
+ assert_eq!(at.read("x05"), "45\n46\n47\n48\n49\n50\n51\n52\n53\n");
+ assert_eq!(at.read("x06"), "54\n55\n56\n57\n58\n59\n60\n61\n62\n");
+ assert_eq!(at.read("x07"), "63\n64\n65\n66\n67\n68\n69\n70\n71\n");
+ assert_eq!(at.read("x08"), "72\n73\n74\n75\n76\n77\n78\n79\n80\n");
+ assert_eq!(at.read("x09"), "81\n82\n83\n84\n85\n86\n87\n88\n89\n");
+ assert_eq!(at.read("x10"), "90\n91\n92\n93\n94\n95\n96\n97\n98\n");
+ assert_eq!(at.read("x11"), "99\n");
+}
+
+/// Test for long numeric suffix not having any value
+#[test]
+fn test_numeric_suffix_no_value() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-l", "9", "--numeric-suffixes", "onehundredlines.txt"])
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert_eq!(at.read("x00"), "00\n01\n02\n03\n04\n05\n06\n07\n08\n");
+ assert_eq!(at.read("x01"), "09\n10\n11\n12\n13\n14\n15\n16\n17\n");
+ assert_eq!(at.read("x02"), "18\n19\n20\n21\n22\n23\n24\n25\n26\n");
+ assert_eq!(at.read("x03"), "27\n28\n29\n30\n31\n32\n33\n34\n35\n");
+ assert_eq!(at.read("x04"), "36\n37\n38\n39\n40\n41\n42\n43\n44\n");
+ assert_eq!(at.read("x05"), "45\n46\n47\n48\n49\n50\n51\n52\n53\n");
+ assert_eq!(at.read("x06"), "54\n55\n56\n57\n58\n59\n60\n61\n62\n");
+ assert_eq!(at.read("x07"), "63\n64\n65\n66\n67\n68\n69\n70\n71\n");
+ assert_eq!(at.read("x08"), "72\n73\n74\n75\n76\n77\n78\n79\n80\n");
+ assert_eq!(at.read("x09"), "81\n82\n83\n84\n85\n86\n87\n88\n89\n");
+ assert_eq!(at.read("x10"), "90\n91\n92\n93\n94\n95\n96\n97\n98\n");
+ assert_eq!(at.read("x11"), "99\n");
+}
+
+/// Test for short hex suffix not having any value
+#[test]
+fn test_short_hex_suffix_no_value() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-l", "9", "-x", "onehundredlines.txt"])
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert_eq!(at.read("x00"), "00\n01\n02\n03\n04\n05\n06\n07\n08\n");
+ assert_eq!(at.read("x01"), "09\n10\n11\n12\n13\n14\n15\n16\n17\n");
+ assert_eq!(at.read("x02"), "18\n19\n20\n21\n22\n23\n24\n25\n26\n");
+ assert_eq!(at.read("x03"), "27\n28\n29\n30\n31\n32\n33\n34\n35\n");
+ assert_eq!(at.read("x04"), "36\n37\n38\n39\n40\n41\n42\n43\n44\n");
+ assert_eq!(at.read("x05"), "45\n46\n47\n48\n49\n50\n51\n52\n53\n");
+ assert_eq!(at.read("x06"), "54\n55\n56\n57\n58\n59\n60\n61\n62\n");
+ assert_eq!(at.read("x07"), "63\n64\n65\n66\n67\n68\n69\n70\n71\n");
+ assert_eq!(at.read("x08"), "72\n73\n74\n75\n76\n77\n78\n79\n80\n");
+ assert_eq!(at.read("x09"), "81\n82\n83\n84\n85\n86\n87\n88\n89\n");
+ assert_eq!(at.read("x0a"), "90\n91\n92\n93\n94\n95\n96\n97\n98\n");
+ assert_eq!(at.read("x0b"), "99\n");
+}
+
+/// Test for long hex suffix not having any value
+#[test]
+fn test_hex_suffix_no_value() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-l", "9", "--hex-suffixes", "onehundredlines.txt"])
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert_eq!(at.read("x00"), "00\n01\n02\n03\n04\n05\n06\n07\n08\n");
+ assert_eq!(at.read("x01"), "09\n10\n11\n12\n13\n14\n15\n16\n17\n");
+ assert_eq!(at.read("x02"), "18\n19\n20\n21\n22\n23\n24\n25\n26\n");
+ assert_eq!(at.read("x03"), "27\n28\n29\n30\n31\n32\n33\n34\n35\n");
+ assert_eq!(at.read("x04"), "36\n37\n38\n39\n40\n41\n42\n43\n44\n");
+ assert_eq!(at.read("x05"), "45\n46\n47\n48\n49\n50\n51\n52\n53\n");
+ assert_eq!(at.read("x06"), "54\n55\n56\n57\n58\n59\n60\n61\n62\n");
+ assert_eq!(at.read("x07"), "63\n64\n65\n66\n67\n68\n69\n70\n71\n");
+ assert_eq!(at.read("x08"), "72\n73\n74\n75\n76\n77\n78\n79\n80\n");
+ assert_eq!(at.read("x09"), "81\n82\n83\n84\n85\n86\n87\n88\n89\n");
+ assert_eq!(at.read("x0a"), "90\n91\n92\n93\n94\n95\n96\n97\n98\n");
+ assert_eq!(at.read("x0b"), "99\n");
+}
+
+/// Test for short numeric suffix having value provided after space - should fail
+#[test]
+fn test_short_numeric_suffix_with_value_spaced() {
+ new_ucmd!()
+ .args(&["-n", "4", "-d", "9", "threebytes.txt"])
+ .fails()
+ .stderr_contains("split: cannot open '9' for reading: No such file or directory");
+}
+
+/// Test for short numeric suffix having value provided after space - should fail
+#[test]
+fn test_short_hex_suffix_with_value_spaced() {
+ new_ucmd!()
+ .args(&["-n", "4", "-x", "9", "threebytes.txt"])
+ .fails()
+ .stderr_contains("split: cannot open '9' for reading: No such file or directory");
}
+/// Test for some combined short options
#[test]
-#[cfg(unix)]
-fn test_elide_dev_null() {
+fn test_short_combination() {
let (at, mut ucmd) = at_and_ucmd!();
- ucmd.args(&["-e", "-n", "3", "/dev/null"])
+ ucmd.args(&["-dxen", "4", "threebytes.txt"])
.succeeds()
.no_stdout()
.no_stderr();
- assert!(!at.plus("xaa").exists());
- assert!(!at.plus("xab").exists());
- assert!(!at.plus("xac").exists());
+ assert_eq!(at.read("x00"), "a");
+ assert_eq!(at.read("x01"), "b");
+ assert_eq!(at.read("x02"), "c");
+ assert!(!at.file_exists("x03"));
}
+/// Test for the last effective suffix, ignoring all others - numeric long last
+/// Any combination of short and long (as well as duplicates) should be allowed
#[test]
-fn test_lines() {
+fn test_effective_suffix_numeric_last() {
let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&[
+ "-n",
+ "4",
+ "--numeric-suffixes=7",
+ "--hex-suffixes=4",
+ "-d",
+ "-x",
+ "--numeric-suffixes=9",
+ "threebytes.txt",
+ ])
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert_eq!(at.read("x09"), "a");
+ assert_eq!(at.read("x10"), "b");
+ assert_eq!(at.read("x11"), "c");
+ assert_eq!(at.read("x12"), "");
+}
- let file_read = |f| {
- let mut s = String::new();
- at.open(f).read_to_string(&mut s).unwrap();
- s
- };
+/// Test for the last effective suffix, ignoring all others - hex long last
+/// Any combination of short and long (as well as duplicates) should be allowed
+#[test]
+fn test_effective_suffix_hex_last() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&[
+ "-n",
+ "4",
+ "--hex-suffixes=7",
+ "--numeric-suffixes=4",
+ "-x",
+ "-d",
+ "--hex-suffixes=9",
+ "threebytes.txt",
+ ])
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert_eq!(at.read("x09"), "a");
+ assert_eq!(at.read("x0a"), "b");
+ assert_eq!(at.read("x0b"), "c");
+ assert_eq!(at.read("x0c"), "");
+}
- // Split into two files without splitting up lines.
- ucmd.args(&["-n", "l/2", "fivelines.txt"]).succeeds();
+#[test]
+fn test_round_robin() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["-n", "r/2", "fivelines.txt"]).succeeds();
- assert_eq!(file_read("xaa"), "1\n2\n3\n");
- assert_eq!(file_read("xab"), "4\n5\n");
+ assert_eq!(at.read("xaa"), "1\n3\n5\n");
+ assert_eq!(at.read("xab"), "2\n4\n");
}
#[test]
-fn test_lines_kth() {
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_round_robin_limited_file_descriptors() {
new_ucmd!()
- .args(&["-n", "l/3/10", "onehundredlines.txt"])
- .succeeds()
- .stdout_only("20\n21\n22\n23\n24\n25\n26\n27\n28\n29\n");
+ .args(&["-n", "r/40", "onehundredlines.txt"])
+ .limit(Resource::NOFILE, 9, 9)
+ .succeeds();
}
#[test]
-fn test_line_bytes() {
+fn test_split_invalid_input() {
+ // Test if stdout/stderr for '--lines' option is correct
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+ at.touch("file");
+
+ scene
+ .ucmd()
+ .args(&["--lines", "0", "file"])
+ .fails()
+ .no_stdout()
+ .stderr_contains("split: invalid number of lines: 0");
+ scene
+ .ucmd()
+ .args(&["-C", "0", "file"])
+ .fails()
+ .no_stdout()
+ .stderr_contains("split: invalid number of bytes: 0");
+ scene
+ .ucmd()
+ .args(&["-b", "0", "file"])
+ .fails()
+ .no_stdout()
+ .stderr_contains("split: invalid number of bytes: 0");
+ scene
+ .ucmd()
+ .args(&["-n", "0", "file"])
+ .fails()
+ .no_stdout()
+ .stderr_contains("split: invalid number of chunks: '0'");
+}
+
+/// Test if there are invalid (non UTF-8) in the arguments - unix
+/// clap is expected to fail/panic
+#[test]
+#[cfg(unix)]
+fn test_split_non_utf8_argument_unix() {
+ use std::ffi::OsStr;
+ use std::os::unix::ffi::OsStrExt;
+
let (at, mut ucmd) = at_and_ucmd!();
- ucmd.args(&["-C", "8", "letters.txt"]).succeeds();
- assert_eq!(at.read("xaa"), "aaaaaaaa");
- assert_eq!(at.read("xab"), "a\nbbbb\n");
- assert_eq!(at.read("xac"), "cccc\ndd\n");
- assert_eq!(at.read("xad"), "ee\n");
+ let name = "test_split_non_utf8_argument";
+ let opt = OsStr::from_bytes("--additional-suffix".as_bytes());
+ RandomFile::new(&at, name).add_lines(2000);
+ // Here, the values 0x66 and 0x6f correspond to 'f' and 'o'
+ // respectively. The value 0x80 is a lone continuation byte, invalid
+ // in a UTF-8 sequence.
+ let opt_value = [0x66, 0x6f, 0x80, 0x6f];
+ let opt_value = OsStr::from_bytes(&opt_value[..]);
+ let name = OsStr::from_bytes(name.as_bytes());
+ ucmd.args(&[opt, opt_value, name])
+ .fails()
+ .stderr_contains("error: invalid UTF-8 was detected in one or more arguments");
}
+/// Test if there are invalid (non UTF-8) in the arguments - windows
+/// clap is expected to fail/panic
#[test]
-fn test_line_bytes_no_final_newline() {
+#[cfg(windows)]
+fn test_split_non_utf8_argument_windows() {
+ use std::ffi::OsString;
+ use std::os::windows::ffi::OsStringExt;
+
let (at, mut ucmd) = at_and_ucmd!();
- ucmd.args(&["-C", "2"])
- .pipe_in("1\n2222\n3\n4")
- .succeeds()
- .no_stdout()
- .no_stderr();
- assert_eq!(at.read("xaa"), "1\n");
- assert_eq!(at.read("xab"), "22");
- assert_eq!(at.read("xac"), "22");
- assert_eq!(at.read("xad"), "\n");
- assert_eq!(at.read("xae"), "3\n");
- assert_eq!(at.read("xaf"), "4");
+ let name = "test_split_non_utf8_argument";
+ let opt = OsString::from("--additional-suffix");
+ RandomFile::new(&at, name).add_lines(2000);
+ // Here the values 0x0066 and 0x006f correspond to 'f' and 'o'
+ // respectively. The value 0xD800 is a lone surrogate half, invalid
+ // in a UTF-16 sequence.
+ let opt_value = [0x0066, 0x006f, 0xD800, 0x006f];
+ let opt_value = OsString::from_wide(&opt_value[..]);
+ let name = OsString::from(name);
+ ucmd.args(&[opt, opt_value, name])
+ .fails()
+ .stderr_contains("error: invalid UTF-8 was detected in one or more arguments");
}
+// Test '--separator' / '-t' option following GNU tests example
+// test separators: '\n' , '\0' , ';'
+// test with '--lines=2' , '--line-bytes=4' , '--number=l/3' , '--number=r/3' , '--number=l/1/3' , '--number=r/1/3'
#[test]
-fn test_line_bytes_no_empty_file() {
+fn test_split_separator_nl_lines() {
let (at, mut ucmd) = at_and_ucmd!();
- ucmd.args(&["-C", "1"])
- .pipe_in("1\n2222\n3\n4")
- .succeeds()
- .no_stdout()
- .no_stderr();
- assert_eq!(at.read("xaa"), "1");
- assert_eq!(at.read("xab"), "\n");
- assert_eq!(at.read("xac"), "2");
- assert_eq!(at.read("xad"), "2");
- assert_eq!(at.read("xae"), "2");
- assert_eq!(at.read("xaf"), "2");
- assert_eq!(at.read("xag"), "\n");
- assert_eq!(at.read("xah"), "3");
- assert_eq!(at.read("xai"), "\n");
- assert_eq!(at.read("xaj"), "4");
- assert!(!at.plus("xak").exists());
+ ucmd.args(&["--lines=2", "-t", "\n"])
+ .pipe_in("1\n2\n3\n4\n5\n")
+ .succeeds();
+
+ assert_eq!(at.read("xaa"), "1\n2\n");
+ assert_eq!(at.read("xab"), "3\n4\n");
+ assert_eq!(at.read("xac"), "5\n");
+ assert!(!at.plus("xad").exists());
}
#[test]
-fn test_line_bytes_no_eof() {
+fn test_split_separator_nl_line_bytes() {
let (at, mut ucmd) = at_and_ucmd!();
- ucmd.args(&["-C", "3"])
- .pipe_in("1\n2222\n3\n4")
- .succeeds()
- .no_stdout()
- .no_stderr();
- assert_eq!(at.read("xaa"), "1\n");
- assert_eq!(at.read("xab"), "222");
- assert_eq!(at.read("xac"), "2\n");
- assert_eq!(at.read("xad"), "3\n");
- assert_eq!(at.read("xae"), "4");
- assert!(!at.plus("xaf").exists());
+ ucmd.args(&["--line-bytes=4", "-t", "\n"])
+ .pipe_in("1\n2\n3\n4\n5\n")
+ .succeeds();
+
+ assert_eq!(at.read("xaa"), "1\n2\n");
+ assert_eq!(at.read("xab"), "3\n4\n");
+ assert_eq!(at.read("xac"), "5\n");
+ assert!(!at.plus("xad").exists());
}
#[test]
-fn test_guard_input() {
- let ts = TestScenario::new(util_name!());
- let at = &ts.fixtures;
+fn test_split_separator_nl_number_l() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["--number=l/3", "--separator=\n", "fivelines.txt"])
+ .succeeds();
- ts.ucmd()
- .args(&["-C", "6"])
- .pipe_in("1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n")
- .succeeds()
- .no_stdout()
- .no_stderr();
- assert_eq!(at.read("xaa"), "1\n2\n3\n");
+ assert_eq!(at.read("xaa"), "1\n2\n");
+ assert_eq!(at.read("xab"), "3\n4\n");
+ assert_eq!(at.read("xac"), "5\n");
+ assert!(!at.plus("xad").exists());
+}
- ts.ucmd()
- .args(&["-C", "6"])
- .pipe_in("1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n")
- .succeeds()
- .no_stdout()
- .no_stderr();
- assert_eq!(at.read("xaa"), "1\n2\n3\n");
+#[test]
+fn test_split_separator_nl_number_r() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["--number=r/3", "--separator", "\n", "fivelines.txt"])
+ .succeeds();
- ts.ucmd()
- .args(&["-C", "6", "xaa"])
- .fails()
- .stderr_only("split: 'xaa' would overwrite input; aborting");
- assert_eq!(at.read("xaa"), "1\n2\n3\n");
+ assert_eq!(at.read("xaa"), "1\n4\n");
+ assert_eq!(at.read("xab"), "2\n5\n");
+ assert_eq!(at.read("xac"), "3\n");
+ assert!(!at.plus("xad").exists());
}
#[test]
-fn test_multiple_of_input_chunk() {
+fn test_split_separator_nul_lines() {
let (at, mut ucmd) = at_and_ucmd!();
- let name = "multiple_of_input_chunk";
- RandomFile::new(&at, name).add_bytes(16 * 1024);
- ucmd.args(&["-b", "8K", name, "b"]).succeeds();
+ ucmd.args(&["--lines=2", "-t", "\\0", "separator_nul.txt"])
+ .succeeds();
- let glob = Glob::new(&at, ".", r"b[[:alpha:]][[:alpha:]]$");
- assert_eq!(glob.count(), 2);
- for filename in glob.collect() {
- assert_eq!(glob.directory.metadata(&filename).len(), 8 * 1024);
- }
- assert_eq!(glob.collate(), at.read_bytes(name));
+ assert_eq!(at.read("xaa"), "1\x002\0");
+ assert_eq!(at.read("xab"), "3\x004\0");
+ assert_eq!(at.read("xac"), "5\0");
+ assert!(!at.plus("xad").exists());
}
#[test]
-fn test_numeric_suffix() {
+fn test_split_separator_nul_line_bytes() {
let (at, mut ucmd) = at_and_ucmd!();
- ucmd.args(&["-n", "4", "--numeric-suffixes", "9", "threebytes.txt"])
- .succeeds()
- .no_stdout()
- .no_stderr();
- assert_eq!(at.read("x09"), "a");
- assert_eq!(at.read("x10"), "b");
- assert_eq!(at.read("x11"), "c");
- assert_eq!(at.read("x12"), "");
+ ucmd.args(&["--line-bytes=4", "-t", "\\0", "separator_nul.txt"])
+ .succeeds();
+
+ assert_eq!(at.read("xaa"), "1\x002\0");
+ assert_eq!(at.read("xab"), "3\x004\0");
+ assert_eq!(at.read("xac"), "5\0");
+ assert!(!at.plus("xad").exists());
}
#[test]
-fn test_hex_suffix() {
+fn test_split_separator_nul_number_l() {
let (at, mut ucmd) = at_and_ucmd!();
- ucmd.args(&["-n", "4", "--hex-suffixes", "9", "threebytes.txt"])
- .succeeds()
- .no_stdout()
- .no_stderr();
- assert_eq!(at.read("x09"), "a");
- assert_eq!(at.read("x0a"), "b");
- assert_eq!(at.read("x0b"), "c");
- assert_eq!(at.read("x0c"), "");
+ ucmd.args(&["--number=l/3", "--separator=\\0", "separator_nul.txt"])
+ .succeeds();
+
+ assert_eq!(at.read("xaa"), "1\x002\0");
+ assert_eq!(at.read("xab"), "3\x004\0");
+ assert_eq!(at.read("xac"), "5\0");
+ assert!(!at.plus("xad").exists());
}
#[test]
-fn test_round_robin() {
+fn test_split_separator_nul_number_r() {
let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["--number=r/3", "--separator=\\0", "separator_nul.txt"])
+ .succeeds();
- let file_read = |f| {
- let mut s = String::new();
- at.open(f).read_to_string(&mut s).unwrap();
- s
- };
+ assert_eq!(at.read("xaa"), "1\x004\0");
+ assert_eq!(at.read("xab"), "2\x005\0");
+ assert_eq!(at.read("xac"), "3\0");
+ assert!(!at.plus("xad").exists());
+}
- ucmd.args(&["-n", "r/2", "fivelines.txt"]).succeeds();
+#[test]
+fn test_split_separator_semicolon_lines() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["--lines=2", "-t", ";", "separator_semicolon.txt"])
+ .succeeds();
+
+ assert_eq!(at.read("xaa"), "1;2;");
+ assert_eq!(at.read("xab"), "3;4;");
+ assert_eq!(at.read("xac"), "5;");
+ assert!(!at.plus("xad").exists());
+}
+
+#[test]
+fn test_split_separator_semicolon_line_bytes() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["--line-bytes=4", "-t", ";", "separator_semicolon.txt"])
+ .succeeds();
+
+ assert_eq!(at.read("xaa"), "1;2;");
+ assert_eq!(at.read("xab"), "3;4;");
+ assert_eq!(at.read("xac"), "5;");
+ assert!(!at.plus("xad").exists());
+}
+
+#[test]
+fn test_split_separator_semicolon_number_l() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["--number=l/3", "--separator=;", "separator_semicolon.txt"])
+ .succeeds();
+
+ assert_eq!(at.read("xaa"), "1;2;");
+ assert_eq!(at.read("xab"), "3;4;");
+ assert_eq!(at.read("xac"), "5;");
+ assert!(!at.plus("xad").exists());
+}
+
+#[test]
+fn test_split_separator_semicolon_number_r() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ ucmd.args(&["--number=r/3", "--separator=;", "separator_semicolon.txt"])
+ .succeeds();
+
+ assert_eq!(at.read("xaa"), "1;4;");
+ assert_eq!(at.read("xab"), "2;5;");
+ assert_eq!(at.read("xac"), "3;");
+ assert!(!at.plus("xad").exists());
+}
+
+#[test]
+fn test_split_separator_semicolon_number_kth_l() {
+ new_ucmd!()
+ .args(&[
+ "--number=l/1/3",
+ "--separator",
+ ";",
+ "separator_semicolon.txt",
+ ])
+ .succeeds()
+ .stdout_only("1;2;");
+}
+
+#[test]
+fn test_split_separator_semicolon_number_kth_r() {
+ new_ucmd!()
+ .args(&[
+ "--number=r/1/3",
+ "--separator",
+ ";",
+ "separator_semicolon.txt",
+ ])
+ .succeeds()
+ .stdout_only("1;4;");
+}
+
+// Test error edge cases for separator option
+#[test]
+fn test_split_separator_no_value() {
+ new_ucmd!()
+ .args(&["-t"])
+ .ignore_stdin_write_error()
+ .pipe_in("a\n")
+ .fails()
+ .stderr_contains(
+ "error: a value is required for '--separator <SEP>' but none was supplied",
+ );
+}
+
+#[test]
+fn test_split_separator_invalid_usage() {
+ let scene = TestScenario::new(util_name!());
+ scene
+ .ucmd()
+ .args(&["--separator=xx"])
+ .ignore_stdin_write_error()
+ .pipe_in("a\n")
+ .fails()
+ .no_stdout()
+ .stderr_contains("split: multi-character separator 'xx'");
+ scene
+ .ucmd()
+ .args(&["-ta", "-tb"])
+ .ignore_stdin_write_error()
+ .pipe_in("a\n")
+ .fails()
+ .no_stdout()
+ .stderr_contains("split: multiple separator characters specified");
+ scene
+ .ucmd()
+ .args(&["-t'\n'", "-tb"])
+ .ignore_stdin_write_error()
+ .pipe_in("a\n")
+ .fails()
+ .no_stdout()
+ .stderr_contains("split: multiple separator characters specified");
+}
- assert_eq!(file_read("xaa"), "1\n3\n5\n");
- assert_eq!(file_read("xab"), "2\n4\n");
+// Test using same separator multiple times
+#[test]
+fn test_split_separator_same_multiple() {
+ let scene = TestScenario::new(util_name!());
+ scene
+ .ucmd()
+ .args(&["--separator=:", "--separator=:", "fivelines.txt"])
+ .succeeds();
+ scene
+ .ucmd()
+ .args(&["-t:", "--separator=:", "fivelines.txt"])
+ .succeeds();
+ scene
+ .ucmd()
+ .args(&["-t", ":", "-t", ":", "fivelines.txt"])
+ .succeeds();
+ scene
+ .ucmd()
+ .args(&["-t:", "-t:", "-t,", "fivelines.txt"])
+ .fails();
}
diff --git a/tests/by-util/test_stat.rs b/tests/by-util/test_stat.rs
index 5a6fa41f2345c521bcd676e05c83c45d1cf0f2bd..189b1d4410911ff7b761670f98d46382f39612bd 100644
--- a/tests/by-util/test_stat.rs
+++ b/tests/by-util/test_stat.rs
@@ -1,11 +1,9 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-extern crate regex;
-
-use crate::common::util::*;
+use crate::common::util::{expected_result, TestScenario};
#[test]
fn test_invalid_arg() {
@@ -53,8 +51,8 @@ fn test_terse_normal_format() {
let ts = TestScenario::new(util_name!());
let actual = ts.ucmd().args(&args).succeeds().stdout_move_str();
let expect = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
- println!("actual: {:?}", actual);
- println!("expect: {:?}", expect);
+ println!("actual: {actual:?}");
+ println!("expect: {expect:?}");
let v_actual: Vec<&str> = actual.trim().split(' ').collect();
let mut v_expect: Vec<&str> = expect.trim().split(' ').collect();
assert!(!v_expect.is_empty());
@@ -83,8 +81,8 @@ fn test_format_created_time() {
let ts = TestScenario::new(util_name!());
let actual = ts.ucmd().args(&args).succeeds().stdout_move_str();
let expect = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
- println!("actual: {:?}", actual);
- println!("expect: {:?}", expect);
+ println!("actual: {actual:?}");
+ println!("expect: {expect:?}");
// note: using a regex instead of `split_whitespace()` in order to detect whitespace differences
let re = regex::Regex::new(r"\s").unwrap();
let v_actual: Vec<&str> = re.split(&actual).collect();
@@ -108,8 +106,8 @@ fn test_format_created_seconds() {
let ts = TestScenario::new(util_name!());
let actual = ts.ucmd().args(&args).succeeds().stdout_move_str();
let expect = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
- println!("actual: {:?}", actual);
- println!("expect: {:?}", expect);
+ println!("actual: {actual:?}");
+ println!("expect: {expect:?}");
// note: using a regex instead of `split_whitespace()` in order to detect whitespace differences
let re = regex::Regex::new(r"\s").unwrap();
let v_actual: Vec<&str> = re.split(&actual).collect();
@@ -180,7 +178,7 @@ fn test_char() {
DEV_FORMAT_STR,
#[cfg(target_os = "linux")]
"/dev/pts/ptmx",
- #[cfg(any(target_vendor = "apple"))]
+ #[cfg(target_vendor = "apple")]
"%a %A %b %B %d %D %f %F %g %G %h %i %m %n %o %s (/%T) %u %U %W %X %y %Y %z %Z",
#[cfg(any(target_os = "android", target_vendor = "apple"))]
"/dev/ptmx",
@@ -200,7 +198,7 @@ fn test_date() {
"%z",
#[cfg(target_os = "linux")]
"/bin/sh",
- #[cfg(any(target_vendor = "apple"))]
+ #[cfg(target_vendor = "apple")]
"%z",
#[cfg(any(target_os = "android", target_vendor = "apple"))]
"/bin/sh",
@@ -215,7 +213,7 @@ fn test_date() {
"%z",
#[cfg(target_os = "linux")]
"/dev/ptmx",
- #[cfg(any(target_vendor = "apple"))]
+ #[cfg(target_vendor = "apple")]
"%z",
#[cfg(any(target_os = "android", target_vendor = "apple"))]
"/dev/ptmx",
@@ -306,6 +304,19 @@ fn test_stdin_pipe_fifo2() {
.succeeded();
}
+#[test]
+#[cfg(all(unix, not(target_os = "android")))]
+fn test_stdin_with_fs_option() {
+ // $ stat -f -
+ new_ucmd!()
+ .arg("-f")
+ .arg("-")
+ .set_stdin(std::process::Stdio::null())
+ .fails()
+ .code_is(1)
+ .stderr_contains("using '-' to denote standard input does not work in file system mode");
+}
+
#[test]
#[cfg(all(
unix,
@@ -327,3 +338,10 @@ fn test_stdin_redirect() {
.stdout_contains("File: -")
.succeeded();
}
+
+#[test]
+fn test_without_argument() {
+ new_ucmd!()
+ .fails()
+ .stderr_contains("missing operand\nTry 'stat --help' for more information.");
+}
diff --git a/tests/by-util/test_stdbuf.rs b/tests/by-util/test_stdbuf.rs
index 344b759db3d996cece49693de49bd3fa72f5f009..b2fd33f77a818bf92be35c7228791681fa63de78 100644
--- a/tests/by-util/test_stdbuf.rs
+++ b/tests/by-util/test_stdbuf.rs
@@ -1,5 +1,9 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
#[cfg(not(target_os = "windows"))]
-use crate::common::util::*;
+use crate::common::util::TestScenario;
#[cfg(not(target_os = "windows"))]
#[test]
@@ -30,7 +34,7 @@ fn test_stdbuf_no_buffer_option_fails() {
ts.ucmd()
.args(&["head"])
.fails()
- .stderr_contains("The following required arguments were not provided:");
+ .stderr_contains("the following required arguments were not provided:");
}
#[cfg(not(target_os = "windows"))]
@@ -61,8 +65,7 @@ fn test_stdbuf_invalid_mode_fails() {
.args(&[*option, "1024R", "head"])
.fails()
.code_is(125)
- .stderr_only("stdbuf: invalid mode '1024R'");
- #[cfg(not(target_pointer_width = "128"))]
+ .usage_error("invalid mode '1024R': Value too large for defined data type");
new_ucmd!()
.args(&[*option, "1Y", "head"])
.fails()
diff --git a/tests/by-util/test_stty.rs b/tests/by-util/test_stty.rs
index d15052591a610775c21566862d5165cf6de37620..a9a9209b034dd03f27fd05a7220be6c153f0c8a8 100644
--- a/tests/by-util/test_stty.rs
+++ b/tests/by-util/test_stty.rs
@@ -1,6 +1,10 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore parenb parmrk ixany iuclc onlcr ofdel icanon noflsh
-use crate::common::util::*;
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
diff --git a/tests/by-util/test_sum.rs b/tests/by-util/test_sum.rs
index 68432a6479412f1602c25dc8bfb4d23de70642fd..13f453ba113ba01ccc9644ec66dee36a3850cc00 100644
--- a/tests/by-util/test_sum.rs
+++ b/tests/by-util/test_sum.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
@@ -64,7 +68,7 @@ fn test_invalid_file() {
at.mkdir("a");
- ucmd.arg("a").fails().stderr_is("sum: a: Is a directory");
+ ucmd.arg("a").fails().stderr_is("sum: a: Is a directory\n");
}
#[test]
@@ -73,5 +77,5 @@ fn test_invalid_metadata() {
ucmd.arg("b")
.fails()
- .stderr_is("sum: b: No such file or directory");
+ .stderr_is("sum: b: No such file or directory\n");
}
diff --git a/tests/by-util/test_sync.rs b/tests/by-util/test_sync.rs
index 4bf2629c4d5e878677449688595c7ac0e6f2174f..9a824cd4861f7a156de1bfe2ef66c155d0a9d772 100644
--- a/tests/by-util/test_sync.rs
+++ b/tests/by-util/test_sync.rs
@@ -1,5 +1,8 @@
-use crate::common::util::*;
-extern crate tempfile;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
use std::fs;
use tempfile::tempdir;
@@ -42,7 +45,7 @@ fn test_sync_no_existing_files() {
.arg("--data")
.arg("do-no-exist")
.fails()
- .stderr_contains("cannot stat");
+ .stderr_contains("error opening");
}
#[test]
@@ -64,9 +67,9 @@ fn test_sync_no_permission_dir() {
ts.ccmd("chmod").arg("0").arg(dir).succeeds();
let result = ts.ucmd().arg("--data").arg(dir).fails();
- result.stderr_contains("sync: cannot stat 'foo': Permission denied");
+ result.stderr_contains("sync: error opening 'foo': Permission denied");
let result = ts.ucmd().arg(dir).fails();
- result.stderr_contains("sync: cannot stat 'foo': Permission denied");
+ result.stderr_contains("sync: error opening 'foo': Permission denied");
}
#[cfg(not(target_os = "windows"))]
diff --git a/tests/by-util/test_tac.rs b/tests/by-util/test_tac.rs
index 72fc185b9e6b56c21453213d45dbcfdb8d91a991..fa5f67f133f0e725dca229407e6a34565e578dda 100644
--- a/tests/by-util/test_tac.rs
+++ b/tests/by-util/test_tac.rs
@@ -1,5 +1,9 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore axxbxx bxxaxx axxx axxxx xxaxx xxax xxxxa axyz zyax zyxa
-use crate::common::util::*;
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
diff --git a/tests/by-util/test_tail.rs b/tests/by-util/test_tail.rs
index c6ecd6d392c21c6786a7e06f88e1432abbbedbb3..1df5eade98a0e3ba54d5ff1f52e742fae463d622 100644
--- a/tests/by-util/test_tail.rs
+++ b/tests/by-util/test_tail.rs
@@ -1,18 +1,21 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (ToDO) abcdefghijklmnopqrstuvwxyz efghijklmnopqrstuvwxyz vwxyz emptyfile file siette ocho nueve diez MULT
// spell-checker:ignore (libs) kqueue
// spell-checker:ignore (jargon) tailable untailable datasame runneradmin tmpi
-extern crate tail;
-
-use crate::common::random::*;
-use crate::common::util::*;
+use crate::common::random::{AlphanumericNewline, RandomString};
+#[cfg(unix)]
+use crate::common::util::expected_result;
+#[cfg(not(windows))]
+use crate::common::util::is_ci;
+use crate::common::util::TestScenario;
use pretty_assertions::assert_eq;
use rand::distributions::Alphanumeric;
+use rstest::rstest;
use std::char::from_digit;
use std::fs::File;
use std::io::Write;
@@ -20,6 +23,7 @@ use std::io::Write;
use std::io::{Seek, SeekFrom};
#[cfg(all(
not(target_vendor = "apple"),
+ not(target_os = "android"),
not(target_os = "windows"),
not(target_os = "freebsd")
))]
@@ -28,24 +32,31 @@ use std::process::Stdio;
use tail::chunks::BUFFER_SIZE as CHUNK_BUFFER_SIZE;
#[cfg(all(
not(target_vendor = "apple"),
+ not(target_os = "android"),
not(target_os = "windows"),
not(target_os = "freebsd")
))]
use tail::text;
-static FOOBAR_TXT: &str = "foobar.txt";
-static FOOBAR_2_TXT: &str = "foobar2.txt";
-static FOOBAR_WITH_NULL_TXT: &str = "foobar_with_null.txt";
+const FOOBAR_TXT: &str = "foobar.txt";
+const FOOBAR_2_TXT: &str = "foobar2.txt";
+const FOOBAR_WITH_NULL_TXT: &str = "foobar_with_null.txt";
#[allow(dead_code)]
-static FOLLOW_NAME_TXT: &str = "follow_name.txt";
+const FOLLOW_NAME_TXT: &str = "follow_name.txt";
#[allow(dead_code)]
-static FOLLOW_NAME_SHORT_EXP: &str = "follow_name_short.expected";
+const FOLLOW_NAME_SHORT_EXP: &str = "follow_name_short.expected";
#[allow(dead_code)]
-static FOLLOW_NAME_EXP: &str = "follow_name.expected";
+const FOLLOW_NAME_EXP: &str = "follow_name.expected";
-#[cfg(not(windows))]
const DEFAULT_SLEEP_INTERVAL_MILLIS: u64 = 1000;
+// The binary integer "10000000" is *not* a valid UTF-8 encoding
+// of a character: https://en.wikipedia.org/wiki/UTF-8#Encoding
+#[cfg(unix)]
+const INVALID_UTF8: u8 = 0x80;
+#[cfg(windows)]
+const INVALID_UTF16: u16 = 0xD800;
+
#[test]
fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
@@ -72,7 +83,7 @@ fn test_stdin_explicit() {
#[test]
// FIXME: the -f test fails with: Assertion failed. Expected 'tail' to be running but exited with status=exit status: 0
-#[cfg(disable_until_fixed)]
+#[ignore = "disabled until fixed"]
#[cfg(not(target_vendor = "apple"))] // FIXME: for currently not working platforms
fn test_stdin_redirect_file() {
// $ echo foo > f
@@ -135,12 +146,8 @@ fn test_stdin_redirect_offset() {
}
#[test]
-#[cfg(all(not(target_vendor = "apple"), not(target_os = "windows")))] // FIXME: for currently not working platforms
+#[cfg(not(target_vendor = "apple"))] // FIXME: for currently not working platforms
fn test_stdin_redirect_offset2() {
- // FIXME: windows: Failed because of difference in printed header. See below.
- // actual : ==> - <==
- // expected: ==> standard input <==
-
// like test_stdin_redirect_offset but with multiple files
let ts = TestScenario::new(util_name!());
@@ -269,7 +276,7 @@ fn test_follow_redirect_stdin_name_retry() {
.args(&args)
.fails()
.no_stdout()
- .stderr_is("tail: cannot follow '-' by name")
+ .stderr_is("tail: cannot follow '-' by name\n")
.code_is(1);
args.pop();
}
@@ -295,14 +302,14 @@ fn test_stdin_redirect_dir() {
.set_stdin(File::open(at.plus("dir")).unwrap())
.fails()
.no_stdout()
- .stderr_is("tail: error reading 'standard input': Is a directory")
+ .stderr_is("tail: error reading 'standard input': Is a directory\n")
.code_is(1);
ts.ucmd()
.set_stdin(File::open(at.plus("dir")).unwrap())
.arg("-")
.fails()
.no_stdout()
- .stderr_is("tail: error reading 'standard input': Is a directory")
+ .stderr_is("tail: error reading 'standard input': Is a directory\n")
.code_is(1);
}
@@ -328,14 +335,14 @@ fn test_stdin_redirect_dir_when_target_os_is_macos() {
.set_stdin(File::open(at.plus("dir")).unwrap())
.fails()
.no_stdout()
- .stderr_is("tail: cannot open 'standard input' for reading: No such file or directory")
+ .stderr_is("tail: cannot open 'standard input' for reading: No such file or directory\n")
.code_is(1);
ts.ucmd()
.set_stdin(File::open(at.plus("dir")).unwrap())
.arg("-")
.fails()
.no_stdout()
- .stderr_is("tail: cannot open 'standard input' for reading: No such file or directory")
+ .stderr_is("tail: cannot open 'standard input' for reading: No such file or directory\n")
.code_is(1);
}
@@ -371,7 +378,7 @@ fn test_follow_stdin_name_retry() {
.args(&args)
.run()
.no_stdout()
- .stderr_is("tail: cannot follow '-' by name")
+ .stderr_is("tail: cannot follow '-' by name\n")
.code_is(1);
args.pop();
}
@@ -468,16 +475,13 @@ fn test_follow_non_utf8_bytes() {
// Now append some bytes that are not valid UTF-8.
//
- // The binary integer "10000000" is *not* a valid UTF-8 encoding
- // of a character: https://en.wikipedia.org/wiki/UTF-8#Encoding
- //
// We also write the newline character because our implementation
// of `tail` is attempting to read a line of input, so the
// presence of a newline character will force the `follow()`
// function to conclude reading input bytes and start writing them
// to output. The newline character is not fundamental to this
// test, it is just a requirement of the current implementation.
- let expected = [0b10000000, b'\n'];
+ let expected = [INVALID_UTF8, b'\n'];
at.append_bytes(FOOBAR_TXT, &expected);
child
@@ -528,37 +532,40 @@ fn test_follow_multiple() {
#[test]
#[cfg(not(target_os = "windows"))] // FIXME: test times out
fn test_follow_name_multiple() {
- let (at, mut ucmd) = at_and_ucmd!();
- let mut child = ucmd
- .arg("--follow=name")
- .arg(FOOBAR_TXT)
- .arg(FOOBAR_2_TXT)
- .run_no_wait();
+ // spell-checker:disable-next-line
+ for argument in ["--follow=name", "--follo=nam", "--f=n"] {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let mut child = ucmd
+ .arg(argument)
+ .arg(FOOBAR_TXT)
+ .arg(FOOBAR_2_TXT)
+ .run_no_wait();
- child
- .make_assertion_with_delay(500)
- .is_alive()
- .with_current_output()
- .stdout_only_fixture("foobar_follow_multiple.expected");
+ child
+ .make_assertion_with_delay(500)
+ .is_alive()
+ .with_current_output()
+ .stdout_only_fixture("foobar_follow_multiple.expected");
- let first_append = "trois\n";
- at.append(FOOBAR_2_TXT, first_append);
+ let first_append = "trois\n";
+ at.append(FOOBAR_2_TXT, first_append);
- child
- .make_assertion_with_delay(DEFAULT_SLEEP_INTERVAL_MILLIS)
- .with_current_output()
- .stdout_only(first_append);
+ child
+ .make_assertion_with_delay(DEFAULT_SLEEP_INTERVAL_MILLIS)
+ .with_current_output()
+ .stdout_only(first_append);
- let second_append = "twenty\nthirty\n";
- at.append(FOOBAR_TXT, second_append);
+ let second_append = "twenty\nthirty\n";
+ at.append(FOOBAR_TXT, second_append);
- child
- .make_assertion_with_delay(DEFAULT_SLEEP_INTERVAL_MILLIS)
- .with_current_output()
- .stdout_only_fixture("foobar_follow_multiple_appended.expected");
+ child
+ .make_assertion_with_delay(DEFAULT_SLEEP_INTERVAL_MILLIS)
+ .with_current_output()
+ .stdout_only_fixture("foobar_follow_multiple_appended.expected");
- child.make_assertion().is_alive();
- child.kill();
+ child.make_assertion().is_alive();
+ child.kill();
+ }
}
#[test]
@@ -621,17 +628,19 @@ fn test_follow_invalid_pid() {
.fails()
.no_stdout()
.stderr_is(format!(
- "tail: invalid PID: '{}': number too large to fit in target type\n",
- max_pid
+ "tail: invalid PID: '{max_pid}': number too large to fit in target type\n"
));
}
// FixME: test PASSES for usual windows builds, but fails for coverage testing builds (likely related to the specific RUSTFLAGS '-Zpanic_abort_tests -Cpanic=abort') This test also breaks tty settings under bash requiring a 'stty sane' or reset. // spell-checker:disable-line
+// FIXME: FreeBSD: See issue https://github.com/uutils/coreutils/issues/4306
+// Fails intermittently in the CI, but couldn't reproduce the failure locally.
#[test]
#[cfg(all(
not(target_vendor = "apple"),
not(target_os = "windows"),
- not(target_os = "android")
+ not(target_os = "android"),
+ not(target_os = "freebsd")
))] // FIXME: for currently not working platforms
fn test_follow_with_pid() {
use std::process::Command;
@@ -649,7 +658,7 @@ fn test_follow_with_pid() {
let mut child = ucmd
.arg("-f")
- .arg(format!("--pid={}", pid))
+ .arg(format!("--pid={pid}"))
.arg(FOOBAR_TXT)
.arg(FOOBAR_2_TXT)
.run_no_wait();
@@ -706,17 +715,17 @@ fn test_single_big_args() {
let mut big_input = at.make_file(FILE);
for i in 0..LINES {
- writeln!(big_input, "Line {}", i).expect("Could not write to FILE");
+ writeln!(big_input, "Line {i}").expect("Could not write to FILE");
}
big_input.flush().expect("Could not flush FILE");
let mut big_expected = at.make_file(EXPECTED_FILE);
for i in (LINES - N_ARG)..LINES {
- writeln!(big_expected, "Line {}", i).expect("Could not write to EXPECTED_FILE");
+ writeln!(big_expected, "Line {i}").expect("Could not write to EXPECTED_FILE");
}
big_expected.flush().expect("Could not flush EXPECTED_FILE");
- ucmd.arg(FILE).arg("-n").arg(format!("{}", N_ARG)).run();
+ ucmd.arg(FILE).arg("-n").arg(format!("{N_ARG}")).run();
// .stdout_is(at.read(EXPECTED_FILE));
}
@@ -753,21 +762,21 @@ fn test_bytes_big() {
let mut big_input = at.make_file(FILE);
for i in 0..BYTES {
let digit = from_digit((i % 10) as u32, 10).unwrap();
- write!(big_input, "{}", digit).expect("Could not write to FILE");
+ write!(big_input, "{digit}").expect("Could not write to FILE");
}
big_input.flush().expect("Could not flush FILE");
let mut big_expected = at.make_file(EXPECTED_FILE);
for i in (BYTES - N_ARG)..BYTES {
let digit = from_digit((i % 10) as u32, 10).unwrap();
- write!(big_expected, "{}", digit).expect("Could not write to EXPECTED_FILE");
+ write!(big_expected, "{digit}").expect("Could not write to EXPECTED_FILE");
}
big_expected.flush().expect("Could not flush EXPECTED_FILE");
let result = ucmd
.arg(FILE)
.arg("-c")
- .arg(format!("{}", N_ARG))
+ .arg(format!("{N_ARG}"))
.succeeds()
.stdout_move_str();
let expected = at.read(EXPECTED_FILE);
@@ -789,13 +798,13 @@ fn test_lines_with_size_suffix() {
let mut big_input = at.make_file(FILE);
for i in 0..LINES {
- writeln!(big_input, "Line {}", i).expect("Could not write to FILE");
+ writeln!(big_input, "Line {i}").expect("Could not write to FILE");
}
big_input.flush().expect("Could not flush FILE");
let mut big_expected = at.make_file(EXPECTED_FILE);
for i in (LINES - N_ARG)..LINES {
- writeln!(big_expected, "Line {}", i).expect("Could not write to EXPECTED_FILE");
+ writeln!(big_expected, "Line {i}").expect("Could not write to EXPECTED_FILE");
}
big_expected.flush().expect("Could not flush EXPECTED_FILE");
@@ -827,7 +836,7 @@ fn test_multiple_input_files_missing() {
.stdout_is_fixture("foobar_follow_multiple.expected")
.stderr_is(
"tail: cannot open 'missing1' for reading: No such file or directory\n\
- tail: cannot open 'missing2' for reading: No such file or directory",
+ tail: cannot open 'missing2' for reading: No such file or directory\n",
)
.code_is(1);
}
@@ -837,7 +846,7 @@ fn test_follow_missing() {
// Ensure that --follow=name does not imply --retry.
// Ensure that --follow={descriptor,name} (without --retry) does *not wait* for the
// file to appear.
- for follow_mode in &["--follow=descriptor", "--follow=name"] {
+ for follow_mode in &["--follow=descriptor", "--follow=name", "--fo=d", "--fo=n"] {
new_ucmd!()
.arg(follow_mode)
.arg("missing")
@@ -845,7 +854,7 @@ fn test_follow_missing() {
.no_stdout()
.stderr_is(
"tail: cannot open 'missing' for reading: No such file or directory\n\
- tail: no files remaining",
+ tail: no files remaining\n",
)
.code_is(1);
}
@@ -861,7 +870,7 @@ fn test_follow_name_stdin() {
.arg("--follow=name")
.arg("-")
.run()
- .stderr_is("tail: cannot follow '-' by name")
+ .stderr_is("tail: cannot follow '-' by name\n")
.code_is(1);
ts.ucmd()
.arg("--follow=name")
@@ -869,7 +878,7 @@ fn test_follow_name_stdin() {
.arg("-")
.arg("FILE2")
.run()
- .stderr_is("tail: cannot follow '-' by name")
+ .stderr_is("tail: cannot follow '-' by name\n")
.code_is(1);
}
@@ -1101,13 +1110,11 @@ fn test_invalid_num() {
.fails()
.stderr_str()
.starts_with("tail: invalid number of lines: '1024R'");
- #[cfg(not(target_pointer_width = "128"))]
new_ucmd!()
.args(&["-c", "1Y", "emptyfile.txt"])
.fails()
.stderr_str()
.starts_with("tail: invalid number of bytes: '1Y': Value too large for defined data type");
- #[cfg(not(target_pointer_width = "128"))]
new_ucmd!()
.args(&["-n", "1Y", "emptyfile.txt"])
.fails()
@@ -1527,6 +1534,7 @@ fn test_retry8() {
#[test]
#[cfg(all(
not(target_vendor = "apple"),
+ not(target_os = "android"),
not(target_os = "windows"),
not(target_os = "freebsd")
))] // FIXME: for currently not working platforms
@@ -1549,13 +1557,12 @@ fn test_retry9() {
"\
tail: 'parent_dir/watched_file' has become inaccessible: No such file or directory\n\
tail: directory containing watched file was removed\n\
- tail: {} cannot be used, reverting to polling\n\
+ tail: {BACKEND} cannot be used, reverting to polling\n\
tail: 'parent_dir/watched_file' has appeared; following new file\n\
tail: 'parent_dir/watched_file' has become inaccessible: No such file or directory\n\
tail: 'parent_dir/watched_file' has appeared; following new file\n\
tail: 'parent_dir/watched_file' has become inaccessible: No such file or directory\n\
- tail: 'parent_dir/watched_file' has appeared; following new file\n",
- BACKEND
+ tail: 'parent_dir/watched_file' has appeared; following new file\n"
);
let expected_stdout = "foo\nbar\nfoo\nbar\n";
@@ -1608,6 +1615,7 @@ fn test_retry9() {
#[test]
#[cfg(all(
not(target_vendor = "apple"),
+ not(target_os = "android"),
not(target_os = "windows"),
not(target_os = "freebsd")
))] // FIXME: for currently not working platforms
@@ -1670,6 +1678,7 @@ fn test_follow_descriptor_vs_rename1() {
#[test]
#[cfg(all(
not(target_vendor = "apple"),
+ not(target_os = "android"),
not(target_os = "windows"),
not(target_os = "freebsd")
))] // FIXME: for currently not working platforms
@@ -2110,6 +2119,7 @@ fn test_follow_name_move_create1() {
#[test]
#[cfg(all(
not(target_vendor = "apple"),
+ not(target_os = "android"),
not(target_os = "windows"),
not(target_os = "freebsd")
))] // FIXME: for currently not working platforms
@@ -2281,9 +2291,8 @@ fn test_follow_name_move2() {
let file2 = "file2";
let expected_stdout = format!(
- "==> {0} <==\n{0}_content\n\n==> {1} <==\n{1}_content\n{0}_content\n\
- more_{1}_content\n\n==> {0} <==\nmore_{0}_content\n",
- file1, file2
+ "==> {file1} <==\n{file1}_content\n\n==> {file2} <==\n{file2}_content\n{file1}_content\n\
+ more_{file2}_content\n\n==> {file1} <==\nmore_{file1}_content\n"
);
let mut expected_stderr = format!(
"{0}: {1}: No such file or directory\n\
@@ -2438,9 +2447,8 @@ fn test_follow_name_move_retry2() {
let file2 = "b";
let expected_stdout = format!(
- "==> {0} <==\n\n==> {1} <==\n\n==> {0} <==\nx\n\n==> {1} <==\
- \nx\n\n==> {0} <==\nx2\n\n==> {1} <==\ny\n\n==> {0} <==\nz\n",
- file1, file2
+ "==> {file1} <==\n\n==> {file2} <==\n\n==> {file1} <==\nx\n\n==> {file2} <==\
+ \nx\n\n==> {file1} <==\nx2\n\n==> {file2} <==\ny\n\n==> {file1} <==\nz\n"
);
let mut expected_stderr = format!(
"{0}: '{1}' has become inaccessible: No such file or directory\n\
@@ -2523,7 +2531,7 @@ fn test_no_such_file() {
new_ucmd!()
.arg("missing")
.fails()
- .stderr_is("tail: cannot open 'missing' for reading: No such file or directory")
+ .stderr_is("tail: cannot open 'missing' for reading: No such file or directory\n")
.no_stdout()
.code_is(1);
}
@@ -2585,7 +2593,7 @@ fn test_fifo() {
#[test]
#[cfg(unix)]
-#[cfg(disable_until_fixed)]
+#[ignore = "disabled until fixed"]
fn test_illegal_seek() {
// This is here for reference only.
// We don't call seek on fifos, so we don't hit this error case.
@@ -3423,7 +3431,7 @@ fn test_args_when_presume_input_pipe_given_input_is_file() {
}
#[test]
-#[cfg(disable_until_fixed)]
+#[ignore = "disabled until fixed"]
// FIXME: currently missing in the error message is the last line >>tail: no files remaining<<
fn test_when_follow_retry_given_redirected_stdin_from_directory_then_correct_error_message() {
let ts = TestScenario::new(util_name!());
@@ -3448,7 +3456,7 @@ fn test_when_argument_file_is_a_directory() {
let at = &ts.fixtures;
at.mkdir("dir");
- let expected = "tail: error reading 'dir': Is a directory";
+ let expected = "tail: error reading 'dir': Is a directory\n";
ts.ucmd()
.arg("dir")
.fails()
@@ -3486,7 +3494,7 @@ fn test_when_argument_file_is_a_symlink() {
at.symlink_file("dir", "dir_link");
- let expected = "tail: error reading 'dir_link': Is a directory";
+ let expected = "tail: error reading 'dir_link': Is a directory\n";
ts.ucmd()
.arg("dir_link")
.fails()
@@ -3504,7 +3512,7 @@ fn test_when_argument_file_is_a_symlink_to_directory_then_error() {
at.mkdir("dir");
at.symlink_file("dir", "dir_link");
- let expected = "tail: error reading 'dir_link': Is a directory";
+ let expected = "tail: error reading 'dir_link': Is a directory\n";
ts.ucmd()
.arg("dir_link")
.fails()
@@ -3515,7 +3523,7 @@ fn test_when_argument_file_is_a_symlink_to_directory_then_error() {
// TODO: make this work on windows
#[test]
#[cfg(unix)]
-#[cfg(disabled_until_fixed)]
+#[ignore = "disabled until fixed"]
fn test_when_argument_file_is_a_faulty_symlink_then_error() {
let ts = TestScenario::new(util_name!());
let at = &ts.fixtures;
@@ -3547,7 +3555,7 @@ fn test_when_argument_file_is_a_faulty_symlink_then_error() {
#[test]
#[cfg(unix)]
-#[cfg(disabled_until_fixed)]
+#[ignore = "disabled until fixed"]
fn test_when_argument_file_is_non_existent_unix_socket_address_then_error() {
use std::os::unix::net;
@@ -3562,17 +3570,17 @@ fn test_when_argument_file_is_non_existent_unix_socket_address_then_error() {
#[cfg(all(not(target_os = "freebsd"), not(target_os = "macos")))]
let expected_stderr = format!(
- "tail: cannot open '{}' for reading: No such device or address",
+ "tail: cannot open '{}' for reading: No such device or address\n",
socket
);
#[cfg(target_os = "freebsd")]
let expected_stderr = format!(
- "tail: cannot open '{}' for reading: Operation not supported",
+ "tail: cannot open '{}' for reading: Operation not supported\n",
socket
);
#[cfg(target_os = "macos")]
let expected_stderr = format!(
- "tail: cannot open '{}' for reading: Operation not supported on socket",
+ "tail: cannot open '{}' for reading: Operation not supported on socket\n",
socket
);
@@ -3589,7 +3597,7 @@ fn test_when_argument_file_is_non_existent_unix_socket_address_then_error() {
let result = file.write_all(random_string.as_bytes());
assert!(result.is_ok());
- let expected_stdout = vec![format!("==> {} <==", path), random_string].join("\n");
+ let expected_stdout = [format!("==> {} <==", path), random_string].join("\n");
ts.ucmd()
.args(&["-c", "+0", path, socket])
.fails()
@@ -3606,14 +3614,14 @@ fn test_when_argument_file_is_non_existent_unix_socket_address_then_error() {
}
#[test]
-#[cfg(disabled_until_fixed)]
+#[ignore = "disabled until fixed"]
fn test_when_argument_files_are_simple_combinations_of_stdin_and_regular_file() {
let scene = TestScenario::new(util_name!());
- let fixtures = &scene.fixtures;
+ let at = &scene.fixtures;
- fixtures.write("empty", "");
- fixtures.write("data", "file data");
- fixtures.write("fifo", "fifo data");
+ at.touch("empty");
+ at.write("data", "file data");
+ at.write("fifo", "fifo data");
let expected = "==> standard input <==\n\
fifo data\n\
@@ -3621,7 +3629,7 @@ fn test_when_argument_files_are_simple_combinations_of_stdin_and_regular_file()
scene
.ucmd()
.args(&["-c", "+0", "-", "empty"])
- .set_stdin(File::open(fixtures.plus("fifo")).unwrap())
+ .set_stdin(File::open(at.plus("fifo")).unwrap())
.run()
.success()
.stdout_only(expected);
@@ -3655,7 +3663,7 @@ fn test_when_argument_files_are_simple_combinations_of_stdin_and_regular_file()
scene
.ucmd()
.args(&["-c", "+0", "empty", "-"])
- .set_stdin(File::open(fixtures.plus("fifo")).unwrap())
+ .set_stdin(File::open(at.plus("fifo")).unwrap())
.run()
.success()
.stdout_only(expected);
@@ -3701,21 +3709,21 @@ fn test_when_argument_files_are_simple_combinations_of_stdin_and_regular_file()
scene
.ucmd()
.args(&["-c", "+0", "-", "-"])
- .set_stdin(File::open(fixtures.plus("fifo")).unwrap())
+ .set_stdin(File::open(at.plus("fifo")).unwrap())
.run()
.success()
.stdout_only(expected);
}
#[test]
-#[cfg(disabled_until_fixed)]
+#[ignore = "disabled until fixed"]
fn test_when_argument_files_are_triple_combinations_of_fifo_pipe_and_regular_file() {
let scene = TestScenario::new(util_name!());
- let fixtures = &scene.fixtures;
+ let at = &scene.fixtures;
- fixtures.write("empty", "");
- fixtures.write("data", "file data");
- fixtures.write("fifo", "fifo data");
+ at.touch("empty");
+ at.write("data", "file data");
+ at.write("fifo", "fifo data");
let expected = "==> standard input <==\n\
\n\
@@ -3726,7 +3734,7 @@ fn test_when_argument_files_are_triple_combinations_of_fifo_pipe_and_regular_fil
scene
.ucmd()
.args(&["-c", "+0", "-", "empty", "-"])
- .set_stdin(File::open(fixtures.plus("empty")).unwrap())
+ .set_stdin(File::open(at.plus("empty")).unwrap())
.run()
.stdout_only(expected)
.success();
@@ -3806,7 +3814,7 @@ fn test_when_argument_files_are_triple_combinations_of_fifo_pipe_and_regular_fil
scene
.ucmd()
.args(&["-c", "+0", "-", "data", "-"])
- .set_stdin(File::open(fixtures.plus("fifo")).unwrap())
+ .set_stdin(File::open(at.plus("fifo")).unwrap())
.run()
.stdout_only(expected)
.success();
@@ -3819,13 +3827,13 @@ fn test_when_argument_files_are_triple_combinations_of_fifo_pipe_and_regular_fil
// test system. However, this behavior shows up on the command line and, at the time of writing this
// description, with this test on macos and windows.
#[test]
-#[cfg(disable_until_fixed)]
+#[ignore = "disabled until fixed"]
fn test_when_follow_retry_then_initial_print_of_file_is_written_to_stdout() {
let scene = TestScenario::new(util_name!());
- let fixtures = &scene.fixtures;
+ let at = &scene.fixtures;
let expected_stdout = "file data";
- fixtures.write("data", expected_stdout);
+ at.write("data", expected_stdout);
let mut child = scene
.ucmd()
@@ -3844,15 +3852,14 @@ fn test_when_follow_retry_then_initial_print_of_file_is_written_to_stdout() {
#[test]
fn test_args_when_settings_check_warnings_then_shows_warnings() {
let scene = TestScenario::new(util_name!());
- let fixtures = &scene.fixtures;
+ let at = &scene.fixtures;
let file_data = "file data\n";
- fixtures.write("data", file_data);
+ at.write("data", file_data);
let expected_stdout = format!(
"tail: warning: --retry ignored; --retry is useful only when following\n\
- {}",
- file_data
+ {file_data}"
);
scene
.ucmd()
@@ -3864,8 +3871,7 @@ fn test_args_when_settings_check_warnings_then_shows_warnings() {
let expected_stdout = format!(
"tail: warning: --retry only effective for the initial open\n\
- {}",
- file_data
+ {file_data}"
);
let mut child = scene
.ucmd()
@@ -3882,8 +3888,7 @@ fn test_args_when_settings_check_warnings_then_shows_warnings() {
let expected_stdout = format!(
"tail: warning: PID ignored; --pid=PID is useful only when following\n\
- {}",
- file_data
+ {file_data}"
);
scene
.ucmd()
@@ -3896,14 +3901,20 @@ fn test_args_when_settings_check_warnings_then_shows_warnings() {
let expected_stdout = format!(
"tail: warning: --retry ignored; --retry is useful only when following\n\
tail: warning: PID ignored; --pid=PID is useful only when following\n\
- {}",
- file_data
+ {file_data}"
);
scene
.ucmd()
.args(&["--pid=1000", "--retry", "data"])
.stderr_to_stdout()
.run()
+ .stdout_only(&expected_stdout)
+ .success();
+ scene
+ .ucmd()
+ .args(&["--pid=1000", "--pid=1000", "--retry", "data"])
+ .stderr_to_stdout()
+ .run()
.stdout_only(expected_stdout)
.success();
}
@@ -3963,9 +3974,8 @@ fn test_args_when_settings_check_warnings_follow_indefinitely_then_warning() {
let expected_stdout = format!(
"tail: warning: following standard input indefinitely is ineffective\n\
==> data <==\n\
- {}\n\
- ==> standard input <==\n",
- file_data
+ {file_data}\n\
+ ==> standard input <==\n"
);
// tail -f data - < /dev/ptmx
let mut child = scene
@@ -4038,7 +4048,7 @@ fn test_args_when_settings_check_warnings_follow_indefinitely_then_warning() {
#[cfg(unix)]
fn test_args_when_settings_check_warnings_follow_indefinitely_then_no_warning() {
let scene = TestScenario::new(util_name!());
- let fixtures = &scene.fixtures;
+ let at = &scene.fixtures;
#[cfg(target_vendor = "apple")]
let delay = 1000;
@@ -4049,16 +4059,15 @@ fn test_args_when_settings_check_warnings_follow_indefinitely_then_no_warning()
let fifo_data = "fifo data\n";
let fifo_name = "fifo";
let file_name = "data";
- fixtures.write(file_name, file_data);
- fixtures.write(fifo_name, fifo_data);
+ at.write(file_name, file_data);
+ at.write(fifo_name, fifo_data);
let pipe_data = "pipe data";
let expected_stdout = format!(
"==> standard input <==\n\
- {}\n\
- ==> {} <==\n\
- {}",
- pipe_data, file_name, file_data
+ {pipe_data}\n\
+ ==> {file_name} <==\n\
+ {file_data}"
);
let mut child = scene
.ucmd()
@@ -4087,15 +4096,14 @@ fn test_args_when_settings_check_warnings_follow_indefinitely_then_no_warning()
{
let expected_stdout = format!(
"==> standard input <==\n\
- {}\n\
- ==> {} <==\n\
- {}",
- fifo_data, file_name, file_data
+ {fifo_data}\n\
+ ==> {file_name} <==\n\
+ {file_data}"
);
let mut child = scene
.ucmd()
.args(&["--follow=descriptor", "-", file_name])
- .set_stdin(File::open(fixtures.plus(fifo_name)).unwrap())
+ .set_stdin(File::open(at.plus(fifo_name)).unwrap())
.stderr_to_stdout()
.run_no_wait();
@@ -4108,15 +4116,14 @@ fn test_args_when_settings_check_warnings_follow_indefinitely_then_no_warning()
let expected_stdout = format!(
"==> standard input <==\n\
- {}\n\
- ==> {} <==\n\
- {}",
- fifo_data, file_name, file_data
+ {fifo_data}\n\
+ ==> {file_name} <==\n\
+ {file_data}"
);
let mut child = scene
.ucmd()
.args(&["--follow=descriptor", "--pid=0", "-", file_name])
- .set_stdin(File::open(fixtures.plus(fifo_name)).unwrap())
+ .set_stdin(File::open(at.plus(fifo_name)).unwrap())
.stderr_to_stdout()
.run_no_wait();
@@ -4131,16 +4138,16 @@ fn test_args_when_settings_check_warnings_follow_indefinitely_then_no_warning()
/// The expected test outputs come from gnu's tail.
#[test]
-#[cfg(disable_until_fixed)]
+#[ignore = "disabled until fixed"]
fn test_follow_when_files_are_pointing_to_same_relative_file_and_data_is_appended() {
let scene = TestScenario::new(util_name!());
- let fixtures = &scene.fixtures;
+ let at = &scene.fixtures;
let file_data = "file data";
let relative_path_name = "data";
- fixtures.write(relative_path_name, file_data);
- let absolute_path = fixtures.plus("data").canonicalize().unwrap();
+ at.write(relative_path_name, file_data);
+ let absolute_path = at.plus("data").canonicalize().unwrap();
// run with relative path first and then the absolute path
let mut child = scene
@@ -4155,7 +4162,7 @@ fn test_follow_when_files_are_pointing_to_same_relative_file_and_data_is_appende
let more_data = "more data";
child.delay(500);
- fixtures.append(relative_path_name, more_data);
+ at.append(relative_path_name, more_data);
let expected_stdout = format!(
"==> {0} <==\n\
@@ -4180,7 +4187,7 @@ fn test_follow_when_files_are_pointing_to_same_relative_file_and_data_is_appende
.stderr_only(expected_stdout);
// run with absolute path first and then the relative path
- fixtures.write(relative_path_name, file_data);
+ at.write(relative_path_name, file_data);
let mut child = scene
.ucmd()
.args(&[
@@ -4192,7 +4199,7 @@ fn test_follow_when_files_are_pointing_to_same_relative_file_and_data_is_appende
child.delay(500);
let more_data = "more data";
- fixtures.append(relative_path_name, more_data);
+ at.append(relative_path_name, more_data);
let expected_stdout = format!(
"==> {0} <==\n\
@@ -4219,16 +4226,16 @@ fn test_follow_when_files_are_pointing_to_same_relative_file_and_data_is_appende
/// The expected test outputs come from gnu's tail.
#[test]
-#[cfg(disable_until_fixed)]
+#[ignore = "disabled until fixed"]
fn test_follow_when_files_are_pointing_to_same_relative_file_and_file_is_truncated() {
let scene = TestScenario::new(util_name!());
- let fixtures = &scene.fixtures;
+ let at = &scene.fixtures;
let file_data = "file data";
let relative_path_name = "data";
- fixtures.write(relative_path_name, file_data);
- let absolute_path = fixtures.plus("data").canonicalize().unwrap();
+ at.write(relative_path_name, file_data);
+ let absolute_path = at.plus("data").canonicalize().unwrap();
let mut child = scene
.ucmd()
@@ -4244,7 +4251,7 @@ fn test_follow_when_files_are_pointing_to_same_relative_file_and_file_is_truncat
child.delay(500);
let less_data = "less";
- fixtures.write(relative_path_name, "less");
+ at.write(relative_path_name, "less");
let expected_stdout = format!(
"==> {0} <==\n\
@@ -4272,17 +4279,17 @@ fn test_follow_when_files_are_pointing_to_same_relative_file_and_file_is_truncat
/// The expected test outputs come from gnu's tail.
#[test]
#[cfg(unix)]
-#[cfg(disable_until_fixed)]
+#[ignore = "disabled until fixed"]
fn test_follow_when_file_and_symlink_are_pointing_to_same_file_and_append_data() {
let scene = TestScenario::new(util_name!());
- let fixtures = &scene.fixtures;
+ let at = &scene.fixtures;
let file_data = "file data";
let path_name = "data";
let link_name = "link";
- fixtures.write(path_name, file_data);
- fixtures.symlink_file(path_name, link_name);
+ at.write(path_name, file_data);
+ at.symlink_file(path_name, link_name);
let mut child = scene
.ucmd()
@@ -4297,21 +4304,17 @@ fn test_follow_when_file_and_symlink_are_pointing_to_same_file_and_append_data()
child.delay(500);
let more_data = "more data";
- fixtures.append(path_name, more_data);
+ at.append(path_name, more_data);
let expected_stdout = format!(
- "==> {0} <==\n\
- {1}\n\
- ==> {2} <==\n\
- {1}\n\
- ==> {0} <==\n\
- {3}\n\
- ==> {2} <==\n\
- {3}",
- path_name, // 0
- file_data, // 1
- link_name, // 2
- more_data, // 3
+ "==> {path_name} <==\n\
+ {file_data}\n\
+ ==> {link_name} <==\n\
+ {file_data}\n\
+ ==> {path_name} <==\n\
+ {more_data}\n\
+ ==> {link_name} <==\n\
+ {more_data}"
);
child.make_assertion_with_delay(500).is_alive();
@@ -4321,7 +4324,7 @@ fn test_follow_when_file_and_symlink_are_pointing_to_same_file_and_append_data()
.with_current_output()
.stdout_only(expected_stdout);
- fixtures.write(path_name, file_data);
+ at.write(path_name, file_data);
let mut child = scene
.ucmd()
.args(&[
@@ -4335,21 +4338,17 @@ fn test_follow_when_file_and_symlink_are_pointing_to_same_file_and_append_data()
child.delay(500);
let more_data = "more data";
- fixtures.append(path_name, more_data);
+ at.append(path_name, more_data);
let expected_stdout = format!(
- "==> {0} <==\n\
- {1}\n\
- ==> {2} <==\n\
- {1}\n\
- ==> {0} <==\n\
- {3}\n\
- ==> {2} <==\n\
- {3}",
- link_name, // 0
- file_data, // 1
- path_name, // 2
- more_data, // 3
+ "==> {link_name} <==\n\
+ {file_data}\n\
+ ==> {path_name} <==\n\
+ {file_data}\n\
+ ==> {link_name} <==\n\
+ {more_data}\n\
+ ==> {path_name} <==\n\
+ {more_data}"
);
child.make_assertion_with_delay(500).is_alive();
@@ -4360,28 +4359,28 @@ fn test_follow_when_file_and_symlink_are_pointing_to_same_file_and_append_data()
.stdout_only(expected_stdout);
}
-// Fails with:
-// 'Assertion failed. Expected 'tail' to be running but exited with status=exit status: 1.
-// stdout:
-// stderr: tail: warning: --retry ignored; --retry is useful only when following
-// tail: error reading 'dir': Is a directory
-// '
#[test]
-#[cfg(disabled_until_fixed)]
fn test_args_when_directory_given_shorthand_big_f_together_with_retry() {
let scene = TestScenario::new(util_name!());
- let fixtures = &scene.fixtures;
+ let at = &scene.fixtures;
let dirname = "dir";
- fixtures.mkdir(dirname);
+ at.mkdir(dirname);
let expected_stderr = format!(
- "tail: error reading '{0}': Is a directory\n\
- tail: {0}: cannot follow end of this type of file\n",
- dirname
+ "tail: error reading '{dirname}': Is a directory\n\
+ tail: {dirname}: cannot follow end of this type of file\n"
);
-
let mut child = scene.ucmd().args(&["-F", "--retry", "dir"]).run_no_wait();
+ child.make_assertion_with_delay(500).is_alive();
+ child
+ .kill()
+ .make_assertion()
+ .with_current_output()
+ .stderr_only(&expected_stderr);
+
+ let mut child = scene.ucmd().args(&["--retry", "-F", "dir"]).run_no_wait();
+
child.make_assertion_with_delay(500).is_alive();
child
.kill()
@@ -4421,12 +4420,12 @@ fn test_args_when_directory_given_shorthand_big_f_together_with_retry() {
))]
fn test_follow_when_files_are_pointing_to_same_relative_file_and_file_stays_same_size() {
let scene = TestScenario::new(util_name!());
- let fixtures = &scene.fixtures;
+ let at = &scene.fixtures;
let file_data = "file data";
let relative_path_name = "data";
- fixtures.write(relative_path_name, file_data);
+ at.write(relative_path_name, file_data);
let absolute_path = scene.fixtures.plus("data").canonicalize().unwrap();
let mut child = scene
@@ -4442,7 +4441,7 @@ fn test_follow_when_files_are_pointing_to_same_relative_file_and_file_stays_same
child.delay(500);
let same_data = "same data"; // equal size to file_data
- fixtures.write(relative_path_name, same_data);
+ at.write(relative_path_name, same_data);
let expected_stdout = format!(
"==> {0} <==\n\
@@ -4462,29 +4461,340 @@ fn test_follow_when_files_are_pointing_to_same_relative_file_and_file_stays_same
.stdout_only(expected_stdout);
}
+#[rstest]
+#[case::exponent_exceed_float_max("1.0e100000")]
+#[case::underscore_delimiter("1_000")]
+#[case::only_point(".")]
+#[case::space_in_primes("' '")]
+#[case::space(" ")]
+#[case::empty("")]
+#[case::comma_separator("0,0")]
+#[case::words_nominator_fract("one.zero")]
+#[case::words_fract(".zero")]
+#[case::words_nominator("one.")]
+#[case::two_points("0..0")]
+#[case::seconds_unit("1.0s")]
+#[case::circumflex_exponent("1.0e^1000")]
+fn test_args_sleep_interval_when_illegal_argument_then_usage_error(#[case] sleep_interval: &str) {
+ new_ucmd!()
+ .args(&["--sleep-interval", sleep_interval])
+ .run()
+ .usage_error(format!("invalid number of seconds: '{sleep_interval}'"))
+ .code_is(1);
+}
+
#[test]
-#[cfg(disable_until_fixed)]
-fn test_args_sleep_interval_when_illegal_argument_then_usage_error() {
+fn test_gnu_args_plus_c() {
let scene = TestScenario::new(util_name!());
- for interval in [
- &format!("{}0", f64::MAX),
- &format!("{}0.0", f64::MAX),
- "1_000",
- ".",
- "' '",
- "",
- " ",
- "0,0",
- "one.zero",
- ".zero",
- "one.",
- "0..0",
- ] {
- scene
- .ucmd()
- .args(&["--sleep-interval", interval])
- .run()
- .usage_error(format!("invalid number of seconds: '{}'", interval))
- .code_is(1);
- }
+
+ // obs-plus-c1
+ scene
+ .ucmd()
+ .arg("+2c")
+ .pipe_in("abcd")
+ .succeeds()
+ .stdout_only("bcd");
+ // obs-plus-c2
+ scene
+ .ucmd()
+ .arg("+8c")
+ .pipe_in("abcd")
+ .succeeds()
+ .stdout_only("");
+ // obs-plus-x1: same as +10c
+ scene
+ .ucmd()
+ .arg("+c")
+ .pipe_in(format!("x{}z", "y".repeat(10)))
+ .succeeds()
+ .stdout_only("yyz");
+}
+
+#[test]
+fn test_gnu_args_c() {
+ let scene = TestScenario::new(util_name!());
+
+ // obs-c3
+ scene
+ .ucmd()
+ .arg("-1c")
+ .pipe_in("abcd")
+ .succeeds()
+ .stdout_only("d");
+ // obs-c4
+ scene
+ .ucmd()
+ .arg("-9c")
+ .pipe_in("abcd")
+ .succeeds()
+ .stdout_only("abcd");
+ // obs-c5
+ scene
+ .ucmd()
+ .arg("-12c")
+ .pipe_in(format!("x{}z", "y".repeat(12)))
+ .succeeds()
+ .stdout_only(&format!("{}z", "y".repeat(11)));
+}
+
+#[test]
+fn test_gnu_args_l() {
+ let scene = TestScenario::new(util_name!());
+
+ // obs-l1
+ scene
+ .ucmd()
+ .arg("-1l")
+ .pipe_in("x")
+ .succeeds()
+ .stdout_only("x");
+ // obs-l2
+ scene
+ .ucmd()
+ .arg("-1l")
+ .pipe_in("x\ny\n")
+ .succeeds()
+ .stdout_only("y\n");
+ // obs-l3
+ scene
+ .ucmd()
+ .arg("-1l")
+ .pipe_in("x\ny")
+ .succeeds()
+ .stdout_only("y");
+ // obs-l: same as -10l
+ scene
+ .ucmd()
+ .arg("-l")
+ .pipe_in(format!("x{}z", "y\n".repeat(10)))
+ .succeeds()
+ .stdout_only(&format!("{}z", "y\n".repeat(9)));
+}
+
+#[test]
+fn test_gnu_args_plus_l() {
+ let scene = TestScenario::new(util_name!());
+
+ // obs-plus-l4
+ scene
+ .ucmd()
+ .arg("+1l")
+ .pipe_in("x\ny\n")
+ .succeeds()
+ .stdout_only("x\ny\n");
+ // ops-plus-l5
+ scene
+ .ucmd()
+ .arg("+2l")
+ .pipe_in("x\ny\n")
+ .succeeds()
+ .stdout_only("y\n");
+ // obs-plus-x2: same as +10l
+ scene
+ .ucmd()
+ .arg("+l")
+ .pipe_in(format!("x\n{}z", "y\n".repeat(10)))
+ .succeeds()
+ .stdout_only("y\ny\nz");
+}
+
+#[test]
+fn test_gnu_args_number() {
+ let scene = TestScenario::new(util_name!());
+
+ // obs-1
+ scene
+ .ucmd()
+ .arg("-1")
+ .pipe_in("x")
+ .succeeds()
+ .stdout_only("x");
+ // obs-2
+ scene
+ .ucmd()
+ .arg("-1")
+ .pipe_in("x\ny\n")
+ .succeeds()
+ .stdout_only("y\n");
+ // obs-3
+ scene
+ .ucmd()
+ .arg("-1")
+ .pipe_in("x\ny")
+ .succeeds()
+ .stdout_only("y");
+}
+
+#[test]
+fn test_gnu_args_plus_number() {
+ let scene = TestScenario::new(util_name!());
+
+ // obs-plus-4
+ scene
+ .ucmd()
+ .arg("+1")
+ .pipe_in("x\ny\n")
+ .succeeds()
+ .stdout_only("x\ny\n");
+ // ops-plus-5
+ scene
+ .ucmd()
+ .arg("+2")
+ .pipe_in("x\ny\n")
+ .succeeds()
+ .stdout_only("y\n");
+}
+
+#[test]
+fn test_gnu_args_b() {
+ let scene = TestScenario::new(util_name!());
+
+ // obs-b
+ scene
+ .ucmd()
+ .arg("-b")
+ .pipe_in("x\n".repeat(512 * 10 / 2 + 1))
+ .succeeds()
+ .stdout_only(&"x\n".repeat(512 * 10 / 2));
+}
+
+#[test]
+fn test_gnu_args_err() {
+ let scene = TestScenario::new(util_name!());
+
+ // err-1
+ scene
+ .ucmd()
+ .arg("+cl")
+ .fails()
+ .no_stdout()
+ .stderr_is("tail: cannot open '+cl' for reading: No such file or directory\n")
+ .code_is(1);
+ // err-2
+ scene
+ .ucmd()
+ .arg("-cl")
+ .fails()
+ .no_stdout()
+ .stderr_is("tail: invalid number of bytes: 'l'\n")
+ .code_is(1);
+ // err-3
+ scene
+ .ucmd()
+ .arg("+2cz")
+ .fails()
+ .no_stdout()
+ .stderr_is("tail: cannot open '+2cz' for reading: No such file or directory\n")
+ .code_is(1);
+ // err-4
+ scene
+ .ucmd()
+ .arg("-2cX")
+ .fails()
+ .no_stdout()
+ .stderr_is("tail: option used in invalid context -- 2\n")
+ .code_is(1);
+ // err-5
+ scene
+ .ucmd()
+ .arg("-c99999999999999999999")
+ .fails()
+ .no_stdout()
+ .stderr_is("tail: invalid number of bytes: '99999999999999999999'\n")
+ .code_is(1);
+ // err-6
+ scene
+ .ucmd()
+ .arg("-c --")
+ .fails()
+ .no_stdout()
+ .stderr_is("tail: invalid number of bytes: '-'\n")
+ .code_is(1);
+ scene
+ .ucmd()
+ .arg("-5cz")
+ .fails()
+ .no_stdout()
+ .stderr_is("tail: option used in invalid context -- 5\n")
+ .code_is(1);
+ scene
+ .ucmd()
+ .arg("-9999999999999999999b")
+ .fails()
+ .no_stdout()
+ .stderr_is("tail: invalid number: '-9999999999999999999b'\n")
+ .code_is(1);
+ scene
+ .ucmd()
+ .arg("-999999999999999999999b")
+ .fails()
+ .no_stdout()
+ .stderr_is(
+ "tail: invalid number: '-999999999999999999999b': Numerical result out of range\n",
+ )
+ .code_is(1);
+}
+
+#[test]
+fn test_gnu_args_f() {
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ let source = "file";
+ at.touch(source);
+ let mut p = scene.ucmd().args(&["+f", source]).run_no_wait();
+ p.make_assertion_with_delay(500).is_alive();
+ p.kill()
+ .make_assertion()
+ .with_all_output()
+ .no_stderr()
+ .no_stdout();
+
+ let mut p = scene
+ .ucmd()
+ .set_stdin(Stdio::piped())
+ .arg("+f")
+ .run_no_wait();
+ p.make_assertion_with_delay(500).is_alive();
+ p.kill()
+ .make_assertion()
+ .with_all_output()
+ .no_stderr()
+ .no_stdout();
+}
+
+#[test]
+#[cfg(unix)]
+fn test_obsolete_encoding_unix() {
+ use std::ffi::OsStr;
+ use std::os::unix::ffi::OsStrExt;
+
+ let scene = TestScenario::new(util_name!());
+ let invalid_utf8_arg = OsStr::from_bytes(&[b'-', INVALID_UTF8, b'b']);
+
+ scene
+ .ucmd()
+ .arg(invalid_utf8_arg)
+ .fails()
+ .no_stdout()
+ .stderr_is("tail: bad argument encoding: '-�b'\n")
+ .code_is(1);
+}
+
+#[test]
+#[cfg(windows)]
+fn test_obsolete_encoding_windows() {
+ use std::ffi::OsString;
+ use std::os::windows::ffi::OsStringExt;
+
+ let scene = TestScenario::new(util_name!());
+ let invalid_utf16_arg = OsString::from_wide(&['-' as u16, INVALID_UTF16, 'b' as u16]);
+
+ scene
+ .ucmd()
+ .arg(&invalid_utf16_arg)
+ .fails()
+ .no_stdout()
+ .stderr_is("tail: bad argument encoding: '-�b'\n")
+ .code_is(1);
}
diff --git a/tests/by-util/test_tee.rs b/tests/by-util/test_tee.rs
index e90c4dd481586993a378898d9b6af2cf882bec23..f3c678b2a6a904a9bef1d412c78e42889170c0b5 100644
--- a/tests/by-util/test_tee.rs
+++ b/tests/by-util/test_tee.rs
@@ -1,4 +1,11 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
+use regex::Regex;
+#[cfg(target_os = "linux")]
+use std::fmt::Write;
// tests for basic tee functionality.
// inspired by:
@@ -11,6 +18,22 @@ fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
}
+#[test]
+fn test_short_help_is_long_help() {
+ // I can't believe that this test is necessary.
+ let help_short = new_ucmd!()
+ .arg("-h")
+ .succeeds()
+ .no_stderr()
+ .stdout_str()
+ .to_owned();
+ new_ucmd!()
+ .arg("--help")
+ .succeeds()
+ .no_stderr()
+ .stdout_is(help_short);
+}
+
#[test]
fn test_tee_processing_multiple_operands() {
// POSIX says: "Processing of at least 13 file operands shall be supported."
@@ -70,7 +93,10 @@ fn test_tee_append() {
fn test_tee_no_more_writeable_1() {
// equals to 'tee /dev/full out2 <multi_read' call
let (at, mut ucmd) = at_and_ucmd!();
- let content = (1..=10).map(|x| format!("{}\n", x)).collect::<String>();
+ let content = (1..=10).fold(String::new(), |mut output, x| {
+ writeln!(output, "{x}").unwrap();
+ output
+ });
let file_out = "tee_file_out";
ucmd.arg("/dev/full")
@@ -83,6 +109,27 @@ fn test_tee_no_more_writeable_1() {
assert_eq!(at.read(file_out), content);
}
+#[test]
+fn test_readonly() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let content_tee = "hello";
+ let content_file = "world";
+ let file_out = "tee_file_out";
+ let writable_file = "tee_file_out2";
+ at.write(file_out, content_file);
+ at.set_readonly(file_out);
+ ucmd.arg(file_out)
+ .arg(writable_file)
+ .pipe_in(content_tee)
+ .ignore_stdin_write_error()
+ .fails()
+ .stdout_is(content_tee)
+ // Windows says "Access is denied" for some reason.
+ .stderr_matches(&Regex::new("(Permission|Access is) denied").unwrap());
+ assert_eq!(at.read(file_out), content_file);
+ assert_eq!(at.read(writable_file), content_tee);
+}
+
#[test]
#[cfg(target_os = "linux")]
fn test_tee_no_more_writeable_2() {
@@ -90,7 +137,10 @@ fn test_tee_no_more_writeable_2() {
// but currently there is no way to redirect stdout to /dev/full
// so this test is disabled
let (_at, mut ucmd) = at_and_ucmd!();
- let _content = (1..=10).map(|x| format!("{}\n", x)).collect::<String>();
+ let _content = (1..=10).fold(String::new(), |mut output, x| {
+ let _ = writeln!(output, "{x}");
+ output
+ });
let file_out_a = "tee_file_out_a";
let file_out_b = "tee_file_out_b";
@@ -108,8 +158,9 @@ fn test_tee_no_more_writeable_2() {
#[cfg(target_os = "linux")]
mod linux_only {
- use crate::common::util::*;
+ use crate::common::util::{AtPath, TestScenario, UCommand};
+ use std::fmt::Write;
use std::fs::File;
use std::process::{Output, Stdio};
@@ -118,9 +169,10 @@ mod linux_only {
use std::os::unix::io::FromRawFd;
let mut fds: [c_int; 2] = [0, 0];
- if unsafe { libc::pipe(&mut fds as *mut c_int) } != 0 {
- panic!("Failed to create pipe");
- }
+ assert!(
+ (unsafe { libc::pipe(&mut fds as *mut c_int) } == 0),
+ "Failed to create pipe"
+ );
// Drop the read end of the pipe
let _ = unsafe { File::from_raw_fd(fds[0]) };
@@ -130,7 +182,10 @@ mod linux_only {
}
fn run_tee(proc: &mut UCommand) -> (String, Output) {
- let content = (1..=100000).map(|x| format!("{}\n", x)).collect::<String>();
+ let content = (1..=100_000).fold(String::new(), |mut output, x| {
+ let _ = writeln!(output, "{x}");
+ output
+ });
#[allow(deprecated)]
let output = proc
@@ -204,9 +259,7 @@ mod linux_only {
contents.len()
);
assert!(contents.starts_with(&compare),
- "Expected truncated output to be a prefix of the correct output, but it isn't.\n Correct: {}\n Compare: {}",
- contents,
- compare);
+ "Expected truncated output to be a prefix of the correct output, but it isn't.\n Correct: {contents}\n Compare: {compare}");
}
#[test]
@@ -274,6 +327,23 @@ mod linux_only {
expect_correct(file_out_a, &at, content.as_str());
}
+ #[test]
+ fn test_pipe_error_warn_nopipe_3_shortcut() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let file_out_a = "tee_file_out_a";
+
+ let proc = ucmd
+ .arg("--output-error=warn-")
+ .arg(file_out_a)
+ .set_stdout(make_broken_pipe());
+
+ let (content, output) = run_tee(proc);
+
+ expect_success(&output);
+ expect_correct(file_out_a, &at, content.as_str());
+ }
+
#[test]
fn test_pipe_error_warn() {
let (at, mut ucmd) = at_and_ucmd!();
@@ -325,6 +395,23 @@ mod linux_only {
expect_correct(file_out_a, &at, content.as_str());
}
+ #[test]
+ fn test_pipe_error_exit_nopipe_shortcut() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ let file_out_a = "tee_file_out_a";
+
+ let proc = ucmd
+ .arg("--output-error=exit-nop")
+ .arg(file_out_a)
+ .set_stdout(make_broken_pipe());
+
+ let (content, output) = run_tee(proc);
+
+ expect_success(&output);
+ expect_correct(file_out_a, &at, content.as_str());
+ }
+
#[test]
fn test_space_error_default() {
let (at, mut ucmd) = at_and_ucmd!();
diff --git a/tests/by-util/test_test.rs b/tests/by-util/test_test.rs
index 27ff13e3c58e38355a5f96090dd7ff0becf29298..1999634efbcfba3f64e87daceca5a43f9fdb21f6 100644
--- a/tests/by-util/test_test.rs
+++ b/tests/by-util/test_test.rs
@@ -1,16 +1,11 @@
-//
// This file is part of the uutils coreutils package.
//
-// (c) mahkoh (ju.orth [at] gmail [dot] com)
-// (c) Daniel Rocco <drocco@gmail.com>
-//
// For the full copyright and license information, please view the LICENSE
// file that was distributed with this source code.
-//
// spell-checker:ignore (words) egid euid pseudofloat
-use crate::common::util::*;
+use crate::common::util::TestScenario;
use std::thread::sleep;
#[test]
@@ -288,7 +283,7 @@ fn test_float_inequality_is_error() {
.args(&["123.45", "-ge", "6"])
.run()
.code_is(2)
- .stderr_is("test: invalid integer '123.45'");
+ .stderr_is("test: invalid integer '123.45'\n");
}
#[test]
@@ -300,21 +295,17 @@ fn test_invalid_utf8_integer_compare() {
let source = [0x66, 0x6f, 0x80, 0x6f];
let arg = OsStr::from_bytes(&source[..]);
- let mut cmd = new_ucmd!();
- cmd.arg("123").arg("-ne");
- cmd.raw.arg(arg);
-
- cmd.run()
+ new_ucmd!()
+ .args(&[OsStr::new("123"), OsStr::new("-ne"), arg])
+ .run()
.code_is(2)
- .stderr_is("test: invalid integer $'fo\\x80o'");
-
- let mut cmd = new_ucmd!();
- cmd.raw.arg(arg);
- cmd.arg("-eq").arg("456");
+ .stderr_is("test: invalid integer $'fo\\x80o'\n");
- cmd.run()
+ new_ucmd!()
+ .args(&[arg, OsStr::new("-eq"), OsStr::new("456")])
+ .run()
.code_is(2)
- .stderr_is("test: invalid integer $'fo\\x80o'");
+ .stderr_is("test: invalid integer $'fo\\x80o'\n");
}
#[test]
@@ -326,7 +317,7 @@ fn test_file_is_itself() {
}
#[test]
-#[cfg(not(any(target_env = "musl", target_os = "android")))]
+#[cfg(not(target_os = "android"))]
fn test_file_is_newer_than_and_older_than_itself() {
// odd but matches GNU
new_ucmd!()
@@ -373,8 +364,7 @@ fn test_same_device_inode() {
}
#[test]
-#[cfg(not(any(target_env = "musl", target_os = "android")))]
-// musl: creation time is not available on this platform currently
+#[cfg(not(target_os = "android"))]
fn test_newer_file() {
let scenario = TestScenario::new(util_name!());
@@ -386,10 +376,21 @@ fn test_newer_file() {
.ucmd()
.args(&["newer_file", "-nt", "regular_file"])
.succeeds();
+
+ scenario
+ .ucmd()
+ .args(&["regular_file", "-nt", "newer_file"])
+ .fails();
+
+ scenario
+ .ucmd()
+ .args(&["regular_file", "-ot", "newer_file"])
+ .succeeds();
+
scenario
.ucmd()
.args(&["newer_file", "-ot", "regular_file"])
- .succeeds();
+ .fails();
}
#[test]
@@ -552,7 +553,7 @@ fn test_nonexistent_file_is_not_symlink() {
}
#[test]
-// FixME: freebsd fails with 'chmod: sticky_file: Inappropriate file type or format'
+// Only the superuser is allowed to set the sticky bit on files on FreeBSD.
// Windows has no concept of sticky bit
#[cfg(not(any(windows, target_os = "freebsd")))]
fn test_file_is_sticky() {
@@ -666,7 +667,7 @@ fn test_nonexistent_file_not_owned_by_euid() {
}
#[test]
-#[cfg(all(not(windows), not(target_os = "freebsd")))]
+#[cfg(not(windows))]
fn test_file_not_owned_by_euid() {
new_ucmd!()
.args(&["-f", "/bin/sh", "-a", "!", "-O", "/bin/sh"])
@@ -674,9 +675,32 @@ fn test_file_not_owned_by_euid() {
}
#[test]
-#[cfg(all(not(windows), not(target_os = "freebsd")))]
+#[cfg(not(windows))]
fn test_file_owned_by_egid() {
- new_ucmd!().args(&["-G", "regular_file"]).succeeds();
+ let scene = TestScenario::new(util_name!());
+ let at = &scene.fixtures;
+
+ // On some platforms (mostly the BSDs) the test fixture files copied to the
+ // /tmp directory will have a different gid than the current egid (due to
+ // the sticky bit set on the /tmp directory). Fix this before running the
+ // test command.
+ use std::ffi::CString;
+ use std::os::unix::ffi::OsStrExt;
+ use std::os::unix::fs::MetadataExt;
+ use uucore::process::getegid;
+
+ let metadata = at.metadata("regular_file");
+ let file_gid = metadata.gid();
+ let user_gid = getegid();
+
+ if user_gid != file_gid {
+ let file_uid = metadata.uid();
+ let path = CString::new(at.plus("regular_file").as_os_str().as_bytes()).expect("bad path");
+ let r = unsafe { libc::chown(path.as_ptr(), file_uid, user_gid) };
+ assert_ne!(r, -1);
+ }
+
+ scene.ucmd().args(&["-G", "regular_file"]).succeeds();
}
#[test]
@@ -689,10 +713,19 @@ fn test_nonexistent_file_not_owned_by_egid() {
}
#[test]
-#[cfg(all(not(windows), not(target_os = "freebsd")))]
+#[cfg(not(windows))]
fn test_file_not_owned_by_egid() {
+ let target_file = if cfg!(target_os = "freebsd") {
+ // The coreutils test runner user has a primary group id of "wheel",
+ // which matches the gid of /bin/sh, so use /sbin/shutdown which has gid
+ // of "operator".
+ "/sbin/shutdown"
+ } else {
+ "/bin/sh"
+ };
+
new_ucmd!()
- .args(&["-f", "/bin/sh", "-a", "!", "-G", "/bin/sh"])
+ .args(&["-f", target_file, "-a", "!", "-G", target_file])
.succeeds();
}
@@ -827,7 +860,7 @@ fn test_erroneous_parenthesized_expression() {
.args(&["a", "!=", "(", "b", "-a", "b", ")", "!=", "c"])
.run()
.code_is(2)
- .stderr_is("test: extra argument 'b'");
+ .stderr_is("test: extra argument 'b'\n");
}
#[test]
@@ -835,6 +868,15 @@ fn test_or_as_filename() {
new_ucmd!().args(&["x", "-a", "-z", "-o"]).run().code_is(1);
}
+#[test]
+#[ignore = "TODO: Busybox has this working"]
+fn test_filename_or_with_equal() {
+ new_ucmd!()
+ .args(&["-f", "=", "a", "-o", "b"])
+ .run()
+ .code_is(0);
+}
+
#[test]
#[ignore = "GNU considers this an error"]
fn test_string_length_and_nothing() {
@@ -866,7 +908,7 @@ fn test_bracket_syntax_missing_right_bracket() {
ucmd.args(&["1", "-eq"])
.run()
.code_is(2)
- .stderr_is("[: missing ']'");
+ .stderr_is("[: missing ']'\n");
}
#[test]
@@ -923,3 +965,16 @@ fn test_long_integer() {
])
.fails();
}
+
+#[test]
+fn test_missing_argument_after() {
+ let mut ucmd = new_ucmd!();
+
+ let result = ucmd.args(&["(", "foo"]).fails();
+ result.no_stdout();
+ assert_eq!(result.exit_status().code().unwrap(), 2);
+ assert_eq!(
+ result.stderr_str().trim(),
+ "test: missing argument after 'foo'"
+ );
+}
diff --git a/tests/by-util/test_timeout.rs b/tests/by-util/test_timeout.rs
index 053a4a438442b523080ac1a72e3b02cc32d469dd..896065a2056c5f13e16ae991e29e1c11fc68cbe9 100644
--- a/tests/by-util/test_timeout.rs
+++ b/tests/by-util/test_timeout.rs
@@ -1,5 +1,9 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore dont
-use crate::common::util::*;
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
@@ -48,11 +52,11 @@ fn test_verbose() {
new_ucmd!()
.args(&[verbose_flag, ".1", "sleep", "10"])
.fails()
- .stderr_only("timeout: sending signal TERM to command 'sleep'");
+ .stderr_only("timeout: sending signal TERM to command 'sleep'\n");
new_ucmd!()
.args(&[verbose_flag, "-s0", "-k.1", ".1", "sleep", "10"])
.fails()
- .stderr_only("timeout: sending signal EXIT to command 'sleep'\ntimeout: sending signal KILL to command 'sleep'");
+ .stderr_only("timeout: sending signal EXIT to command 'sleep'\ntimeout: sending signal KILL to command 'sleep'\n");
}
}
@@ -89,6 +93,18 @@ fn test_preserve_status() {
.no_stdout();
}
+#[test]
+fn test_preserve_status_even_when_send_signal() {
+ // When sending CONT signal, process doesn't get killed or stopped.
+ // So, expected result is success and code 0.
+ new_ucmd!()
+ .args(&["-s", "CONT", "--preserve-status", ".1", "sleep", "5"])
+ .succeeds()
+ .code_is(0)
+ .no_stderr()
+ .no_stdout();
+}
+
#[test]
fn test_dont_overflow() {
new_ucmd!()
@@ -121,6 +137,14 @@ fn test_invalid_signal() {
.usage_error("'invalid': invalid signal");
}
+#[test]
+fn test_invalid_multi_byte_characters() {
+ new_ucmd!()
+ .args(&["10€", "sleep", "0"])
+ .fails()
+ .usage_error("invalid time interval '10€'");
+}
+
/// Test that the long form of the `--kill-after` argument is recognized.
#[test]
fn test_kill_after_long() {
@@ -130,3 +154,19 @@ fn test_kill_after_long() {
.no_stdout()
.no_stderr();
}
+
+#[test]
+fn test_kill_subprocess() {
+ new_ucmd!()
+ .args(&[
+ // Make sure the CI can spawn the subprocess.
+ "10",
+ "sh",
+ "-c",
+ "trap 'echo inside_trap' TERM; sleep 30",
+ ])
+ .fails()
+ .code_is(124)
+ .stdout_contains("inside_trap")
+ .stderr_contains("Terminated");
+}
diff --git a/tests/by-util/test_touch.rs b/tests/by-util/test_touch.rs
index dc641a37761a9d97e6b6aa989dfd626dc3366e07..44a198452e34098e2c9c8f285a7d61aa8c35a783 100644
--- a/tests/by-util/test_touch.rs
+++ b/tests/by-util/test_touch.rs
@@ -1,18 +1,13 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (formats) cymdhm cymdhms mdhm mdhms ymdhm ymdhms datetime mktime
-// This test relies on
-// --cfg unsound_local_offset
-// https://github.com/time-rs/time/blob/deb8161b84f355b31e39ce09e40c4d6ce3fea837/src/sys/local_offset_at/unix.rs#L112-L120=
-// See https://github.com/time-rs/time/issues/293#issuecomment-946382614=
-// Defined in .cargo/config
-
-extern crate touch;
-use self::touch::filetime::{self, FileTime};
-
-extern crate time;
-use time::macros::{datetime, format_description};
-
-use crate::common::util::*;
+use crate::common::util::{AtPath, TestScenario};
+#[cfg(not(target_os = "freebsd"))]
+use filetime::set_symlink_file_times;
+use filetime::FileTime;
use std::fs::remove_file;
use std::path::PathBuf;
@@ -37,26 +32,12 @@ fn set_file_times(at: &AtPath, path: &str, atime: FileTime, mtime: FileTime) {
filetime::set_file_times(at.plus_as_string(path), atime, mtime).unwrap();
}
-// Adjusts for local timezone
fn str_to_filetime(format: &str, s: &str) -> FileTime {
- let format_description = match format {
- "%y%m%d%H%M" => format_description!("[year repr:last_two][month][day][hour][minute]"),
- "%y%m%d%H%M.%S" => {
- format_description!("[year repr:last_two][month][day][hour][minute].[second]")
- }
- "%Y%m%d%H%M" => format_description!("[year][month][day][hour][minute]"),
- "%Y%m%d%H%M.%S" => format_description!("[year][month][day][hour][minute].[second]"),
- _ => panic!("unexpected dt format"),
- };
- let tm = time::PrimitiveDateTime::parse(s, &format_description).unwrap();
- let d = match time::OffsetDateTime::now_local() {
- Ok(now) => now,
- Err(e) => {
- panic!("Error {} retrieving the OffsetDateTime::now_local", e);
- }
- };
- let offset_dt = tm.assume_offset(d.offset());
- FileTime::from_unix_time(offset_dt.unix_timestamp(), tm.nanosecond())
+ let tm = chrono::NaiveDateTime::parse_from_str(s, format).unwrap();
+ FileTime::from_unix_time(
+ tm.and_utc().timestamp(),
+ tm.and_utc().timestamp_subsec_nanos(),
+ )
}
#[test]
@@ -108,10 +89,7 @@ fn test_touch_set_mdhm_time() {
let start_of_year = str_to_filetime(
"%Y%m%d%H%M",
- &format!(
- "{}01010000",
- time::OffsetDateTime::now_local().unwrap().year()
- ),
+ &format!("{}01010000", time::OffsetDateTime::now_utc().year()),
);
let (atime, mtime) = get_file_times(&at, file);
assert_eq!(atime, mtime);
@@ -214,19 +192,30 @@ fn test_touch_set_cymdhms_time() {
#[test]
fn test_touch_set_only_atime() {
- let (at, mut ucmd) = at_and_ucmd!();
+ let atime_args = [
+ "-a",
+ "--time=access",
+ "--time=atime",
+ "--time=atim", // spell-checker:disable-line
+ "--time=a",
+ "--time=use",
+ ];
let file = "test_touch_set_only_atime";
- ucmd.args(&["-t", "201501011234", "-a", file])
- .succeeds()
- .no_stderr();
+ for atime_arg in atime_args {
+ let (at, mut ucmd) = at_and_ucmd!();
- assert!(at.file_exists(file));
+ ucmd.args(&["-t", "201501011234", atime_arg, file])
+ .succeeds()
+ .no_stderr();
- let start_of_year = str_to_filetime("%Y%m%d%H%M", "201501010000");
- let (atime, mtime) = get_file_times(&at, file);
- assert!(atime != mtime);
- assert_eq!(atime.unix_seconds() - start_of_year.unix_seconds(), 45240);
+ assert!(at.file_exists(file));
+
+ let start_of_year = str_to_filetime("%Y%m%d%H%M", "201501010000");
+ let (atime, mtime) = get_file_times(&at, file);
+ assert!(atime != mtime);
+ assert_eq!(atime.unix_seconds() - start_of_year.unix_seconds(), 45240);
+ }
}
#[test]
@@ -259,14 +248,39 @@ fn test_touch_set_both_date_and_reference() {
let ref_file = "test_touch_reference";
let file = "test_touch_set_both_date_and_reference";
- let start_of_year = str_to_filetime("%Y%m%d%H%M", "201501010000");
+ let start_of_year = str_to_filetime("%Y%m%d%H%M", "201501011234");
at.touch(ref_file);
set_file_times(&at, ref_file, start_of_year, start_of_year);
assert!(at.file_exists(ref_file));
ucmd.args(&["-d", "Thu Jan 01 12:34:00 2015", "-r", ref_file, file])
- .fails();
+ .succeeds()
+ .no_stderr();
+ let (atime, mtime) = get_file_times(&at, file);
+ assert_eq!(atime, start_of_year);
+ assert_eq!(mtime, start_of_year);
+}
+
+#[test]
+fn test_touch_set_both_offset_date_and_reference() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let ref_file = "test_touch_reference";
+ let file = "test_touch_set_both_date_and_reference";
+
+ let start_of_year = str_to_filetime("%Y%m%d%H%M", "201501011234");
+ let five_days_later = str_to_filetime("%Y%m%d%H%M", "201501061234");
+
+ at.touch(ref_file);
+ set_file_times(&at, ref_file, start_of_year, start_of_year);
+ assert!(at.file_exists(ref_file));
+
+ ucmd.args(&["-d", "+5 days", "-r", ref_file, file])
+ .succeeds()
+ .no_stderr();
+ let (atime, mtime) = get_file_times(&at, file);
+ assert_eq!(atime, five_days_later);
+ assert_eq!(mtime, five_days_later);
}
#[test]
@@ -286,19 +300,23 @@ fn test_touch_set_both_time_and_date() {
#[test]
fn test_touch_set_only_mtime() {
- let (at, mut ucmd) = at_and_ucmd!();
+ let mtime_args = ["-m", "--time=modify", "--time=mtime", "--time=m"];
let file = "test_touch_set_only_mtime";
- ucmd.args(&["-t", "201501011234", "-m", file])
- .succeeds()
- .no_stderr();
+ for mtime_arg in mtime_args {
+ let (at, mut ucmd) = at_and_ucmd!();
- assert!(at.file_exists(file));
+ ucmd.args(&["-t", "201501011234", mtime_arg, file])
+ .succeeds()
+ .no_stderr();
- let start_of_year = str_to_filetime("%Y%m%d%H%M", "201501010000");
- let (atime, mtime) = get_file_times(&at, file);
- assert!(atime != mtime);
- assert_eq!(mtime.unix_seconds() - start_of_year.unix_seconds(), 45240);
+ assert!(at.file_exists(file));
+
+ let start_of_year = str_to_filetime("%Y%m%d%H%M", "201501010000");
+ let (atime, mtime) = get_file_times(&at, file);
+ assert!(atime != mtime);
+ assert_eq!(mtime.unix_seconds() - start_of_year.unix_seconds(), 45240);
+ }
}
#[test]
@@ -425,7 +443,7 @@ fn test_touch_set_date3() {
assert!(at.file_exists(file));
- let expected = FileTime::from_unix_time(1623786360, 0);
+ let expected = FileTime::from_unix_time(1_623_786_360, 0);
let (atime, mtime) = get_file_times(&at, file);
assert_eq!(atime, mtime);
assert_eq!(atime, expected);
@@ -464,9 +482,9 @@ fn test_touch_set_date5() {
// Slightly different result on Windows for nano seconds
// TODO: investigate
#[cfg(windows)]
- let expected = FileTime::from_unix_time(67413, 23456700);
+ let expected = FileTime::from_unix_time(67413, 23_456_700);
#[cfg(not(windows))]
- let expected = FileTime::from_unix_time(67413, 23456789);
+ let expected = FileTime::from_unix_time(67413, 23_456_789);
let (atime, mtime) = get_file_times(&at, file);
assert_eq!(atime, mtime);
@@ -485,7 +503,7 @@ fn test_touch_set_date6() {
assert!(at.file_exists(file));
- let expected = FileTime::from_unix_time(946684800, 0);
+ let expected = FileTime::from_unix_time(946_684_800, 0);
let (atime, mtime) = get_file_times(&at, file);
assert_eq!(atime, mtime);
@@ -504,7 +522,7 @@ fn test_touch_set_date7() {
assert!(at.file_exists(file));
- let expected = FileTime::from_unix_time(1074254400, 0);
+ let expected = FileTime::from_unix_time(1_074_254_400, 0);
let (atime, mtime) = get_file_times(&at, file);
assert_eq!(atime, mtime);
@@ -593,7 +611,15 @@ fn test_touch_set_date_relative_smoke() {
// > (equivalent to ‘day’), the string ‘yesterday’ is worth one day
// > in the past (equivalent to ‘day ago’).
//
- let times = ["yesterday", "tomorrow", "now"];
+ let times = [
+ "yesterday",
+ "tomorrow",
+ "now",
+ "2 seconds",
+ "2 years 1 week",
+ "2 days ago",
+ "2 months and 1 second",
+ ];
for time in times {
let (at, mut ucmd) = at_and_ucmd!();
at.touch("f");
@@ -602,6 +628,11 @@ fn test_touch_set_date_relative_smoke() {
.no_stderr()
.no_stdout();
}
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.touch("f");
+ ucmd.args(&["-d", "a", "f"])
+ .fails()
+ .stderr_contains("touch: Unable to parse date");
}
#[test]
@@ -630,61 +661,21 @@ fn test_touch_mtime_dst_succeeds() {
assert_eq!(target_time, mtime);
}
-// // is_dst_switch_hour returns true if timespec ts is just before the switch
-// // to Daylight Saving Time.
-// // For example, in EST (UTC-5), Timespec { sec: 1583647200, nsec: 0 }
-// // for March 8 2020 01:00:00 AM
-// // is just before the switch because on that day clock jumps by 1 hour,
-// // so 1 minute after 01:59:00 is 03:00:00.
-// fn is_dst_switch_hour(ts: time::Timespec) -> bool {
-// let ts_after = ts + time::Duration::hours(1);
-// let tm = time::at(ts);
-// let tm_after = time::at(ts_after);
-// tm_after.tm_hour == tm.tm_hour + 2
-// }
-
-// get_dst_switch_hour returns date string for which touch -m -t fails.
-// For example, in EST (UTC-5), that will be "202003080200" so
-// touch -m -t 202003080200 file
-// fails (that date/time does not exist).
-// In other locales it will be a different date/time, and in some locales
-// it doesn't exist at all, in which case this function will return None.
-fn get_dst_switch_hour() -> Option<String> {
- //let now = time::OffsetDateTime::now_local().unwrap();
- let now = match time::OffsetDateTime::now_local() {
- Ok(now) => now,
- Err(e) => {
- panic!("Error {} retrieving the OffsetDateTime::now_local", e);
- }
- };
-
- // Start from January 1, 2020, 00:00.
- let tm = datetime!(2020-01-01 00:00 UTC);
- tm.to_offset(now.offset());
-
- // let mut ts = tm.to_timespec();
- // // Loop through all hours in year 2020 until we find the hour just
- // // before the switch to DST.
- // for _i in 0..(366 * 24) {
- // // if is_dst_switch_hour(ts) {
- // // let mut tm = time::at(ts);
- // // tm.tm_hour += 1;
- // // let s = time::strftime("%Y%m%d%H%M", &tm).unwrap();
- // // return Some(s);
- // // }
- // ts = ts + time::Duration::hours(1);
- // }
- None
-}
-
#[test]
+#[cfg(unix)]
fn test_touch_mtime_dst_fails() {
let (_at, mut ucmd) = at_and_ucmd!();
let file = "test_touch_set_mtime_dst_fails";
- if let Some(s) = get_dst_switch_hour() {
- ucmd.args(&["-m", "-t", &s, file]).fails();
- }
+ // Some timezones use daylight savings time, this leads to problems if the
+ // specified time is within the jump forward. In EST (UTC-5), there is a
+ // jump from 1:59AM to 3:00AM on, March 8 2020, so any thing in-between is
+ // invalid.
+ // See https://www.gnu.org/software/libc/manual/html_node/TZ-Variable.html
+ // for information on the TZ variable, which where the string is copied from.
+ ucmd.env("TZ", "EST+5EDT,M3.2.0/2,M11.1.0/2")
+ .args(&["-m", "-t", "202003080200", file])
+ .fails();
}
#[test]
@@ -712,8 +703,7 @@ fn test_touch_no_such_file_error_msg() {
let path_str = path.to_str().unwrap();
new_ucmd!().arg(&path).fails().stderr_only(format!(
- "touch: cannot touch '{}': No such file or directory",
- path_str
+ "touch: cannot touch '{path_str}': No such file or directory\n"
));
}
@@ -755,7 +745,7 @@ fn test_touch_permission_denied_error_msg() {
let full_path = at.plus_as_string(path_str);
ucmd.arg(&full_path).fails().stderr_only(format!(
- "touch: cannot touch '{}': Permission denied",
+ "touch: cannot touch '{}': Permission denied\n",
&full_path
));
}
@@ -842,3 +832,74 @@ fn test_touch_trailing_slash_no_create() {
at.relative_symlink_dir("dir2", "link2");
ucmd.args(&["-c", "link2/"]).succeeds();
}
+
+#[test]
+fn test_touch_no_dereference_ref_dangling() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.touch("file");
+ at.relative_symlink_file("nowhere", "dangling");
+
+ ucmd.args(&["-h", "-r", "dangling", "file"]).succeeds();
+}
+
+#[test]
+fn test_touch_no_dereference_dangling() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.relative_symlink_file("nowhere", "dangling");
+
+ ucmd.args(&["-h", "dangling"]).succeeds();
+}
+
+#[test]
+fn test_touch_dash() {
+ let (_, mut ucmd) = at_and_ucmd!();
+
+ ucmd.args(&["-h", "-"]).succeeds().no_stderr().no_stdout();
+}
+
+#[test]
+fn test_touch_invalid_date_format() {
+ let (_at, mut ucmd) = at_and_ucmd!();
+ let file = "test_touch_invalid_date_format";
+
+ ucmd.args(&["-m", "-t", "+1000000000000 years", file])
+ .fails()
+ .stderr_contains("touch: invalid date format '+1000000000000 years'");
+}
+
+#[test]
+#[cfg(not(target_os = "freebsd"))]
+fn test_touch_symlink_with_no_deref() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let target = "foo.txt";
+ let symlink = "bar.txt";
+ let time = FileTime::from_unix_time(123, 0);
+
+ at.touch(target);
+ at.relative_symlink_file(target, symlink);
+ set_symlink_file_times(at.plus(symlink), time, time).unwrap();
+
+ ucmd.args(&["-a", "--no-dereference", symlink]).succeeds();
+ // Modification time shouldn't be set to the destination's modification time
+ assert_eq!(time, get_symlink_times(&at, symlink).1);
+}
+
+#[test]
+#[cfg(not(target_os = "freebsd"))]
+fn test_touch_reference_symlink_with_no_deref() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let target = "foo.txt";
+ let symlink = "bar.txt";
+ let arg = "baz.txt";
+ let time = FileTime::from_unix_time(123, 0);
+
+ at.touch(target);
+ at.relative_symlink_file(target, symlink);
+ set_symlink_file_times(at.plus(symlink), time, time).unwrap();
+ at.touch(arg);
+
+ ucmd.args(&["--reference", symlink, "--no-dereference", arg])
+ .succeeds();
+ // Times should be taken from the symlink, not the destination
+ assert_eq!((time, time), get_symlink_times(&at, arg));
+}
diff --git a/tests/by-util/test_tr.rs b/tests/by-util/test_tr.rs
index 7f60f88a146ab36b6b4bd79f39b9e93fe541fecf..4179e21fbeae118783b684d583490ebc04a4fa21 100644
--- a/tests/by-util/test_tr.rs
+++ b/tests/by-util/test_tr.rs
@@ -1,5 +1,9 @@
-// spell-checker:ignore aabbaa aabbcc aabc abbb abcc abcdefabcdef abcdefghijk abcdefghijklmn abcdefghijklmnop ABCDEFGHIJKLMNOPQRS abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ ABCDEFZZ abcxyz ABCXYZ abcxyzabcxyz ABCXYZABCXYZ acbdef alnum amzamz AMZXAMZ bbbd cclass cefgm cntrl compl dabcdef dncase Gzabcdefg PQRST upcase wxyzz xdigit xycde xyyye xyyz xyzzzzxyzzzz ZABCDEF Zamz Cdefghijkl Cdefghijklmn
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore aabbaa aabbcc aabc abbb abbbcddd abcc abcdefabcdef abcdefghijk abcdefghijklmn abcdefghijklmnop ABCDEFGHIJKLMNOPQRS abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ ABCDEFZZ abcxyz ABCXYZ abcxyzabcxyz ABCXYZABCXYZ acbdef alnum amzamz AMZXAMZ bbbd cclass cefgm cntrl compl dabcdef dncase Gzabcdefg PQRST upcase wxyzz xdigit XXXYYY xycde xyyye xyyz xyzzzzxyzzzz ZABCDEF Zamz Cdefghijkl Cdefghijklmn asdfqqwweerr qwerr asdfqwer qwer aassddffqwer asdfqwer
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
@@ -25,12 +29,12 @@ fn test_small_set2() {
}
#[test]
-fn test_unicode() {
+fn test_invalid_unicode() {
new_ucmd!()
- .args(&[", ┬─┬", "╯︵┻â”â”»"])
- .pipe_in("(,°□°）, ┬─┬")
- .run()
- .stdout_is("(╯°□°）╯︵┻â”â”»");
+ .args(&["-dc", "abc"])
+ .pipe_in([0o200, b'a', b'b', b'c'])
+ .succeeds()
+ .stdout_is("abc");
}
#[test]
@@ -42,6 +46,32 @@ fn test_delete() {
.stdout_is("BD");
}
+#[test]
+fn test_delete_afterwards_is_not_flag() {
+ new_ucmd!()
+ .args(&["a-z", "-d"])
+ .pipe_in("aBcD")
+ .succeeds()
+ .stdout_is("-BdD");
+}
+
+#[test]
+fn test_delete_multi() {
+ new_ucmd!()
+ .args(&["-d", "-d", "a-z"])
+ .pipe_in("aBcD")
+ .succeeds()
+ .stdout_is("BD");
+}
+
+#[test]
+fn test_delete_late() {
+ new_ucmd!()
+ .args(&["-d", "a-z", "-d"])
+ .fails()
+ .stderr_contains("extra operand '-d'");
+}
+
#[test]
fn test_delete_complement() {
new_ucmd!()
@@ -74,6 +104,14 @@ fn test_complement1() {
.stdout_is("aX");
}
+#[test]
+fn test_complement_afterwards_is_not_flag() {
+ new_ucmd!()
+ .args(&["a", "X", "-c"])
+ .fails()
+ .stderr_contains("extra operand '-c'");
+}
+
#[test]
fn test_complement2() {
new_ucmd!()
@@ -86,10 +124,10 @@ fn test_complement2() {
#[test]
fn test_complement3() {
new_ucmd!()
- .args(&["-c", "abcdefgh", "123"]) // spell-checker:disable-line
+ .args(&["-c", "abcdefgh", "123"])
.pipe_in("the cat and the bat")
.run()
- .stdout_is("3he3ca33a3d33he3ba3"); // spell-checker:disable-line
+ .stdout_is("3he3ca33a3d33he3ba3");
}
#[test]
@@ -114,12 +152,46 @@ fn test_complement5() {
.stdout_is("0a1b2c3");
}
+#[test]
+fn test_complement_multi_early() {
+ new_ucmd!()
+ .args(&["-c", "-c", "a", "X"])
+ .pipe_in("ab")
+ .succeeds()
+ .stdout_is("aX");
+}
+
+#[test]
+fn test_complement_multi_middle() {
+ new_ucmd!()
+ .args(&["-c", "a", "-c", "X"])
+ .fails()
+ .stderr_contains("tr: extra operand 'X'");
+}
+
+#[test]
+fn test_complement_multi_late() {
+ new_ucmd!()
+ .args(&["-c", "a", "X", "-c"])
+ .fails()
+ .stderr_contains("tr: extra operand '-c'");
+}
+
#[test]
fn test_squeeze() {
new_ucmd!()
.args(&["-s", "a-z"])
.pipe_in("aaBBcDcc")
- .run()
+ .succeeds()
+ .stdout_is("aBBcDc");
+}
+
+#[test]
+fn test_squeeze_multi() {
+ new_ucmd!()
+ .args(&["-ss", "-s", "a-z"])
+ .pipe_in("aaBBcDcc")
+ .succeeds()
.stdout_is("aBBcDc");
}
@@ -128,7 +200,16 @@ fn test_squeeze_complement() {
new_ucmd!()
.args(&["-sc", "a-z"])
.pipe_in("aaBBcDcc")
- .run()
+ .succeeds()
+ .stdout_is("aaBcDcc");
+}
+
+#[test]
+fn test_squeeze_complement_multi() {
+ new_ucmd!()
+ .args(&["-scsc", "a-z"]) // spell-checker:disable-line
+ .pipe_in("aaBBcDcc")
+ .succeeds()
.stdout_is("aaBcDcc");
}
@@ -159,6 +240,15 @@ fn test_translate_and_squeeze_multiple_lines() {
.stdout_is("yaay\nyaay"); // spell-checker:disable-line
}
+#[test]
+fn test_delete_and_squeeze_one_set() {
+ new_ucmd!()
+ .args(&["-ds", "a-z"])
+ .fails()
+ .stderr_contains("missing operand after 'a-z'")
+ .stderr_contains("Two strings must be given when deleting and squeezing.");
+}
+
#[test]
fn test_delete_and_squeeze() {
new_ucmd!()
@@ -177,6 +267,15 @@ fn test_delete_and_squeeze_complement() {
.stdout_is("abc");
}
+#[test]
+fn test_delete_and_squeeze_complement_squeeze_set2() {
+ new_ucmd!()
+ .args(&["-dsc", "abX", "XYZ"])
+ .pipe_in("abbbcdddXXXYYY")
+ .succeeds()
+ .stdout_is("abbbX");
+}
+
#[test]
fn test_set1_longer_than_set2() {
new_ucmd!()
@@ -192,7 +291,7 @@ fn test_set1_shorter_than_set2() {
.args(&["ab", "xyz"])
.pipe_in("abcde")
.run()
- .stdout_is("xycde"); // spell-checker:disable-line
+ .stdout_is("xycde");
}
#[test]
@@ -201,8 +300,17 @@ fn test_truncate() {
new_ucmd!()
.args(&["-t", "abc", "xy"])
.pipe_in("abcde")
- .run()
- .stdout_is("xycde"); // spell-checker:disable-line
+ .succeeds()
+ .stdout_is("xycde");
+}
+
+#[test]
+fn test_truncate_multi() {
+ new_ucmd!()
+ .args(&["-tt", "-t", "abc", "xy"])
+ .pipe_in("abcde")
+ .succeeds()
+ .stdout_is("xycde");
}
#[test]
@@ -211,7 +319,7 @@ fn test_truncate_with_set1_shorter_than_set2() {
.args(&["-t", "ab", "xyz"])
.pipe_in("abcde")
.run()
- .stdout_is("xycde"); // spell-checker:disable-line
+ .stdout_is("xycde");
}
#[test]
@@ -729,10 +837,11 @@ fn check_against_gnu_tr_tests_w() {
// {IN=>"\300\301\377\345\345\350\345"},
// {OUT=>"\300\301\377\345"}],
new_ucmd!()
- .args(&["-ds", "\u{350}", "\u{345}"])
- .pipe_in("\u{300}\u{301}\u{377}\u{345}\u{345}\u{350}\u{345}")
+ .arg("-ds")
+ .args(&["\\350", "\\345"])
+ .pipe_in([0o300, 0o301, 0o377, 0o345, 0o345, 0o350, 0o345])
.succeeds()
- .stdout_is("\u{300}\u{301}\u{377}\u{345}");
+ .stdout_is_bytes([0o300, 0o301, 0o377, 0o345]);
}
#[test]
@@ -925,7 +1034,7 @@ fn check_against_gnu_tr_tests_bs_at_end() {
.pipe_in(r"\")
.succeeds()
.stdout_is("x")
- .stderr_is("tr: warning: an unescaped backslash at end of string is not portable");
+ .stderr_is("tr: warning: an unescaped backslash at end of string is not portable\n");
}
#[test]
@@ -938,7 +1047,7 @@ fn check_against_gnu_tr_tests_ross_0a() {
.args(&["-cs", "[:upper:]", "X[Y*]"])
.pipe_in("")
.fails()
- .stderr_is("tr: when translating with complemented character classes,\nstring2 must map all characters in the domain to one");
+ .stderr_is("tr: when translating with complemented character classes,\nstring2 must map all characters in the domain to one\n");
}
#[test]
@@ -1050,6 +1159,24 @@ fn check_against_gnu_tr_tests_empty_cc() {
.stderr_is("tr: missing character class name '[::]'\n");
}
+#[test]
+fn check_against_gnu_tr_tests_repeat_set1() {
+ new_ucmd!()
+ .args(&["[a*]", "a"])
+ .pipe_in("")
+ .fails()
+ .stderr_is("tr: the [c*] repeat construct may not appear in string1\n");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_repeat_set2() {
+ new_ucmd!()
+ .args(&["a", "[a*][a*]"])
+ .pipe_in("")
+ .fails()
+ .stderr_is("tr: only one [c*] repeat construct may appear in string2\n");
+}
+
#[test]
fn check_against_gnu_tr_tests_repeat_bs_9() {
// # Weird repeat counts.
@@ -1124,3 +1251,158 @@ fn check_against_gnu_tr_tests_no_abort_1() {
.succeeds()
.stdout_is("abb");
}
+
+#[test]
+fn test_delete_flag_takes_only_one_operand() {
+ // gnu tr -d fails with more than 1 argument
+ new_ucmd!().args(&["-d", "a", "p"]).fails().stderr_contains(
+ "extra operand 'p'\nOnly one string may be given when deleting without squeezing repeats.",
+ );
+}
+
+#[test]
+fn test_truncate_flag_fails_with_more_than_two_operand() {
+ new_ucmd!()
+ .args(&["-t", "a", "b", "c"])
+ .fails()
+ .stderr_contains("extra operand 'c'");
+}
+
+#[test]
+fn test_squeeze_flag_fails_with_more_than_two_operand() {
+ new_ucmd!()
+ .args(&["-s", "a", "b", "c"])
+ .fails()
+ .stderr_contains("extra operand 'c'");
+}
+
+#[test]
+fn test_complement_flag_fails_with_more_than_two_operand() {
+ new_ucmd!()
+ .args(&["-c", "a", "b", "c"])
+ .fails()
+ .stderr_contains("extra operand 'c'");
+}
+
+#[test]
+fn check_regression_class_space() {
+ // This invocation checks:
+ // 1. that the [:space:] class has exactly 6 characters,
+ // 2. that the [:space:] class contains at least the given 6 characters (and therefore no other characters), and
+ // 3. that the given characters occur in exactly this order.
+ new_ucmd!()
+ .args(&["[:space:][:upper:]", "123456[:lower:]"])
+ // 0x0B = "\v" ("VERTICAL TAB")
+ // 0x0C = "\f" ("FEED FORWARD")
+ .pipe_in("A\t\n\u{0B}\u{0C}\r B")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("a123456b");
+}
+
+#[test]
+fn check_regression_class_blank() {
+ // This invocation checks:
+ // 1. that the [:blank:] class has exactly 2 characters,
+ // 2. that the [:blank:] class contains at least the given 2 characters (and therefore no other characters), and
+ // 3. that the given characters occur in exactly this order.
+ new_ucmd!()
+ .args(&["[:blank:][:upper:]", "12[:lower:]"])
+ .pipe_in("A\t B")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("a12b");
+}
+
+// Check regression found in https://github.com/uutils/coreutils/issues/6163
+#[test]
+fn check_regression_issue_6163_no_match() {
+ new_ucmd!()
+ .args(&["-c", "-t", "Y", "Z"])
+ .pipe_in("X\n")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("X\n");
+}
+
+#[test]
+fn check_regression_issue_6163_match() {
+ new_ucmd!()
+ .args(&["-c", "-t", "Y", "Z"])
+ .pipe_in("\0\n")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("Z\n");
+}
+
+#[test]
+fn check_ignore_truncate_when_deleting_and_squeezing() {
+ new_ucmd!()
+ .args(&["-dts", "asdf", "qwe"])
+ .pipe_in("asdfqqwweerr\n")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("qwerr\n");
+}
+
+#[test]
+fn check_ignore_truncate_when_deleting() {
+ new_ucmd!()
+ .args(&["-dt", "asdf"])
+ .pipe_in("asdfqwer\n")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("qwer\n");
+}
+
+#[test]
+fn check_ignore_truncate_when_squeezing() {
+ new_ucmd!()
+ .args(&["-ts", "asdf"])
+ .pipe_in("aassddffqwer\n")
+ .succeeds()
+ .no_stderr()
+ .stdout_only("asdfqwer\n");
+}
+
+#[test]
+fn check_disallow_blank_in_set2_when_translating() {
+ new_ucmd!().args(&["-t", "1234", "[:blank:]"]).fails();
+}
+
+#[test]
+fn check_class_in_set2_must_be_matched_in_set1() {
+ new_ucmd!().args(&["-t", "1[:upper:]", "[:upper:]"]).fails();
+}
+
+#[test]
+fn check_set1_longer_set2_ends_in_class() {
+ new_ucmd!().args(&["[:lower:]a", "[:upper:]"]).fails();
+}
+
+#[test]
+fn check_set1_longer_set2_ends_in_class_with_trunc() {
+ new_ucmd!()
+ .args(&["-t", "[:lower:]a", "[:upper:]"])
+ .succeeds();
+}
+
+#[test]
+fn check_complement_2_unique_in_set2() {
+ let x226 = "x".repeat(226);
+
+ // [y*] is expanded tp "y" here
+ let arg = x226 + "[y*]xxx";
+ new_ucmd!().args(&["-c", "[:upper:]", arg.as_str()]).fails();
+}
+
+#[test]
+fn check_complement_1_unique_in_set2() {
+ let x226 = "x".repeat(226);
+
+ // [y*] is expanded to "" here
+ let arg = x226 + "[y*]xxxx";
+ new_ucmd!()
+ .args(&["-c", "[:upper:]", arg.as_str()])
+ .succeeds();
+}
diff --git a/tests/by-util/test_true.rs b/tests/by-util/test_true.rs
index aba32578bcf3df7dabadad4c990a49d9fe9d5445..750c60132e8ea111e4913273fad29b31da745427 100644
--- a/tests/by-util/test_true.rs
+++ b/tests/by-util/test_true.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "netbsd"))]
use std::fs::OpenOptions;
diff --git a/tests/by-util/test_truncate.rs b/tests/by-util/test_truncate.rs
index 52c419e8d2bf2681b6131e4c189fc8ccc3b606be..4d639c0f32b822ffcde7c14f35510fde5f8cedfd 100644
--- a/tests/by-util/test_truncate.rs
+++ b/tests/by-util/test_truncate.rs
@@ -1,11 +1,11 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (words) RFILE
-use crate::common::util::*;
+use crate::common::util::TestScenario;
use std::io::{Seek, SeekFrom, Write};
static FILE1: &str = "truncate_test_1";
@@ -19,13 +19,8 @@ fn test_increase_file_size() {
ucmd.args(&["-s", "+5K", FILE1]).succeeds();
file.seek(SeekFrom::End(0)).unwrap();
- let actual = file.seek(SeekFrom::Current(0)).unwrap();
- assert!(
- expected == actual,
- "expected '{}' got '{}'",
- expected,
- actual
- );
+ let actual = file.stream_position().unwrap();
+ assert!(expected == actual, "expected '{expected}' got '{actual}'");
}
#[test]
@@ -36,13 +31,8 @@ fn test_increase_file_size_kb() {
ucmd.args(&["-s", "+5KB", FILE1]).succeeds();
file.seek(SeekFrom::End(0)).unwrap();
- let actual = file.seek(SeekFrom::Current(0)).unwrap();
- assert!(
- expected == actual,
- "expected '{}' got '{}'",
- expected,
- actual
- );
+ let actual = file.stream_position().unwrap();
+ assert!(expected == actual, "expected '{expected}' got '{actual}'");
}
#[test]
@@ -53,9 +43,6 @@ fn test_reference() {
let mut file = at.make_file(FILE2);
// manpage: "A FILE argument that does not exist is created."
- // TODO: 'truncate' does not create the file in this case,
- // but should because '--no-create' wasn't specified.
- at.touch(FILE1); // TODO: remove this when 'no-create' is fixed
scene.ucmd().arg("-s").arg("+5KB").arg(FILE1).succeeds();
scene
@@ -66,13 +53,8 @@ fn test_reference() {
.succeeds();
file.seek(SeekFrom::End(0)).unwrap();
- let actual = file.seek(SeekFrom::Current(0)).unwrap();
- assert!(
- expected == actual,
- "expected '{}' got '{}'",
- expected,
- actual
- );
+ let actual = file.stream_position().unwrap();
+ assert!(expected == actual, "expected '{expected}' got '{actual}'");
}
#[test]
@@ -83,13 +65,8 @@ fn test_decrease_file_size() {
file.write_all(b"1234567890").unwrap();
ucmd.args(&["--size=-4", FILE2]).succeeds();
file.seek(SeekFrom::End(0)).unwrap();
- let actual = file.seek(SeekFrom::Current(0)).unwrap();
- assert!(
- expected == actual,
- "expected '{}' got '{}'",
- expected,
- actual
- );
+ let actual = file.stream_position().unwrap();
+ assert!(expected == actual, "expected '{expected}' got '{actual}'");
}
#[test]
@@ -100,13 +77,8 @@ fn test_space_in_size() {
file.write_all(b"1234567890").unwrap();
ucmd.args(&["--size", " 4", FILE2]).succeeds();
file.seek(SeekFrom::End(0)).unwrap();
- let actual = file.seek(SeekFrom::Current(0)).unwrap();
- assert!(
- expected == actual,
- "expected '{}' got '{}'",
- expected,
- actual
- );
+ let actual = file.stream_position().unwrap();
+ assert!(expected == actual, "expected '{expected}' got '{actual}'");
}
#[test]
@@ -134,13 +106,8 @@ fn test_at_most_shrinks() {
file.write_all(b"1234567890").unwrap();
ucmd.args(&["--size", "<4", FILE2]).succeeds();
file.seek(SeekFrom::End(0)).unwrap();
- let actual = file.seek(SeekFrom::Current(0)).unwrap();
- assert!(
- expected == actual,
- "expected '{}' got '{}'",
- expected,
- actual
- );
+ let actual = file.stream_position().unwrap();
+ assert!(expected == actual, "expected '{expected}' got '{actual}'");
}
#[test]
@@ -151,13 +118,8 @@ fn test_at_most_no_change() {
file.write_all(b"1234567890").unwrap();
ucmd.args(&["--size", "<40", FILE2]).succeeds();
file.seek(SeekFrom::End(0)).unwrap();
- let actual = file.seek(SeekFrom::Current(0)).unwrap();
- assert!(
- expected == actual,
- "expected '{}' got '{}'",
- expected,
- actual
- );
+ let actual = file.stream_position().unwrap();
+ assert!(expected == actual, "expected '{expected}' got '{actual}'");
}
#[test]
@@ -168,13 +130,8 @@ fn test_at_least_grows() {
file.write_all(b"1234567890").unwrap();
ucmd.args(&["--size", ">15", FILE2]).succeeds();
file.seek(SeekFrom::End(0)).unwrap();
- let actual = file.seek(SeekFrom::Current(0)).unwrap();
- assert!(
- expected == actual,
- "expected '{}' got '{}'",
- expected,
- actual
- );
+ let actual = file.stream_position().unwrap();
+ assert!(expected == actual, "expected '{expected}' got '{actual}'");
}
#[test]
@@ -185,13 +142,8 @@ fn test_at_least_no_change() {
file.write_all(b"1234567890").unwrap();
ucmd.args(&["--size", ">4", FILE2]).succeeds();
file.seek(SeekFrom::End(0)).unwrap();
- let actual = file.seek(SeekFrom::Current(0)).unwrap();
- assert!(
- expected == actual,
- "expected '{}' got '{}'",
- expected,
- actual
- );
+ let actual = file.stream_position().unwrap();
+ assert!(expected == actual, "expected '{expected}' got '{actual}'");
}
#[test]
@@ -202,13 +154,8 @@ fn test_round_down() {
file.write_all(b"1234567890").unwrap();
ucmd.args(&["--size", "/4", FILE2]).succeeds();
file.seek(SeekFrom::End(0)).unwrap();
- let actual = file.seek(SeekFrom::Current(0)).unwrap();
- assert!(
- expected == actual,
- "expected '{}' got '{}'",
- expected,
- actual
- );
+ let actual = file.stream_position().unwrap();
+ assert!(expected == actual, "expected '{expected}' got '{actual}'");
}
#[test]
@@ -219,13 +166,8 @@ fn test_round_up() {
file.write_all(b"1234567890").unwrap();
ucmd.args(&["--size", "%4", FILE2]).succeeds();
file.seek(SeekFrom::End(0)).unwrap();
- let actual = file.seek(SeekFrom::Current(0)).unwrap();
- assert!(
- expected == actual,
- "expected '{}' got '{}'",
- expected,
- actual
- );
+ let actual = file.stream_position().unwrap();
+ assert!(expected == actual, "expected '{expected}' got '{actual}'");
}
#[test]
@@ -238,13 +180,8 @@ fn test_size_and_reference() {
ucmd.args(&["--reference", FILE1, "--size", "+5", FILE2])
.succeeds();
file2.seek(SeekFrom::End(0)).unwrap();
- let actual = file2.seek(SeekFrom::Current(0)).unwrap();
- assert!(
- expected == actual,
- "expected '{}' got '{}'",
- expected,
- actual
- );
+ let actual = file2.stream_position().unwrap();
+ assert!(expected == actual, "expected '{expected}' got '{actual}'");
}
#[test]
@@ -254,7 +191,7 @@ fn test_error_filename_only() {
.args(&["file"])
.fails()
.code_is(1)
- .stderr_contains("error: The following required arguments were not provided:");
+ .stderr_contains("error: the following required arguments were not provided:");
}
#[test]
@@ -300,21 +237,19 @@ fn test_reference_with_size_file_not_found() {
#[test]
fn test_truncate_bytes_size() {
- // TODO: this should succeed without error, uncomment when '--no-create' is fixed
- // new_ucmd!()
- // .args(&["--no-create", "--size", "K", "file"])
- // .succeeds();
+ new_ucmd!()
+ .args(&["--no-create", "--size", "K", "file"])
+ .succeeds();
new_ucmd!()
.args(&["--size", "1024R", "file"])
.fails()
.code_is(1)
- .stderr_only("truncate: Invalid number: '1024R'");
- #[cfg(not(target_pointer_width = "128"))]
+ .stderr_only("truncate: Invalid number: '1024R': Value too large for defined data type\n");
new_ucmd!()
.args(&["--size", "1Y", "file"])
.fails()
.code_is(1)
- .stderr_only("truncate: Invalid number: '1Y': Value too large for defined data type");
+ .stderr_only("truncate: Invalid number: '1Y': Value too large for defined data type\n");
}
/// Test that truncating a non-existent file creates that file.
@@ -330,9 +265,39 @@ fn test_new_file() {
assert_eq!(at.read_bytes(filename), vec![b'\0'; 8]);
}
+/// Test that truncating a non-existent file creates that file, even in reference-mode.
+#[test]
+fn test_new_file_reference() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let mut old_file = at.make_file(FILE1);
+ old_file.write_all(b"1234567890").unwrap();
+ let filename = "new_file_that_does_not_exist_yet";
+ ucmd.args(&["-r", FILE1, filename])
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert!(at.file_exists(filename));
+ assert_eq!(at.read_bytes(filename), vec![b'\0'; 10]);
+}
+
+/// Test that truncating a non-existent file creates that file, even in size-and-reference-mode.
+#[test]
+fn test_new_file_size_and_reference() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let mut old_file = at.make_file(FILE1);
+ old_file.write_all(b"1234567890").unwrap();
+ let filename = "new_file_that_does_not_exist_yet";
+ ucmd.args(&["-s", "+3", "-r", FILE1, filename])
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert!(at.file_exists(filename));
+ assert_eq!(at.read_bytes(filename), vec![b'\0'; 13]);
+}
+
/// Test for not creating a non-existent file.
#[test]
-fn test_new_file_no_create() {
+fn test_new_file_no_create_size_only() {
let (at, mut ucmd) = at_and_ucmd!();
let filename = "new_file_that_does_not_exist_yet";
ucmd.args(&["-s", "8", "-c", filename])
@@ -342,6 +307,34 @@ fn test_new_file_no_create() {
assert!(!at.file_exists(filename));
}
+/// Test for not creating a non-existent file.
+#[test]
+fn test_new_file_no_create_reference_only() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let mut old_file = at.make_file(FILE1);
+ old_file.write_all(b"1234567890").unwrap();
+ let filename = "new_file_that_does_not_exist_yet";
+ ucmd.args(&["-r", FILE1, "-c", filename])
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert!(!at.file_exists(filename));
+}
+
+/// Test for not creating a non-existent file.
+#[test]
+fn test_new_file_no_create_size_and_reference() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let mut old_file = at.make_file(FILE1);
+ old_file.write_all(b"1234567890").unwrap();
+ let filename = "new_file_that_does_not_exist_yet";
+ ucmd.args(&["-r", FILE1, "-s", "+8", "-c", filename])
+ .succeeds()
+ .no_stdout()
+ .no_stderr();
+ assert!(!at.file_exists(filename));
+}
+
#[test]
fn test_division_by_zero_size_only() {
new_ucmd!()
diff --git a/tests/by-util/test_tsort.rs b/tests/by-util/test_tsort.rs
index e424fe651c50da27284f5d2bcddbf1f1e1854c09..79195efa211f5514cdeac5f69418cb18efcc0118 100644
--- a/tests/by-util/test_tsort.rs
+++ b/tests/by-util/test_tsort.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
@@ -20,6 +24,14 @@ fn test_sort_self_loop() {
.stdout_only("first\nsecond\n");
}
+#[test]
+fn test_sort_floating_nodes() {
+ new_ucmd!()
+ .pipe_in("d d\nc c\na a\nb b")
+ .succeeds()
+ .stdout_only("a\nb\nc\nd\n");
+}
+
#[test]
fn test_no_such_file() {
new_ucmd!()
@@ -50,7 +62,14 @@ fn test_multiple_arguments() {
.arg("call_graph.txt")
.arg("invalid_file")
.fails()
- .stderr_contains(
- "Found argument 'invalid_file' which wasn't expected, or isn't valid in this context",
- );
+ .stderr_contains("unexpected argument 'invalid_file' found");
+}
+
+#[test]
+fn test_error_on_dir() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.mkdir("tsort_test_dir");
+ ucmd.arg("tsort_test_dir")
+ .fails()
+ .stderr_contains("tsort: tsort_test_dir: read error: Is a directory");
}
diff --git a/tests/by-util/test_tty.rs b/tests/by-util/test_tty.rs
index 726167673b3b2226b90a911ff60d2421115b9338..0f2c588063ad55f7cc088a2f188c11139a118198 100644
--- a/tests/by-util/test_tty.rs
+++ b/tests/by-util/test_tty.rs
@@ -1,6 +1,10 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use std::fs::File;
-use crate::common::util::*;
+use crate::common::util::TestScenario;
#[test]
#[cfg(not(windows))]
diff --git a/tests/by-util/test_uname.rs b/tests/by-util/test_uname.rs
index a0d20cab65e0ec6edb10d4bf0cdac0cfe38fa815..3676eefbaafe84ab58cfafeb961d642d0e9ee549 100644
--- a/tests/by-util/test_uname.rs
+++ b/tests/by-util/test_uname.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
@@ -28,8 +32,11 @@ fn test_uname_processor() {
#[test]
fn test_uname_hardware_platform() {
- let result = new_ucmd!().arg("-i").succeeds();
- assert_eq!(result.stdout_str().trim_end(), "unknown");
+ new_ucmd!()
+ .arg("-i")
+ .succeeds()
+ .stdout_str_apply(str::trim_end)
+ .stdout_only("unknown");
}
#[test]
diff --git a/tests/by-util/test_unexpand.rs b/tests/by-util/test_unexpand.rs
index 1639ee1bc696a0ee6f906630799277539a17867a..6bbd949995a65dc6cc15ac7f1328e899846e090b 100644
--- a/tests/by-util/test_unexpand.rs
+++ b/tests/by-util/test_unexpand.rs
@@ -1,4 +1,9 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+// spell-checker:ignore contenta
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
@@ -231,3 +236,34 @@ fn test_tabs_shortcut_with_too_large_size() {
new_ucmd!().arg(arg).fails().stderr_contains(expected_error);
}
+
+#[test]
+fn test_is_directory() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let dir_name = "dir";
+ at.mkdir(dir_name);
+
+ ucmd.arg(dir_name)
+ .fails()
+ .stderr_contains(format!("unexpand: {dir_name}: Is a directory"));
+}
+
+#[test]
+fn test_multiple_files() {
+ let (at, mut ucmd) = at_and_ucmd!();
+
+ at.write("file", "content");
+ at.write("file1", "a b");
+
+ ucmd.args(&["file", "file1"])
+ .succeeds()
+ .stdout_is("contenta b");
+}
+
+#[test]
+fn test_one_nonexisting_file() {
+ new_ucmd!()
+ .arg("asdf.txt")
+ .fails()
+ .stderr_contains("asdf.txt: No such file or directory");
+}
diff --git a/tests/by-util/test_uniq.rs b/tests/by-util/test_uniq.rs
index 22a56c0e25bd25bac0608c888f2e972fe295c01d..8585ebd835f1bce25aef09885eadf297436fa448 100644
--- a/tests/by-util/test_uniq.rs
+++ b/tests/by-util/test_uniq.rs
@@ -1,7 +1,11 @@
-use std::io::Write;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-// spell-checker:ignore nabcd
-use crate::common::util::*;
+// spell-checker:ignore nabcd badoption schar
+use crate::common::util::TestScenario;
+use uucore::posix::OBSOLETE;
static INPUT: &str = "sorted.txt";
static OUTPUT: &str = "sorted-output.txt";
@@ -14,6 +18,20 @@ fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
}
+#[test]
+fn test_help_and_version_on_stdout() {
+ new_ucmd!()
+ .arg("--help")
+ .succeeds()
+ .no_stderr()
+ .stdout_contains("Usage");
+ new_ucmd!()
+ .arg("--version")
+ .succeeds()
+ .no_stderr()
+ .stdout_contains("uniq");
+}
+
#[test]
fn test_stdin_default() {
new_ucmd!()
@@ -76,7 +94,7 @@ fn test_stdin_skip_and_check_2_chars() {
}
#[test]
-fn test_stdin_skip_1_field() {
+fn test_stdin_skip_2_fields() {
new_ucmd!()
.args(&["-f2"])
.pipe_in_fixture(SKIP_FIELDS)
@@ -84,6 +102,42 @@ fn test_stdin_skip_1_field() {
.stdout_is_fixture("skip-2-fields.expected");
}
+#[test]
+fn test_stdin_skip_2_fields_obsolete() {
+ new_ucmd!()
+ .args(&["-2"])
+ .pipe_in_fixture(SKIP_FIELDS)
+ .run()
+ .stdout_is_fixture("skip-2-fields.expected");
+}
+
+#[test]
+fn test_stdin_skip_21_fields() {
+ new_ucmd!()
+ .args(&["-f21"])
+ .pipe_in_fixture(SKIP_FIELDS)
+ .run()
+ .stdout_is_fixture("skip-21-fields.expected");
+}
+
+#[test]
+fn test_stdin_skip_21_fields_obsolete() {
+ new_ucmd!()
+ .args(&["-21"])
+ .pipe_in_fixture(SKIP_FIELDS)
+ .run()
+ .stdout_is_fixture("skip-21-fields.expected");
+}
+
+#[test]
+fn test_stdin_skip_invalid_fields_obsolete() {
+ new_ucmd!()
+ .args(&["-5q"])
+ .run()
+ .failure()
+ .stderr_contains("error: unexpected argument '-q' found\n");
+}
+
#[test]
fn test_stdin_all_repeated() {
new_ucmd!()
@@ -91,6 +145,21 @@ fn test_stdin_all_repeated() {
.pipe_in_fixture(INPUT)
.run()
.stdout_is_fixture("sorted-all-repeated.expected");
+ new_ucmd!()
+ .args(&["--all-repeated=none"])
+ .pipe_in_fixture(INPUT)
+ .run()
+ .stdout_is_fixture("sorted-all-repeated.expected");
+ new_ucmd!()
+ .args(&["--all-repeated=non"])
+ .pipe_in_fixture(INPUT)
+ .run()
+ .stdout_is_fixture("sorted-all-repeated.expected");
+ new_ucmd!()
+ .args(&["--all-repeated=n"])
+ .pipe_in_fixture(INPUT)
+ .run()
+ .stdout_is_fixture("sorted-all-repeated.expected");
}
#[test]
@@ -98,8 +167,7 @@ fn test_all_repeated_followed_by_filename() {
let filename = "test.txt";
let (at, mut ucmd) = at_and_ucmd!();
- let mut file = at.make_file(filename);
- file.write_all(b"a\na\n").unwrap();
+ at.write(filename, "a\na\n");
ucmd.args(&["--all-repeated", filename])
.run()
@@ -114,6 +182,16 @@ fn test_stdin_all_repeated_separate() {
.pipe_in_fixture(INPUT)
.run()
.stdout_is_fixture("sorted-all-repeated-separate.expected");
+ new_ucmd!()
+ .args(&["--all-repeated=separat"]) // spell-checker:disable-line
+ .pipe_in_fixture(INPUT)
+ .run()
+ .stdout_is_fixture("sorted-all-repeated-separate.expected");
+ new_ucmd!()
+ .args(&["--all-repeated=s"])
+ .pipe_in_fixture(INPUT)
+ .run()
+ .stdout_is_fixture("sorted-all-repeated-separate.expected");
}
#[test]
@@ -123,6 +201,16 @@ fn test_stdin_all_repeated_prepend() {
.pipe_in_fixture(INPUT)
.run()
.stdout_is_fixture("sorted-all-repeated-prepend.expected");
+ new_ucmd!()
+ .args(&["--all-repeated=prepen"]) // spell-checker:disable-line
+ .pipe_in_fixture(INPUT)
+ .run()
+ .stdout_is_fixture("sorted-all-repeated-prepend.expected");
+ new_ucmd!()
+ .args(&["--all-repeated=p"])
+ .pipe_in_fixture(INPUT)
+ .run()
+ .stdout_is_fixture("sorted-all-repeated-prepend.expected");
}
#[test]
@@ -162,14 +250,13 @@ fn test_stdin_zero_terminated() {
}
#[test]
-fn test_invalid_utf8() {
+fn test_gnu_locale_fr_schar() {
new_ucmd!()
- .arg("not-utf8-sequence.txt")
+ .args(&["-f1", "locale-fr-schar.txt"])
+ .env("LC_ALL", "C")
.run()
- .failure()
- .stderr_only(
- "uniq: failed to convert line to utf8: invalid utf-8 sequence of 1 bytes from index 0",
- );
+ .success()
+ .stdout_is_fixture_bytes("locale-fr-schar.txt");
}
#[test]
@@ -186,8 +273,7 @@ fn test_group_followed_by_filename() {
let filename = "test.txt";
let (at, mut ucmd) = at_and_ucmd!();
- let mut file = at.make_file(filename);
- file.write_all(b"a\na\n").unwrap();
+ at.write(filename, "a\na\n");
ucmd.args(&["--group", filename])
.run()
@@ -202,6 +288,11 @@ fn test_group_prepend() {
.pipe_in_fixture(INPUT)
.run()
.stdout_is_fixture("group-prepend.expected");
+ new_ucmd!()
+ .args(&["--group=p"])
+ .pipe_in_fixture(INPUT)
+ .run()
+ .stdout_is_fixture("group-prepend.expected");
}
#[test]
@@ -211,6 +302,11 @@ fn test_group_append() {
.pipe_in_fixture(INPUT)
.run()
.stdout_is_fixture("group-append.expected");
+ new_ucmd!()
+ .args(&["--group=a"])
+ .pipe_in_fixture(INPUT)
+ .run()
+ .stdout_is_fixture("group-append.expected");
}
#[test]
@@ -220,6 +316,16 @@ fn test_group_both() {
.pipe_in_fixture(INPUT)
.run()
.stdout_is_fixture("group-both.expected");
+ new_ucmd!()
+ .args(&["--group=bot"])
+ .pipe_in_fixture(INPUT)
+ .run()
+ .stdout_is_fixture("group-both.expected");
+ new_ucmd!()
+ .args(&["--group=b"])
+ .pipe_in_fixture(INPUT)
+ .run()
+ .stdout_is_fixture("group-both.expected");
}
#[test]
@@ -229,6 +335,11 @@ fn test_group_separate() {
.pipe_in_fixture(INPUT)
.run()
.stdout_is_fixture("group.expected");
+ new_ucmd!()
+ .args(&["--group=s"])
+ .pipe_in_fixture(INPUT)
+ .run()
+ .stdout_is_fixture("group.expected");
}
#[test]
@@ -432,15 +543,15 @@ fn gnu_tests() {
stderr: None,
exit: None,
},
- // // Obsolete syntax for "-f 1"
- // TestCase {
- // name: "obs30",
- // args: &["-1"],
- // input: "a a\nb a\n",
- // stdout: Some("a a\n"),
- // stderr: None,
- // exit: None,
- // },
+ // Obsolete syntax for "-f 1"
+ TestCase {
+ name: "obs30",
+ args: &["-1"],
+ input: "a a\nb a\n",
+ stdout: Some("a a\n"),
+ stderr: None,
+ exit: None,
+ },
TestCase {
name: "31",
args: &["-f", "1"],
@@ -481,23 +592,23 @@ fn gnu_tests() {
stderr: None,
exit: None,
},
- // // Obsolete syntax for "-s 1"
- // TestCase {
- // name: "obs-plus40",
- // args: &["+1"],
- // input: "aaa\naaa\n",
- // stdout: Some("aaa\n"),
- // stderr: None,
- // exit: None,
- // },
- // TestCase {
- // name: "obs-plus41",
- // args: &["+1"],
- // input: "baa\naaa\n",
- // stdout: Some("baa\n"),
- // stderr: None,
- // exit: None,
- // },
+ // Obsolete syntax for "-s 1"
+ TestCase {
+ name: "obs-plus40",
+ args: &["+1"],
+ input: "aaa\naaa\n",
+ stdout: Some("aaa\n"),
+ stderr: None,
+ exit: None,
+ },
+ TestCase {
+ name: "obs-plus41",
+ args: &["+1"],
+ input: "baa\naaa\n",
+ stdout: Some("baa\n"),
+ stderr: None,
+ exit: None,
+ },
TestCase {
name: "42",
args: &["-s", "1"],
@@ -514,23 +625,23 @@ fn gnu_tests() {
stderr: None,
exit: None,
},
- // // Obsolete syntax for "-s 1"
- // TestCase {
- // name: "obs-plus44",
- // args: &["+1", "--"],
- // input: "aaa\naaa\n",
- // stdout: Some("aaa\n"),
- // stderr: None,
- // exit: None,
- // },
- // TestCase {
- // name: "obs-plus45",
- // args: &["+1", "--"],
- // input: "baa\naaa\n",
- // stdout: Some("baa\n"),
- // stderr: None,
- // exit: None,
- // },
+ // Obsolete syntax for "-s 1"
+ TestCase {
+ name: "obs-plus44",
+ args: &["+1", "--"],
+ input: "aaa\naaa\n",
+ stdout: Some("aaa\n"),
+ stderr: None,
+ exit: None,
+ },
+ TestCase {
+ name: "obs-plus45",
+ args: &["+1", "--"],
+ input: "baa\naaa\n",
+ stdout: Some("baa\n"),
+ stderr: None,
+ exit: None,
+ },
TestCase {
name: "50",
args: &["-f", "1", "-s", "1"],
@@ -715,17 +826,17 @@ fn gnu_tests() {
stderr: None,
exit: None,
},
- /*
- Disable as it fails too often. See:
- https://github.com/uutils/coreutils/issues/3509
TestCase {
name: "112",
args: &["-D", "-c"],
- input: "a a\na b\n",
+ input: "", // Note: Different from GNU test, but should not matter
stdout: Some(""),
- stderr: Some("uniq: printing all duplicated lines and repeat counts is meaningless"),
+ stderr: Some(concat!(
+ "uniq: printing all duplicated lines and repeat counts is meaningless\n",
+ "Try 'uniq --help' for more information.\n"
+ )),
exit: Some(1),
- },*/
+ },
TestCase {
name: "113",
args: &["--all-repeated=separate"],
@@ -774,6 +885,21 @@ fn gnu_tests() {
stderr: None,
exit: None,
},
+ TestCase {
+ name: "119",
+ args: &["--all-repeated=badoption"],
+ input: "", // Note: Different from GNU test, but should not matter
+ stdout: Some(""),
+ stderr: Some(concat!(
+ "uniq: invalid argument 'badoption' for '--all-repeated'\n",
+ "Valid arguments are:\n",
+ " - 'none'\n",
+ " - 'prepend'\n",
+ " - 'separate'\n",
+ "Try 'uniq --help' for more information.\n"
+ )),
+ exit: Some(1),
+ },
// \x08 is the backspace char
TestCase {
name: "120",
@@ -783,6 +909,16 @@ fn gnu_tests() {
stderr: None,
exit: None,
},
+ // u128::MAX = 340282366920938463463374607431768211455
+ TestCase {
+ name: "121",
+ args: &["-d", "-u", "-w340282366920938463463374607431768211456"],
+ input: "a\na\n\x08",
+ stdout: Some(""),
+ stderr: None,
+ exit: None,
+ },
+ // Test 122 is the same as 121, just different big int overflow number
TestCase {
name: "123",
args: &["--zero-terminated"],
@@ -927,16 +1063,108 @@ fn gnu_tests() {
stderr: None,
exit: None,
},
+ TestCase {
+ name: "141",
+ args: &["--group", "-c"],
+ input: "",
+ stdout: Some(""),
+ stderr: Some(concat!(
+ "uniq: --group is mutually exclusive with -c/-d/-D/-u\n",
+ "Try 'uniq --help' for more information.\n"
+ )),
+ exit: Some(1),
+ },
+ TestCase {
+ name: "142",
+ args: &["--group", "-d"],
+ input: "",
+ stdout: Some(""),
+ stderr: Some(concat!(
+ "uniq: --group is mutually exclusive with -c/-d/-D/-u\n",
+ "Try 'uniq --help' for more information.\n"
+ )),
+ exit: Some(1),
+ },
+ TestCase {
+ name: "143",
+ args: &["--group", "-u"],
+ input: "",
+ stdout: Some(""),
+ stderr: Some(concat!(
+ "uniq: --group is mutually exclusive with -c/-d/-D/-u\n",
+ "Try 'uniq --help' for more information.\n"
+ )),
+ exit: Some(1),
+ },
+ TestCase {
+ name: "144",
+ args: &["--group", "-D"],
+ input: "",
+ stdout: Some(""),
+ stderr: Some(concat!(
+ "uniq: --group is mutually exclusive with -c/-d/-D/-u\n",
+ "Try 'uniq --help' for more information.\n"
+ )),
+ exit: Some(1),
+ },
+ TestCase {
+ name: "145",
+ args: &["--group=badoption"],
+ input: "",
+ stdout: Some(""),
+ stderr: Some(concat!(
+ "uniq: invalid argument 'badoption' for '--group'\n",
+ "Valid arguments are:\n",
+ " - 'prepend'\n",
+ " - 'append'\n",
+ " - 'separate'\n",
+ " - 'both'\n",
+ "Try 'uniq --help' for more information.\n"
+ )),
+ exit: Some(1),
+ },
];
+ // run regular version of tests with regular file as input
for case in cases {
+ // prep input file
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.write("input-file", case.input);
+
+ // first - run a version of tests with regular file as input
eprintln!("Test {}", case.name);
- let result = new_ucmd!().args(case.args).run_piped_stdin(case.input);
+ // set environment variable for obsolete skip char option tests
+ if case.name.starts_with("obs-plus") {
+ ucmd.env("_POSIX2_VERSION", OBSOLETE.to_string());
+ }
+ let result = ucmd.args(case.args).arg("input-file").run();
+ if let Some(stdout) = case.stdout {
+ result.stdout_is(stdout);
+ }
+ if let Some(stderr) = case.stderr {
+ result.stderr_is(stderr);
+ }
+ if let Some(exit) = case.exit {
+ result.code_is(exit);
+ }
+
+ // then - ".stdin" version of tests with input piped in
+ // NOTE: GNU has another variant for stdin redirect from a file
+ // as in `uniq < input-file`
+ // For now we treat it as equivalent of piped in stdin variant
+ // as in `cat input-file | uniq`
+ eprintln!("Test {}.stdin", case.name);
+ // set environment variable for obsolete skip char option tests
+ let mut ucmd = new_ucmd!();
+ if case.name.starts_with("obs-plus") {
+ ucmd.env("_POSIX2_VERSION", OBSOLETE.to_string());
+ }
+ let result = ucmd.args(case.args).run_piped_stdin(case.input);
if let Some(stdout) = case.stdout {
result.stdout_is(stdout);
}
if let Some(stderr) = case.stderr {
- result.stderr_contains(stderr);
+ result.stderr_is(stderr);
}
if let Some(exit) = case.exit {
result.code_is(exit);
diff --git a/tests/by-util/test_unlink.rs b/tests/by-util/test_unlink.rs
index 36b09be7b0e1736f9dee53ed7c08147a28be2f33..055f47f107653873244df438e43b5f26061b1d2c 100644
--- a/tests/by-util/test_unlink.rs
+++ b/tests/by-util/test_unlink.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
diff --git a/tests/by-util/test_uptime.rs b/tests/by-util/test_uptime.rs
index 946bb30fafdd819e476d3015ec88644281fc491d..382d5f2ef7f928c654648c2ea107fa0128f6fef4 100644
--- a/tests/by-util/test_uptime.rs
+++ b/tests/by-util/test_uptime.rs
@@ -1,6 +1,23 @@
-extern crate regex;
-use self::regex::Regex;
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+//
+// spell-checker:ignore bincode serde utmp runlevel testusr testx
+
+use crate::common::util::TestScenario;
+
+#[cfg(not(target_os = "macos"))]
+use bincode::serialize;
+use regex::Regex;
+#[cfg(not(target_os = "macos"))]
+use serde::Serialize;
+#[cfg(not(target_os = "macos"))]
+use serde_big_array::BigArray;
+#[cfg(not(target_os = "macos"))]
+use std::fs::File;
+#[cfg(not(target_os = "macos"))]
+use std::{io::Write, path::PathBuf};
#[test]
fn test_invalid_arg() {
@@ -8,9 +25,10 @@ fn test_invalid_arg() {
}
#[test]
+#[cfg(not(target_os = "openbsd"))]
fn test_uptime() {
TestScenario::new(util_name!())
- .ucmd_keepenv()
+ .ucmd()
.succeeds()
.stdout_contains("load average:")
.stdout_contains(" up ");
@@ -18,7 +36,227 @@ fn test_uptime() {
// Don't check for users as it doesn't show in some CI
}
+/// Checks for files without utmpx records for which boot time cannot be calculated
+#[test]
+#[cfg(not(any(target_os = "openbsd", target_os = "freebsd")))]
+// Disabled for freebsd, since it doesn't use the utmpxname() sys call to change the default utmpx
+// file that is accessed using getutxent()
+fn test_uptime_for_file_without_utmpx_records() {
+ let (at, mut ucmd) = at_and_ucmd!();
+ at.write("file1", "hello");
+
+ ucmd.arg(at.plus_as_string("file1"))
+ .fails()
+ .stderr_contains("uptime: couldn't get boot time")
+ .stdout_contains("up ???? days ??:??")
+ .stdout_contains("load average");
+}
+
+/// Checks whether uptime displays the correct stderr msg when its called with a fifo
+#[test]
+#[cfg(all(unix, feature = "cp"))]
+fn test_uptime_with_fifo() {
+ // This test can go on forever in the CI in some cases, might need aborting
+ // Sometimes writing to the pipe is broken
+ let ts = TestScenario::new(util_name!());
+
+ let at = &ts.fixtures;
+ at.mkfifo("fifo1");
+
+ at.write("a", "hello");
+ // Creating a child process to write to the fifo
+ let mut child = ts
+ .ccmd("cp")
+ .arg(at.plus_as_string("a"))
+ .arg(at.plus_as_string("fifo1"))
+ .run_no_wait();
+
+ ts.ucmd()
+ .arg("fifo1")
+ .fails()
+ .stderr_contains("uptime: couldn't get boot time: Illegal seek")
+ .stdout_contains("up ???? days ??:??")
+ .stdout_contains("load average");
+
+ child.kill();
+}
+
+#[test]
+#[cfg(not(any(target_os = "openbsd", target_os = "freebsd")))]
+fn test_uptime_with_non_existent_file() {
+ // Disabled for freebsd, since it doesn't use the utmpxname() sys call to change the default utmpx
+ // file that is accessed using getutxent()
+ let ts = TestScenario::new(util_name!());
+
+ ts.ucmd()
+ .arg("file1")
+ .fails()
+ .stderr_contains("uptime: couldn't get boot time: No such file or directory")
+ .stdout_contains("up ???? days ??:??");
+}
+
+// TODO create a similar test for macos
+// This will pass
+#[test]
+#[cfg(not(any(target_os = "openbsd", target_os = "macos")))]
+fn test_uptime_with_file_containing_valid_boot_time_utmpx_record() {
+ // This test will pass for freebsd but we currently don't support changing the utmpx file for
+ // freebsd.
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ // Regex matches for "up 00::00" ,"up 12 days 00::00", the time can be any valid time and
+ // the days can be more than 1 digit or not there. This will match even if the amount of whitespace is
+ // wrong between the days and the time.
+
+ let re = Regex::new(r"up [(\d){1,} days]*\d{1,2}:\d\d").unwrap();
+ utmp(&at.plus("testx"));
+ ts.ucmd()
+ .arg("testx")
+ .succeeds()
+ .stdout_matches(&re)
+ .stdout_contains("load average");
+
+ // Helper function to create byte sequences
+ fn slice_32(slice: &[u8]) -> [i8; 32] {
+ let mut arr: [i8; 32] = [0; 32];
+
+ for (i, val) in slice.iter().enumerate() {
+ arr[i] = *val as i8;
+ }
+ arr
+ }
+ // Creates a file utmp records of three different types including a valid BOOT_TIME entry
+ fn utmp(path: &PathBuf) {
+ // Definitions of our utmpx structs
+ const BOOT_TIME: i32 = 2;
+ const RUN_LVL: i32 = 1;
+ const USER_PROCESS: i32 = 7;
+ #[derive(Serialize)]
+ #[repr(C)]
+ pub struct TimeVal {
+ pub tv_sec: i32,
+ pub tv_usec: i32,
+ }
+
+ #[derive(Serialize)]
+ #[repr(C)]
+ pub struct ExitStatus {
+ e_termination: i16,
+ e_exit: i16,
+ }
+ #[derive(Serialize)]
+ #[repr(C, align(4))]
+ pub struct Utmp {
+ pub ut_type: i32,
+ pub ut_pid: i32,
+ pub ut_line: [i8; 32],
+ pub ut_id: [i8; 4],
+
+ pub ut_user: [i8; 32],
+ #[serde(with = "BigArray")]
+ pub ut_host: [i8; 256],
+ pub ut_exit: ExitStatus,
+ pub ut_session: i32,
+ pub ut_tv: TimeVal,
+
+ pub ut_addr_v6: [i32; 4],
+ glibc_reserved: [i8; 20],
+ }
+
+ let utmp = Utmp {
+ ut_type: BOOT_TIME,
+ ut_pid: 0,
+ ut_line: slice_32("~".as_bytes()),
+ ut_id: [126, 126, 0, 0],
+ ut_user: slice_32("reboot".as_bytes()),
+ ut_host: [0; 256],
+ ut_exit: ExitStatus {
+ e_termination: 0,
+ e_exit: 0,
+ },
+ ut_session: 0,
+ ut_tv: TimeVal {
+ tv_sec: 1716371201,
+ tv_usec: 290913,
+ },
+ ut_addr_v6: [127, 0, 0, 1],
+ glibc_reserved: [0; 20],
+ };
+ let utmp1 = Utmp {
+ ut_type: RUN_LVL,
+ ut_pid: std::process::id() as i32,
+ ut_line: slice_32("~".as_bytes()),
+ ut_id: [126, 126, 0, 0],
+ ut_user: slice_32("runlevel".as_bytes()),
+ ut_host: [0; 256],
+ ut_exit: ExitStatus {
+ e_termination: 0,
+ e_exit: 0,
+ },
+ ut_session: 0,
+ ut_tv: TimeVal {
+ tv_sec: 1716371209,
+ tv_usec: 162250,
+ },
+ ut_addr_v6: [0, 0, 0, 0],
+ glibc_reserved: [0; 20],
+ };
+ let utmp2 = Utmp {
+ ut_type: USER_PROCESS,
+ ut_pid: std::process::id() as i32,
+ ut_line: slice_32(":1".as_bytes()),
+ ut_id: [126, 126, 0, 0],
+ ut_user: slice_32("testusr".as_bytes()),
+ ut_host: [0; 256],
+ ut_exit: ExitStatus {
+ e_termination: 0,
+ e_exit: 0,
+ },
+ ut_session: 0,
+ ut_tv: TimeVal {
+ tv_sec: 1716371283,
+ tv_usec: 858764,
+ },
+ ut_addr_v6: [0, 0, 0, 0],
+ glibc_reserved: [0; 20],
+ };
+
+ let mut buf = serialize(&utmp).unwrap();
+ buf.append(&mut serialize(&utmp1).unwrap());
+ buf.append(&mut serialize(&utmp2).unwrap());
+ let mut f = File::create(path).unwrap();
+ f.write_all(&buf).unwrap();
+ }
+}
+
+#[test]
+#[cfg(not(target_os = "openbsd"))]
+fn test_uptime_with_extra_argument() {
+ let ts = TestScenario::new(util_name!());
+
+ ts.ucmd()
+ .arg("a")
+ .arg("b")
+ .fails()
+ .stderr_contains("extra operand 'b'");
+}
+/// Checks whether uptime displays the correct stderr msg when its called with a directory
+#[test]
+#[cfg(not(target_os = "openbsd"))]
+fn test_uptime_with_dir() {
+ let ts = TestScenario::new(util_name!());
+ let at = &ts.fixtures;
+ at.mkdir("dir1");
+
+ ts.ucmd()
+ .arg("dir1")
+ .fails()
+ .stderr_contains("uptime: couldn't get boot time: Is a directory")
+ .stdout_contains("up ???? days ??:??");
+}
+
#[test]
+#[cfg(not(target_os = "openbsd"))]
fn test_uptime_since() {
let re = Regex::new(r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}").unwrap();
diff --git a/tests/by-util/test_users.rs b/tests/by-util/test_users.rs
index 747995d99e8977b49e139c59e36813a69751acdc..3d87aa9d068a6f3aae0ce30460d54edcae107e67 100644
--- a/tests/by-util/test_users.rs
+++ b/tests/by-util/test_users.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
#[test]
fn test_invalid_arg() {
@@ -17,12 +21,10 @@ fn test_users_check_name() {
#[cfg(target_os = "linux")]
let util_name = util_name!();
#[cfg(target_vendor = "apple")]
- let util_name = format!("g{}", util_name!());
+ let util_name = &format!("g{}", util_name!());
- // note: clippy::needless_borrow *false positive*
- #[allow(clippy::needless_borrow)]
- let expected = TestScenario::new(&util_name)
- .cmd_keepenv(util_name)
+ let expected = TestScenario::new(util_name)
+ .cmd(util_name)
.env("LC_ALL", "C")
.succeeds()
.stdout_move_str();
diff --git a/tests/by-util/test_vdir.rs b/tests/by-util/test_vdir.rs
index dc5e9f5ec8aa4adec2e9390b2bad896ec61379f4..97d5b847fb81d8061a36ae604c60f0f93a9533c3 100644
--- a/tests/by-util/test_vdir.rs
+++ b/tests/by-util/test_vdir.rs
@@ -1,11 +1,9 @@
-#[cfg(not(windows))]
-extern crate libc;
-extern crate regex;
-#[cfg(not(windows))]
-extern crate tempfile;
-
-use self::regex::Regex;
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::TestScenario;
+use regex::Regex;
/*
* As vdir use the same functions than ls, we don't have to retest them here.
@@ -29,7 +27,7 @@ fn test_default_output() {
scene
.ucmd()
.succeeds()
- .stdout_matches(&Regex::new("[rwx-]{10}.*some-file1$").unwrap());
+ .stdout_matches(&Regex::new("[rwx-]{10}.*some-file1\n$").unwrap());
}
#[test]
diff --git a/tests/by-util/test_wc.rs b/tests/by-util/test_wc.rs
index db0df44a0427ca2c98f3d515e245e7f08fd656c5..71b10e19131f86e0150a2336348ce04e09b5d094 100644
--- a/tests/by-util/test_wc.rs
+++ b/tests/by-util/test_wc.rs
@@ -1,4 +1,8 @@
-use crate::common::util::*;
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use crate::common::util::{vec_of_size, TestScenario};
// spell-checker:ignore (flags) lwmcL clmwL ; (path) bogusfile emptyfile manyemptylines moby notrailingnewline onelongemptyline onelongword weirdchars
@@ -26,7 +30,7 @@ fn test_count_bytes_large_stdin() {
128 * 1024,
] {
let data = vec_of_size(n);
- let expected = format!("{}\n", n);
+ let expected = format!("{n}\n");
new_ucmd!()
.args(&["-c"])
.pipe_in(data)
@@ -67,7 +71,7 @@ fn test_utf8_words() {
.arg("-w")
.pipe_in_fixture("UTF_8_weirdchars.txt")
.run()
- .stdout_is("87\n");
+ .stdout_is("89\n");
}
#[test]
@@ -76,7 +80,7 @@ fn test_utf8_line_length_words() {
.arg("-Lw")
.pipe_in_fixture("UTF_8_weirdchars.txt")
.run()
- .stdout_is(" 87 48\n");
+ .stdout_is(" 89 48\n");
}
#[test]
@@ -94,7 +98,7 @@ fn test_utf8_line_length_chars_words() {
.arg("-Lmw")
.pipe_in_fixture("UTF_8_weirdchars.txt")
.run()
- .stdout_is(" 87 442 48\n");
+ .stdout_is(" 89 442 48\n");
}
#[test]
@@ -139,7 +143,7 @@ fn test_utf8_chars_words() {
.arg("-mw")
.pipe_in_fixture("UTF_8_weirdchars.txt")
.run()
- .stdout_is(" 87 442\n");
+ .stdout_is(" 89 442\n");
}
#[test]
@@ -157,7 +161,7 @@ fn test_utf8_line_length_lines_words() {
.arg("-Llw")
.pipe_in_fixture("UTF_8_weirdchars.txt")
.run()
- .stdout_is(" 25 87 48\n");
+ .stdout_is(" 25 89 48\n");
}
#[test]
@@ -175,7 +179,7 @@ fn test_utf8_lines_words_chars() {
.arg("-mlw")
.pipe_in_fixture("UTF_8_weirdchars.txt")
.run()
- .stdout_is(" 25 87 442\n");
+ .stdout_is(" 25 89 442\n");
}
#[test]
@@ -193,7 +197,17 @@ fn test_utf8_all() {
.arg("-lwmcL")
.pipe_in_fixture("UTF_8_weirdchars.txt")
.run()
- .stdout_is(" 25 87 442 513 48\n");
+ .stdout_is(" 25 89 442 513 48\n");
+}
+
+#[test]
+fn test_ascii_control() {
+ // GNU coreutils "d1" test
+ new_ucmd!()
+ .arg("-w")
+ .pipe_in(*b"\x01\n")
+ .run()
+ .stdout_is("1\n");
}
#[test]
@@ -239,6 +253,14 @@ fn test_single_only_lines() {
.stdout_is("18 moby_dick.txt\n");
}
+#[test]
+fn test_single_only_bytes() {
+ new_ucmd!()
+ .args(&["-c", "lorem_ipsum.txt"])
+ .run()
+ .stdout_is("772 lorem_ipsum.txt\n");
+}
+
#[test]
fn test_single_all_counts() {
new_ucmd!()
@@ -268,12 +290,16 @@ fn test_multiple_default() {
"lorem_ipsum.txt",
"moby_dick.txt",
"alice_in_wonderland.txt",
+ "alice in wonderland.txt",
])
.run()
- .stdout_is(
- " 13 109 772 lorem_ipsum.txt\n 18 204 1115 moby_dick.txt\n 5 57 302 \
- alice_in_wonderland.txt\n 36 370 2189 total\n",
- );
+ .stdout_is(concat!(
+ " 13 109 772 lorem_ipsum.txt\n",
+ " 18 204 1115 moby_dick.txt\n",
+ " 5 57 302 alice_in_wonderland.txt\n",
+ " 5 57 302 alice in wonderland.txt\n",
+ " 41 427 2491 total\n",
+ ));
}
/// Test for an empty file.
@@ -352,17 +378,24 @@ fn test_file_bytes_dictate_width() {
new_ucmd!()
.args(&["-lwc", "alice_in_wonderland.txt", "lorem_ipsum.txt"])
.run()
- .stdout_is(
- " 5 57 302 alice_in_wonderland.txt\n 13 109 772 \
- lorem_ipsum.txt\n 18 166 1074 total\n",
- );
+ .stdout_is(concat!(
+ " 5 57 302 alice_in_wonderland.txt\n",
+ " 13 109 772 lorem_ipsum.txt\n",
+ " 18 166 1074 total\n",
+ ));
// . is a directory, so minimum_width should get set to 7
#[cfg(not(windows))]
- const STDOUT: &str = " 0 0 0 emptyfile.txt\n 0 0 0 \
- .\n 0 0 0 total\n";
+ const STDOUT: &str = concat!(
+ " 0 0 0 emptyfile.txt\n",
+ " 0 0 0 .\n",
+ " 0 0 0 total\n",
+ );
#[cfg(windows)]
- const STDOUT: &str = " 0 0 0 emptyfile.txt\n 0 0 0 total\n";
+ const STDOUT: &str = concat!(
+ " 0 0 0 emptyfile.txt\n",
+ " 0 0 0 total\n",
+ );
new_ucmd!()
.args(&["-lwc", "emptyfile.txt", "."])
.run()
@@ -375,7 +408,7 @@ fn test_read_from_directory_error() {
#[cfg(not(windows))]
const STDERR: &str = ".: Is a directory";
#[cfg(windows)]
- const STDERR: &str = ".: Access is denied";
+ const STDERR: &str = ".: Permission denied";
#[cfg(not(windows))]
const STDOUT: &str = " 0 0 0 .\n";
@@ -392,15 +425,10 @@ fn test_read_from_directory_error() {
/// Test that getting counts from nonexistent file is an error.
#[test]
fn test_read_from_nonexistent_file() {
- #[cfg(not(windows))]
- const MSG: &str = "bogusfile: No such file or directory";
- #[cfg(windows)]
- const MSG: &str = "bogusfile: The system cannot find the file specified";
new_ucmd!()
.args(&["bogusfile"])
.fails()
- .stderr_contains(MSG)
- .stdout_is("");
+ .stderr_only("wc: bogusfile: No such file or directory\n");
}
#[test]
@@ -409,11 +437,24 @@ fn test_files_from_pseudo_filesystem() {
use pretty_assertions::assert_ne;
let result = new_ucmd!().arg("-c").arg("/proc/cpuinfo").succeeds();
assert_ne!(result.stdout_str(), "0 /proc/cpuinfo\n");
+
+ // the following block fails on Android with a "Permission denied" error
+ #[cfg(target_os = "linux")]
+ {
+ let (at, mut ucmd) = at_and_ucmd!();
+ let result = ucmd.arg("-c").arg("/sys/kernel/profiling").succeeds();
+ let actual = at.read("/sys/kernel/profiling").len();
+ assert_eq!(
+ result.stdout_str(),
+ format!("{actual} /sys/kernel/profiling\n")
+ );
+ }
}
#[test]
fn test_files0_disabled_files_argument() {
- const MSG: &str = "file operands cannot be combined with --files0-from";
+ const MSG: &str =
+ "extra operand 'lorem_ipsum.txt'\nfile operands cannot be combined with --files0-from";
new_ucmd!()
.args(&["--files0-from=files0_list.txt"])
.arg("lorem_ipsum.txt")
@@ -424,13 +465,30 @@ fn test_files0_disabled_files_argument() {
#[test]
fn test_files0_from() {
+ // file
new_ucmd!()
.args(&["--files0-from=files0_list.txt"])
.run()
- .stdout_is(
- " 13 109 772 lorem_ipsum.txt\n 18 204 1115 moby_dick.txt\n 5 57 302 \
- alice_in_wonderland.txt\n 36 370 2189 total\n",
- );
+ .success()
+ .stdout_is(concat!(
+ " 13 109 772 lorem_ipsum.txt\n",
+ " 18 204 1115 moby_dick.txt\n",
+ " 5 57 302 alice_in_wonderland.txt\n",
+ " 36 370 2189 total\n",
+ ));
+
+ // stream
+ new_ucmd!()
+ .args(&["--files0-from=-"])
+ .pipe_in_fixture("files0_list.txt")
+ .run()
+ .success()
+ .stdout_is(concat!(
+ "13 109 772 lorem_ipsum.txt\n",
+ "18 204 1115 moby_dick.txt\n",
+ "5 57 302 alice_in_wonderland.txt\n",
+ "36 370 2189 total\n",
+ ));
}
#[test]
@@ -439,7 +497,7 @@ fn test_files0_from_with_stdin() {
.args(&["--files0-from=-"])
.pipe_in("lorem_ipsum.txt")
.run()
- .stdout_is(" 13 109 772 lorem_ipsum.txt\n");
+ .stdout_is("13 109 772 lorem_ipsum.txt\n");
}
#[test]
@@ -448,10 +506,12 @@ fn test_files0_from_with_stdin_in_file() {
.args(&["--files0-from=files0_list_with_stdin.txt"])
.pipe_in_fixture("alice_in_wonderland.txt")
.run()
- .stdout_is(
- " 13 109 772 lorem_ipsum.txt\n 18 204 1115 moby_dick.txt\n 5 57 302 \
- -\n 36 370 2189 total\n",
- );
+ .stdout_is(concat!(
+ " 13 109 772 lorem_ipsum.txt\n",
+ " 18 204 1115 moby_dick.txt\n",
+ " 5 57 302 -\n", // alice_in_wonderland.txt
+ " 36 370 2189 total\n",
+ ));
}
#[test]
@@ -464,3 +524,253 @@ fn test_files0_from_with_stdin_try_read_from_stdin() {
.stderr_contains(MSG)
.stdout_is("");
}
+
+#[test]
+fn test_total_auto() {
+ new_ucmd!()
+ .args(&["lorem_ipsum.txt", "--total=auto"])
+ .run()
+ .stdout_is(" 13 109 772 lorem_ipsum.txt\n");
+ new_ucmd!()
+ .args(&["lorem_ipsum.txt", "--tot=au"])
+ .run()
+ .stdout_is(" 13 109 772 lorem_ipsum.txt\n");
+
+ new_ucmd!()
+ .args(&["lorem_ipsum.txt", "moby_dick.txt", "--total=auto"])
+ .run()
+ .stdout_is(concat!(
+ " 13 109 772 lorem_ipsum.txt\n",
+ " 18 204 1115 moby_dick.txt\n",
+ " 31 313 1887 total\n",
+ ));
+}
+
+#[test]
+fn test_total_always() {
+ new_ucmd!()
+ .args(&["lorem_ipsum.txt", "--total=always"])
+ .run()
+ .stdout_is(concat!(
+ " 13 109 772 lorem_ipsum.txt\n",
+ " 13 109 772 total\n",
+ ));
+ new_ucmd!()
+ .args(&["lorem_ipsum.txt", "--total=al"])
+ .run()
+ .stdout_is(concat!(
+ " 13 109 772 lorem_ipsum.txt\n",
+ " 13 109 772 total\n",
+ ));
+
+ new_ucmd!()
+ .args(&["lorem_ipsum.txt", "moby_dick.txt", "--total=always"])
+ .run()
+ .stdout_is(concat!(
+ " 13 109 772 lorem_ipsum.txt\n",
+ " 18 204 1115 moby_dick.txt\n",
+ " 31 313 1887 total\n",
+ ));
+}
+
+#[test]
+fn test_total_never() {
+ new_ucmd!()
+ .args(&["lorem_ipsum.txt", "--total=never"])
+ .run()
+ .stdout_is(" 13 109 772 lorem_ipsum.txt\n");
+
+ new_ucmd!()
+ .args(&["lorem_ipsum.txt", "moby_dick.txt", "--total=never"])
+ .run()
+ .stdout_is(concat!(
+ " 13 109 772 lorem_ipsum.txt\n",
+ " 18 204 1115 moby_dick.txt\n",
+ ));
+ new_ucmd!()
+ .args(&["lorem_ipsum.txt", "moby_dick.txt", "--total=n"])
+ .run()
+ .stdout_is(concat!(
+ " 13 109 772 lorem_ipsum.txt\n",
+ " 18 204 1115 moby_dick.txt\n",
+ ));
+}
+
+#[test]
+fn test_total_only() {
+ new_ucmd!()
+ .args(&["lorem_ipsum.txt", "--total=only"])
+ .run()
+ .stdout_is("13 109 772\n");
+
+ new_ucmd!()
+ .args(&["lorem_ipsum.txt", "moby_dick.txt", "--total=only"])
+ .run()
+ .stdout_is("31 313 1887\n");
+ new_ucmd!()
+ .args(&["lorem_ipsum.txt", "moby_dick.txt", "--t=o"])
+ .run()
+ .stdout_is("31 313 1887\n");
+}
+
+#[test]
+fn test_zero_length_files() {
+ // A trailing zero is ignored, but otherwise empty file names are an error...
+ const LIST: &str = "\0moby_dick.txt\0\0alice_in_wonderland.txt\0\0lorem_ipsum.txt\0";
+
+ // Try with and without the last \0
+ for l in [LIST.len(), LIST.len() - 1] {
+ new_ucmd!()
+ .args(&["--files0-from=-"])
+ .pipe_in(&LIST[..l])
+ .run()
+ .failure()
+ .stdout_is(concat!(
+ "18 204 1115 moby_dick.txt\n",
+ "5 57 302 alice_in_wonderland.txt\n",
+ "13 109 772 lorem_ipsum.txt\n",
+ "36 370 2189 total\n",
+ ))
+ .stderr_is(concat!(
+ "wc: -:1: invalid zero-length file name\n",
+ "wc: -:3: invalid zero-length file name\n",
+ "wc: -:5: invalid zero-length file name\n",
+ ));
+ }
+
+ // But, just as important, a zero-length file name may still be at the end...
+ new_ucmd!()
+ .args(&["--files0-from=-"])
+ .pipe_in(
+ LIST.as_bytes()
+ .iter()
+ .chain(b"\0")
+ .copied()
+ .collect::<Vec<_>>(),
+ )
+ .run()
+ .failure()
+ .stdout_is(concat!(
+ "18 204 1115 moby_dick.txt\n",
+ "5 57 302 alice_in_wonderland.txt\n",
+ "13 109 772 lorem_ipsum.txt\n",
+ "36 370 2189 total\n",
+ ))
+ .stderr_is(concat!(
+ "wc: -:1: invalid zero-length file name\n",
+ "wc: -:3: invalid zero-length file name\n",
+ "wc: -:5: invalid zero-length file name\n",
+ "wc: -:7: invalid zero-length file name\n",
+ ));
+}
+
+#[test]
+fn test_files0_errors_quoting() {
+ new_ucmd!()
+ .args(&["--files0-from=files0 with nonexistent.txt"])
+ .run()
+ .failure()
+ .stderr_is(concat!(
+ "wc: this_file_does_not_exist.txt: No such file or directory\n",
+ "wc: 'files0 with nonexistent.txt':2: invalid zero-length file name\n",
+ "wc: 'this file does not exist.txt': No such file or directory\n",
+ "wc: \"this files doesn't exist either.txt\": No such file or directory\n",
+ ))
+ .stdout_is("0 0 0 total\n");
+}
+
+#[test]
+fn test_files0_progressive_stream() {
+ use std::process::Stdio;
+ // You should be able to run wc and have a back-and-forth exchange with wc...
+ let mut child = new_ucmd!()
+ .args(&["--files0-from=-"])
+ .set_stdin(Stdio::piped())
+ .set_stdout(Stdio::piped())
+ .set_stderr(Stdio::piped())
+ .run_no_wait();
+
+ macro_rules! chk {
+ ($fn:ident, $exp:literal) => {
+ assert_eq!(child.$fn($exp.len()), $exp.as_bytes());
+ };
+ }
+
+ // File in, count out...
+ child.write_in("moby_dick.txt\0");
+ chk!(stdout_exact_bytes, "18 204 1115 moby_dick.txt\n");
+ child.write_in("lorem_ipsum.txt\0");
+ chk!(stdout_exact_bytes, "13 109 772 lorem_ipsum.txt\n");
+
+ // Introduce an error!
+ child.write_in("\0");
+ chk!(
+ stderr_exact_bytes,
+ "wc: -:3: invalid zero-length file name\n"
+ );
+
+ // wc is quick to forgive, let's move on...
+ child.write_in("alice_in_wonderland.txt\0");
+ chk!(stdout_exact_bytes, "5 57 302 alice_in_wonderland.txt\n");
+
+ // Fin.
+ child
+ .wait()
+ .expect("wc should finish")
+ .failure()
+ .stdout_only("36 370 2189 total\n");
+}
+
+#[test]
+fn files0_from_dir() {
+ // On Unix, `read(open("."))` fails. On Windows, `open(".")` fails. Thus, the errors happen in
+ // different contexts.
+ #[cfg(not(windows))]
+ macro_rules! dir_err {
+ ($p:literal) => {
+ concat!("wc: ", $p, ": read error: Is a directory\n")
+ };
+ }
+ #[cfg(windows)]
+ macro_rules! dir_err {
+ ($p:literal) => {
+ concat!("wc: cannot open ", $p, " for reading: Permission denied\n")
+ };
+ }
+
+ new_ucmd!()
+ .args(&["--files0-from=dir with spaces"])
+ .fails()
+ .stderr_only(dir_err!("'dir with spaces'"));
+
+ // Those contexts have different rules about quoting in errors...
+ #[cfg(windows)]
+ const DOT_ERR: &str = dir_err!("'.'");
+ #[cfg(not(windows))]
+ const DOT_ERR: &str = dir_err!(".");
+ new_ucmd!()
+ .args(&["--files0-from=."])
+ .fails()
+ .stderr_only(DOT_ERR);
+
+ // That also means you cannot `< . wc --files0-from=-` on Windows.
+ #[cfg(not(windows))]
+ new_ucmd!()
+ .args(&["--files0-from=-"])
+ .set_stdin(std::fs::File::open(".").unwrap())
+ .fails()
+ .stderr_only(dir_err!("-"));
+}
+
+#[test]
+fn test_args_override() {
+ new_ucmd!()
+ .args(&["-ll", "-l", "alice_in_wonderland.txt"])
+ .run()
+ .stdout_is("5 alice_in_wonderland.txt\n");
+
+ new_ucmd!()
+ .args(&["--total=always", "--total=never", "alice_in_wonderland.txt"])
+ .run()
+ .stdout_is(" 5 57 302 alice_in_wonderland.txt\n");
+}
diff --git a/tests/by-util/test_who.rs b/tests/by-util/test_who.rs
index 6acba20991e478f9565195e9c3627f9a4e84d5b8..36325fe7c57f5919c239f681d394332d4dc5082c 100644
--- a/tests/by-util/test_who.rs
+++ b/tests/by-util/test_who.rs
@@ -1,11 +1,11 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
// spell-checker:ignore (flags) runlevel mesg
-use crate::common::util::*;
+use crate::common::util::{expected_result, TestScenario};
#[test]
fn test_invalid_arg() {
@@ -25,6 +25,7 @@ fn test_count() {
#[cfg(unix)]
#[test]
+#[cfg(not(target_os = "openbsd"))]
fn test_boot() {
let ts = TestScenario::new(util_name!());
for opt in ["-b", "--boot", "--b"] {
@@ -44,8 +45,8 @@ fn test_heading() {
// specifically number of TABs between "TIME" and "COMMENT" may be variant
let actual = ts.ucmd().arg(opt).succeeds().stdout_move_str();
let expect = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
- println!("actual: {:?}", actual);
- println!("expect: {:?}", expect);
+ println!("actual: {actual:?}");
+ println!("expect: {expect:?}");
let v_actual: Vec<&str> = actual.split_whitespace().collect();
let v_expect: Vec<&str> = expect.split_whitespace().collect();
assert_eq!(v_actual, v_expect);
@@ -65,6 +66,7 @@ fn test_short() {
#[cfg(unix)]
#[test]
+#[cfg(not(target_os = "openbsd"))]
fn test_login() {
let ts = TestScenario::new(util_name!());
for opt in ["-l", "--login", "--log"] {
@@ -75,6 +77,7 @@ fn test_login() {
#[cfg(unix)]
#[test]
+#[cfg(not(target_os = "openbsd"))]
fn test_m() {
let ts = TestScenario::new(util_name!());
let expected_stdout = unwrap_or_return!(expected_result(&ts, &["-m"])).stdout_move_str();
@@ -83,6 +86,7 @@ fn test_m() {
#[cfg(unix)]
#[test]
+#[cfg(not(target_os = "openbsd"))]
fn test_process() {
let ts = TestScenario::new(util_name!());
for opt in ["-p", "--process", "--p"] {
@@ -93,6 +97,7 @@ fn test_process() {
#[cfg(unix)]
#[test]
+#[cfg(not(target_os = "openbsd"))]
fn test_runlevel() {
let ts = TestScenario::new(util_name!());
for opt in ["-r", "--runlevel", "--r"] {
@@ -106,6 +111,7 @@ fn test_runlevel() {
#[cfg(unix)]
#[test]
+#[cfg(not(target_os = "openbsd"))]
fn test_time() {
let ts = TestScenario::new(util_name!());
for opt in ["-t", "--time", "--t"] {
@@ -141,6 +147,7 @@ fn test_mesg() {
#[cfg(unix)]
#[test]
+#[cfg(not(target_os = "openbsd"))]
fn test_arg1_arg2() {
let args = ["am", "i"];
let ts = TestScenario::new(util_name!());
@@ -151,7 +158,7 @@ fn test_arg1_arg2() {
#[test]
fn test_too_many_args() {
const EXPECTED: &str =
- "error: The value 'u' was provided to '[FILE]...' but it wasn't expecting any more values";
+ "error: unexpected value 'u' for '[FILE]...' found; no more were expected";
let args = ["am", "i", "u"];
new_ucmd!().args(&args).fails().stderr_contains(EXPECTED);
@@ -165,8 +172,8 @@ fn test_users() {
for opt in ["-u", "--users", "--us"] {
let actual = ts.ucmd().arg(opt).succeeds().stdout_move_str();
let expect = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
- println!("actual: {:?}", actual);
- println!("expect: {:?}", expect);
+ println!("actual: {actual:?}");
+ println!("expect: {expect:?}");
let mut v_actual: Vec<&str> = actual.split_whitespace().collect();
let mut v_expect: Vec<&str> = expect.split_whitespace().collect();
@@ -195,6 +202,7 @@ fn test_lookup() {
#[cfg(unix)]
#[test]
+#[cfg(not(target_os = "openbsd"))]
fn test_dead() {
let ts = TestScenario::new(util_name!());
for opt in ["-d", "--dead", "--de"] {
diff --git a/tests/by-util/test_whoami.rs b/tests/by-util/test_whoami.rs
index a64dbb7cd91bf84fb208b9a3f927054f799c9b1b..d32c4ec243cba05a73b18304cc97938daf94506a 100644
--- a/tests/by-util/test_whoami.rs
+++ b/tests/by-util/test_whoami.rs
@@ -1,9 +1,11 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-use crate::common::util::*;
+#[cfg(unix)]
+use crate::common::util::expected_result;
+use crate::common::util::{is_ci, whoami, TestScenario};
#[test]
fn test_invalid_arg() {
@@ -43,8 +45,13 @@ fn test_normal_compare_env() {
if whoami == "nobody" {
println!("test skipped:");
} else if !is_ci() {
- new_ucmd!().succeeds().stdout_is(format!("{}\n", whoami));
+ new_ucmd!().succeeds().stdout_is(format!("{whoami}\n"));
} else {
println!("test skipped:");
}
}
+
+#[test]
+fn test_succeeds_on_all_platforms() {
+ new_ucmd!().succeeds().no_stderr();
+}
diff --git a/tests/by-util/test_yes.rs b/tests/by-util/test_yes.rs
index 41bf3e8d9714019d06074545a1f99f038957ffc7..f40d6d5b8e2801c5fa93985689cd53d3ff3c8664 100644
--- a/tests/by-util/test_yes.rs
+++ b/tests/by-util/test_yes.rs
@@ -1,29 +1,36 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+use std::ffi::OsStr;
use std::process::{ExitStatus, Stdio};
#[cfg(unix)]
use std::os::unix::process::ExitStatusExt;
-use crate::common::util::*;
+use crate::common::util::TestScenario;
#[cfg(unix)]
-fn check_termination(result: &ExitStatus) {
+fn check_termination(result: ExitStatus) {
assert_eq!(result.signal(), Some(libc::SIGPIPE));
}
#[cfg(not(unix))]
-fn check_termination(result: &ExitStatus) {
+fn check_termination(result: ExitStatus) {
assert!(result.success(), "yes did not exit successfully");
}
+const NO_ARGS: &[&str] = &[];
+
/// Run `yes`, capture some of the output, close the pipe, and verify it.
-fn run(args: &[&str], expected: &[u8]) {
+fn run(args: &[impl AsRef<OsStr>], expected: &[u8]) {
let mut cmd = new_ucmd!();
let mut child = cmd.args(args).set_stdout(Stdio::piped()).run_no_wait();
let buf = child.stdout_exact_bytes(expected.len());
child.close_stdout();
#[allow(deprecated)]
- check_termination(&child.wait_with_output().unwrap().status);
+ check_termination(child.wait_with_output().unwrap().status);
assert_eq!(buf.as_slice(), expected);
}
@@ -32,9 +39,14 @@ fn test_invalid_arg() {
new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
}
+#[test]
+fn test_version() {
+ new_ucmd!().arg("--version").succeeds();
+}
+
#[test]
fn test_simple() {
- run(&[], b"y\ny\ny\ny\n");
+ run(NO_ARGS, b"y\ny\ny\ny\n");
}
#[test]
@@ -44,7 +56,7 @@ fn test_args() {
#[test]
fn test_long_output() {
- run(&[], "y\n".repeat(512 * 1024).as_bytes());
+ run(NO_ARGS, "y\n".repeat(512 * 1024).as_bytes());
}
/// Test with an output that seems likely to get mangled in case of incomplete writes.
@@ -88,3 +100,20 @@ fn test_piped_to_dev_full() {
}
}
}
+
+#[test]
+#[cfg(any(unix, target_os = "wasi"))]
+fn test_non_utf8() {
+ #[cfg(unix)]
+ use std::os::unix::ffi::OsStrExt;
+ #[cfg(target_os = "wasi")]
+ use std::os::wasi::ffi::OsStrExt;
+
+ run(
+ &[
+ OsStr::from_bytes(b"\xbf\xff\xee"),
+ OsStr::from_bytes(b"bar"),
+ ],
+ &b"\xbf\xff\xee bar\n".repeat(5000),
+ );
+}
diff --git a/tests/common/macros.rs b/tests/common/macros.rs
index 4f5965d5ab97162dd109d99ca6f3087f9f16eca6..4902ca49b4dc804b71d054383f10f4b679488c4f 100644
--- a/tests/common/macros.rs
+++ b/tests/common/macros.rs
@@ -1,7 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
/// Platform-independent helper for constructing a `PathBuf` from individual elements
#[macro_export]
diff --git a/tests/common/mod.rs b/tests/common/mod.rs
index f73cd42af244f0a4fdea7abb4a94ccf052b0301d..05e2b13824c6bba06ef5a459dab884a023bcd5bd 100644
--- a/tests/common/mod.rs
+++ b/tests/common/mod.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
#[macro_use]
pub mod macros;
pub mod random;
diff --git a/tests/common/random.rs b/tests/common/random.rs
index bf1e6a9071f4608df0eb5d368dcc20406258b144..82a58578eef8042dec5fc673423dba49b60fc29f 100644
--- a/tests/common/random.rs
+++ b/tests/common/random.rs
@@ -1,7 +1,7 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
use rand::distributions::{Distribution, Uniform};
use rand::{thread_rng, Rng};
@@ -208,6 +208,7 @@ mod tests {
}
#[test]
+ #[allow(clippy::cognitive_complexity)] // Ignore clippy lint of too long function sign
fn test_random_string_generate_with_delimiter_should_end_with_delimiter() {
let random_string = RandomString::generate_with_delimiter(Alphanumeric, 0, 1, true, 1);
assert_eq!(1, random_string.len());
@@ -251,6 +252,7 @@ mod tests {
}
#[test]
+ #[allow(clippy::cognitive_complexity)] // Ignore clippy lint of too long function sign
fn test_random_string_generate_with_delimiter_should_not_end_with_delimiter() {
let random_string = RandomString::generate_with_delimiter(Alphanumeric, 0, 0, false, 1);
assert_eq!(1, random_string.len());
diff --git a/tests/common/util.rs b/tests/common/util.rs
index c60a3637e8b1f2289bdd63308a844dbf4b0eba66..275a6ae680f240663c5b04192354cfee6d026d78 100644
--- a/tests/common/util.rs
+++ b/tests/common/util.rs
@@ -1,43 +1,49 @@
-// * This file is part of the uutils coreutils package.
-// *
-// * For the full copyright and license information, please view the LICENSE
-// * file that was distributed with this source code.
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
-//spell-checker: ignore (linux) rlimit prlimit coreutil ggroups uchild uncaptured
+//spell-checker: ignore (linux) rlimit prlimit coreutil ggroups uchild uncaptured scmd SHLVL canonicalized openpty
+//spell-checker: ignore (linux) winsize xpixel ypixel setrlimit FSIZE
#![allow(dead_code)]
+#[cfg(unix)]
+use libc::mode_t;
+#[cfg(unix)]
+use nix::pty::OpenptyResult;
use pretty_assertions::assert_eq;
-#[cfg(target_os = "linux")]
-use rlimit::prlimit;
-use rstest::rstest;
#[cfg(unix)]
+use rlimit::setrlimit;
+#[cfg(feature = "sleep")]
+use rstest::rstest;
use std::borrow::Cow;
+use std::collections::VecDeque;
#[cfg(not(windows))]
use std::ffi::CString;
-use std::ffi::OsStr;
+use std::ffi::{OsStr, OsString};
use std::fs::{self, hard_link, remove_file, File, OpenOptions};
use std::io::{self, BufWriter, Read, Result, Write};
#[cfg(unix)]
+use std::os::fd::OwnedFd;
+#[cfg(unix)]
use std::os::unix::fs::{symlink as symlink_dir, symlink as symlink_file, PermissionsExt};
+#[cfg(unix)]
+use std::os::unix::process::CommandExt;
+#[cfg(unix)]
+use std::os::unix::process::ExitStatusExt;
#[cfg(windows)]
use std::os::windows::fs::{symlink_dir, symlink_file};
#[cfg(windows)]
-use std::path::MAIN_SEPARATOR;
+use std::path::MAIN_SEPARATOR_STR;
use std::path::{Path, PathBuf};
-use std::process::{Child, Command, Output, Stdio};
+use std::process::{Child, Command, ExitStatus, Output, Stdio};
use std::rc::Rc;
use std::sync::mpsc::{self, RecvTimeoutError};
use std::thread::{sleep, JoinHandle};
use std::time::{Duration, Instant};
-use std::{env, hint, thread};
+use std::{env, hint, mem, thread};
use tempfile::{Builder, TempDir};
-use uucore::Args;
-
-#[cfg(windows)]
-static PROGNAME: &str = concat!(env!("CARGO_PKG_NAME"), ".exe");
-#[cfg(not(windows))]
-static PROGNAME: &str = env!("CARGO_PKG_NAME");
static TESTS_DIR: &str = "tests";
static FIXTURES_DIR: &str = "fixtures";
@@ -48,12 +54,17 @@ static ALREADY_RUN: &str = " you have already run this UCommand, if you want to
static MULTIPLE_STDIN_MEANINGLESS: &str = "Ucommand is designed around a typical use case of: provide args and input stream -> spawn process -> block until completion -> return output streams. For verifying that a particular section of the input stream is what causes a particular behavior, use the Command type directly.";
static NO_STDIN_MEANINGLESS: &str = "Setting this flag has no effect if there is no stdin";
+static END_OF_TRANSMISSION_SEQUENCE: &[u8] = &[b'\n', 0x04];
+
+pub const TESTS_BINARY: &str = env!("CARGO_BIN_EXE_coreutils");
+pub const PATH: &str = env!("PATH");
+
+/// Default environment variables to run the commands with
+const DEFAULT_ENV: [(&str, &str); 2] = [("LC_ALL", "C"), ("TZ", "UTC")];
/// Test if the program is running under CI
pub fn is_ci() -> bool {
- std::env::var("CI")
- .unwrap_or_else(|_| String::from("false"))
- .eq_ignore_ascii_case("true")
+ std::env::var("CI").is_ok_and(|s| s.eq_ignore_ascii_case("true"))
}
/// Read a test scenario fixture, returning its bytes
@@ -66,17 +77,14 @@ fn read_scenario_fixture<S: AsRef<OsStr>>(tmpd: &Option<Rc<TempDir>>, file_rel_p
/// within a struct which has convenience assertion functions about those outputs
#[derive(Debug, Clone)]
pub struct CmdResult {
- /// bin_path provided by `TestScenario` or `UCommand`
- bin_path: String,
- /// util_name provided by `TestScenario` or `UCommand`
+ /// `bin_path` provided by `TestScenario` or `UCommand`
+ bin_path: PathBuf,
+ /// `util_name` provided by `TestScenario` or `UCommand`
util_name: Option<String>,
//tmpd is used for convenience functions for asserts against fixtures
tmpd: Option<Rc<TempDir>>,
/// exit status for command (if there is one)
- code: Option<i32>,
- /// zero-exit from running the Command?
- /// see [`success`]
- success: bool,
+ exit_status: Option<ExitStatus>,
/// captured standard output after running the Command
stdout: Vec<u8>,
/// captured standard error after running the Command
@@ -84,26 +92,235 @@ pub struct CmdResult {
}
impl CmdResult {
- pub fn new(
- bin_path: String,
- util_name: Option<String>,
+ pub fn new<S, T, U, V>(
+ bin_path: S,
+ util_name: Option<T>,
tmpd: Option<Rc<TempDir>>,
- code: Option<i32>,
- success: bool,
- stdout: &[u8],
- stderr: &[u8],
- ) -> Self {
+ exit_status: Option<ExitStatus>,
+ stdout: U,
+ stderr: V,
+ ) -> Self
+ where
+ S: Into<PathBuf>,
+ T: AsRef<str>,
+ U: Into<Vec<u8>>,
+ V: Into<Vec<u8>>,
+ {
Self {
- bin_path,
- util_name,
+ bin_path: bin_path.into(),
+ util_name: util_name.map(|s| s.as_ref().into()),
tmpd,
- code,
- success,
- stdout: stdout.to_vec(),
- stderr: stderr.to_vec(),
+ exit_status,
+ stdout: stdout.into(),
+ stderr: stderr.into(),
}
}
+ /// Apply a function to `stdout` as bytes and return a new [`CmdResult`]
+ pub fn stdout_apply<'a, F, R>(&'a self, function: F) -> Self
+ where
+ F: Fn(&'a [u8]) -> R,
+ R: Into<Vec<u8>>,
+ {
+ Self::new(
+ self.bin_path.clone(),
+ self.util_name.clone(),
+ self.tmpd.clone(),
+ self.exit_status,
+ function(&self.stdout),
+ self.stderr.as_slice(),
+ )
+ }
+
+ /// Apply a function to `stdout` as `&str` and return a new [`CmdResult`]
+ pub fn stdout_str_apply<'a, F, R>(&'a self, function: F) -> Self
+ where
+ F: Fn(&'a str) -> R,
+ R: Into<Vec<u8>>,
+ {
+ Self::new(
+ self.bin_path.clone(),
+ self.util_name.clone(),
+ self.tmpd.clone(),
+ self.exit_status,
+ function(self.stdout_str()),
+ self.stderr.as_slice(),
+ )
+ }
+
+ /// Apply a function to `stderr` as bytes and return a new [`CmdResult`]
+ pub fn stderr_apply<'a, F, R>(&'a self, function: F) -> Self
+ where
+ F: Fn(&'a [u8]) -> R,
+ R: Into<Vec<u8>>,
+ {
+ Self::new(
+ self.bin_path.clone(),
+ self.util_name.clone(),
+ self.tmpd.clone(),
+ self.exit_status,
+ self.stdout.as_slice(),
+ function(&self.stderr),
+ )
+ }
+
+ /// Apply a function to `stderr` as `&str` and return a new [`CmdResult`]
+ pub fn stderr_str_apply<'a, F, R>(&'a self, function: F) -> Self
+ where
+ F: Fn(&'a str) -> R,
+ R: Into<Vec<u8>>,
+ {
+ Self::new(
+ self.bin_path.clone(),
+ self.util_name.clone(),
+ self.tmpd.clone(),
+ self.exit_status,
+ self.stdout.as_slice(),
+ function(self.stderr_str()),
+ )
+ }
+
+ /// Assert `stdout` as bytes with a predicate function returning a `bool`.
+ #[track_caller]
+ pub fn stdout_check<'a, F>(&'a self, predicate: F) -> &Self
+ where
+ F: Fn(&'a [u8]) -> bool,
+ {
+ assert!(
+ predicate(&self.stdout),
+ "Predicate for stdout as `bytes` evaluated to false.\nstdout='{:?}'\nstderr='{:?}'\n",
+ &self.stdout,
+ &self.stderr
+ );
+ self
+ }
+
+ /// Assert `stdout` as `&str` with a predicate function returning a `bool`.
+ #[track_caller]
+ pub fn stdout_str_check<'a, F>(&'a self, predicate: F) -> &Self
+ where
+ F: Fn(&'a str) -> bool,
+ {
+ assert!(
+ predicate(self.stdout_str()),
+ "Predicate for stdout as `str` evaluated to false.\nstdout='{}'\nstderr='{}'\n",
+ self.stdout_str(),
+ self.stderr_str()
+ );
+ self
+ }
+
+ /// Assert `stderr` as bytes with a predicate function returning a `bool`.
+ #[track_caller]
+ pub fn stderr_check<'a, F>(&'a self, predicate: F) -> &Self
+ where
+ F: Fn(&'a [u8]) -> bool,
+ {
+ assert!(
+ predicate(&self.stderr),
+ "Predicate for stderr as `bytes` evaluated to false.\nstdout='{:?}'\nstderr='{:?}'\n",
+ &self.stdout,
+ &self.stderr
+ );
+ self
+ }
+
+ /// Assert `stderr` as `&str` with a predicate function returning a `bool`.
+ #[track_caller]
+ pub fn stderr_str_check<'a, F>(&'a self, predicate: F) -> &Self
+ where
+ F: Fn(&'a str) -> bool,
+ {
+ assert!(
+ predicate(self.stderr_str()),
+ "Predicate for stderr as `str` evaluated to false.\nstdout='{}'\nstderr='{}'\n",
+ self.stdout_str(),
+ self.stderr_str()
+ );
+ self
+ }
+
+ /// Return the exit status of the child process, if any.
+ ///
+ /// Returns None if the child process is still running or hasn't been started.
+ pub fn try_exit_status(&self) -> Option<ExitStatus> {
+ self.exit_status
+ }
+
+ /// Return the exit status of the child process.
+ ///
+ /// # Panics
+ ///
+ /// If the child process is still running or hasn't been started.
+ pub fn exit_status(&self) -> ExitStatus {
+ self.try_exit_status()
+ .expect("Program must be run first or has not finished, yet")
+ }
+
+ /// Return the signal the child process received if any.
+ ///
+ /// # Platform specific behavior
+ ///
+ /// This method is only available on unix systems.
+ #[cfg(unix)]
+ pub fn signal(&self) -> Option<i32> {
+ self.exit_status().signal()
+ }
+
+ /// Assert that the given signal `value` equals the signal the child process received.
+ ///
+ /// See also [`std::os::unix::process::ExitStatusExt::signal`].
+ ///
+ /// # Platform specific behavior
+ ///
+ /// This assertion method is only available on unix systems.
+ #[cfg(unix)]
+ #[track_caller]
+ pub fn signal_is(&self, value: i32) -> &Self {
+ let actual = self.signal().unwrap_or_else(|| {
+ panic!(
+ "Expected process to be terminated by the '{}' signal, but exit status is: '{}'",
+ value,
+ self.try_exit_status()
+ .map_or("Not available".to_string(), |e| e.to_string())
+ )
+ });
+
+ assert_eq!(actual, value);
+ self
+ }
+
+ /// Assert that the given signal `name` equals the signal the child process received.
+ ///
+ /// Strings like `SIGINT`, `INT` or a number like `15` are all valid names. See also
+ /// [`std::os::unix::process::ExitStatusExt::signal`] and
+ /// [`uucore::signals::signal_by_name_or_value`]
+ ///
+ /// # Platform specific behavior
+ ///
+ /// This assertion method is only available on unix systems.
+ #[cfg(unix)]
+ #[track_caller]
+ pub fn signal_name_is(&self, name: &str) -> &Self {
+ use uucore::signals::signal_by_name_or_value;
+ let expected: i32 = signal_by_name_or_value(name)
+ .unwrap_or_else(|| panic!("Invalid signal name or value: '{name}'"))
+ .try_into()
+ .unwrap();
+
+ let actual = self.signal().unwrap_or_else(|| {
+ panic!(
+ "Expected process to be terminated by the '{}' signal, but exit status is: '{}'",
+ name,
+ self.try_exit_status()
+ .map_or("Not available".to_string(), |e| e.to_string())
+ )
+ });
+
+ assert_eq!(actual, expected);
+ self
+ }
+
/// Returns a reference to the program's standard output as a slice of bytes
pub fn stdout(&self) -> &[u8] {
&self.stdout
@@ -136,6 +353,11 @@ impl CmdResult {
std::str::from_utf8(&self.stderr).unwrap()
}
+ /// Returns the program's standard error as a string slice, automatically handling invalid utf8
+ pub fn stderr_str_lossy(&self) -> Cow<'_, str> {
+ String::from_utf8_lossy(&self.stderr)
+ }
+
/// Returns the program's standard error as a string
/// consumes self
pub fn stderr_move_str(self) -> String {
@@ -151,12 +373,19 @@ impl CmdResult {
/// Returns the program's exit code
/// Panics if not run or has not finished yet for example when run with `run_no_wait()`
pub fn code(&self) -> i32 {
- self.code
- .expect("Program must be run first or has not finished, yet")
+ self.exit_status().code().unwrap()
}
#[track_caller]
pub fn code_is(&self, expected_code: i32) -> &Self {
+ let fails = self.code() != expected_code;
+ if fails {
+ eprintln!(
+ "stdout:\n{}\nstderr:\n{}",
+ self.stdout_str(),
+ self.stderr_str()
+ );
+ }
assert_eq!(self.code(), expected_code);
self
}
@@ -172,15 +401,16 @@ impl CmdResult {
/// Returns whether the program succeeded
pub fn succeeded(&self) -> bool {
- self.success
+ self.exit_status.map_or(true, |e| e.success())
}
/// asserts that the command resulted in a success (zero) status code
#[track_caller]
pub fn success(&self) -> &Self {
assert!(
- self.success,
- "Command was expected to succeed.\nstdout = {}\n stderr = {}",
+ self.succeeded(),
+ "Command was expected to succeed. code: {}\nstdout = {}\n stderr = {}",
+ self.code(),
self.stdout_str(),
self.stderr_str()
);
@@ -191,7 +421,7 @@ impl CmdResult {
#[track_caller]
pub fn failure(&self) -> &Self {
assert!(
- !self.success,
+ !self.succeeded(),
"Command was expected to fail.\nstdout = {}\n stderr = {}",
self.stdout_str(),
self.stderr_str()
@@ -269,7 +499,11 @@ impl CmdResult {
/// whose bytes equal those of the passed in slice
#[track_caller]
pub fn stdout_is_bytes<T: AsRef<[u8]>>(&self, msg: T) -> &Self {
- assert_eq!(self.stdout, msg.as_ref());
+ assert_eq!(self.stdout, msg.as_ref(),
+ "stdout as bytes wasn't equal to expected bytes. Result as strings:\nstdout ='{:?}'\nexpected='{:?}'",
+ std::str::from_utf8(&self.stdout),
+ std::str::from_utf8(msg.as_ref()),
+ );
self
}
@@ -328,7 +562,7 @@ impl CmdResult {
let contents = String::from_utf8(read_scenario_fixture(&self.tmpd, file_rel_path)).unwrap();
let possible_values = template_vars.iter().map(|vars| {
let mut contents = contents.clone();
- for kv in vars.iter() {
+ for kv in vars {
contents = contents.replace(&kv.0, &kv.1);
}
contents
@@ -336,15 +570,13 @@ impl CmdResult {
self.stdout_is_any(&possible_values.collect::<Vec<_>>());
}
- /// asserts that the command resulted in stderr stream output that equals the
- /// passed in value, when both are trimmed of trailing whitespace
+ /// assert that the command resulted in stderr stream output that equals the
+ /// passed in value.
+ ///
/// `stderr_only` is a better choice unless stdout may or will be non-empty
#[track_caller]
pub fn stderr_is<T: AsRef<str>>(&self, msg: T) -> &Self {
- assert_eq!(
- self.stderr_str().trim_end(),
- String::from(msg.as_ref()).trim_end()
- );
+ assert_eq!(self.stderr_str(), msg.as_ref());
self
}
@@ -352,7 +584,13 @@ impl CmdResult {
/// whose bytes equal those of the passed in slice
#[track_caller]
pub fn stderr_is_bytes<T: AsRef<[u8]>>(&self, msg: T) -> &Self {
- assert_eq!(self.stderr, msg.as_ref());
+ assert_eq!(
+ &self.stderr,
+ msg.as_ref(),
+ "stderr as bytes wasn't equal to expected bytes. Result as strings:\nstderr ='{:?}'\nexpected='{:?}'",
+ std::str::from_utf8(&self.stderr),
+ std::str::from_utf8(msg.as_ref())
+ );
self
}
@@ -390,7 +628,7 @@ impl CmdResult {
/// asserts that
/// 1. the command resulted in stderr stream output that equals the
- /// passed in value, when both are trimmed of trailing whitespace
+ /// passed in value
/// 2. the command resulted in empty (zero-length) stdout stream output
#[track_caller]
pub fn stderr_only<T: AsRef<str>>(&self, msg: T) -> &Self {
@@ -408,14 +646,14 @@ impl CmdResult {
#[track_caller]
pub fn fails_silently(&self) -> &Self {
- assert!(!self.success);
+ assert!(!self.succeeded());
assert!(self.stderr.is_empty());
self
}
/// asserts that
/// 1. the command resulted in stderr stream output that equals the
- /// the following format when both are trimmed of trailing whitespace
+ /// the following format
/// `"{util_name}: {msg}\nTry '{bin_path} {util_name} --help' for more information."`
/// This the expected format when a `UUsageError` is returned or when `show_error!` is called
/// `msg` should be the same as the one provided to `UUsageError::new` or `show_error!`
@@ -424,9 +662,9 @@ impl CmdResult {
#[track_caller]
pub fn usage_error<T: AsRef<str>>(&self, msg: T) -> &Self {
self.stderr_only(format!(
- "{0}: {2}\nTry '{1} {0} --help' for more information.",
+ "{0}: {2}\nTry '{1} {0} --help' for more information.\n",
self.util_name.as_ref().unwrap(), // This shouldn't be called using a normal command
- self.bin_path,
+ self.bin_path.display(),
msg.as_ref()
))
}
@@ -442,6 +680,17 @@ impl CmdResult {
self
}
+ #[track_caller]
+ pub fn stdout_contains_line<T: AsRef<str>>(&self, cmp: T) -> &Self {
+ assert!(
+ self.stdout_str().lines().any(|line| line == cmp.as_ref()),
+ "'{}' does not contain line '{}'",
+ self.stdout_str(),
+ cmp.as_ref()
+ );
+ self
+ }
+
#[track_caller]
pub fn stderr_contains<T: AsRef<str>>(&self, cmp: T) -> &Self {
assert!(
@@ -473,17 +722,27 @@ impl CmdResult {
#[track_caller]
pub fn stdout_matches(&self, regex: ®ex::Regex) -> &Self {
assert!(
- regex.is_match(self.stdout_str().trim()),
+ regex.is_match(self.stdout_str()),
"Stdout does not match regex:\n{}",
self.stdout_str()
);
self
}
+ #[track_caller]
+ pub fn stderr_matches(&self, regex: ®ex::Regex) -> &Self {
+ assert!(
+ regex.is_match(self.stderr_str()),
+ "Stderr does not match regex:\n{}",
+ self.stderr_str()
+ );
+ self
+ }
+
#[track_caller]
pub fn stdout_does_not_match(&self, regex: ®ex::Regex) -> &Self {
assert!(
- !regex.is_match(self.stdout_str().trim()),
+ !regex.is_match(self.stdout_str()),
"Stdout matches regex:\n{}",
self.stdout_str()
);
@@ -520,6 +779,26 @@ pub fn get_root_path() -> &'static str {
}
}
+/// Compares the extended attributes (xattrs) of two files or directories.
+///
+/// # Returns
+///
+/// `true` if both paths have the same set of extended attributes, `false` otherwise.
+#[cfg(all(unix, not(any(target_os = "macos", target_os = "openbsd"))))]
+pub fn compare_xattrs<P: AsRef<std::path::Path>>(path1: P, path2: P) -> bool {
+ let get_sorted_xattrs = |path: P| {
+ xattr::list(path)
+ .map(|attrs| {
+ let mut attrs = attrs.collect::<Vec<_>>();
+ attrs.sort();
+ attrs
+ })
+ .unwrap_or_else(|_| Vec::new())
+ };
+
+ get_sorted_xattrs(path1) == get_sorted_xattrs(path2)
+}
+
/// Object-oriented path struct that represents and operates on
/// paths relative to the directory it was constructed for.
#[derive(Clone)]
@@ -538,14 +817,14 @@ impl AtPath {
self.subdir.to_str().unwrap().to_owned()
}
- pub fn plus(&self, name: &str) -> PathBuf {
+ pub fn plus<P: AsRef<Path>>(&self, name: P) -> PathBuf {
let mut pathbuf = self.subdir.clone();
pathbuf.push(name);
pathbuf
}
- pub fn plus_as_string(&self, name: &str) -> String {
- String::from(self.plus(name).to_str().unwrap())
+ pub fn plus_as_string<P: AsRef<Path>>(&self, name: P) -> String {
+ self.plus(name).display().to_string()
}
fn minus(&self, name: &str) -> PathBuf {
@@ -608,7 +887,6 @@ impl AtPath {
pub fn append(&self, name: &str, contents: &str) {
log_info("write(append)", self.plus_as_string(name));
let mut f = OpenOptions::new()
- .write(true)
.append(true)
.create(true)
.open(self.plus(name))
@@ -620,7 +898,6 @@ impl AtPath {
pub fn append_bytes(&self, name: &str, contents: &[u8]) {
log_info("write(append)", self.plus_as_string(name));
let mut f = OpenOptions::new()
- .write(true)
.append(true)
.create(true)
.open(self.plus(name))
@@ -668,7 +945,8 @@ impl AtPath {
fs::remove_dir(self.plus(dir)).unwrap();
}
- pub fn mkdir(&self, dir: &str) {
+ pub fn mkdir<P: AsRef<Path>>(&self, dir: P) {
+ let dir = dir.as_ref();
log_info("mkdir", self.plus_as_string(dir));
fs::create_dir(self.plus(dir)).unwrap();
}
@@ -685,7 +963,8 @@ impl AtPath {
}
}
- pub fn touch(&self, file: &str) {
+ pub fn touch<P: AsRef<Path>>(&self, file: P) {
+ let file = file.as_ref();
log_info("touch", self.plus_as_string(file));
File::create(self.plus(file)).unwrap();
}
@@ -739,7 +1018,7 @@ impl AtPath {
pub fn relative_symlink_file(&self, original: &str, link: &str) {
#[cfg(windows)]
- let original = original.replace('/', &MAIN_SEPARATOR.to_string());
+ let original = original.replace('/', MAIN_SEPARATOR_STR);
log_info(
"symlink",
format!("{},{}", &original, &self.plus_as_string(link)),
@@ -761,7 +1040,7 @@ impl AtPath {
pub fn relative_symlink_dir(&self, original: &str, link: &str) {
#[cfg(windows)]
- let original = original.replace('/', &MAIN_SEPARATOR.to_string());
+ let original = original.replace('/', MAIN_SEPARATOR_STR);
log_info(
"symlink",
format!("{},{}", &original, &self.plus_as_string(link)),
@@ -808,7 +1087,7 @@ impl AtPath {
}
}
- pub fn file_exists(&self, path: &str) -> bool {
+ pub fn file_exists<P: AsRef<Path>>(&self, path: P) -> bool {
match fs::metadata(self.plus(path)) {
Ok(m) => m.is_file(),
Err(_) => false,
@@ -885,24 +1164,21 @@ pub struct TestScenario {
}
impl TestScenario {
- pub fn new(util_name: &str) -> Self {
+ pub fn new<T>(util_name: T) -> Self
+ where
+ T: AsRef<str>,
+ {
let tmpd = Rc::new(TempDir::new().unwrap());
let ts = Self {
- bin_path: {
- // Instead of hard coding the path relative to the current
- // directory, use Cargo's OUT_DIR to find path to executable.
- // This allows tests to be run using profiles other than debug.
- let target_dir = path_concat!(env!("OUT_DIR"), "..", "..", "..", PROGNAME);
- PathBuf::from(AtPath::new(Path::new(&target_dir)).root_dir_resolved())
- },
- util_name: String::from(util_name),
+ bin_path: PathBuf::from(TESTS_BINARY),
+ util_name: util_name.as_ref().into(),
fixtures: AtPath::new(tmpd.as_ref().path()),
tmpd,
};
let mut fixture_path_builder = env::current_dir().unwrap();
fixture_path_builder.push(TESTS_DIR);
fixture_path_builder.push(FIXTURES_DIR);
- fixture_path_builder.push(util_name);
+ fixture_path_builder.push(util_name.as_ref());
if let Ok(m) = fs::metadata(&fixture_path_builder) {
if m.is_dir() {
recursive_copy(&fixture_path_builder, &ts.fixtures.subdir).unwrap();
@@ -914,58 +1190,57 @@ impl TestScenario {
/// Returns builder for invoking the target uutils binary. Paths given are
/// treated relative to the environment's unique temporary test directory.
pub fn ucmd(&self) -> UCommand {
- self.composite_cmd(&self.bin_path, &self.util_name, true)
- }
-
- /// Returns builder for invoking the target uutils binary. Paths given are
- /// treated relative to the environment's unique temporary test directory.
- pub fn composite_cmd<S: AsRef<OsStr>, T: AsRef<OsStr>>(
- &self,
- bin: S,
- util_name: T,
- env_clear: bool,
- ) -> UCommand {
- UCommand::new_from_tmp(bin, &Some(util_name), self.tmpd.clone(), env_clear)
+ UCommand::from_test_scenario(self)
}
/// Returns builder for invoking any system command. Paths given are treated
/// relative to the environment's unique temporary test directory.
- pub fn cmd<S: AsRef<OsStr>>(&self, bin: S) -> UCommand {
- UCommand::new_from_tmp::<S, S>(bin, &None, self.tmpd.clone(), true)
+ pub fn cmd<S: Into<PathBuf>>(&self, bin_path: S) -> UCommand {
+ let mut command = UCommand::new();
+ command.bin_path(bin_path);
+ command.temp_dir(self.tmpd.clone());
+ command
}
/// Returns builder for invoking any uutils command. Paths given are treated
/// relative to the environment's unique temporary test directory.
- pub fn ccmd<S: AsRef<OsStr>>(&self, bin: S) -> UCommand {
- self.composite_cmd(&self.bin_path, bin, true)
- }
-
- // different names are used rather than an argument
- // because the need to keep the environment is exceedingly rare.
- pub fn ucmd_keepenv(&self) -> UCommand {
- self.composite_cmd(&self.bin_path, &self.util_name, false)
+ pub fn ccmd<S: AsRef<str>>(&self, util_name: S) -> UCommand {
+ UCommand::with_util(util_name, self.tmpd.clone())
}
+}
- /// Returns builder for invoking any system command. Paths given are treated
- /// relative to the environment's unique temporary test directory.
- /// Differs from the builder returned by `cmd` in that `cmd_keepenv` does not call
- /// `Command::env_clear` (Clears the entire environment map for the child process.)
- pub fn cmd_keepenv<S: AsRef<OsStr>>(&self, bin: S) -> UCommand {
- UCommand::new_from_tmp::<S, S>(bin, &None, self.tmpd.clone(), false)
- }
+#[cfg(unix)]
+#[derive(Debug, Default)]
+pub struct TerminalSimulation {
+ size: Option<libc::winsize>,
+ stdin: bool,
+ stdout: bool,
+ stderr: bool,
}
-/// A `UCommand` is a wrapper around an individual Command that provides several additional features
+/// A `UCommand` is a builder wrapping an individual Command that provides several additional features:
/// 1. it has convenience functions that are more ergonomic to use for piping in stdin, spawning the command
/// and asserting on the results.
/// 2. it tracks arguments provided so that in test cases which may provide variations of an arg in loops
/// the test failure can display the exact call which preceded an assertion failure.
-/// 3. it provides convenience construction arguments to set the Command working directory and/or clear its environment.
-#[derive(Debug)]
+/// 3. it provides convenience construction methods to set the Command uutils utility and temporary directory.
+///
+/// Per default `UCommand` runs a command given as an argument in a shell, platform independently.
+/// It does so with safety in mind, so the working directory is set to an individual temporary
+/// directory and the environment variables are cleared per default.
+///
+/// The default behavior can be changed with builder methods:
+/// * [`UCommand::with_util`]: Run `coreutils UTIL_NAME` instead of the shell
+/// * [`UCommand::from_test_scenario`]: Run `coreutils UTIL_NAME` instead of the shell in the
+/// temporary directory of the [`TestScenario`]
+/// * [`UCommand::current_dir`]: Sets the working directory
+/// * ...
+#[derive(Debug, Default)]
pub struct UCommand {
- pub raw: Command,
- comm_string: String,
- bin_path: String,
+ args: VecDeque<OsString>,
+ env_vars: Vec<(OsString, OsString)>,
+ current_dir: Option<PathBuf>,
+ bin_path: Option<PathBuf>,
util_name: Option<String>,
has_run: bool,
ignore_stdin_write_error: bool,
@@ -973,80 +1248,85 @@ pub struct UCommand {
stdout: Option<Stdio>,
stderr: Option<Stdio>,
bytes_into_stdin: Option<Vec<u8>>,
- #[cfg(any(target_os = "linux", target_os = "android"))]
+ #[cfg(unix)]
limits: Vec<(rlimit::Resource, u64, u64)>,
stderr_to_stdout: bool,
timeout: Option<Duration>,
+ #[cfg(unix)]
+ terminal_simulation: Option<TerminalSimulation>,
tmpd: Option<Rc<TempDir>>, // drop last
+ #[cfg(unix)]
+ umask: Option<mode_t>,
}
impl UCommand {
- pub fn new<T: AsRef<OsStr>, S: AsRef<OsStr>, U: AsRef<OsStr>>(
- bin_path: T,
- util_name: &Option<S>,
- curdir: U,
- env_clear: bool,
- ) -> Self {
- let bin_path = bin_path.as_ref();
- let util_name = util_name.as_ref().map(std::convert::AsRef::as_ref);
-
- let mut ucmd = Self {
- tmpd: None,
- has_run: false,
- raw: {
- let mut cmd = Command::new(bin_path);
- cmd.current_dir(curdir.as_ref());
- if env_clear {
- cmd.env_clear();
- if cfg!(windows) {
- // spell-checker:ignore (dll) rsaenh
- // %SYSTEMROOT% is required on Windows to initialize crypto provider
- // ... and crypto provider is required for std::rand
- // From `procmon`: RegQueryValue HKLM\SOFTWARE\Microsoft\Cryptography\Defaults\Provider\Microsoft Strong Cryptographic Provider\Image Path
- // SUCCESS Type: REG_SZ, Length: 66, Data: %SystemRoot%\system32\rsaenh.dll"
- if let Some(systemroot) = env::var_os("SYSTEMROOT") {
- cmd.env("SYSTEMROOT", systemroot);
- }
- } else {
- // if someone is setting LD_PRELOAD, there's probably a good reason for it
- if let Some(ld_preload) = env::var_os("LD_PRELOAD") {
- cmd.env("LD_PRELOAD", ld_preload);
- }
- }
- }
- cmd
- },
- comm_string: String::from(bin_path.to_str().unwrap()),
- bin_path: bin_path.to_str().unwrap().to_string(),
- util_name: util_name.map(|un| un.to_str().unwrap().to_string()),
- ignore_stdin_write_error: false,
- bytes_into_stdin: None,
- stdin: None,
- stdout: None,
- stderr: None,
- #[cfg(any(target_os = "linux", target_os = "android"))]
- limits: vec![],
- stderr_to_stdout: false,
- timeout: Some(Duration::from_secs(30)),
- };
-
- if let Some(un) = util_name {
- ucmd.arg(un);
+ /// Create a new plain [`UCommand`].
+ ///
+ /// Executes a command that must be given as argument (for example with [`UCommand::arg`] in a
+ /// shell (`sh -c` on unix platforms or `cmd /C` on windows).
+ ///
+ /// Per default the environment is cleared and the working directory is set to an individual
+ /// temporary directory for safety purposes.
+ pub fn new() -> Self {
+ Self {
+ ..Default::default()
}
+ }
+ /// Create a [`UCommand`] for a specific uutils utility.
+ ///
+ /// Sets the temporary directory to `tmpd` and the execution binary to the path where
+ /// `coreutils` is found.
+ pub fn with_util<T>(util_name: T, tmpd: Rc<TempDir>) -> Self
+ where
+ T: AsRef<str>,
+ {
+ let mut ucmd = Self::new();
+ ucmd.util_name = Some(util_name.as_ref().into());
+ ucmd.bin_path(TESTS_BINARY).temp_dir(tmpd);
ucmd
}
- pub fn new_from_tmp<T: AsRef<OsStr>, S: AsRef<OsStr>>(
- bin_path: T,
- util_name: &Option<S>,
- tmpd: Rc<TempDir>,
- env_clear: bool,
- ) -> Self {
- let tmpd_path_buf = String::from(tmpd.as_ref().path().to_str().unwrap());
- let mut ucmd: Self = Self::new(bin_path, util_name, tmpd_path_buf, env_clear);
- ucmd.tmpd = Some(tmpd);
- ucmd
+ /// Create a [`UCommand`] from a [`TestScenario`].
+ ///
+ /// The temporary directory and uutils utility are inherited from the [`TestScenario`] and the
+ /// execution binary is set to `coreutils`.
+ pub fn from_test_scenario(scene: &TestScenario) -> Self {
+ Self::with_util(&scene.util_name, scene.tmpd.clone())
+ }
+
+ /// Set the execution binary.
+ ///
+ /// Make sure the binary found at this path is executable. It's safest to provide the
+ /// canonicalized path instead of just the name of the executable, since path resolution is not
+ /// guaranteed to work on all platforms.
+ fn bin_path<T>(&mut self, bin_path: T) -> &mut Self
+ where
+ T: Into<PathBuf>,
+ {
+ self.bin_path = Some(bin_path.into());
+ self
+ }
+
+ /// Set the temporary directory.
+ ///
+ /// Per default an individual temporary directory is created for every [`UCommand`]. If not
+ /// specified otherwise with [`UCommand::current_dir`] the working directory is set to this
+ /// temporary directory.
+ fn temp_dir(&mut self, temp_dir: Rc<TempDir>) -> &mut Self {
+ self.tmpd = Some(temp_dir);
+ self
+ }
+
+ /// Set the working directory for this [`UCommand`]
+ ///
+ /// Per default the working directory is set to the [`UCommands`] temporary directory.
+ pub fn current_dir<T>(&mut self, current_dir: T) -> &mut Self
+ where
+ T: Into<PathBuf>,
+ {
+ self.current_dir = Some(current_dir.into());
+ self
}
pub fn set_stdin<T: Into<Stdio>>(&mut self, stdin: T) -> &mut Self {
@@ -1072,29 +1352,14 @@ impl UCommand {
/// Add a parameter to the invocation. Path arguments are treated relative
/// to the test environment directory.
pub fn arg<S: AsRef<OsStr>>(&mut self, arg: S) -> &mut Self {
- assert!(!self.has_run, "{}", ALREADY_RUN);
- self.comm_string.push(' ');
- self.comm_string
- .push_str(arg.as_ref().to_str().unwrap_or_default());
- self.raw.arg(arg.as_ref());
+ self.args.push_back(arg.as_ref().into());
self
}
/// Add multiple parameters to the invocation. Path arguments are treated relative
/// to the test environment directory.
pub fn args<S: AsRef<OsStr>>(&mut self, args: &[S]) -> &mut Self {
- assert!(!self.has_run, "{}", MULTIPLE_STDIN_MEANINGLESS);
- let strings = args
- .iter()
- .map(|s| s.as_ref().to_os_string())
- .collect_ignore();
-
- for s in strings {
- self.comm_string.push(' ');
- self.comm_string.push_str(&s);
- }
-
- self.raw.args(args.as_ref());
+ self.args.extend(args.iter().map(|s| s.as_ref().into()));
self
}
@@ -1129,13 +1394,25 @@ impl UCommand {
K: AsRef<OsStr>,
V: AsRef<OsStr>,
{
- assert!(!self.has_run, "{}", ALREADY_RUN);
- self.raw.env(key, val);
+ self.env_vars
+ .push((key.as_ref().into(), val.as_ref().into()));
+ self
+ }
+
+ pub fn envs<I, K, V>(&mut self, iter: I) -> &mut Self
+ where
+ I: IntoIterator<Item = (K, V)>,
+ K: AsRef<OsStr>,
+ V: AsRef<OsStr>,
+ {
+ for (k, v) in iter {
+ self.env(k, v);
+ }
self
}
- #[cfg(any(target_os = "linux", target_os = "android"))]
- pub fn with_limit(
+ #[cfg(unix)]
+ pub fn limit(
&mut self,
resource: rlimit::Resource,
soft_limit: u64,
@@ -1145,6 +1422,13 @@ impl UCommand {
self
}
+ #[cfg(unix)]
+ /// The umask is a value that restricts the permissions of newly created files and directories.
+ pub fn umask(&mut self, umask: mode_t) -> &mut Self {
+ self.umask = Some(umask);
+ self
+ }
+
/// Set the timeout for [`UCommand::run`] and similar methods in [`UCommand`].
///
/// After the timeout elapsed these `run` methods (besides [`UCommand::run_no_wait`]) will
@@ -1157,26 +1441,195 @@ impl UCommand {
self
}
- /// Spawns the command, feeds the stdin if any, and returns the
- /// child process immediately.
- pub fn run_no_wait(&mut self) -> UChild {
- assert!(!self.has_run, "{}", ALREADY_RUN);
- self.has_run = true;
- log_info("run", &self.comm_string);
-
- let mut captured_stdout = None;
- let mut captured_stderr = None;
- let command = if self.stderr_to_stdout {
- let mut output = CapturedOutput::default();
+ /// Set if process should be run in a simulated terminal
+ ///
+ /// This is useful to test behavior that is only active if e.g. [`stdout.is_terminal()`] is [`true`].
+ /// This function uses default terminal size and attaches stdin, stdout and stderr to that terminal.
+ /// For more control over the terminal simulation, use `terminal_sim_stdio`
+ /// (unix: pty, windows: `ConPTY`[not yet supported])
+ #[cfg(unix)]
+ pub fn terminal_simulation(&mut self, enable: bool) -> &mut Self {
+ if enable {
+ self.terminal_simulation = Some(TerminalSimulation {
+ stdin: true,
+ stdout: true,
+ stderr: true,
+ ..Default::default()
+ });
+ } else {
+ self.terminal_simulation = None;
+ }
+ self
+ }
- let command = self
- .raw
- .stdin(self.stdin.take().unwrap_or_else(Stdio::null))
- .stdout(Stdio::from(output.try_clone().unwrap()))
- .stderr(Stdio::from(output.try_clone().unwrap()));
- captured_stdout = Some(output);
+ /// Allows to simulate a terminal use-case with specific properties.
+ ///
+ /// This is useful to test behavior that is only active if e.g. [`stdout.is_terminal()`] is [`true`].
+ /// This function allows to set a specific size and to attach the terminal to only parts of the in/out.
+ #[cfg(unix)]
+ pub fn terminal_sim_stdio(&mut self, config: TerminalSimulation) -> &mut Self {
+ self.terminal_simulation = Some(config);
+ self
+ }
- command
+ #[cfg(unix)]
+ fn read_from_pty(pty_fd: std::os::fd::OwnedFd, out: File) {
+ let read_file = std::fs::File::from(pty_fd);
+ let mut reader = std::io::BufReader::new(read_file);
+ let mut writer = std::io::BufWriter::new(out);
+ let result = std::io::copy(&mut reader, &mut writer);
+ match result {
+ Ok(_) => {}
+ // Input/output error (os error 5) is returned due to pipe closes. Buffer gets content anyway.
+ Err(e) if e.raw_os_error().unwrap_or_default() == 5 => {}
+ Err(e) => {
+ eprintln!("Unexpected error: {e:?}");
+ panic!("error forwarding output of pty");
+ }
+ }
+ }
+
+ #[cfg(unix)]
+ fn spawn_reader_thread(
+ &self,
+ captured_output: Option<CapturedOutput>,
+ pty_fd_master: OwnedFd,
+ name: String,
+ ) -> Option<CapturedOutput> {
+ if let Some(mut captured_output_i) = captured_output {
+ let fd = captured_output_i.try_clone().unwrap();
+
+ let handle = std::thread::Builder::new()
+ .name(name)
+ .spawn(move || {
+ Self::read_from_pty(pty_fd_master, fd);
+ })
+ .unwrap();
+
+ captured_output_i.reader_thread_handle = Some(handle);
+ Some(captured_output_i)
+ } else {
+ None
+ }
+ }
+
+ /// Build the `std::process::Command` and apply the defaults on fields which were not specified
+ /// by the user.
+ ///
+ /// These __defaults__ are:
+ /// * `bin_path`: Depending on the platform and os, the native shell (unix -> `/bin/sh` etc.).
+ /// This default also requires to set the first argument to `-c` on unix (`/C` on windows) if
+ /// this argument wasn't specified explicitly by the user.
+ /// * `util_name`: `None`. If neither `bin_path` nor `util_name` were given the arguments are
+ /// run in a shell (See `bin_path` above).
+ /// * `temp_dir`: If `current_dir` was not set, a new temporary directory will be created in
+ /// which this command will be run and `current_dir` will be set to this `temp_dir`.
+ /// * `current_dir`: The temporary directory given by `temp_dir`.
+ /// * `timeout`: `30 seconds`
+ /// * `stdin`: `Stdio::null()`
+ /// * `ignore_stdin_write_error`: `false`
+ /// * `stdout`, `stderr`: If not specified the output will be captured with [`CapturedOutput`]
+ /// * `stderr_to_stdout`: `false`
+ /// * `bytes_into_stdin`: `None`
+ /// * `limits`: `None`.
+ fn build(
+ &mut self,
+ ) -> (
+ Command,
+ Option<CapturedOutput>,
+ Option<CapturedOutput>,
+ Option<File>,
+ ) {
+ if self.bin_path.is_some() {
+ if let Some(util_name) = &self.util_name {
+ self.args.push_front(util_name.into());
+ }
+ } else if let Some(util_name) = &self.util_name {
+ self.bin_path = Some(PathBuf::from(TESTS_BINARY));
+ self.args.push_front(util_name.into());
+ // neither `bin_path` nor `util_name` was set so we apply the default to run the arguments
+ // in a platform specific shell
+ } else if cfg!(unix) {
+ #[cfg(target_os = "android")]
+ let bin_path = PathBuf::from("/system/bin/sh");
+ #[cfg(not(target_os = "android"))]
+ let bin_path = PathBuf::from("/bin/sh");
+
+ self.bin_path = Some(bin_path);
+ let c_arg = OsString::from("-c");
+ if !self.args.contains(&c_arg) {
+ self.args.push_front(c_arg);
+ }
+ } else {
+ self.bin_path = Some(PathBuf::from("cmd"));
+ let c_arg = OsString::from("/C");
+ let k_arg = OsString::from("/K");
+ if !self
+ .args
+ .iter()
+ .any(|s| s.eq_ignore_ascii_case(&c_arg) || s.eq_ignore_ascii_case(&k_arg))
+ {
+ self.args.push_front(c_arg);
+ }
+ };
+
+ // unwrap is safe here because we have set `self.bin_path` before
+ let mut command = Command::new(self.bin_path.as_ref().unwrap());
+ command.args(&self.args);
+
+ // We use a temporary directory as working directory if not specified otherwise with
+ // `current_dir()`. If neither `current_dir` nor a temporary directory is available, then we
+ // create our own.
+ if let Some(current_dir) = &self.current_dir {
+ command.current_dir(current_dir);
+ } else if let Some(temp_dir) = &self.tmpd {
+ command.current_dir(temp_dir.path());
+ } else {
+ let temp_dir = tempfile::tempdir().unwrap();
+ self.current_dir = Some(temp_dir.path().into());
+ command.current_dir(temp_dir.path());
+ self.tmpd = Some(Rc::new(temp_dir));
+ }
+
+ command.env_clear();
+ if cfg!(windows) {
+ // spell-checker:ignore (dll) rsaenh
+ // %SYSTEMROOT% is required on Windows to initialize crypto provider
+ // ... and crypto provider is required for std::rand
+ // From `procmon`: RegQueryValue HKLM\SOFTWARE\Microsoft\Cryptography\Defaults\Provider\Microsoft Strong Cryptographic Provider\Image Path
+ // SUCCESS Type: REG_SZ, Length: 66, Data: %SystemRoot%\system32\rsaenh.dll"
+ if let Some(systemroot) = env::var_os("SYSTEMROOT") {
+ command.env("SYSTEMROOT", systemroot);
+ }
+ } else {
+ // if someone is setting LD_PRELOAD, there's probably a good reason for it
+ if let Some(ld_preload) = env::var_os("LD_PRELOAD") {
+ command.env("LD_PRELOAD", ld_preload);
+ }
+ }
+
+ command
+ .envs(DEFAULT_ENV)
+ .envs(self.env_vars.iter().cloned());
+
+ if self.timeout.is_none() {
+ self.timeout = Some(Duration::from_secs(30));
+ }
+
+ let mut captured_stdout = None;
+ let mut captured_stderr = None;
+ #[cfg(unix)]
+ let mut stdin_pty: Option<File> = None;
+ #[cfg(not(unix))]
+ let stdin_pty: Option<File> = None;
+ if self.stderr_to_stdout {
+ let mut output = CapturedOutput::default();
+
+ command
+ .stdin(self.stdin.take().unwrap_or_else(Stdio::null))
+ .stdout(Stdio::from(output.try_clone().unwrap()))
+ .stderr(Stdio::from(output.try_clone().unwrap()));
+ captured_stdout = Some(output);
} else {
let stdout = if self.stdout.is_some() {
self.stdout.take().unwrap()
@@ -1196,26 +1649,101 @@ impl UCommand {
stdio
};
- self.raw
+ command
.stdin(self.stdin.take().unwrap_or_else(Stdio::null))
.stdout(stdout)
- .stderr(stderr)
+ .stderr(stderr);
};
- let child = command.spawn().unwrap();
+ #[cfg(unix)]
+ if let Some(simulated_terminal) = &self.terminal_simulation {
+ let terminal_size = simulated_terminal.size.unwrap_or(libc::winsize {
+ ws_col: 80,
+ ws_row: 30,
+ ws_xpixel: 80 * 8,
+ ws_ypixel: 30 * 10,
+ });
+
+ if simulated_terminal.stdin {
+ let OpenptyResult {
+ slave: pi_slave,
+ master: pi_master,
+ } = nix::pty::openpty(&terminal_size, None).unwrap();
+ stdin_pty = Some(File::from(pi_master));
+ command.stdin(pi_slave);
+ }
- #[cfg(target_os = "linux")]
- for &(resource, soft_limit, hard_limit) in &self.limits {
- prlimit(
- child.id() as i32,
- resource,
- Some((soft_limit, hard_limit)),
- None,
- )
- .unwrap();
+ if simulated_terminal.stdout {
+ let OpenptyResult {
+ slave: po_slave,
+ master: po_master,
+ } = nix::pty::openpty(&terminal_size, None).unwrap();
+ captured_stdout = self.spawn_reader_thread(
+ captured_stdout,
+ po_master,
+ "stdout_reader".to_string(),
+ );
+ command.stdout(po_slave);
+ }
+
+ if simulated_terminal.stderr {
+ let OpenptyResult {
+ slave: pe_slave,
+ master: pe_master,
+ } = nix::pty::openpty(&terminal_size, None).unwrap();
+ captured_stderr = self.spawn_reader_thread(
+ captured_stderr,
+ pe_master,
+ "stderr_reader".to_string(),
+ );
+ command.stderr(pe_slave);
+ }
+ }
+
+ #[cfg(unix)]
+ if !self.limits.is_empty() {
+ // just to be safe: move a copy of the limits list into the closure.
+ // this way the closure is fully self-contained.
+ let limits_copy = self.limits.clone();
+ let closure = move || -> Result<()> {
+ for &(resource, soft_limit, hard_limit) in &limits_copy {
+ setrlimit(resource, soft_limit, hard_limit)?;
+ }
+ Ok(())
+ };
+ // SAFETY: the closure is self-contained and doesn't do any memory
+ // writes that would need to be propagated back to the parent process.
+ // also, the closure doesn't access stdin, stdout and stderr.
+ unsafe {
+ command.pre_exec(closure);
+ }
+ }
+
+ #[cfg(unix)]
+ if let Some(umask) = self.umask {
+ unsafe {
+ command.pre_exec(move || {
+ libc::umask(umask);
+ Ok(())
+ });
+ }
}
- let mut child = UChild::from(self, child, captured_stdout, captured_stderr);
+ (command, captured_stdout, captured_stderr, stdin_pty)
+ }
+
+ /// Spawns the command, feeds the stdin if any, and returns the
+ /// child process immediately.
+ pub fn run_no_wait(&mut self) -> UChild {
+ assert!(!self.has_run, "{}", ALREADY_RUN);
+ self.has_run = true;
+
+ let (mut command, captured_stdout, captured_stderr, stdin_pty) = self.build();
+ log_info("run", self.to_string());
+
+ let child = command.spawn().unwrap();
+
+ let mut child = UChild::from(self, child, captured_stdout, captured_stderr, stdin_pty);
if let Some(input) = self.bytes_into_stdin.take() {
child.pipe_in(input);
@@ -1226,7 +1754,7 @@ impl UCommand {
/// Spawns the command, feeds the stdin if any, waits for the result
/// and returns a command result.
- /// It is recommended that you instead use succeeds() or fails()
+ /// It is recommended that you instead use `succeeds()` or `fails()`
pub fn run(&mut self) -> CmdResult {
self.run_no_wait().wait().unwrap()
}
@@ -1234,7 +1762,7 @@ impl UCommand {
/// Spawns the command, feeding the passed in stdin, waits for the result
/// and returns a command result.
/// It is recommended that, instead of this, you use a combination of `pipe_in()`
- /// with succeeds() or fails()
+ /// with `succeeds()` or `fails()`
pub fn run_piped_stdin<T: Into<Vec<u8>>>(&mut self, input: T) -> CmdResult {
self.pipe_in(input).run()
}
@@ -1263,12 +1791,24 @@ impl UCommand {
}
}
+impl std::fmt::Display for UCommand {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ let mut comm_string: Vec<String> = vec![self
+ .bin_path
+ .as_ref()
+ .map_or(String::new(), |p| p.display().to_string())];
+ comm_string.extend(self.args.iter().map(|s| s.to_string_lossy().to_string()));
+ f.write_str(&comm_string.join(" "))
+ }
+}
+
/// Stored the captured output in a temporary file. The file is deleted as soon as
/// [`CapturedOutput`] is dropped.
#[derive(Debug)]
struct CapturedOutput {
current_file: File,
output: tempfile::NamedTempFile, // drop last
+ reader_thread_handle: Option<thread::JoinHandle<()>>,
}
impl CapturedOutput {
@@ -1277,6 +1817,7 @@ impl CapturedOutput {
Self {
current_file: output.reopen().unwrap(),
output,
+ reader_thread_handle: None,
}
}
@@ -1353,6 +1894,7 @@ impl Default for CapturedOutput {
Self {
current_file: file.reopen().unwrap(),
output: file,
+ reader_thread_handle: None,
}
}
}
@@ -1379,12 +1921,10 @@ impl<'a> UChildAssertion<'a> {
}
fn with_output(&mut self, mode: AssertionMode) -> CmdResult {
- let (code, success) = match self.uchild.is_alive() {
- true => (None, true),
- false => {
- let status = self.uchild.raw.wait().unwrap();
- (status.code(), status.success())
- }
+ let exit_status = if self.uchild.is_alive() {
+ None
+ } else {
+ Some(self.uchild.raw.wait().unwrap())
};
let (stdout, stderr) = match mode {
AssertionMode::All => (
@@ -1397,15 +1937,14 @@ impl<'a> UChildAssertion<'a> {
self.uchild.stderr_exact_bytes(expected_stderr_size),
),
};
- CmdResult {
- bin_path: self.uchild.bin_path.clone(),
- util_name: self.uchild.util_name.clone(),
- tmpd: self.uchild.tmpd.clone(),
- code,
- success,
+ CmdResult::new(
+ self.uchild.bin_path.clone(),
+ self.uchild.util_name.clone(),
+ self.uchild.tmpd.clone(),
+ exit_status,
stdout,
stderr,
- }
+ )
}
// Make assertions of [`CmdResult`] with all output from start of the process until now.
@@ -1485,10 +2024,11 @@ impl<'a> UChildAssertion<'a> {
/// Abstraction for a [`std::process::Child`] to handle the child process.
pub struct UChild {
raw: Child,
- bin_path: String,
+ bin_path: PathBuf,
util_name: Option<String>,
captured_stdout: Option<CapturedOutput>,
captured_stderr: Option<CapturedOutput>,
+ stdin_pty: Option<File>,
ignore_stdin_write_error: bool,
stderr_to_stdout: bool,
join_handle: Option<JoinHandle<io::Result<()>>>,
@@ -1502,13 +2042,15 @@ impl UChild {
child: Child,
captured_stdout: Option<CapturedOutput>,
captured_stderr: Option<CapturedOutput>,
+ stdin_pty: Option<File>,
) -> Self {
Self {
raw: child,
- bin_path: ucommand.bin_path.clone(),
+ bin_path: ucommand.bin_path.clone().unwrap(),
util_name: ucommand.util_name.clone(),
captured_stdout,
captured_stderr,
+ stdin_pty,
ignore_stdin_write_error: ucommand.ignore_stdin_write_error,
stderr_to_stdout: ucommand.stderr_to_stdout,
join_handle: None,
@@ -1631,8 +2173,7 @@ impl UChild {
bin_path,
util_name,
tmpd,
- code: output.status.code(),
- success: output.status.success(),
+ exit_status: Some(output.status),
stdout: output.stdout,
stderr: output.stderr,
})
@@ -1650,11 +2191,19 @@ impl UChild {
/// error.
#[deprecated = "Please use wait() -> io::Result<CmdResult> instead."]
pub fn wait_with_output(mut self) -> io::Result<Output> {
+ // some apps do not stop execution until their stdin gets closed.
+ // to prevent a endless waiting here, we close the stdin.
+ self.join(); // ensure that all pending async input is piped in
+ self.close_stdin();
+
let output = if let Some(timeout) = self.timeout {
let child = self.raw;
let (sender, receiver) = mpsc::channel();
- let handle = thread::spawn(move || sender.send(child.wait_with_output()));
+ let handle = thread::Builder::new()
+ .name("wait_with_output".to_string())
+ .spawn(move || sender.send(child.wait_with_output()))
+ .unwrap();
match receiver.recv_timeout(timeout) {
Ok(result) => {
@@ -1686,9 +2235,15 @@ impl UChild {
};
if let Some(stdout) = self.captured_stdout.as_mut() {
+ if let Some(handle) = stdout.reader_thread_handle.take() {
+ handle.join().unwrap();
+ }
output.stdout = stdout.output_bytes();
}
if let Some(stderr) = self.captured_stderr.as_mut() {
+ if let Some(handle) = stderr.reader_thread_handle.take() {
+ handle.join().unwrap();
+ }
output.stderr = stderr.output_bytes();
}
@@ -1697,7 +2252,7 @@ impl UChild {
/// Read, consume and return the output as [`String`] from [`Child`]'s stdout.
///
- /// See also [`UChild::stdout_bytes] for side effects.
+ /// See also [`UChild::stdout_bytes`] for side effects.
pub fn stdout(&mut self) -> String {
String::from_utf8(self.stdout_bytes()).unwrap()
}
@@ -1850,6 +2405,29 @@ impl UChild {
}
}
+ fn access_stdin_as_writer<'a>(&'a mut self) -> Box<dyn Write + Send + 'a> {
+ if let Some(stdin_fd) = &self.stdin_pty {
+ Box::new(BufWriter::new(stdin_fd.try_clone().unwrap()))
+ } else {
+ let stdin: &mut std::process::ChildStdin = self.raw.stdin.as_mut().unwrap();
+ Box::new(BufWriter::new(stdin))
+ }
+ }
+
+ fn take_stdin_as_writer(&mut self) -> Box<dyn Write + Send> {
+ if let Some(stdin_fd) = mem::take(&mut self.stdin_pty) {
+ Box::new(BufWriter::new(stdin_fd))
+ } else {
+ let stdin = self
+ .raw
+ .stdin
+ .take()
+ .expect("Could not pipe into child process. Was it set to Stdio::null()?");
+
+ Box::new(BufWriter::new(stdin))
+ }
+ }
+
/// Pipe data into [`Child`] stdin in a separate thread to avoid deadlocks.
///
/// In contrast to [`UChild::write_in`], this method is designed to simulate a pipe on the
@@ -1871,24 +2449,24 @@ impl UChild {
/// [`JoinHandle`]: std::thread::JoinHandle
pub fn pipe_in<T: Into<Vec<u8>>>(&mut self, content: T) -> &mut Self {
let ignore_stdin_write_error = self.ignore_stdin_write_error;
- let content = content.into();
- let stdin = self
- .raw
- .stdin
- .take()
- .expect("Could not pipe into child process. Was it set to Stdio::null()?");
-
- let join_handle = thread::spawn(move || {
- let mut writer = BufWriter::new(stdin);
-
- match writer.write_all(&content).and_then(|_| writer.flush()) {
- Err(error) if !ignore_stdin_write_error => Err(io::Error::new(
- io::ErrorKind::Other,
- format!("failed to write to stdin of child: {error}"),
- )),
- Ok(_) | Err(_) => Ok(()),
- }
- });
+ let mut content: Vec<u8> = content.into();
+ if self.stdin_pty.is_some() {
+ content.append(&mut END_OF_TRANSMISSION_SEQUENCE.to_vec());
+ }
+ let mut writer = self.take_stdin_as_writer();
+
+ let join_handle = std::thread::Builder::new()
+ .name("pipe_in".to_string())
+ .spawn(
+ move || match writer.write_all(&content).and_then(|()| writer.flush()) {
+ Err(error) if !ignore_stdin_write_error => Err(io::Error::new(
+ io::ErrorKind::Other,
+ format!("failed to write to stdin of child: {error}"),
+ )),
+ Ok(()) | Err(_) => Ok(()),
+ },
+ )
+ .unwrap();
self.join_handle = Some(join_handle);
self
@@ -1931,14 +2509,15 @@ impl UChild {
/// # Errors
/// If [`ChildStdin::write_all`] or [`ChildStdin::flush`] returned an error
pub fn try_write_in<T: Into<Vec<u8>>>(&mut self, data: T) -> io::Result<()> {
- let stdin = self.raw.stdin.as_mut().unwrap();
+ let ignore_stdin_write_error = self.ignore_stdin_write_error;
+ let mut writer = self.access_stdin_as_writer();
- match stdin.write_all(&data.into()).and_then(|_| stdin.flush()) {
- Err(error) if !self.ignore_stdin_write_error => Err(io::Error::new(
+ match writer.write_all(&data.into()).and_then(|()| writer.flush()) {
+ Err(error) if !ignore_stdin_write_error => Err(io::Error::new(
io::ErrorKind::Other,
format!("failed to write to stdin of child: {error}"),
)),
- Ok(_) | Err(_) => Ok(()),
+ Ok(()) | Err(_) => Ok(()),
}
}
@@ -1971,6 +2550,11 @@ impl UChild {
/// Note, this does not have any effect if using the [`UChild::pipe_in`] method.
pub fn close_stdin(&mut self) -> &mut Self {
self.raw.stdin.take();
+ if self.stdin_pty.is_some() {
+ // a pty can not be closed. We need to send a EOT:
+ let _ = self.try_write_in(END_OF_TRANSMISSION_SEQUENCE);
+ self.stdin_pty.take();
+ }
self
}
}
@@ -2014,7 +2598,7 @@ pub fn host_name_for(util_name: &str) -> Cow<str> {
if util_name.starts_with('g') && util_name != "groups" {
util_name.into()
} else {
- format!("g{}", util_name).into()
+ format!("g{util_name}").into()
}
}
#[cfg(target_os = "linux")]
@@ -2137,19 +2721,21 @@ fn parse_coreutil_version(version_string: &str) -> f32 {
///```
#[cfg(unix)]
pub fn expected_result(ts: &TestScenario, args: &[&str]) -> std::result::Result<CmdResult, String> {
- println!("{}", check_coreutil_version(&ts.util_name, VERSION_MIN)?);
- let util_name = &host_name_for(&ts.util_name);
+ let util_name = ts.util_name.as_str();
+ println!("{}", check_coreutil_version(util_name, VERSION_MIN)?);
+ let util_name = host_name_for(util_name);
let result = ts
- .cmd_keepenv(util_name.as_ref())
- .env("LC_ALL", "C")
+ .cmd(util_name.as_ref())
+ .env("PATH", PATH)
+ .envs(DEFAULT_ENV)
.args(args)
.run();
let (stdout, stderr): (String, String) = if cfg!(target_os = "linux") {
(
result.stdout_str().to_string(),
- result.stderr_str().to_string(),
+ result.stderr_str_lossy().to_string(),
)
} else {
// `host_name_for` added prefix, strip 'g' prefix from results:
@@ -2157,7 +2743,7 @@ pub fn expected_result(ts: &TestScenario, args: &[&str]) -> std::result::Result<
let to = &from[1..];
(
result.stdout_str().replace(&from, to),
- result.stderr_str().replace(&from, to),
+ result.stderr_str_lossy().replace(&from, to),
)
};
@@ -2165,8 +2751,7 @@ pub fn expected_result(ts: &TestScenario, args: &[&str]) -> std::result::Result<
ts.bin_path.as_os_str().to_str().unwrap().to_string(),
Some(ts.util_name.clone()),
Some(result.tmpd()),
- Some(result.code()),
- result.succeeded(),
+ result.exit_status,
stdout.as_bytes(),
stderr.as_bytes(),
))
@@ -2174,11 +2759,11 @@ pub fn expected_result(ts: &TestScenario, args: &[&str]) -> std::result::Result<
/// This is a convenience wrapper to run a ucmd with root permissions.
/// It can be used to test programs when being root is needed
-/// This runs 'sudo -E --non-interactive target/debug/coreutils util_name args`
+/// This runs `sudo -E --non-interactive target/debug/coreutils util_name args`
/// This is primarily designed to run in an environment where whoami is in $path
/// and where non-interactive sudo is possible.
/// To check if i) non-interactive sudo is possible and ii) if sudo works, this runs:
-/// 'sudo -E --non-interactive whoami' first.
+/// `sudo -E --non-interactive whoami` first.
///
/// This return an `Err()` if run inside CICD because there's no 'sudo'.
///
@@ -2202,26 +2787,44 @@ pub fn run_ucmd_as_root(
ts: &TestScenario,
args: &[&str],
) -> std::result::Result<CmdResult, String> {
- if !is_ci() {
+ run_ucmd_as_root_with_stdin_stdout(ts, args, None, None)
+}
+
+#[cfg(unix)]
+pub fn run_ucmd_as_root_with_stdin_stdout(
+ ts: &TestScenario,
+ args: &[&str],
+ stdin: Option<&str>,
+ stdout: Option<&str>,
+) -> std::result::Result<CmdResult, String> {
+ if is_ci() {
+ Err(format!("{UUTILS_INFO}: {}", "cannot run inside CI"))
+ } else {
// check if we can run 'sudo'
log_info("run", "sudo -E --non-interactive whoami");
match Command::new("sudo")
- .env("LC_ALL", "C")
+ .envs(DEFAULT_ENV)
.args(["-E", "--non-interactive", "whoami"])
.output()
{
Ok(output) if String::from_utf8_lossy(&output.stdout).eq("root\n") => {
// we can run sudo and we're root
// run ucmd as root:
- Ok(ts
- .cmd_keepenv("sudo")
- .env("LC_ALL", "C")
+ let mut cmd = ts.cmd("sudo");
+ cmd.env("PATH", PATH)
+ .envs(DEFAULT_ENV)
.arg("-E")
.arg("--non-interactive")
.arg(&ts.bin_path)
.arg(&ts.util_name)
- .args(args)
- .run())
+ .args(args);
+ if let Some(stdin) = stdin {
+ cmd.set_stdin(File::open(stdin).unwrap());
+ }
+ if let Some(stdout) = stdout {
+ cmd.set_stdout(File::open(stdout).unwrap());
+ }
+ Ok(cmd.run())
}
Ok(output)
if String::from_utf8_lossy(&output.stderr).eq("sudo: a password is required\n") =>
@@ -2231,8 +2834,6 @@ pub fn run_ucmd_as_root(
Ok(_output) => Err("\"sudo whoami\" didn't return \"root\"".to_string()),
Err(e) => Err(format!("{UUTILS_WARNING}: {e}")),
}
- } else {
- Err(format!("{UUTILS_INFO}: {}", "cannot run inside CI"))
}
}
@@ -2242,151 +2843,138 @@ mod tests {
// spell-checker:ignore (tests) asdfsadfa
use super::*;
- #[test]
- fn test_code_is() {
- let res = CmdResult {
- bin_path: String::new(),
- util_name: None,
- tmpd: None,
- code: Some(32),
- success: false,
- stdout: "".into(),
- stderr: "".into(),
- };
- res.code_is(32);
+ pub fn run_cmd<T: AsRef<OsStr>>(cmd: T) -> CmdResult {
+ UCommand::new().arg(cmd).run()
}
#[test]
- #[should_panic]
- fn test_code_is_fail() {
- let res = CmdResult {
- bin_path: String::new(),
- util_name: None,
- tmpd: None,
- code: Some(32),
- success: false,
- stdout: "".into(),
- stderr: "".into(),
- };
- res.code_is(1);
- }
+ fn test_command_result_when_no_output_with_exit_32() {
+ let result = run_cmd("exit 32");
- #[test]
- fn test_failure() {
- let res = CmdResult {
- bin_path: String::new(),
- util_name: None,
- tmpd: None,
- code: None,
- success: false,
- stdout: "".into(),
- stderr: "".into(),
- };
- res.failure();
+ if cfg!(windows) {
+ std::assert!(result.bin_path.ends_with("cmd"));
+ } else {
+ std::assert!(result.bin_path.ends_with("sh"));
+ }
+
+ std::assert!(result.util_name.is_none());
+ std::assert!(result.tmpd.is_some());
+
+ assert!(result.exit_status.is_some());
+ std::assert_eq!(result.code(), 32);
+ result.code_is(32);
+ assert!(!result.succeeded());
+ result.failure();
+ result.fails_silently();
+ assert!(result.stderr.is_empty());
+ assert!(result.stdout.is_empty());
+ result.no_output();
+ result.no_stderr();
+ result.no_stdout();
}
#[test]
#[should_panic]
- fn test_failure_fail() {
- let res = CmdResult {
- bin_path: String::new(),
- util_name: None,
- tmpd: None,
- code: None,
- success: true,
- stdout: "".into(),
- stderr: "".into(),
- };
- res.failure();
+ fn test_command_result_when_exit_32_then_success_panic() {
+ run_cmd("exit 32").success();
}
#[test]
- fn test_success() {
- let res = CmdResult {
- bin_path: String::new(),
- util_name: None,
- tmpd: None,
- code: None,
- success: true,
- stdout: "".into(),
- stderr: "".into(),
- };
- res.success();
+ fn test_command_result_when_no_output_with_exit_0() {
+ let result = run_cmd("exit 0");
+
+ assert!(result.exit_status.is_some());
+ std::assert_eq!(result.code(), 0);
+ result.code_is(0);
+ assert!(result.succeeded());
+ result.success();
+ assert!(result.stderr.is_empty());
+ assert!(result.stdout.is_empty());
+ result.no_output();
+ result.no_stderr();
+ result.no_stdout();
}
#[test]
#[should_panic]
- fn test_success_fail() {
- let res = CmdResult {
- bin_path: String::new(),
- util_name: None,
- tmpd: None,
- code: None,
- success: false,
- stdout: "".into(),
- stderr: "".into(),
- };
- res.success();
+ fn test_command_result_when_exit_0_then_failure_panics() {
+ run_cmd("exit 0").failure();
}
#[test]
- fn test_no_stderr_output() {
- let res = CmdResult {
- bin_path: String::new(),
- util_name: None,
- tmpd: None,
- code: None,
- success: true,
- stdout: "".into(),
- stderr: "".into(),
- };
- res.no_stderr();
- res.no_stdout();
+ #[should_panic]
+ fn test_command_result_when_exit_0_then_silent_failure_panics() {
+ run_cmd("exit 0").fails_silently();
}
#[test]
- #[should_panic]
- fn test_no_stderr_fail() {
- let res = CmdResult {
- bin_path: String::new(),
- util_name: None,
- tmpd: None,
- code: None,
- success: true,
- stdout: "".into(),
- stderr: "asdfsadfa".into(),
- };
+ fn test_command_result_when_stdout_with_exit_0() {
+ #[cfg(windows)]
+ let (result, vector, string) = (
+ run_cmd("echo hello& exit 0"),
+ vec![b'h', b'e', b'l', b'l', b'o', b'\r', b'\n'],
+ "hello\r\n",
+ );
+ #[cfg(not(windows))]
+ let (result, vector, string) = (
+ run_cmd("echo hello; exit 0"),
+ vec![b'h', b'e', b'l', b'l', b'o', b'\n'],
+ "hello\n",
+ );
- res.no_stderr();
+ assert!(result.exit_status.is_some());
+ std::assert_eq!(result.code(), 0);
+ result.code_is(0);
+ assert!(result.succeeded());
+ result.success();
+ assert!(result.stderr.is_empty());
+ std::assert_eq!(result.stdout, vector);
+ result.no_stderr();
+ result.stdout_is(string);
+ result.stdout_is_bytes(&vector);
+ result.stdout_only(string);
+ result.stdout_only_bytes(&vector);
}
#[test]
- #[should_panic]
- fn test_no_stdout_fail() {
- let res = CmdResult {
- bin_path: String::new(),
- util_name: None,
- tmpd: None,
- code: None,
- success: true,
- stdout: "asdfsadfa".into(),
- stderr: "".into(),
- };
+ fn test_command_result_when_stderr_with_exit_0() {
+ #[cfg(windows)]
+ let (result, vector, string) = (
+ run_cmd("echo hello>&2& exit 0"),
+ vec![b'h', b'e', b'l', b'l', b'o', b'\r', b'\n'],
+ "hello\r\n",
+ );
+ #[cfg(not(windows))]
+ let (result, vector, string) = (
+ run_cmd("echo hello >&2; exit 0"),
+ vec![b'h', b'e', b'l', b'l', b'o', b'\n'],
+ "hello\n",
+ );
- res.no_stdout();
+ assert!(result.exit_status.is_some());
+ std::assert_eq!(result.code(), 0);
+ result.code_is(0);
+ assert!(result.succeeded());
+ result.success();
+ assert!(result.stdout.is_empty());
+ result.no_stdout();
+ std::assert_eq!(result.stderr, vector);
+ result.stderr_is(string);
+ result.stderr_is_bytes(&vector);
+ result.stderr_only(string);
+ result.stderr_only_bytes(&vector);
}
#[test]
fn test_std_does_not_contain() {
- let res = CmdResult {
- bin_path: String::new(),
- util_name: None,
- tmpd: None,
- code: None,
- success: true,
- stdout: "This is a likely error message\n".into(),
- stderr: "This is a likely error message\n".into(),
- };
+ #[cfg(windows)]
+ let res = run_cmd(
+ "(echo This is a likely error message& echo This is a likely error message>&2) & exit 0",
+ );
+ #[cfg(not(windows))]
+ let res = run_cmd(
+ "echo This is a likely error message; echo This is a likely error message >&2; exit 0",
+ );
res.stdout_does_not_contain("unlikely");
res.stderr_does_not_contain("unlikely");
}
@@ -2394,15 +2982,10 @@ mod tests {
#[test]
#[should_panic]
fn test_stdout_does_not_contain_fail() {
- let res = CmdResult {
- bin_path: String::new(),
- util_name: None,
- tmpd: None,
- code: None,
- success: true,
- stdout: "This is a likely error message\n".into(),
- stderr: "".into(),
- };
+ #[cfg(windows)]
+ let res = run_cmd("echo This is a likely error message& exit 0");
+ #[cfg(not(windows))]
+ let res = run_cmd("echo This is a likely error message; exit 0");
res.stdout_does_not_contain("likely");
}
@@ -2410,30 +2993,25 @@ mod tests {
#[test]
#[should_panic]
fn test_stderr_does_not_contain_fail() {
- let res = CmdResult {
- bin_path: String::new(),
- util_name: None,
- tmpd: None,
- code: None,
- success: true,
- stdout: "".into(),
- stderr: "This is a likely error message\n".into(),
- };
+ #[cfg(windows)]
+ let res = run_cmd("echo This is a likely error message>&2 & exit 0");
+ #[cfg(not(windows))]
+ let res = run_cmd("echo This is a likely error message >&2; exit 0");
res.stderr_does_not_contain("likely");
}
#[test]
fn test_stdout_matches() {
- let res = CmdResult {
- bin_path: String::new(),
- util_name: None,
- tmpd: None,
- code: None,
- success: true,
- stdout: "This is a likely error message\n".into(),
- stderr: "This is a likely error message\n".into(),
- };
+ #[cfg(windows)]
+ let res = run_cmd(
+ "(echo This is a likely error message& echo This is a likely error message>&2 ) & exit 0",
+ );
+ #[cfg(not(windows))]
+ let res = run_cmd(
+ "echo This is a likely error message; echo This is a likely error message >&2; exit 0",
+ );
+
let positive = regex::Regex::new(".*likely.*").unwrap();
let negative = regex::Regex::new(".*unlikely.*").unwrap();
res.stdout_matches(&positive);
@@ -2443,70 +3021,188 @@ mod tests {
#[test]
#[should_panic]
fn test_stdout_matches_fail() {
- let res = CmdResult {
- bin_path: String::new(),
- util_name: None,
- tmpd: None,
- code: None,
- success: true,
- stdout: "This is a likely error message\n".into(),
- stderr: "This is a likely error message\n".into(),
- };
- let negative = regex::Regex::new(".*unlikely.*").unwrap();
+ #[cfg(windows)]
+ let res = run_cmd(
+ "(echo This is a likely error message& echo This is a likely error message>&2) & exit 0",
+ );
+ #[cfg(not(windows))]
+ let res = run_cmd(
+ "echo This is a likely error message; echo This is a likely error message >&2; exit 0",
+ );
+ let negative = regex::Regex::new(".*unlikely.*").unwrap();
res.stdout_matches(&negative);
}
#[test]
#[should_panic]
fn test_stdout_not_matches_fail() {
- let res = CmdResult {
- bin_path: String::new(),
- util_name: None,
- tmpd: None,
- code: None,
- success: true,
- stdout: "This is a likely error message\n".into(),
- stderr: "This is a likely error message\n".into(),
- };
- let positive = regex::Regex::new(".*likely.*").unwrap();
+ #[cfg(windows)]
+ let res = run_cmd(
+ "(echo This is a likely error message& echo This is a likely error message>&2) & exit 0",
+ );
+ #[cfg(not(windows))]
+ let res = run_cmd(
+ "echo This is a likely error message; echo This is a likely error message >&2; exit 0",
+ );
+ let positive = regex::Regex::new(".*likely.*").unwrap();
res.stdout_does_not_match(&positive);
}
+ #[cfg(feature = "echo")]
#[test]
fn test_normalized_newlines_stdout_is() {
- let res = CmdResult {
- bin_path: String::new(),
- util_name: None,
- tmpd: None,
- code: None,
- success: true,
- stdout: "A\r\nB\nC".into(),
- stderr: "".into(),
- };
+ let ts = TestScenario::new("echo");
+ let res = ts.ucmd().args(&["-ne", "A\r\nB\nC"]).run();
res.normalized_newlines_stdout_is("A\r\nB\nC");
res.normalized_newlines_stdout_is("A\nB\nC");
res.normalized_newlines_stdout_is("A\nB\r\nC");
}
+ #[cfg(feature = "echo")]
#[test]
#[should_panic]
fn test_normalized_newlines_stdout_is_fail() {
- let res = CmdResult {
- bin_path: String::new(),
- util_name: None,
- tmpd: None,
- code: None,
- success: true,
- stdout: "A\r\nB\nC".into(),
- stderr: "".into(),
- };
+ let ts = TestScenario::new("echo");
+ let res = ts.ucmd().args(&["-ne", "A\r\nB\nC"]).run();
res.normalized_newlines_stdout_is("A\r\nB\nC\n");
}
+ #[cfg(feature = "echo")]
+ #[test]
+ fn test_cmd_result_stdout_check_and_stdout_str_check() {
+ let result = TestScenario::new("echo").ucmd().arg("Hello world").run();
+
+ result.stdout_str_check(|stdout| stdout.ends_with("world\n"));
+ result.stdout_check(|stdout| stdout.get(0..2).unwrap().eq(&[b'H', b'e']));
+ result.no_stderr();
+ }
+
+ #[cfg(feature = "echo")]
+ #[test]
+ fn test_cmd_result_stderr_check_and_stderr_str_check() {
+ let ts = TestScenario::new("echo");
+ let result = run_cmd(format!(
+ "{} {} Hello world >&2",
+ ts.bin_path.display(),
+ ts.util_name
+ ));
+
+ result.stderr_str_check(|stderr| stderr.ends_with("world\n"));
+ result.stderr_check(|stderr| stderr.get(0..2).unwrap().eq(&[b'H', b'e']));
+ result.no_stdout();
+ }
+
+ #[cfg(feature = "echo")]
+ #[test]
+ #[should_panic]
+ fn test_cmd_result_stdout_str_check_when_false_then_panics() {
+ let result = TestScenario::new("echo").ucmd().arg("Hello world").run();
+ result.stdout_str_check(str::is_empty);
+ }
+
+ #[cfg(feature = "echo")]
+ #[test]
+ #[should_panic]
+ fn test_cmd_result_stdout_check_when_false_then_panics() {
+ let result = TestScenario::new("echo").ucmd().arg("Hello world").run();
+ result.stdout_check(<[u8]>::is_empty);
+ }
+
+ #[cfg(feature = "echo")]
+ #[test]
+ #[should_panic]
+ fn test_cmd_result_stderr_str_check_when_false_then_panics() {
+ let result = TestScenario::new("echo").ucmd().arg("Hello world").run();
+ result.stderr_str_check(|s| !s.is_empty());
+ }
+
+ #[cfg(feature = "echo")]
+ #[test]
+ #[should_panic]
+ fn test_cmd_result_stderr_check_when_false_then_panics() {
+ let result = TestScenario::new("echo").ucmd().arg("Hello world").run();
+ result.stderr_check(|s| !s.is_empty());
+ }
+
+ #[cfg(feature = "echo")]
+ #[test]
+ #[should_panic]
+ fn test_cmd_result_stdout_check_when_predicate_panics_then_panic() {
+ let result = TestScenario::new("echo").ucmd().run();
+ result.stdout_str_check(|_| panic!("Just testing"));
+ }
+
+ #[cfg(feature = "echo")]
+ #[cfg(unix)]
+ #[test]
+ fn test_cmd_result_signal_when_normal_exit_then_no_signal() {
+ let result = TestScenario::new("echo").ucmd().run();
+ assert!(result.signal().is_none());
+ }
+
+ #[cfg(feature = "sleep")]
+ #[cfg(unix)]
+ #[test]
+ #[should_panic = "Program must be run first or has not finished"]
+ fn test_cmd_result_signal_when_still_running_then_panic() {
+ let mut child = TestScenario::new("sleep").ucmd().arg("60").run_no_wait();
+
+ child
+ .make_assertion()
+ .is_alive()
+ .with_current_output()
+ .signal();
+ }
+
+ #[cfg(feature = "sleep")]
+ #[cfg(unix)]
+ #[test]
+ fn test_cmd_result_signal_when_kill_then_signal() {
+ let mut child = TestScenario::new("sleep").ucmd().arg("60").run_no_wait();
+
+ child.kill();
+ child
+ .make_assertion()
+ .is_not_alive()
+ .with_current_output()
+ .signal_is(9)
+ .signal_name_is("SIGKILL")
+ .signal_name_is("KILL")
+ .signal_name_is("9")
+ .signal()
+ .expect("Signal was none");
+
+ let result = child.wait().unwrap();
+ result
+ .signal_is(9)
+ .signal_name_is("SIGKILL")
+ .signal_name_is("KILL")
+ .signal_name_is("9")
+ .signal()
+ .expect("Signal was none");
+ }
+
+ #[cfg(feature = "sleep")]
+ #[cfg(unix)]
+ #[rstest]
+ #[case::signal_full_name_lower_case("sigkill")]
+ #[case::signal_short_name_lower_case("kill")]
+ #[case::signal_only_part_of_name("IGKILL")] // spell-checker: disable-line
+ #[case::signal_just_sig("SIG")]
+ #[case::signal_value_too_high("100")]
+ #[case::signal_value_negative("-1")]
+ #[should_panic = "Invalid signal name or value"]
+ fn test_cmd_result_signal_when_invalid_signal_name_then_panic(#[case] signal_name: &str) {
+ let mut child = TestScenario::new("sleep").ucmd().arg("60").run_no_wait();
+ child.kill();
+ let result = child.wait().unwrap();
+ result.signal_name_is(signal_name);
+ }
+
#[test]
#[cfg(unix)]
fn test_parse_coreutil_version() {
@@ -2591,7 +3287,9 @@ mod tests {
#[cfg(unix)]
#[cfg(feature = "whoami")]
fn test_run_ucmd_as_root() {
- if !is_ci() {
+ if is_ci() {
+ println!("TEST SKIPPED (cannot run inside CI)");
+ } else {
// Skip test if we can't guarantee non-interactive `sudo`, or if we're not "root"
if let Ok(output) = Command::new("sudo")
.env("LC_ALL", "C")
@@ -2610,8 +3308,6 @@ mod tests {
} else {
println!("TEST SKIPPED (cannot run sudo)");
}
- } else {
- println!("TEST SKIPPED (cannot run inside CI)");
}
}
@@ -2656,9 +3352,10 @@ mod tests {
// check `child.is_alive()` and `child.delay()` is working
let mut trials = 10;
while child.is_alive() {
- if trials <= 0 {
- panic!("Assertion failed: child process is still alive.")
- }
+ assert!(
+ trials > 0,
+ "Assertion failed: child process is still alive."
+ );
child.delay(500);
trials -= 1;
@@ -2821,10 +3518,7 @@ mod tests {
Err(error) if error.kind() == io::ErrorKind::Other => {
std::assert_eq!(error.to_string(), "wait: Timeout of '1s' reached");
}
- Err(error) => panic!(
- "Assertion failed: Expected error with timeout but was: {}",
- error
- ),
+ Err(error) => panic!("Assertion failed: Expected error with timeout but was: {error}"),
Ok(_) => panic!("Assertion failed: Expected timeout of `wait`."),
}
}
@@ -2853,11 +3547,8 @@ mod tests {
Err(error) if error.kind() == io::ErrorKind::Other => {
std::assert_eq!(error.to_string(), "kill: Timeout of '0s' reached");
}
- Err(error) => panic!(
- "Assertion failed: Expected error with timeout but was: {}",
- error
- ),
- Ok(_) => panic!("Assertion failed: Expected timeout of `try_kill`."),
+ Err(error) => panic!("Assertion failed: Expected error with timeout but was: {error}"),
+ Ok(()) => panic!("Assertion failed: Expected timeout of `try_kill`."),
}
}
@@ -2892,4 +3583,342 @@ mod tests {
let ts = TestScenario::new("sleep");
ts.ucmd().timeout(Duration::from_secs(60)).arg("1.0").run();
}
+
+ #[cfg(feature = "echo")]
+ #[test]
+ fn test_ucommand_when_default() {
+ let shell_cmd = format!("{TESTS_BINARY} echo -n hello");
+
+ let mut command = UCommand::new();
+ command.arg(&shell_cmd).succeeds().stdout_is("hello");
+
+ #[cfg(target_os = "android")]
+ let (expected_bin, expected_arg) = (PathBuf::from("/system/bin/sh"), OsString::from("-c"));
+ #[cfg(all(unix, not(target_os = "android")))]
+ let (expected_bin, expected_arg) = (PathBuf::from("/bin/sh"), OsString::from("-c"));
+ #[cfg(windows)]
+ let (expected_bin, expected_arg) = (PathBuf::from("cmd"), OsString::from("/C"));
+
+ std::assert_eq!(&expected_bin, command.bin_path.as_ref().unwrap());
+ assert!(command.util_name.is_none());
+ std::assert_eq!(command.args, &[expected_arg, OsString::from(&shell_cmd)]);
+ assert!(command.tmpd.is_some());
+ }
+
+ #[cfg(feature = "echo")]
+ #[test]
+ fn test_ucommand_with_util() {
+ let tmpd = tempfile::tempdir().unwrap();
+ let mut command = UCommand::with_util("echo", Rc::new(tmpd));
+
+ command
+ .args(&["-n", "hello"])
+ .succeeds()
+ .stdout_only("hello");
+
+ std::assert_eq!(
+ &PathBuf::from(TESTS_BINARY),
+ command.bin_path.as_ref().unwrap()
+ );
+ std::assert_eq!("echo", &command.util_name.unwrap());
+ std::assert_eq!(
+ &[
+ OsString::from("echo"),
+ OsString::from("-n"),
+ OsString::from("hello")
+ ],
+ command.args.make_contiguous()
+ );
+ assert!(command.tmpd.is_some());
+ }
+
+ #[cfg(all(unix, not(any(target_os = "macos", target_os = "openbsd"))))]
+ #[test]
+ fn test_compare_xattrs() {
+ use tempfile::tempdir;
+
+ let temp_dir = tempdir().unwrap();
+ let file_path1 = temp_dir.path().join("test_file1.txt");
+ let file_path2 = temp_dir.path().join("test_file2.txt");
+
+ File::create(&file_path1).unwrap();
+ File::create(&file_path2).unwrap();
+
+ let test_attr = "user.test_attr";
+ let test_value = b"test value";
+ xattr::set(&file_path1, test_attr, test_value).unwrap();
+
+ assert!(!compare_xattrs(&file_path1, &file_path2));
+
+ xattr::set(&file_path2, test_attr, test_value).unwrap();
+ assert!(compare_xattrs(&file_path1, &file_path2));
+ }
+
+ #[cfg(unix)]
+ #[cfg(feature = "env")]
+ #[test]
+ fn test_simulation_of_terminal_false() {
+ let scene = TestScenario::new("util");
+
+ let out = scene.ccmd("env").arg("sh").arg("is_a_tty.sh").succeeds();
+ std::assert_eq!(
+ String::from_utf8_lossy(out.stdout()),
+ "stdin is not a tty\nstdout is not a tty\nstderr is not a tty\n"
+ );
+ std::assert_eq!(
+ String::from_utf8_lossy(out.stderr()),
+ "This is an error message.\n"
+ );
+ }
+
+ #[cfg(unix)]
+ #[cfg(feature = "env")]
+ #[test]
+ fn test_simulation_of_terminal_true() {
+ let scene = TestScenario::new("util");
+
+ let out = scene
+ .ccmd("env")
+ .arg("sh")
+ .arg("is_a_tty.sh")
+ .terminal_simulation(true)
+ .succeeds();
+ std::assert_eq!(
+ String::from_utf8_lossy(out.stdout()),
+ "stdin is a tty\r\nterminal size: 30 80\r\nstdout is a tty\r\nstderr is a tty\r\n"
+ );
+ std::assert_eq!(
+ String::from_utf8_lossy(out.stderr()),
+ "This is an error message.\r\n"
+ );
+ }
+
+ #[cfg(unix)]
+ #[cfg(feature = "env")]
+ #[test]
+ fn test_simulation_of_terminal_for_stdin_only() {
+ let scene = TestScenario::new("util");
+
+ let out = scene
+ .ccmd("env")
+ .arg("sh")
+ .arg("is_a_tty.sh")
+ .terminal_sim_stdio(TerminalSimulation {
+ stdin: true,
+ stdout: false,
+ stderr: false,
+ ..Default::default()
+ })
+ .succeeds();
+ std::assert_eq!(
+ String::from_utf8_lossy(out.stdout()),
+ "stdin is a tty\nterminal size: 30 80\nstdout is not a tty\nstderr is not a tty\n"
+ );
+ std::assert_eq!(
+ String::from_utf8_lossy(out.stderr()),
+ "This is an error message.\n"
+ );
+ }
+
+ #[cfg(unix)]
+ #[cfg(feature = "env")]
+ #[test]
+ fn test_simulation_of_terminal_for_stdout_only() {
+ let scene = TestScenario::new("util");
+
+ let out = scene
+ .ccmd("env")
+ .arg("sh")
+ .arg("is_a_tty.sh")
+ .terminal_sim_stdio(TerminalSimulation {
+ stdin: false,
+ stdout: true,
+ stderr: false,
+ ..Default::default()
+ })
+ .succeeds();
+ std::assert_eq!(
+ String::from_utf8_lossy(out.stdout()),
+ "stdin is not a tty\r\nstdout is a tty\r\nstderr is not a tty\r\n"
+ );
+ std::assert_eq!(
+ String::from_utf8_lossy(out.stderr()),
+ "This is an error message.\n"
+ );
+ }
+
+ #[cfg(unix)]
+ #[cfg(feature = "env")]
+ #[test]
+ fn test_simulation_of_terminal_for_stderr_only() {
+ let scene = TestScenario::new("util");
+
+ let out = scene
+ .ccmd("env")
+ .arg("sh")
+ .arg("is_a_tty.sh")
+ .terminal_sim_stdio(TerminalSimulation {
+ stdin: false,
+ stdout: false,
+ stderr: true,
+ ..Default::default()
+ })
+ .succeeds();
+ std::assert_eq!(
+ String::from_utf8_lossy(out.stdout()),
+ "stdin is not a tty\nstdout is not a tty\nstderr is a tty\n"
+ );
+ std::assert_eq!(
+ String::from_utf8_lossy(out.stderr()),
+ "This is an error message.\r\n"
+ );
+ }
+
+ #[cfg(unix)]
+ #[cfg(feature = "env")]
+ #[test]
+ fn test_simulation_of_terminal_size_information() {
+ let scene = TestScenario::new("util");
+
+ let out = scene
+ .ccmd("env")
+ .arg("sh")
+ .arg("is_a_tty.sh")
+ .terminal_sim_stdio(TerminalSimulation {
+ size: Some(libc::winsize {
+ ws_col: 40,
+ ws_row: 10,
+ ws_xpixel: 40 * 8,
+ ws_ypixel: 10 * 10,
+ }),
+ stdout: true,
+ stdin: true,
+ stderr: true,
+ })
+ .succeeds();
+ std::assert_eq!(
+ String::from_utf8_lossy(out.stdout()),
+ "stdin is a tty\r\nterminal size: 10 40\r\nstdout is a tty\r\nstderr is a tty\r\n"
+ );
+ std::assert_eq!(
+ String::from_utf8_lossy(out.stderr()),
+ "This is an error message.\r\n"
+ );
+ }
+
+ #[cfg(unix)]
+ #[cfg(feature = "env")]
+ #[test]
+ fn test_simulation_of_terminal_pty_sends_eot_automatically() {
+ let scene = TestScenario::new("util");
+
+ let mut cmd = scene.ccmd("env");
+ cmd.timeout(std::time::Duration::from_secs(10));
+ cmd.args(&["cat", "-"]);
+ cmd.terminal_simulation(true);
+ let child = cmd.run_no_wait();
+ let out = child.wait().unwrap(); // cat would block if there is no eot
+
+ std::assert_eq!(String::from_utf8_lossy(out.stderr()), "");
+ std::assert_eq!(String::from_utf8_lossy(out.stdout()), "\r\n");
+ }
+
+ #[cfg(unix)]
+ #[cfg(feature = "env")]
+ #[test]
+ fn test_simulation_of_terminal_pty_pipes_into_data_and_sends_eot_automatically() {
+ let scene = TestScenario::new("util");
+
+ let message = "Hello stdin forwarding!";
+
+ let mut cmd = scene.ccmd("env");
+ cmd.args(&["cat", "-"]);
+ cmd.terminal_simulation(true);
+ cmd.pipe_in(message);
+ let child = cmd.run_no_wait();
+ let out = child.wait().unwrap();
+
+ std::assert_eq!(
+ String::from_utf8_lossy(out.stdout()),
+ format!("{message}\r\n")
+ );
+ std::assert_eq!(String::from_utf8_lossy(out.stderr()), "");
+ }
+
+ #[cfg(unix)]
+ #[cfg(feature = "env")]
+ #[test]
+ fn test_simulation_of_terminal_pty_write_in_data_and_sends_eot_automatically() {
+ let scene = TestScenario::new("util");
+
+ let mut cmd = scene.ccmd("env");
+ cmd.args(&["cat", "-"]);
+ cmd.terminal_simulation(true);
+ let mut child = cmd.run_no_wait();
+ child.write_in("Hello stdin forwarding via write_in!");
+ let out = child.wait().unwrap();
+
+ std::assert_eq!(
+ String::from_utf8_lossy(out.stdout()),
+ "Hello stdin forwarding via write_in!\r\n"
+ );
+ std::assert_eq!(String::from_utf8_lossy(out.stderr()), "");
+ }
+
+ #[cfg(unix)]
+ #[test]
+ fn test_application_of_process_resource_limits_unlimited_file_size() {
+ let ts = TestScenario::new("util");
+ ts.cmd("sh")
+ .args(&["-c", "ulimit -Sf; ulimit -Hf"])
+ .succeeds()
+ .no_stderr()
+ .stdout_is("unlimited\nunlimited\n");
+ }
+
+ #[cfg(unix)]
+ #[test]
+ fn test_application_of_process_resource_limits_limited_file_size() {
+ let unit_size_bytes = if cfg!(target_os = "macos") { 1024 } else { 512 };
+
+ let ts = TestScenario::new("util");
+ ts.cmd("sh")
+ .args(&["-c", "ulimit -Sf; ulimit -Hf"])
+ .limit(
+ rlimit::Resource::FSIZE,
+ 8 * unit_size_bytes,
+ 16 * unit_size_bytes,
+ )
+ .succeeds()
+ .no_stderr()
+ .stdout_is("8\n16\n");
+ }
+
+ #[cfg(unix)]
+ #[test]
+ fn test_altering_umask() {
+ use uucore::mode::get_umask;
+ let p_umask = get_umask();
+ // make sure we are not testing against the same umask
+ let c_umask = if p_umask == 0o002 { 0o007 } else { 0o002 };
+ let expected = if cfg!(target_os = "android") {
+ if p_umask == 0o002 {
+ "007\n"
+ } else {
+ "002\n"
+ }
+ } else if p_umask == 0o002 {
+ "0007\n"
+ } else {
+ "0002\n"
+ };
+
+ let ts = TestScenario::new("util");
+ ts.cmd("sh")
+ .args(&["-c", "umask"])
+ .umask(c_umask)
+ .succeeds()
+ .stdout_is(expected);
+ std::assert_eq!(p_umask, get_umask()); // make sure parent umask didn't change
+ }
}
diff --git a/tests/fixtures/cksum/base64/blake2b_single_file.expected b/tests/fixtures/cksum/base64/blake2b_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..18bec38f017c5370bfbbb1c221261d7b077589f1
--- /dev/null
+++ b/tests/fixtures/cksum/base64/blake2b_single_file.expected
@@ -0,0 +1 @@
+BLAKE2b (lorem_ipsum.txt) = DpegkYnlYMN4nAv/HwIBZoYe+FfR+/5FdN4YQuPAbKu5V15K9jCaFmFYwrQI08A4wbSdgos1FYFCzcA5bRGVww==
diff --git a/tests/fixtures/cksum/base64/bsd_single_file.expected b/tests/fixtures/cksum/base64/bsd_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..293ada3bd612b09973cc53965e5bb857e6097d1e
--- /dev/null
+++ b/tests/fixtures/cksum/base64/bsd_single_file.expected
@@ -0,0 +1 @@
+08109 1 lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/single_file.expected b/tests/fixtures/cksum/base64/crc_single_file.expected
similarity index 100%
rename from tests/fixtures/cksum/single_file.expected
rename to tests/fixtures/cksum/base64/crc_single_file.expected
diff --git a/tests/fixtures/cksum/base64/md5_multiple_files.expected b/tests/fixtures/cksum/base64/md5_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..e7f844b9ac7f8e7c18c2504f8ab00ecb7a888a9b
--- /dev/null
+++ b/tests/fixtures/cksum/base64/md5_multiple_files.expected
@@ -0,0 +1,2 @@
+MD5 (lorem_ipsum.txt) = zXJGkPfcYXdd+sQApx8sqg==
+MD5 (alice_in_wonderland.txt) = 9vpwM+FhZqlYmqHAOI/9WA==
diff --git a/tests/fixtures/cksum/base64/md5_single_file.expected b/tests/fixtures/cksum/base64/md5_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..8a12f79278cb32e1524acbb72601f5bac549e919
--- /dev/null
+++ b/tests/fixtures/cksum/base64/md5_single_file.expected
@@ -0,0 +1 @@
+MD5 (lorem_ipsum.txt) = zXJGkPfcYXdd+sQApx8sqg==
diff --git a/tests/fixtures/cksum/base64/sha1_single_file.expected b/tests/fixtures/cksum/base64/sha1_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..b12608e77c7700f2e247a6ef97a7f006bedfbd01
--- /dev/null
+++ b/tests/fixtures/cksum/base64/sha1_single_file.expected
@@ -0,0 +1 @@
+SHA1 (lorem_ipsum.txt) = qx3QuuHYiDo9GKZt5q+9KCUs++8=
diff --git a/tests/fixtures/cksum/base64/sha224_single_file.expected b/tests/fixtures/cksum/base64/sha224_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..69d85abdb86e2c5e0d46b099d377ea262ce55a26
--- /dev/null
+++ b/tests/fixtures/cksum/base64/sha224_single_file.expected
@@ -0,0 +1 @@
+SHA224 (lorem_ipsum.txt) = PeZvvK0QbhtAqzkb5WxR0gB+sfnGVdD04pv8AQ==
diff --git a/tests/fixtures/cksum/base64/sha256_single_file.expected b/tests/fixtures/cksum/base64/sha256_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..d9a8814a30b96edfc7fb40bc08cc1d0ea79a749d
--- /dev/null
+++ b/tests/fixtures/cksum/base64/sha256_single_file.expected
@@ -0,0 +1 @@
+SHA256 (lorem_ipsum.txt) = 98QgUBxQ4AswklAQDWfqXpEJgVNrRYL+nENb2Ss/HwI=
diff --git a/tests/fixtures/cksum/base64/sha384_single_file.expected b/tests/fixtures/cksum/base64/sha384_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..8a8333d3553bf856e31f8c07e0de86f7a55ad2a7
--- /dev/null
+++ b/tests/fixtures/cksum/base64/sha384_single_file.expected
@@ -0,0 +1 @@
+SHA384 (lorem_ipsum.txt) = S+S5Cg0NMpZpkpIQGfJKvIJNz7ixxAgQLx9niPuAupqaTFp7V1ozU6kKjucZSB3L
diff --git a/tests/fixtures/cksum/base64/sha512_single_file.expected b/tests/fixtures/cksum/base64/sha512_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..da36c4295fb27b2a8f2437c03b3055a47536aa9a
--- /dev/null
+++ b/tests/fixtures/cksum/base64/sha512_single_file.expected
@@ -0,0 +1 @@
+SHA512 (lorem_ipsum.txt) = llRkqyVWqtWOvHPYmtIh5Vl5dSnsr8D0ZsEXlc/21uLGD5agfFQs/R9Cbl5P4KSKoVZnukQJayE9CBPNA436BQ==
diff --git a/tests/fixtures/cksum/base64/sm3_single_file.expected b/tests/fixtures/cksum/base64/sm3_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..e4ca582c938f100184d79ec3248b58481610d414
--- /dev/null
+++ b/tests/fixtures/cksum/base64/sm3_single_file.expected
@@ -0,0 +1 @@
+SM3 (lorem_ipsum.txt) = bSlrgF0GC/7SKAjfMI27m0MXeU3U7WdAoQdwp4Jpm8I=
diff --git a/tests/fixtures/cksum/base64/sysv_single_file.expected b/tests/fixtures/cksum/base64/sysv_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..e0f7252cbe88751d344b1ca7d9dcc889b450eaaf
--- /dev/null
+++ b/tests/fixtures/cksum/base64/sysv_single_file.expected
@@ -0,0 +1 @@
+6985 2 lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/blake2b_multiple_files.expected b/tests/fixtures/cksum/blake2b_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..97d06eb6fea0905a8950d9a296a4add930a120ca
--- /dev/null
+++ b/tests/fixtures/cksum/blake2b_multiple_files.expected
@@ -0,0 +1,2 @@
+BLAKE2b (lorem_ipsum.txt) = 0e97a09189e560c3789c0bff1f020166861ef857d1fbfe4574de1842e3c06cabb9575e4af6309a166158c2b408d3c038c1b49d828b35158142cdc0396d1195c3
+BLAKE2b (alice_in_wonderland.txt) = 91b8b0f0868e905ad18b8ac35e4a1dacd289857b19258ab5d1e071761af758b0134ec152d4f011fe1825ca889c80c2e072ca70eb50548c25fc49a98937515af4
diff --git a/tests/fixtures/cksum/blake2b_single_file.expected b/tests/fixtures/cksum/blake2b_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..64ede7ca040f0ab40e665691e3c87cb81820a4f0
--- /dev/null
+++ b/tests/fixtures/cksum/blake2b_single_file.expected
@@ -0,0 +1 @@
+BLAKE2b (lorem_ipsum.txt) = 0e97a09189e560c3789c0bff1f020166861ef857d1fbfe4574de1842e3c06cabb9575e4af6309a166158c2b408d3c038c1b49d828b35158142cdc0396d1195c3
diff --git a/tests/fixtures/cksum/blake2b_stdin.expected b/tests/fixtures/cksum/blake2b_stdin.expected
new file mode 100644
index 0000000000000000000000000000000000000000..15c34ea775ac3eadb7f28c0b0c5567a276cd47aa
--- /dev/null
+++ b/tests/fixtures/cksum/blake2b_stdin.expected
@@ -0,0 +1 @@
+BLAKE2b (-) = 0e97a09189e560c3789c0bff1f020166861ef857d1fbfe4574de1842e3c06cabb9575e4af6309a166158c2b408d3c038c1b49d828b35158142cdc0396d1195c3
diff --git a/tests/fixtures/cksum/bsd_multiple_files.expected b/tests/fixtures/cksum/bsd_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..941a2a512f8b2880d5aad29efdeb57cf7710731a
--- /dev/null
+++ b/tests/fixtures/cksum/bsd_multiple_files.expected
@@ -0,0 +1,2 @@
+08109 1 lorem_ipsum.txt
+01814 1 alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/bsd_single_file.expected b/tests/fixtures/cksum/bsd_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..293ada3bd612b09973cc53965e5bb857e6097d1e
--- /dev/null
+++ b/tests/fixtures/cksum/bsd_single_file.expected
@@ -0,0 +1 @@
+08109 1 lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/bsd_stdin.expected b/tests/fixtures/cksum/bsd_stdin.expected
new file mode 100644
index 0000000000000000000000000000000000000000..4843ba08246d1d85daf3e56a619b3bd942e3407b
--- /dev/null
+++ b/tests/fixtures/cksum/bsd_stdin.expected
@@ -0,0 +1 @@
+08109 1
diff --git a/tests/fixtures/cksum/multiple_files.expected b/tests/fixtures/cksum/crc_multiple_files.expected
similarity index 100%
rename from tests/fixtures/cksum/multiple_files.expected
rename to tests/fixtures/cksum/crc_multiple_files.expected
diff --git a/tests/fixtures/cksum/crc_single_file.expected b/tests/fixtures/cksum/crc_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..e9fc1ca7cf440d1c502b93db99e07a5f904eb3f9
--- /dev/null
+++ b/tests/fixtures/cksum/crc_single_file.expected
@@ -0,0 +1 @@
+378294376 772 lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/stdin.expected b/tests/fixtures/cksum/crc_stdin.expected
similarity index 100%
rename from tests/fixtures/cksum/stdin.expected
rename to tests/fixtures/cksum/crc_stdin.expected
diff --git a/tests/fixtures/cksum/length_is_zero.expected b/tests/fixtures/cksum/length_is_zero.expected
new file mode 100644
index 0000000000000000000000000000000000000000..97d06eb6fea0905a8950d9a296a4add930a120ca
--- /dev/null
+++ b/tests/fixtures/cksum/length_is_zero.expected
@@ -0,0 +1,2 @@
+BLAKE2b (lorem_ipsum.txt) = 0e97a09189e560c3789c0bff1f020166861ef857d1fbfe4574de1842e3c06cabb9575e4af6309a166158c2b408d3c038c1b49d828b35158142cdc0396d1195c3
+BLAKE2b (alice_in_wonderland.txt) = 91b8b0f0868e905ad18b8ac35e4a1dacd289857b19258ab5d1e071761af758b0134ec152d4f011fe1825ca889c80c2e072ca70eb50548c25fc49a98937515af4
diff --git a/tests/fixtures/cksum/length_larger_than_512.expected b/tests/fixtures/cksum/length_larger_than_512.expected
new file mode 100644
index 0000000000000000000000000000000000000000..312b6230e9aebb38eb65adbaabfc124f89d7f40a
--- /dev/null
+++ b/tests/fixtures/cksum/length_larger_than_512.expected
@@ -0,0 +1,2 @@
+cksum: invalid length: ‘1024’
+cksum: maximum digest length for ‘BLAKE2b’ is 512 bits
diff --git a/tests/fixtures/cksum/md5_multiple_files.expected b/tests/fixtures/cksum/md5_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..54023e7615fb9f58f9fa8cb00ea063166f9927e3
--- /dev/null
+++ b/tests/fixtures/cksum/md5_multiple_files.expected
@@ -0,0 +1,2 @@
+MD5 (lorem_ipsum.txt) = cd724690f7dc61775dfac400a71f2caa
+MD5 (alice_in_wonderland.txt) = f6fa7033e16166a9589aa1c0388ffd58
diff --git a/tests/fixtures/cksum/md5_single_file.expected b/tests/fixtures/cksum/md5_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..5975053d1e21d4301eee2d030851e0756b77de62
--- /dev/null
+++ b/tests/fixtures/cksum/md5_single_file.expected
@@ -0,0 +1 @@
+MD5 (lorem_ipsum.txt) = cd724690f7dc61775dfac400a71f2caa
diff --git a/tests/fixtures/cksum/md5_stdin.expected b/tests/fixtures/cksum/md5_stdin.expected
new file mode 100644
index 0000000000000000000000000000000000000000..b3b1090bccc2d9fd6631cf63e8ef45b3f256f8f9
--- /dev/null
+++ b/tests/fixtures/cksum/md5_stdin.expected
@@ -0,0 +1 @@
+MD5 (-) = cd724690f7dc61775dfac400a71f2caa
diff --git a/tests/fixtures/cksum/raw/blake2b_single_file.expected b/tests/fixtures/cksum/raw/blake2b_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..19b3112206d5f3139d164156f5b95c092366afdd
--- /dev/null
+++ b/tests/fixtures/cksum/raw/blake2b_single_file.expected
@@ -0,0 +1 @@
+— ‘‰å`Ãxœ ÿ f† øWÑûþEtÞBãÀl«¹W^Jö0šaX´ÓÀ8Á´‚‹5BÍÀ9m•Ã
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/bsd_single_file.expected b/tests/fixtures/cksum/raw/bsd_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..538ab19f728ab3fda4e0d351395e1477a96e8777
--- /dev/null
+++ b/tests/fixtures/cksum/raw/bsd_single_file.expected
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/crc_single_file.expected b/tests/fixtures/cksum/raw/crc_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..de175b04582d35c013c6a0f676cc9a0492315d36
--- /dev/null
+++ b/tests/fixtures/cksum/raw/crc_single_file.expected
@@ -0,0 +1 @@
+ŒPh
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/md5_single_file.expected b/tests/fixtures/cksum/raw/md5_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..e7b47aebbcba99b6dbaa03e825f0be3b5bfdb012
--- /dev/null
+++ b/tests/fixtures/cksum/raw/md5_single_file.expected
@@ -0,0 +1 @@
+ÍrF÷Üaw]úÄ�§ ,ª
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/sha1_single_file.expected b/tests/fixtures/cksum/raw/sha1_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..0f634be4749aff4bb590709f0c828f33faf63651
--- /dev/null
+++ b/tests/fixtures/cksum/raw/sha1_single_file.expected
@@ -0,0 +1 @@
+« кá؈:=¦m毽(%,ûï
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/sha224_single_file.expected b/tests/fixtures/cksum/raw/sha224_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..bc3fa6bf18f53f72894471200626992087ef971d
--- /dev/null
+++ b/tests/fixtures/cksum/raw/sha224_single_file.expected
@@ -0,0 +1 @@
+=æo¼n@«9ålQÒ�~±ùÆUÐôâ›ü
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/sha256_single_file.expected b/tests/fixtures/cksum/raw/sha256_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..b9ce06f39d9e10d0a5ab49fcb7b664411f446585
--- /dev/null
+++ b/tests/fixtures/cksum/raw/sha256_single_file.expected
@@ -0,0 +1 @@
+÷Ä P Pà 0’P
gê^‘ SkE‚þœC[Ù+?
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/sha384_single_file.expected b/tests/fixtures/cksum/raw/sha384_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..4b337f859ed294d41a46fc45ebc3d261b735c55f
--- /dev/null
+++ b/tests/fixtures/cksum/raw/sha384_single_file.expected
@@ -0,0 +1,3 @@
+Kä¹
+
2–i’’òJ¼‚Mϸ±Ä/ gˆû€ºššLZ{WZ3S©
+ŽçH Ë
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/sha512_single_file.expected b/tests/fixtures/cksum/raw/sha512_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..79f78cf00cb2294024e05c131117b1d6b6a822e4
--- /dev/null
+++ b/tests/fixtures/cksum/raw/sha512_single_file.expected
@@ -0,0 +1 @@
+–Td«%VªÕŽ¼sØšÒ!åYyu)ì¯ÀôfÁ•ÏöÖâÆ– |T,ý Bn^Oऊ¡VgºD k!=Íú
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/sm3_single_file.expected b/tests/fixtures/cksum/raw/sm3_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..3506406dc4247c9d14fee8e3a8cf4a62b38f4cae
--- /dev/null
+++ b/tests/fixtures/cksum/raw/sm3_single_file.expected
@@ -0,0 +1 @@
+m)k€] þÒ(ß0»›CyMÔíg@¡p§‚i›Â
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/sysv_single_file.expected b/tests/fixtures/cksum/raw/sysv_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..b975da49c019cf9b4afdda4f8188bc2bc354b70d
--- /dev/null
+++ b/tests/fixtures/cksum/raw/sysv_single_file.expected
@@ -0,0 +1 @@
+I
\ No newline at end of file
diff --git a/tests/fixtures/cksum/sha1_multiple_files.expected b/tests/fixtures/cksum/sha1_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..f20ea9471534ecae078b38239c92a0c1eb66a876
--- /dev/null
+++ b/tests/fixtures/cksum/sha1_multiple_files.expected
@@ -0,0 +1,2 @@
+SHA1 (lorem_ipsum.txt) = ab1dd0bae1d8883a3d18a66de6afbd28252cfbef
+SHA1 (alice_in_wonderland.txt) = 22b54b2520e8b4fa59eb10719028a4e587c12d1e
diff --git a/tests/fixtures/cksum/sha1_single_file.expected b/tests/fixtures/cksum/sha1_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..1b820559f613323d35f2418d467e346d00c1e307
--- /dev/null
+++ b/tests/fixtures/cksum/sha1_single_file.expected
@@ -0,0 +1 @@
+SHA1 (lorem_ipsum.txt) = ab1dd0bae1d8883a3d18a66de6afbd28252cfbef
diff --git a/tests/fixtures/cksum/sha1_stdin.expected b/tests/fixtures/cksum/sha1_stdin.expected
new file mode 100644
index 0000000000000000000000000000000000000000..ced9ce80d49e608ab08ba0a4abe6c34122f6cf7d
--- /dev/null
+++ b/tests/fixtures/cksum/sha1_stdin.expected
@@ -0,0 +1 @@
+SHA1 (-) = ab1dd0bae1d8883a3d18a66de6afbd28252cfbef
diff --git a/tests/fixtures/cksum/sha224_multiple_files.expected b/tests/fixtures/cksum/sha224_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..0d6b45b102d5625fbc1bd09e1a9ca65451504cb2
--- /dev/null
+++ b/tests/fixtures/cksum/sha224_multiple_files.expected
@@ -0,0 +1,2 @@
+SHA224 (lorem_ipsum.txt) = 3de66fbcad106e1b40ab391be56c51d2007eb1f9c655d0f4e29bfc01
+SHA224 (alice_in_wonderland.txt) = 54c9c7d78458886418ce0845111fc49fe1c628ffd4bf3da14226ffd9
diff --git a/tests/fixtures/cksum/sha224_single_file.expected b/tests/fixtures/cksum/sha224_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..a08d66bb4edf362eb0d5370eaa9ccff5d000049a
--- /dev/null
+++ b/tests/fixtures/cksum/sha224_single_file.expected
@@ -0,0 +1 @@
+SHA224 (lorem_ipsum.txt) = 3de66fbcad106e1b40ab391be56c51d2007eb1f9c655d0f4e29bfc01
diff --git a/tests/fixtures/cksum/sha224_stdin.expected b/tests/fixtures/cksum/sha224_stdin.expected
new file mode 100644
index 0000000000000000000000000000000000000000..1bd1386988587aeaedaf683b81e1e4095ca62f0c
--- /dev/null
+++ b/tests/fixtures/cksum/sha224_stdin.expected
@@ -0,0 +1 @@
+SHA224 (-) = 3de66fbcad106e1b40ab391be56c51d2007eb1f9c655d0f4e29bfc01
diff --git a/tests/fixtures/cksum/sha256_multiple_files.expected b/tests/fixtures/cksum/sha256_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..e6fd8beb5203cd6c49125d5b56d2f76cb67e3fc0
--- /dev/null
+++ b/tests/fixtures/cksum/sha256_multiple_files.expected
@@ -0,0 +1,2 @@
+SHA256 (lorem_ipsum.txt) = f7c420501c50e00b309250100d67ea5e910981536b4582fe9c435bd92b3f1f02
+SHA256 (alice_in_wonderland.txt) = 14ab7e5a0aa3a670222744714bc96961d51012cb216225d965db71824a46e5fe
diff --git a/tests/fixtures/cksum/sha256_single_file.expected b/tests/fixtures/cksum/sha256_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..e16abcb0f37a22629b1635fb3ea9917e74158119
--- /dev/null
+++ b/tests/fixtures/cksum/sha256_single_file.expected
@@ -0,0 +1 @@
+SHA256 (lorem_ipsum.txt) = f7c420501c50e00b309250100d67ea5e910981536b4582fe9c435bd92b3f1f02
diff --git a/tests/fixtures/cksum/sha256_stdin.expected b/tests/fixtures/cksum/sha256_stdin.expected
new file mode 100644
index 0000000000000000000000000000000000000000..87bd8419531e9664d52dc90e8d116d9795727a58
--- /dev/null
+++ b/tests/fixtures/cksum/sha256_stdin.expected
@@ -0,0 +1 @@
+SHA256 (-) = f7c420501c50e00b309250100d67ea5e910981536b4582fe9c435bd92b3f1f02
diff --git a/tests/fixtures/cksum/sha384_multiple_files.expected b/tests/fixtures/cksum/sha384_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..a5a3324a25480bd430133dd734dd2fb36e6517dc
--- /dev/null
+++ b/tests/fixtures/cksum/sha384_multiple_files.expected
@@ -0,0 +1,2 @@
+SHA384 (lorem_ipsum.txt) = 4be4b90a0d0d32966992921019f24abc824dcfb8b1c408102f1f6788fb80ba9a9a4c5a7b575a3353a90a8ee719481dcb
+SHA384 (alice_in_wonderland.txt) = b7966c97ef84ab5858db2e0cdd33fbaf4fa8346d84de65aba001e738c242598a43272854d0073ad1099404eaa1d93766
diff --git a/tests/fixtures/cksum/sha384_single_file.expected b/tests/fixtures/cksum/sha384_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..8d673e60b063fb11230ca06e29c22a144e622ded
--- /dev/null
+++ b/tests/fixtures/cksum/sha384_single_file.expected
@@ -0,0 +1 @@
+SHA384 (lorem_ipsum.txt) = 4be4b90a0d0d32966992921019f24abc824dcfb8b1c408102f1f6788fb80ba9a9a4c5a7b575a3353a90a8ee719481dcb
diff --git a/tests/fixtures/cksum/sha384_stdin.expected b/tests/fixtures/cksum/sha384_stdin.expected
new file mode 100644
index 0000000000000000000000000000000000000000..3c0d5c8189e70deeea9086df0ea8714111fe7200
--- /dev/null
+++ b/tests/fixtures/cksum/sha384_stdin.expected
@@ -0,0 +1 @@
+SHA384 (-) = 4be4b90a0d0d32966992921019f24abc824dcfb8b1c408102f1f6788fb80ba9a9a4c5a7b575a3353a90a8ee719481dcb
diff --git a/tests/fixtures/cksum/sha512_multiple_files.expected b/tests/fixtures/cksum/sha512_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..0f533b27c8f15afbafdf31dbbc4f599f475c7e8a
--- /dev/null
+++ b/tests/fixtures/cksum/sha512_multiple_files.expected
@@ -0,0 +1,2 @@
+SHA512 (lorem_ipsum.txt) = 965464ab2556aad58ebc73d89ad221e559797529ecafc0f466c11795cff6d6e2c60f96a07c542cfd1f426e5e4fe0a48aa15667ba44096b213d0813cd038dfa05
+SHA512 (alice_in_wonderland.txt) = 251646d5a7eb481e0f3aced7839d78dd5e97153f822dc55938e17059c485990d85d602e2881b528b565ab6262584a69c97b068b26bda81acc9356c53c7c1c96d
diff --git a/tests/fixtures/cksum/sha512_single_file.expected b/tests/fixtures/cksum/sha512_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..e9a02c96a0dbbc5339d65c93d65f9015358e7d7b
--- /dev/null
+++ b/tests/fixtures/cksum/sha512_single_file.expected
@@ -0,0 +1 @@
+SHA512 (lorem_ipsum.txt) = 965464ab2556aad58ebc73d89ad221e559797529ecafc0f466c11795cff6d6e2c60f96a07c542cfd1f426e5e4fe0a48aa15667ba44096b213d0813cd038dfa05
diff --git a/tests/fixtures/cksum/sha512_stdin.expected b/tests/fixtures/cksum/sha512_stdin.expected
new file mode 100644
index 0000000000000000000000000000000000000000..8321c4cc3e938d05726aff0f0e56e49de25ac2a4
--- /dev/null
+++ b/tests/fixtures/cksum/sha512_stdin.expected
@@ -0,0 +1 @@
+SHA512 (-) = 965464ab2556aad58ebc73d89ad221e559797529ecafc0f466c11795cff6d6e2c60f96a07c542cfd1f426e5e4fe0a48aa15667ba44096b213d0813cd038dfa05
diff --git a/tests/fixtures/cksum/sm3_multiple_files.expected b/tests/fixtures/cksum/sm3_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..eae2cde2f3de779d93e92f59555538be505c6507
--- /dev/null
+++ b/tests/fixtures/cksum/sm3_multiple_files.expected
@@ -0,0 +1,2 @@
+SM3 (lorem_ipsum.txt) = 6d296b805d060bfed22808df308dbb9b4317794dd4ed6740a10770a782699bc2
+SM3 (alice_in_wonderland.txt) = d66617ae3c4e87828298dcd836f79efbab488c53b84e09c3e8e83a16c902418d
diff --git a/tests/fixtures/cksum/sm3_single_file.expected b/tests/fixtures/cksum/sm3_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..cf4b8304a3d1bf2ef086b550a999e12c72c91df1
--- /dev/null
+++ b/tests/fixtures/cksum/sm3_single_file.expected
@@ -0,0 +1 @@
+SM3 (lorem_ipsum.txt) = 6d296b805d060bfed22808df308dbb9b4317794dd4ed6740a10770a782699bc2
diff --git a/tests/fixtures/cksum/sm3_stdin.expected b/tests/fixtures/cksum/sm3_stdin.expected
new file mode 100644
index 0000000000000000000000000000000000000000..436fcfb41426073d932f4f5a274db02a6d6cd129
--- /dev/null
+++ b/tests/fixtures/cksum/sm3_stdin.expected
@@ -0,0 +1 @@
+SM3 (-) = 6d296b805d060bfed22808df308dbb9b4317794dd4ed6740a10770a782699bc2
diff --git a/tests/fixtures/cksum/sysv_multiple_files.expected b/tests/fixtures/cksum/sysv_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..83a6d6d839f0b273e2e1a3645291e29d64b2e767
--- /dev/null
+++ b/tests/fixtures/cksum/sysv_multiple_files.expected
@@ -0,0 +1,2 @@
+6985 2 lorem_ipsum.txt
+27441 1 alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/sysv_single_file.expected b/tests/fixtures/cksum/sysv_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..e0f7252cbe88751d344b1ca7d9dcc889b450eaaf
--- /dev/null
+++ b/tests/fixtures/cksum/sysv_single_file.expected
@@ -0,0 +1 @@
+6985 2 lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/sysv_stdin.expected b/tests/fixtures/cksum/sysv_stdin.expected
new file mode 100644
index 0000000000000000000000000000000000000000..f0fba8c815c10c09d266fac5d475714edde16774
--- /dev/null
+++ b/tests/fixtures/cksum/sysv_stdin.expected
@@ -0,0 +1 @@
+6985 2
diff --git a/tests/fixtures/cksum/untagged/blake2b_multiple_files.expected b/tests/fixtures/cksum/untagged/blake2b_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..7c68c85733235f7c1cc1f7acbe0633af0bf42a35
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/blake2b_multiple_files.expected
@@ -0,0 +1,2 @@
+0e97a09189e560c3789c0bff1f020166861ef857d1fbfe4574de1842e3c06cabb9575e4af6309a166158c2b408d3c038c1b49d828b35158142cdc0396d1195c3 lorem_ipsum.txt
+91b8b0f0868e905ad18b8ac35e4a1dacd289857b19258ab5d1e071761af758b0134ec152d4f011fe1825ca889c80c2e072ca70eb50548c25fc49a98937515af4 alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/blake2b_single_file.expected b/tests/fixtures/cksum/untagged/blake2b_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..1f5444c87cd5a9131d96cfbfbee94515a40001b1
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/blake2b_single_file.expected
@@ -0,0 +1 @@
+0e97a09189e560c3789c0bff1f020166861ef857d1fbfe4574de1842e3c06cabb9575e4af6309a166158c2b408d3c038c1b49d828b35158142cdc0396d1195c3 lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/blake2b_stdin.expected b/tests/fixtures/cksum/untagged/blake2b_stdin.expected
new file mode 100644
index 0000000000000000000000000000000000000000..0892bff36dc1dea1605551e7b1247fa1fc05a4bc
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/blake2b_stdin.expected
@@ -0,0 +1 @@
+0e97a09189e560c3789c0bff1f020166861ef857d1fbfe4574de1842e3c06cabb9575e4af6309a166158c2b408d3c038c1b49d828b35158142cdc0396d1195c3 -
diff --git a/tests/fixtures/cksum/untagged/bsd_multiple_files.expected b/tests/fixtures/cksum/untagged/bsd_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..941a2a512f8b2880d5aad29efdeb57cf7710731a
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/bsd_multiple_files.expected
@@ -0,0 +1,2 @@
+08109 1 lorem_ipsum.txt
+01814 1 alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/bsd_single_file.expected b/tests/fixtures/cksum/untagged/bsd_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..293ada3bd612b09973cc53965e5bb857e6097d1e
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/bsd_single_file.expected
@@ -0,0 +1 @@
+08109 1 lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/bsd_stdin.expected b/tests/fixtures/cksum/untagged/bsd_stdin.expected
new file mode 100644
index 0000000000000000000000000000000000000000..4843ba08246d1d85daf3e56a619b3bd942e3407b
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/bsd_stdin.expected
@@ -0,0 +1 @@
+08109 1
diff --git a/tests/fixtures/cksum/untagged/crc_multiple_files.expected b/tests/fixtures/cksum/untagged/crc_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..d7a4f5b4f3bfbe5cdc91d91bcc1bf56d6e5e9dff
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/crc_multiple_files.expected
@@ -0,0 +1,2 @@
+378294376 772 lorem_ipsum.txt
+3805907707 302 alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/crc_single_file.expected b/tests/fixtures/cksum/untagged/crc_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..e9fc1ca7cf440d1c502b93db99e07a5f904eb3f9
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/crc_single_file.expected
@@ -0,0 +1 @@
+378294376 772 lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/crc_stdin.expected b/tests/fixtures/cksum/untagged/crc_stdin.expected
new file mode 100644
index 0000000000000000000000000000000000000000..28b37d0bed1d23df5659248b93ea6e68456938e6
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/crc_stdin.expected
@@ -0,0 +1 @@
+378294376 772
diff --git a/tests/fixtures/cksum/untagged/md5_multiple_files.expected b/tests/fixtures/cksum/untagged/md5_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..4b63cbff7fd336e68a370f9989bf32dbbaa2e1aa
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/md5_multiple_files.expected
@@ -0,0 +1,2 @@
+cd724690f7dc61775dfac400a71f2caa lorem_ipsum.txt
+f6fa7033e16166a9589aa1c0388ffd58 alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/md5_single_file.expected b/tests/fixtures/cksum/untagged/md5_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..ca9eb678596f042c38d3e38238d0e12bd33570c9
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/md5_single_file.expected
@@ -0,0 +1 @@
+cd724690f7dc61775dfac400a71f2caa lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/md5_stdin.expected b/tests/fixtures/cksum/untagged/md5_stdin.expected
new file mode 100644
index 0000000000000000000000000000000000000000..f4094dcc7e0be8e4d2d2bd97e548a9bcfab40e94
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/md5_stdin.expected
@@ -0,0 +1 @@
+cd724690f7dc61775dfac400a71f2caa -
diff --git a/tests/fixtures/cksum/untagged/sha1_multiple_files.expected b/tests/fixtures/cksum/untagged/sha1_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..1712c7409112977f7171906200a750ad444a9acf
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha1_multiple_files.expected
@@ -0,0 +1,2 @@
+ab1dd0bae1d8883a3d18a66de6afbd28252cfbef lorem_ipsum.txt
+22b54b2520e8b4fa59eb10719028a4e587c12d1e alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/sha1_single_file.expected b/tests/fixtures/cksum/untagged/sha1_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..c8e8ddca6f9a851585fbc07e8f684af6a3cec190
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha1_single_file.expected
@@ -0,0 +1 @@
+ab1dd0bae1d8883a3d18a66de6afbd28252cfbef lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/sha1_stdin.expected b/tests/fixtures/cksum/untagged/sha1_stdin.expected
new file mode 100644
index 0000000000000000000000000000000000000000..2396ed481ecb108d28c28157cd6711bb4323c073
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha1_stdin.expected
@@ -0,0 +1 @@
+ab1dd0bae1d8883a3d18a66de6afbd28252cfbef -
diff --git a/tests/fixtures/cksum/untagged/sha224_multiple_files.expected b/tests/fixtures/cksum/untagged/sha224_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..3eb2b500a00b202fc326beb19ad738e11ab61e24
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha224_multiple_files.expected
@@ -0,0 +1,2 @@
+3de66fbcad106e1b40ab391be56c51d2007eb1f9c655d0f4e29bfc01 lorem_ipsum.txt
+54c9c7d78458886418ce0845111fc49fe1c628ffd4bf3da14226ffd9 alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/sha224_single_file.expected b/tests/fixtures/cksum/untagged/sha224_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..c5ab1f7d1438feaaf142ecb981e925877e3edfbd
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha224_single_file.expected
@@ -0,0 +1 @@
+3de66fbcad106e1b40ab391be56c51d2007eb1f9c655d0f4e29bfc01 lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/sha224_stdin.expected b/tests/fixtures/cksum/untagged/sha224_stdin.expected
new file mode 100644
index 0000000000000000000000000000000000000000..691e451b3738ca660e7edb66de7ef49d9c527219
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha224_stdin.expected
@@ -0,0 +1 @@
+3de66fbcad106e1b40ab391be56c51d2007eb1f9c655d0f4e29bfc01 -
diff --git a/tests/fixtures/cksum/untagged/sha256_multiple_files.expected b/tests/fixtures/cksum/untagged/sha256_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..a57fa2eaf1b8d316edd9983e316ea75d6bf1563b
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha256_multiple_files.expected
@@ -0,0 +1,2 @@
+f7c420501c50e00b309250100d67ea5e910981536b4582fe9c435bd92b3f1f02 lorem_ipsum.txt
+14ab7e5a0aa3a670222744714bc96961d51012cb216225d965db71824a46e5fe alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/sha256_single_file.expected b/tests/fixtures/cksum/untagged/sha256_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..1b1be9516bee128fb344dece46391105bd065e83
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha256_single_file.expected
@@ -0,0 +1 @@
+f7c420501c50e00b309250100d67ea5e910981536b4582fe9c435bd92b3f1f02 lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/sha256_stdin.expected b/tests/fixtures/cksum/untagged/sha256_stdin.expected
new file mode 100644
index 0000000000000000000000000000000000000000..998db6c664bd3aa331e95ceeaba35a0e562283ac
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha256_stdin.expected
@@ -0,0 +1 @@
+f7c420501c50e00b309250100d67ea5e910981536b4582fe9c435bd92b3f1f02 -
diff --git a/tests/fixtures/cksum/untagged/sha384_multiple_files.expected b/tests/fixtures/cksum/untagged/sha384_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..d309034b4af8f6eaefb7beab39660580c88d4515
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha384_multiple_files.expected
@@ -0,0 +1,2 @@
+4be4b90a0d0d32966992921019f24abc824dcfb8b1c408102f1f6788fb80ba9a9a4c5a7b575a3353a90a8ee719481dcb lorem_ipsum.txt
+b7966c97ef84ab5858db2e0cdd33fbaf4fa8346d84de65aba001e738c242598a43272854d0073ad1099404eaa1d93766 alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/sha384_single_file.expected b/tests/fixtures/cksum/untagged/sha384_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..88d4da577265193a06364391421918f688be9e0f
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha384_single_file.expected
@@ -0,0 +1 @@
+4be4b90a0d0d32966992921019f24abc824dcfb8b1c408102f1f6788fb80ba9a9a4c5a7b575a3353a90a8ee719481dcb lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/sha384_stdin.expected b/tests/fixtures/cksum/untagged/sha384_stdin.expected
new file mode 100644
index 0000000000000000000000000000000000000000..cde20b78b930765e45d4426543c495a0ea092226
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha384_stdin.expected
@@ -0,0 +1 @@
+4be4b90a0d0d32966992921019f24abc824dcfb8b1c408102f1f6788fb80ba9a9a4c5a7b575a3353a90a8ee719481dcb -
diff --git a/tests/fixtures/cksum/untagged/sha512_multiple_files.expected b/tests/fixtures/cksum/untagged/sha512_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..a5dafa7c329fa65d250668538a8ea29364b70860
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha512_multiple_files.expected
@@ -0,0 +1,2 @@
+965464ab2556aad58ebc73d89ad221e559797529ecafc0f466c11795cff6d6e2c60f96a07c542cfd1f426e5e4fe0a48aa15667ba44096b213d0813cd038dfa05 lorem_ipsum.txt
+251646d5a7eb481e0f3aced7839d78dd5e97153f822dc55938e17059c485990d85d602e2881b528b565ab6262584a69c97b068b26bda81acc9356c53c7c1c96d alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/sha512_single_file.expected b/tests/fixtures/cksum/untagged/sha512_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..adea498d60995b1a3fe74a53829378fb6d596c7d
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha512_single_file.expected
@@ -0,0 +1 @@
+965464ab2556aad58ebc73d89ad221e559797529ecafc0f466c11795cff6d6e2c60f96a07c542cfd1f426e5e4fe0a48aa15667ba44096b213d0813cd038dfa05 lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/sha512_stdin.expected b/tests/fixtures/cksum/untagged/sha512_stdin.expected
new file mode 100644
index 0000000000000000000000000000000000000000..dd9c968438aa9747cc46a5e00a8dff2bf8e4e2e8
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sha512_stdin.expected
@@ -0,0 +1 @@
+965464ab2556aad58ebc73d89ad221e559797529ecafc0f466c11795cff6d6e2c60f96a07c542cfd1f426e5e4fe0a48aa15667ba44096b213d0813cd038dfa05 -
diff --git a/tests/fixtures/cksum/untagged/sm3_multiple_files.expected b/tests/fixtures/cksum/untagged/sm3_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..de12ab0b9b6aeefbb1c6d4eaed873d9c0a35eb08
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sm3_multiple_files.expected
@@ -0,0 +1,2 @@
+6d296b805d060bfed22808df308dbb9b4317794dd4ed6740a10770a782699bc2 lorem_ipsum.txt
+d66617ae3c4e87828298dcd836f79efbab488c53b84e09c3e8e83a16c902418d alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/sm3_single_file.expected b/tests/fixtures/cksum/untagged/sm3_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..54d5f40d23383085d1ac9ff298fd39ee13174d3f
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sm3_single_file.expected
@@ -0,0 +1 @@
+6d296b805d060bfed22808df308dbb9b4317794dd4ed6740a10770a782699bc2 lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/sm3_stdin.expected b/tests/fixtures/cksum/untagged/sm3_stdin.expected
new file mode 100644
index 0000000000000000000000000000000000000000..6ba002b45b6e7cbbcae3ea6856328e9ee827c7e0
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sm3_stdin.expected
@@ -0,0 +1 @@
+6d296b805d060bfed22808df308dbb9b4317794dd4ed6740a10770a782699bc2 -
diff --git a/tests/fixtures/cksum/untagged/sysv_multiple_files.expected b/tests/fixtures/cksum/untagged/sysv_multiple_files.expected
new file mode 100644
index 0000000000000000000000000000000000000000..83a6d6d839f0b273e2e1a3645291e29d64b2e767
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sysv_multiple_files.expected
@@ -0,0 +1,2 @@
+6985 2 lorem_ipsum.txt
+27441 1 alice_in_wonderland.txt
diff --git a/tests/fixtures/cksum/untagged/sysv_single_file.expected b/tests/fixtures/cksum/untagged/sysv_single_file.expected
new file mode 100644
index 0000000000000000000000000000000000000000..e0f7252cbe88751d344b1ca7d9dcc889b450eaaf
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sysv_single_file.expected
@@ -0,0 +1 @@
+6985 2 lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/untagged/sysv_stdin.expected b/tests/fixtures/cksum/untagged/sysv_stdin.expected
new file mode 100644
index 0000000000000000000000000000000000000000..f0fba8c815c10c09d266fac5d475714edde16774
--- /dev/null
+++ b/tests/fixtures/cksum/untagged/sysv_stdin.expected
@@ -0,0 +1 @@
+6985 2
diff --git a/tests/fixtures/comm/a_nul b/tests/fixtures/comm/a_nul
new file mode 100644
index 0000000000000000000000000000000000000000..3142c801ccd54e1a9bc9d587e5ab16369ead768d
--- /dev/null
+++ b/tests/fixtures/comm/a_nul
@@ -0,0 +1 @@
+a�z
\ No newline at end of file
diff --git a/tests/fixtures/comm/ab_delimiter_hyphen_help.expected b/tests/fixtures/comm/ab_delimiter_hyphen_help.expected
new file mode 100644
index 0000000000000000000000000000000000000000..c245aa27f13f9f82c60b09fe712f31713fbe3db8
--- /dev/null
+++ b/tests/fixtures/comm/ab_delimiter_hyphen_help.expected
@@ -0,0 +1,3 @@
+a
+--helpb
+--help--helpz
diff --git a/tests/fixtures/comm/ab_delimiter_hyphen_one.expected b/tests/fixtures/comm/ab_delimiter_hyphen_one.expected
new file mode 100644
index 0000000000000000000000000000000000000000..458f98dd42f13d88e4e782e13fa88e37866ad06e
--- /dev/null
+++ b/tests/fixtures/comm/ab_delimiter_hyphen_one.expected
@@ -0,0 +1,3 @@
+a
+-1b
+-1-1z
diff --git a/tests/fixtures/comm/ab_nul.expected b/tests/fixtures/comm/ab_nul.expected
new file mode 100644
index 0000000000000000000000000000000000000000..f826106bb1926f3ce2c6553b72bb0a007c432f4f
--- /dev/null
+++ b/tests/fixtures/comm/ab_nul.expected
@@ -0,0 +1 @@
+a� b� z�
\ No newline at end of file
diff --git a/tests/fixtures/comm/ab_nul_total.expected b/tests/fixtures/comm/ab_nul_total.expected
new file mode 100644
index 0000000000000000000000000000000000000000..9f46f9558b1ba3396542ba574fb0983b5609c602
--- /dev/null
+++ b/tests/fixtures/comm/ab_nul_total.expected
@@ -0,0 +1 @@
+a� b� z�1 1 1 total�
\ No newline at end of file
diff --git a/tests/fixtures/comm/ab_total.expected b/tests/fixtures/comm/ab_total.expected
new file mode 100644
index 0000000000000000000000000000000000000000..430354a6620aa249be8be167e815e2a2344c063b
--- /dev/null
+++ b/tests/fixtures/comm/ab_total.expected
@@ -0,0 +1,4 @@
+a
+ b
+ z
+1 1 1 total
diff --git a/tests/fixtures/comm/ab_total_delimiter_word.expected b/tests/fixtures/comm/ab_total_delimiter_word.expected
new file mode 100644
index 0000000000000000000000000000000000000000..f7215ea28a34b4106537b0deed0210f2c3f40a7c
--- /dev/null
+++ b/tests/fixtures/comm/ab_total_delimiter_word.expected
@@ -0,0 +1,4 @@
+a
+wordb
+wordwordz
+1word1word1wordtotal
diff --git a/tests/fixtures/comm/ab_total_suppressed_regular_output.expected b/tests/fixtures/comm/ab_total_suppressed_regular_output.expected
new file mode 100644
index 0000000000000000000000000000000000000000..733c1d344e5dae5348c3574317344034fe9de185
--- /dev/null
+++ b/tests/fixtures/comm/ab_total_suppressed_regular_output.expected
@@ -0,0 +1 @@
+1 1 1 total
diff --git a/tests/fixtures/comm/b_nul b/tests/fixtures/comm/b_nul
new file mode 100644
index 0000000000000000000000000000000000000000..ca4569669d4dc6241500f5a98422c2e6725d7921
--- /dev/null
+++ b/tests/fixtures/comm/b_nul
@@ -0,0 +1 @@
+b�z
\ No newline at end of file
diff --git a/tests/fixtures/cut/8bit-delim.txt b/tests/fixtures/cut/8bit-delim.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2312c916aef6cbf4e1ed47dec3df443c95b3e164
--- /dev/null
+++ b/tests/fixtures/cut/8bit-delim.txt
@@ -0,0 +1 @@
+abc
diff --git a/tests/fixtures/dircolors/internal.expected b/tests/fixtures/dircolors/internal.expected
index 7bc91ef470cad981c8de72819704e3e1afb34e84..e151973f20016fac63345d1ce15ba6fafa06164d 100644
--- a/tests/fixtures/dircolors/internal.expected
+++ b/tests/fixtures/dircolors/internal.expected
@@ -1,8 +1,5 @@
# Configuration file for dircolors, a utility to help you set the
# LS_COLORS environment variable used by GNU ls with the --color option.
-# Copyright (C) 1996-2022 Free Software Foundation, Inc.
-# Copying and distribution of this file, with or without modification,
-# are permitted provided the copyright notice and this notice are preserved.
# The keywords COLOR, OPTIONS, and EIGHTBIT (honored by the
# slackware version of dircolors) are recognized but ignored.
# Global config options can be specified before TERM or COLORTERM entries
@@ -46,40 +43,26 @@ TERM xterm*
# 40=black 41=red 42=green 43=yellow 44=blue 45=magenta 46=cyan 47=white
#NORMAL 00 # no color code at all
#FILE 00 # regular file: use no color at all
-RESET 0 # reset to "normal" color
-DIR 01;34 # directory
-LINK 01;36 # symbolic link. (If you set this to 'target' instead of a
- # numerical value, the color is as for the file pointed to.)
-MULTIHARDLINK 00 # regular file with more than one link
-FIFO 40;33 # pipe
-SOCK 01;35 # socket
-DOOR 01;35 # door
-BLK 40;33;01 # block device driver
-CHR 40;33;01 # character device driver
-ORPHAN 40;31;01 # symlink to nonexistent file, or non-stat'able file ...
-MISSING 00 # ... and the files they point to
-SETUID 37;41 # file that is setuid (u+s)
-SETGID 30;43 # file that is setgid (g+s)
-CAPABILITY 00 # file with capability (very expensive to lookup)
-STICKY_OTHER_WRITABLE 30;42 # dir that is sticky and other-writable (+t,o+w)
-OTHER_WRITABLE 34;42 # dir that is other-writable (o+w) and not sticky
-STICKY 37;44 # dir with the sticky bit set (+t) and not other-writable
-# This is for files with execute permission:
+RESET 0
+DIR 01;34
+LINK 01;36
+MULTIHARDLINK 00
+FIFO 40;33
+SOCK 01;35
+DOOR 01;35
+BLK 40;33;01
+CHR 40;33;01
+ORPHAN 40;31;01
+MISSING 00
+SETUID 37;41
+SETGID 30;43
+CAPABILITY 00
+STICKY_OTHER_WRITABLE 30;42
+OTHER_WRITABLE 34;42
+STICKY 37;44
EXEC 01;32
# List any file extensions like '.gz' or '.tar' that you would like ls
# to color below. Put the extension, a space, and the color init string.
-# (and any comments you want to add after a '#')
-# If you use DOS-style suffixes, you may want to uncomment the following:
-#.cmd 01;32 # executables (bright green)
-#.exe 01;32
-#.com 01;32
-#.btm 01;32
-#.bat 01;32
-# Or if you want to color scripts even if they do not have the
-# executable bit actually set.
-#.sh 01;32
-#.csh 01;32
- # archives or compressed (bright red)
.tar 01;31
.tgz 01;31
.arc 01;31
@@ -126,7 +109,6 @@ EXEC 01;32
.swm 01;31
.dwm 01;31
.esd 01;31
-# image formats
.avif 01;35
.jpg 01;35
.jpeg 01;35
@@ -176,10 +158,8 @@ EXEC 01;32
.yuv 01;35
.cgm 01;35
.emf 01;35
-# https://wiki.xiph.org/MIME_Types_and_File_Extensions
.ogv 01;35
.ogx 01;35
-# audio formats
.aac 00;36
.au 00;36
.flac 00;36
@@ -192,12 +172,10 @@ EXEC 01;32
.ogg 00;36
.ra 00;36
.wav 00;36
-# https://wiki.xiph.org/MIME_Types_and_File_Extensions
.oga 00;36
.opus 00;36
.spx 00;36
.xspf 00;36
-# backup files
*~ 00;90
*# 00;90
.bak 00;90
diff --git a/tests/fixtures/env/runBat.bat b/tests/fixtures/env/runBat.bat
new file mode 100644
index 0000000000000000000000000000000000000000..63ab744d3abd208198a41d95f947a5289a6d61ea
--- /dev/null
+++ b/tests/fixtures/env/runBat.bat
@@ -0,0 +1 @@
+echo Hello Windows World!
diff --git a/tests/fixtures/fmt/prefixed-one-word-per-line.txt b/tests/fixtures/fmt/prefixed-one-word-per-line.txt
new file mode 100644
index 0000000000000000000000000000000000000000..afb9aeec0df2ffbc31a18cd8cd289ddd190e79d8
--- /dev/null
+++ b/tests/fixtures/fmt/prefixed-one-word-per-line.txt
@@ -0,0 +1,19 @@
+- this
+- is
+- a
+- file
+- with
+- one
+- word
+- per
+- line
+
+=1this
+=1is
+=1a
+=2file
+=2with
+=2one
+=3word
+=3per
+=3line
diff --git a/tests/fixtures/fmt/prefixed-one-word-per-line_p-.txt b/tests/fixtures/fmt/prefixed-one-word-per-line_p-.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4d1073550d9c40befafaab27bc429b8537699959
--- /dev/null
+++ b/tests/fixtures/fmt/prefixed-one-word-per-line_p-.txt
@@ -0,0 +1,11 @@
+- this is a file with one word per line
+
+=1this
+=1is
+=1a
+=2file
+=2with
+=2one
+=3word
+=3per
+=3line
diff --git a/tests/fixtures/fmt/prefixed-one-word-per-line_p=.txt b/tests/fixtures/fmt/prefixed-one-word-per-line_p=.txt
new file mode 100644
index 0000000000000000000000000000000000000000..488cf86de766baaa57085359f1720f77be1fee4a
--- /dev/null
+++ b/tests/fixtures/fmt/prefixed-one-word-per-line_p=.txt
@@ -0,0 +1,11 @@
+- this
+- is
+- a
+- file
+- with
+- one
+- word
+- per
+- line
+
+=1this 1is 1a 2file 2with 2one 3word 3per 3line
diff --git a/tests/fixtures/fmt/prefixed-one-word-per-line_p=_P=2.txt b/tests/fixtures/fmt/prefixed-one-word-per-line_p=_P=2.txt
new file mode 100644
index 0000000000000000000000000000000000000000..19e951096a3f0be248872b5e6d0ce78c5c1ccbef
--- /dev/null
+++ b/tests/fixtures/fmt/prefixed-one-word-per-line_p=_P=2.txt
@@ -0,0 +1,15 @@
+- this
+- is
+- a
+- file
+- with
+- one
+- word
+- per
+- line
+
+=1this 1is 1a
+=2file
+=2with
+=2one
+=3word 3per 3line
diff --git a/tests/fixtures/head/lorem_ipsum_backwards_15_lines.expected b/tests/fixtures/head/lorem_ipsum_backwards_15_lines.expected
new file mode 100644
index 0000000000000000000000000000000000000000..9865c1b35ab10bce0ab40f2b0bcf33df26856d24
--- /dev/null
+++ b/tests/fixtures/head/lorem_ipsum_backwards_15_lines.expected
@@ -0,0 +1,9 @@
+Lorem ipsum dolor sit amet,
+consectetur adipiscing elit.
+Nunc interdum suscipit sem vel ornare.
+Proin euismod,
+justo sed mollis dictum,
+eros urna ultricies augue,
+eu pharetra mi ex id ante.
+Duis convallis porttitor aliquam.
+Nunc vitae tincidunt ex.
diff --git a/tests/fixtures/install/helloworld.rs b/tests/fixtures/install/helloworld.rs
index 47ad8c634112b312f330c58f581a654f46618be7..bb2a816fc00df28cfb690c0cb166f7c4316a2b5b 100644
--- a/tests/fixtures/install/helloworld.rs
+++ b/tests/fixtures/install/helloworld.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
fn main() {
println!("Hello World!");
}
diff --git a/tests/fixtures/install/helloworld_freebsd b/tests/fixtures/install/helloworld_freebsd
new file mode 100755
index 0000000000000000000000000000000000000000..bfd788630303b757c533a76daf1bee115f830032
--- /dev/null
+++ b/tests/fixtures/install/helloworld_freebsd
@@ -0,0 +1,689 @@
+ELF ���������>����p
+�����@�������èÂ���������@�8� �@� � �������@�������@�������@�������h������h�������������������¨������¨������¨���������������������������������������������������������lú������lú�������������������pú������p
+�����p
+�����à¡�����à¡������������������Pœ�����P¼�����P¼�����`$������`$�������������������°À�����°ð�����°ð�����P�������9�������������������ȼ�����ÈÜ�����ÈÜ�����À������À�������������Råtd���Pœ�����P¼�����P¼�����`$������°3�������������Påtd���h¡������h¡������h¡������D ������D �������������Qåtd���������������������������������������������������������À������À������À������0�������0��������������/libexec/ld-elf.so.1�������������FreeBSD��������������FreeBSD�������������������������������������������������������������������������%����������������������*���"�������������������9��� �������������������M����������������������R����������������������Z����������������������`����������������������e����������������������l����������������������v����������������������‚����������������������Š��������������������������������������������˜����������������������ª����������������������·����������������������Ë����������������������à����������������������ö����������������������ÿ������������������������������������������� ���������������������������������������������������������������'���������������������6���������������������=���������������������E���������������������J���������������������R���������������������Y���������������������p���������������������„���������������������¤���������������������¶���������������������Í���������������������Û���������������������é���������������������ü������������������������������������������'���������������������-���������������������A���������������������X���������������������o���������������������z���������������������������������������������������������������Ÿ���������������������¦���������������������¬���������������������²���������������������·���������������������½���������������������Æ���������������������Ë���������������������Ò���������������������Ù���������������������à������������������������� ��ñ������������ �����°ð�������������������������������������������������������������������������������ò��0����������0��������/��P�������°(z���þ������P&y ��������S&y ��� �����``' ���%������°(z���þ���������>������������À��>���¦Ý£k½Pvž@���@���1���#����������9���?�������������������������������������������������2���:���<���7���;������������������� �����������*���������������/��� ������+�����������8���������������3�������!���$������������������6���.���
����������� �������5���
+�������>���������������������������������������������������������������������������������������������������������������������������������� ��������������������� �������(����������"���)��� ���&��� ���'���������� ����������������4���,������%���-���0���=����environ�__progname�atexit�_init_tls�exit�__cxa_finalize�_Jv_RegisterClasses�poll�__error�fcntl�open�signal�sigaction�sigaltstack�sysconf�mmap�mprotect�pthread_attr_init�pthread_self�pthread_attr_get_np�pthread_attr_destroy�pthread_attr_getstack�_umtx_op�free�munmap�abort�malloc�_Unwind_Resume�posix_memalign�memcpy�realloc�bcmp�memmove�memset�_Unwind_RaiseException�pthread_setspecific�_Unwind_GetLanguageSpecificData�_Unwind_GetIPInfo�_Unwind_GetRegionStart�_Unwind_SetGR�_Unwind_SetIP�pthread_key_create�pthread_key_delete�_Unwind_DeleteException�write�pthread_getspecific�_Unwind_GetTextRelBase�_Unwind_GetDataRelBase�strerror_r�strlen�_Unwind_GetIP�dl_iterate_phdr�sysctl�fstat�lseek�read�close�realpath�stat�calloc�getenv�getcwd�_Unwind_Backtrace�libthr.so.3�FBSD_1.0�libgcc_s.so.1�GCC_3.0�GCC_3.3�GCC_4.2.0�libc.so.7����x¼������������`
�����€¼������������DW������¼������������mW������ ¼������������QW������¸¼������������~W������м������������œW������à¼������������ØW������ø¼������������X������½������������ X������½������������è|������(½������������Ø������8½������������Ø������H½������������0è�����`½������������Àª�����h½������������<X������€½������������<X������˜½������������™X������¨½������������ÙX������¸½������������@>������Ƚ������������7Y������ؽ������������NY������è½������������@>������ø½������������À?������¾������������WY������¾������������NY������(¾������������P*�����@¾������������C�����H¾�������������F�����P¾������������`F�����X¾������������³Y������p¾������������óW������ˆ¾������������óW������ ¾������������yX������¸¾������������yX������о������������–Z������à¾������������¨Z������ð¾������������ @�������¿������������¨Z������¿������������ÊZ������ ¿������������àZ������0¿������������íZ������@¿������������[������P¿������������.[������`¿������������݈������p¿������������Y[������€¿������������ƒ\������˜¿������������ƒ\������°¿������������ƒ\������È¿������������ƒ\������à¿������������ƒ\������ø¿������������¨\������À������������xY������À������������?������(À������������¶\������8À������������·\������HÀ������������Â\������XÀ������������è\������hÀ������������ ]������xÀ������������¶\������ˆÀ������������·\������˜À������������&]������¨À������������¶\������¸À������������<]������ÐÀ������������W]������èÀ������������W]�������Á������������øb������Á������������øb������0Á������������ c������HÁ������������ c������`Á������������—f������xÁ������������—f������Á������������—f������¨Á������������—f������ÀÁ������������—f������ØÁ������������Jg������ðÁ������������Jg������Â������������tg������Â������������‰g������0Â������������Øg������HÂ������������Øg������`Â������������Øg������xÂ������������Øg������Â������������Øg������¨Â������������Øg������ÀÂ������������Øg������ØÂ������������Øg������ðÂ������������Øg������Ã������������Øg������ Ã������������Øg������8Ã������������Øg������PÃ������������Øg������hÃ������������Øg������€Ã������������Øg������˜Ã������������Øg������°Ã������������Øg������ÈÃ������������Øg������àÃ������������Øg������øÃ������������Øg������Ä������������Øg������(Ä������������Øg������@Ä������������Øg������XÄ������������Øg������pÄ������������Øg������ˆÄ������������Øg������ Ä������������Øg������¸Ä������������Øg������ÐÄ������������Øg������èÄ������������Øg�������Å������������Øg������Å������������Øg������0Å������������Øg������HÅ������������Øg������`Å������������Øg������xÅ������������Øg������Å������������Øg������¨Å������������Øg������ÀÅ������������Øg������ØÅ������������Øg������ðÅ������������Øg������Æ������������Øg������ Æ������������Øg������8Æ������������Øg������PÆ������������x������hÆ������������x������€Æ������������Øg������˜Æ������������Øg������°Æ������������Øg������ÈÆ������������Øg������àÆ������������Øg������øÆ������������Øg������Ç������������Øg������(Ç������������Øg������@Ç������������Øg������XÇ������������Øg������pÇ������������Øg������ˆÇ������������Øg������ Ç������������Ûx������¸Ç������������+y������ÐÇ������������0è�����èÇ������������à�����ðÇ������������0è�����È�����������������È������������0è�����(È������������@è�����0È������������à±�����HÈ������������ð±�����PÈ������������P*�����hÈ������������� �����pÈ������������@ �����xÈ������������@ �����€È������������®y������˜È������������®y������°È������������®y������ÈÈ������������®y������àÈ������������®y������øÈ������������®y������É������������®y������(É������������®y������@É������������®y������XÉ������������®y������pÉ������������®y������ˆÉ������������®y������ É������������®y������¸É������������®y������ÐÉ������������®y������èÉ������������®y�������Ê������������®y������Ê������������®y������0Ê������������®y������HÊ������������æy������`Ê������������æy������xÊ������������æy������Ê������������æy������¨Ê������������æy������ÀÊ������������æy������ØÊ������������æy������ðÊ������������æy������Ë������������æy������ Ë������������Yz������0Ë������������Y������@Ë������������’z������PË������������´z������`Ë������������æy������xË������������æy������Ë������������æy������¨Ë������������æy������ÀË������������æy������ØË������������æy������ðË������������æy������Ì������������æy������ Ì������������æy������8Ì������������M{������PÌ������������M{������hÌ������������M{������€Ì������������Èz������ˆÌ������������¤Y������Ì������������dY������˜Ì������������ëz������ Ì������������Åz������¨Ì������������èz������°Ì������������¤Y������¸Ì������������Øz������ÀÌ������������Óz������ÈÌ������������ãz������ÐÌ������������¤Y������ØÌ������������Íz������àÌ������������Ýz������èÌ������������”Y������ðÌ������������pY������øÌ������������ïz�������Í������������¤Y������Í������������¤Y������Í������������Êz������Í������������Úz������ Í������������&~������(Í������������ðz������0Í������������¤Y������8Í������������Ðz������@Í������������àz������HÍ������������îz������PÍ������������Å}������hÍ������������~������xÍ������������(~������Í������������(~������¨Í������������(~������ÀÍ������������(~������ØÍ������������w~������èÍ������������…~�������Î������������ ������Î������������ ������0Î������������ ������HÎ������������ ������`Î������������ ������xÎ������������ ������Î������������ ������¨Î������������ ������ÀÎ������������ ������ØÎ������������ ������ðÎ������������ ������Ï������������ ������ Ï������������ ������8Ï������������ ������PÏ������������ ������hÏ������������ ������€Ï������������ ������˜Ï������������ ������°Ï������������ ������ÈÏ������������ ������àÏ������������0è�����øÏ������������ð)������Ð������������0è�����Ð������������0S����� Ð������������P*�����8Ð������������`*�����@Ð������������f}������XÐ������������f}������pÐ������������������ˆÐ������������c������ Ð������������c������¸Ð������������c������ÐÐ������������É������èÐ������������c�������Ñ������������‚������Ñ������������=‚������0Ñ������������P*�����HÑ������������ð6�����PÑ������������P*�����hÑ������������ 6�����pÑ������������P*�����ˆÑ������������°7�����Ñ������������P*�����¨Ñ������������05�����°Ñ������������Ð&�����ÈÑ������������à&�����ÐÑ������������à'�����ØÑ������������ (�����àÑ������������ >�����øÑ������������ ©������Ò������������€©�����Ò������������°ª�����Ò������������Ð&�����(Ò�������������…�����0Ò������������P…�����8Ò������������P†�����@Ò������������(~������XÒ������������(~������pÒ������������Úƒ������ˆÒ������������Úƒ������ Ò������������Úƒ������¸Ò������������Úƒ������ÐÒ������������Úƒ������èÒ�������������„�������Ó�������������„������Ó������������+„������(Ó������������f„������8Ó������������g„������PÓ������������|„������`Ó������������¯„������pÓ������������P…������ˆÓ������������m…������˜Ó������������P…������°Ó������������¤…������ÈÓ������������Æ…������àÓ������������ç…������øÓ������������è|������Ô������������†������ Ô������������è|������0Ô������������Òˆ������@Ô������������݈������PÔ������������Þˆ������hÔ������������Þˆ������€Ô������������?‰������˜Ô������������^‰������¨Ô������������q‰������¸Ô������������Þˆ������ÐÔ������������y‰������èÔ������������}�������Õ������������y‰������Õ������������’‰������0Õ������������y‰������HÕ������������®‰������`Õ������������½‰������xÕ������������Õ‰������Õ������������Õ‰������¨Õ������������Õ‰������ÀÕ������������Õ‰������ØÕ������������Õ‰������ðÕ������������Õ‰������Ö������������Õ‰������ Ö������������Õ‰������8Ö������������Õ‰������PÖ������������Õ‰������hÖ������������Õ‰������€Ö������������Õ‰������˜Ö������������Õ‰������°Ö������������í‰������ÈÖ������������/Š������àÖ������������NŠ������øÖ������������xŠ������×������������€›����� ×������������ ›�����(×������������°€�����0×������������P*�����H×������������àŒ�����P×������������ðŒ�����X×������������‰Š������h×������������‹������x×������������*‹������ˆ×������������0‹������˜×������������ì‰������¨×������������è|������¸×������������@‹������È×������������¸‹������Ø×������������Í‹������è×������������Û‹������ø×������������
Œ������Ø������������]������Ø������������xŒ������(Ø������������†Œ������8Ø������������f„������HØ������������ˆŒ������XØ������������GŒ������pØ������������ >�����ˆØ�������������©�����Ø������������P*�����¨Ø������������@«�����°Ø������������P*�����ÈØ������������àª�����ÐØ������������0«�����ØØ������������p§�����ðØ������������§�����øØ������������€¨������Ù������������0è�����Ù������������Àª����� Ù������������è|������0Ù������������ÖŒ������@Ù������������������PÙ������������9������`Ù������������f������pÙ������������f„������€Ù������������›������˜Ù������������è|������¨Ù������������q‰������¸Ù������������è|������ÈÙ������������Ï������ØÙ������������Ò������èÙ������������7‹������øÙ������������ð>������Ú������������Ø������Ú������������f„������(Ú������������Ù������8Ú������������P*�����PÚ������������P+�����XÚ������������`+�����`Ú������������`+�����hÚ������������P*�����€Ú������������p+�����ˆÚ������������€+�����Ú������������€+�����˜Ú������������ Ž������¨Ú������������ Ž������ÀÚ������������FŽ������ÐÚ������������OŽ������àÚ������������jŽ������ðÚ������������ŽŽ�������Û������������½Ž������Û������������çŽ������(Û������������½Ž������@Û������������������XÛ������������������pÛ������������������ˆÛ������������������ Û������������2������°Û������������‰������ÀÛ������������������ØÛ������������������ðÛ������������ÿ�������Ü������������)������Ü������������w������(Ü������������£������8Ü������������æ������PÜ������������æ������hÜ������������"‘������€Ü������������"‘������˜Ü������������X‘������°Ü������������X‘������ˆÞ������������ÈÜ�����°ð������������à=������¸ð������������¸ð�����Ðð������������P �����àð������������ 4�����ðð������������P �����øð������������ ����� Þ�������������������¨Þ�������������������°Þ�������������������¸Þ�������������������ÀÞ�������������������ÈÞ�������� �����������ÐÞ��������
+�����������ØÞ�������� �����������àÞ�������� �����������èÞ��������
�����������ðÞ�������������������øÞ��������������������ß�������������������ß�������������������ß�������������������ß������������������� ß�������������������(ß�������������������0ß�������������������8ß�������������������@ß�������������������Hß�������������������Pß�������������������Xß�������� �����������`ß�������� �����������hß�������� �����������pß�������� �����������xß�������� �����������€ß��������!�����������ˆß��������"�����������ß��������#�����������˜ß��������$����������� ß��������%�����������¨ß��������&�����������°ß��������'�����������¸ß��������(�����������Àß��������)�����������Èß��������*�����������Ðß��������+�����������Øß��������,�����������àß��������-�����������èß��������.�����������ðß��������/�����������øß��������0������������à��������1�����������à��������2�����������à��������3�����������à��������4����������� à��������5�����������(à��������6�����������0à��������7�����������8à��������8�����������@à��������9�����������Hà��������:�����������Pà��������;�����������Xà��������<�����������`à��������=�����������€à�������������������ˆà�������������������à�������������������˜à������������������� à�������������������¨à�������������������������������������������
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+���€���€���€���€no storage spaceassertion `left {invalid syntax}��������������q€€q€€q€€q€€entity not foundÿþþþþþþþÿþþþþþþþk���������������0123456789abcdef����ñÿ��ñÿ��ñÿ��ñÿ�� at
+
+
) when slicing `.debug_types.dwo������ ���ÿÿÿÿ��€��€ �€â�€.gnu_debugaltlinStripPrefixError invalid filename¿¿���������������������� right` failed: connection reset������������������ÆHýÿ^1ýÿ ýÿâýÿhost unreachablerange end index Ò���Õ��"Ò��1Ò��ÃÑ��˜Ò��˜Ò��¤Ò��³Ò��7Ó��âÛ��âÛ��îÛ��ûÛ�� Ü��=ï�� í��1ï�� í��$÷��O÷��[÷��$÷��f�»�»�»�»�»�»�»�»��‰�»�»�“�»�»�»�»�»�»�»�»�»�»�»�»�»�»�»�»�»�»�»�»��»�»�»�»�¯�>�FE�eE�dB�àE�F�âF�G�‘J�öC�Õ>�žG�H�iH�ˆD�žH�æD�øH�]I�ªK�žI� J�L�XL�"^�Ài�ÿh� i�^i�ùr�
s�¥w�¥w�¥w�¥w�¥w�Os�¥w�¥w�¥w�‰r�Ås�¥w�¥w�¥w�¥w�¥w�¥w�¥w�¥w�¥w�‰r�«t�D„��†�
†� †�
†�‡�
†�
†�
†�
†�
†�
†�
†�
†�6…�6…�|…�|…�D„� ‡�ÿŠ�‹�+Œ�+Œ�+Œ�+Œ�+Œ�+Œ�+Œ�+Œ�+Œ�+Œ�+Œ�+Œ�+Œ�+Œ�>‹� ‹�+Œ�O‹�+Œ�`‹�+Œ�+Œ�+Œ�+Œ�+Œ�+Œ�+Œ�+Œ�+Œ�+Œ�jŠ�q‹�Í‹�+Œ�`Œ�+Œ�+Œ�¢Š�jŠ�¢Š�+Œ�jŠ�¢Š�jŠ�¢Š�qŒ�+Œ�+Œ�jŠ�¢Š�+Œ�+Œ�+Œ�jŠ�¢Š� —�F—�F—�F—�F—�F—�F—�F—�F—�€—�Ž—�F—�F—�œ—�F—�F—�F—�F—�F—�F—�F—�F—�F—�F—�F—�F—�F—�F—�F—�F—�F—�F—�F—�F—�F—�F—�F—�F—�F—�ª—�Σ�á£�á£�á£�á£�á£�á£�á£�á£�ÿ£�¤�á£�á£�
¤�á£�á£�á£�á£�á£�á£�á£�á£�á£�á£�á£�á£�á£�á£�á£�á£�á£�á£�á£�á£�¤�á£�á£�á£�á£�¤�ÌÚ�™Ú�_Ú�‚Ú�uÚ�ÄÚ�ŸÚ�ÊÚ�ðÚ�ûÚ�ŸÚ�kÞ�kÞ�kÞ�kÞ�Û�LÛ�WÛ�ŸÚ�ÒÛ�ìÛ� Ü�<Ü�ÒÛ�7Þ�7Þ�7Þ�7Þ�RÜ�áÜ�ûÜ�ÒÛ�¥Û�ƒÜ�óÛ�Ü�¥Û�Þ�Þ�Þ�Þ�*Ý�µÜ�ÎÜ�¥Û�xÛ�]Ý�ÇÛ�âÛ�xÛ�ÏÝ�ÏÝ�ÏÝ�ÏÝ�ƒÝ�‰Ü�¡Ü�xÛ�ŠÞ�JÞ�JÞ�EÞ�™Þ�ìò� ó�1ó�Ìó�Ðó�Ëô�Üô�íô�þô�õ�õ�,õ�=õ�Nõ�_õ�põ�õ�’õ�£õ�´õ�Åõ�Ñõ�âõ�óõ�ö�ö�&ö�7ö�Hö�Yö�jö�{ö�Œö�ö�®ö�¿ö�Íö�Ûö�éö�÷ö�÷�÷�!÷�/÷�=÷�ƒ��� �ƒ��~�� �Œ���X�^��f�m�Š�q�w�Š�~�…�Y�“�Í�Y�“�Í�u��›�u�¢�¾�M<�`>�`>�`>�`>�`>�`>�ä;�ì;�`>�+<�
+<�G<�G<�`>�`>�`>�7<�`>�ø;�`>�<�wŽ�ÑŽ� �wŽ�íŽ� �µ�£·�…Â�Ä·�…Â�…Â�…Â�´·�,¶�@·�eÂ�a·�eÂ�eÂ�eÂ�Q·�’¾�¦¾�EÂ�Ô¾�EÂ�EÂ�EÂ�½¾�å¾�¿�%Â�^¿�%Â�%Â�%Â�/¿�À�cÀ�Â�»À�Â�Â�Â�ŒÀ�fæ�gè�o �¦è�o �o �o �Šè�ñæ�×ç�¼�è�¼�¼�¼�øç�a!�/ �\!�w!�™!�Õ!�"*�X*�X*�X*�X*�X*�X*�X*�X*�X*�X*�X*�X*�T+�T,�X*�X*�X*�X*�X*�X*�X*�X*�X*�!,�¡*�a+�+�ô)�ô)�ô)�ô)�ô)�ô)�ô)�ô)�ô)�ô)�ô)�ô)�ô)�ô)�ô)�ô)�ô)�ô)�ô)�ô)�ô)�ô)�ô)� ,�¡@�(A�wA�¥A�RA�¯A�B�ÎA�;B�2B�;B�iA�ÔA�§A�íA�äA�íA�þ@�òA�A�!B�B�!B�Œ2�I3�~3�3�~3�~3�~3�l3�!Q�LO�˜R�S�+R�²S�¿S�[S�ÙS�‹R�ÌS�ÊQ�\P� U�lT�»T�1U�ûV�Ji�(W�Ji�Ji�Ji�W�_u�vu�ku�‚u�Žu�_u�_u�_u�vu�ku�_u�_u�_u�_u�_u�_u�_u�_u�_u�_u�_u�_u�_u�_u�_u�_u�_u�_u�_u�_u�_u�vu�ku�ku�ku�ku�ku�ku�‚u�_u�ku�ku�ku�ku�_u�_u�u�Ku�›u�¤u�àu�v�:‘�™�}‘�œ‘�î‘�’�†’�ß’�“�[“�‡“�“�Ö“�;”�f”�¼”�Ø”�vŽ�¤Ž�óŽ�þ”�·Œ��T•�»•�ë�ˆ�É•�KŽ�–�/–�?�“–�¦–�‚�Ø�)—�O—�'�}—�ó—�*˜�«˜�d�ØŒ�;�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜�X˜��›�…‘�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�…‘�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�…‘�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�…‘�£ž�…‘�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�“ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�…‘�£ž�£ž�…‘�£ž�£ž�…‘�£ž�…‘�£ž�…‘�£ž�£ž�…‘�£ž�£ž�£ž�£ž�£ž�£ž�£ž�…‘�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�£ž�…‘�:�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�:�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�:�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�:�8œ�:�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�(œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�:�8œ�8œ�:�8œ�8œ�:�8œ�:�8œ�:�8œ�8œ�:�8œ�8œ�8œ�8œ�8œ�8œ�8œ�:�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�8œ�:�Ú›�´Ÿ�´Ÿ�´Ÿ�´Ÿ�´Ÿ�´Ÿ��´Ÿ�cœ�cœ�cœ�´Ÿ�´Ÿ�6�´Ÿ�
œ�T�´Ÿ�´Ÿ�´Ÿ�v�´Ÿ�Ú›�´Ÿ�´Ÿ�´Ÿ�´Ÿ�´Ÿ�´Ÿ�•�´Ÿ�¿›�´Ÿ�´Ÿ�´Ÿ�´Ÿ�´Ÿ�´Ÿ�´Ÿ�Ú›�´Ÿ�Œœ�´Ÿ�ªœ�¿›�´Ÿ�´Ÿ�´�Ó�´Ÿ�´Ÿ�õ�¿›�ž�
œ�ל�
œ�´Ÿ�´Ÿ�6ž�´Ÿ�Ú›�´Ÿ�Už�tž�´Ÿ�´Ÿ�Ú›�´Ÿ�Ú›�´Ÿ�Ú›�´Ÿ�’ž�Ú›�¿›�¿›�¿›�ªœ�´Ÿ�´Ÿ�´Ÿ�Œœ�´Ÿ�
œ�ל�
œ�´Ÿ�´Ÿ�´Ÿ�´Ÿ�±ž�´Ÿ�´Ÿ�´Ÿ�´Ÿ�´Ÿ�´Ÿ�О�´Ÿ�´Ÿ�´Ÿ�´Ÿ�´Ÿ�´Ÿ�´Ÿ�´Ÿ�´Ÿ�´Ÿ�´Ÿ�¿›�ïž�Eœ�ùœ�´Ÿ�´Ÿ�´Ÿ�´Ÿ�
+Ÿ�´Ÿ�´Ÿ�´Ÿ�´Ÿ�¿›�¿›�´Ÿ�´Ÿ�´Ÿ�¿›�¿›�¿›�¿›�´Ÿ�´Ÿ�´Ÿ�´Ÿ�´Ÿ�%Ÿ�F�^�e�l�Wš�r�Wš�F�Ê �·¡�ü¡�1¢�‹¢�Ö¢�£�x£�Õ£�¤�0¤�›¤�̤�«¡�«¡�«¡�«¡�«¡�«¡�«¡�=¥�«¡�«¡�I¡�«¡�«¡�¡�j¥�ˆ¥�«¡�«¡�«¡�«¡�«¡�ò¥�1¦�l¦�¨¦�i¬�q¬�y¬�a¬�€¬�a¬�³¬�½¬�Ǭ�©¬�Ь�©¬�ù¬�� �ñ¬��ñ¬�6�_�‰��‰�‰�‰�Ê�v¯�œ¯�˯�Ö¯�˯�˯�˯�°�»µ� µ� µ� µ�Ñ´�»´�ß´� µ� µ� µ�É´�É´� µ�ú´� µ�õ�É´�Ñ´�»´�ß´� µ� µ�ú´� µ�µ� µ� µ�»´�ú´�˵�ú´�ß´�µ� µ� µ�ß´�É´�Ñ´�µ�»´�É´�Ñ´�µ�»´� ·�D·�4¹�4¹�4¹�·�¦´�À·�4¹�4¹�\µ�4¹�\µ�4¹�4¹�4¹�4¹�4¹�\µ�‚µ�4¹�¦´�4¹�\µ�\µ�4¹�4¹�4¹�4¹�4¹�4¹�\µ�\µ�¸�°¸�›¶�À¶�Í·�ƒ·�Þ·� ·�"´�<·�”·�”·�Ø´�¿·�Ø´� ¸�”·�Í·�ƒ·�Þ·�Ø´�ñµ�¿·�"´�ï·�Ø´�Ø´�ƒ·�¿·�*¸�¿·�Þ·�ï·�Ø´�Ø´�Þ·�”·�Í·�ý·�ƒ·�”·�Í·�ý·�ƒ·�Ä�¹�Dº�ź�E»�Å»�ö»�q¼�Ö¿�#Á�Æ�7Á�Æ�Æ�Æ�eÁ�-¿�¢À�bÆ�¶À�bÆ�bÆ�bÆ�çÀ�ÎÁ�ßÁ�YÆ�øÁ�YÆ�YÆ�YÆ�&Â�м�»¿�2Å�п�2Å�2Å�2Å�ö¿�uÌ�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�ÜÌ�nÍ�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�ŒË�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�ŒË�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë�(Ë� Î�(Ë�qÎ�™Î�þÎ�Ï� Ï�$Ï�3Í�*Ï�3Í�+Ï�=Ï�OÏ�¨Í�`Ï�¨Í�lÌ�¹Ï�<Õ�ÒÏ�<Õ�<Õ�<Õ�ÿÏ�±Ë�AÏ� Õ�ZÏ� Õ� Õ� Õ�‡Ï�Ù/�00� 0�(0�Hello World!
+library/alloc/src/raw_vec.rscapacity overflowlibrary/alloc/src/ffi/c_str.rsfrom_str_radix_int: must lie in the range `[2, 36]` - found library/core/src/num/mod.rslibrary/core/src/fmt/mod.rs..BorrowMutErroralready borrowed: panicked at library/core/src/panicking.rsassertion failed: idx < CAPACITYlibrary/core/src/slice/memchr.rsindex out of bounds: the len is assertion failed: page_size != 0 but the index is panic in a function that cannot unwindpanic in a destructor during cleanup== right` failed
+ left:
+ right:
+ left: -> chardyn u128Zero <= mut true����for<kind) = i128 as main/���boolshim {
+,
+(
+library/core/src/fmt/num.rs00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899range start index out of range for slice of length slice index starts at but ends at attempted to index slice up to maximum usizesource slice length () does not match destination slice length (attempted to index str up to maximum usize�����������������������������������������������������������������������������library/core/src/str/pattern.rs�[...]begin <= end (`byte index is not a char boundary; it is inside (bytes �������NulErrordeadlock�������thread 'extern ") of ` is out of bounds of `library/core/src/str/mod.rslibrary/core/src/unicode/printable.rs�
+
$jk¯±¼ÏÑÔ Õ Ö×Úàáçèî ðøúû ';>NOžžŸ{‹“–¢²º†± 6=>VóÐÑ67VWª®¯½5à‡‰Žž
)14:EFIJNOde\¶·
+ 69:¨©ØÙ 7‘¨
+;>fi’o_¿îïZbôüÿSTš›./'(U ¡£¤§¨º¼Ä :?EQ¦§ÌÍ "%>?çìïÿÅÆ #%&(38:HJLPSUVXZ\^`cefksx}Š¤ª¯°ÀЮ¯no¾“^"{-f/.€‚ 1 $ +D*€ª$$(4 NC7
+;E9c 0!@8K/
+ @ ' 6: PI73
3.
+&RK+*& N$ D
+H' u B>*;
+Q€‹b H
+€¦^"E
+
:
+6,€¹<dS H
+FEHS
I
+€öF
+ GI7
+9
+6; V2
ƒ›fu €ÄŠLc
„0ª‚G¡¹‚9*\&
+F
+(‚°[eK9@ —ø„Ö* ¢ç3 Œ‰k
’`G t<€ö
+spFz W €‡G…B„P €Õ+>!p-@ :Ð*‚æ€÷)L
+ƒDL=€Â<U4,d V
+€®8
, €šƒØ
w_ 8
+("NT 6 €Ë%
+„�
+
+- .012§©ª«úûýþÿ xy‹¢0WX‹Œ ÝKLûü./?\]_â„Ž‘’©±º»ÅÆÉÊÞäåÿ�)147:;=IJ]„Ž’©±´º»ÆÊÎÏäå�
)14:;EFIJ^de„‘›ÉÎÏ
):;EIW[\^_de‘©´º»ÅÉßäåð
EIde€„²¼¾¿Õ×ðñƒ…‹¤¦¾¿ÅÇÏÚÛH˜½ÍÆÎÏINOWY^_‰Ž±¶·¿ÁÆÇ×[\ö÷þÿ€mqÞß no _}~®¯»¼ FGNOXZ\^~µÅÔÕÜðñõrstu–&./§¯·¿ÇÏ×ßš@—˜0 ÒÔÎÿNOZ['/îïno7=?BE‘SguÈÉÐÑØÙçþÿ� _"‚ß‚D¬€« /4
+PU
+ NW PC- : %_ mj%€È‚°‚ýY j
+Y+F
+, 1 , €¬
+/1M€¤<<8+‚ÿ/-!!€Œ‚— ˆ”/; €¾"t €Ö €ÿ€ß ò7 \€¸€Ë
+;
+8F t ZY €ƒ
+ L€Š«¤ 1¡Ú& €¦õ *L€€¾
library/core/src/unicode/unicode_data.rslibrary/core/src/escape.rs�����ƒ �‘`�] � ` ï, +*0 ,o¦à,¨`- û`.�þ 6žÿ`6ýá6
+!7$
á7«a9/¡90 aHó ¡L@4aPðj¡QOo!R¼¡R�ÏaSeÑ¡S�Ú!T�àáU®âaWìä!YÐè¡Y �îYðZ�p��-H 0e# [ : +<* 7
+ :
+9 9:
+ ; (7 : 9
+ HQ b I7 $ f
�� @ -u"v Û:
+0 10( 8:˜
Æ@�Ã!�` �i�
+ P�—
& .0'C /3*î����â•�(¥��PF 1{6)
+1=$> 4
+_9ÃQëUje� õ
+
+( .
�RzH� 4��;�?Q��.� ”�72�d �=��m�`€ð�/rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/alloc/src/collections/btree/node.rsassertion failed: edge.height == self.height - 1assertion failed: src.len() == dst.len()/rust/deps/gimli-0.28.0/src/read/abbrev.rsdest is out of bounds/rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/core/src/slice/index.rs/rust/deps/miniz_oxide-0.7.1/src/inflate/core.rs�������€���@���À��� ��� ���`���à���������P���Ð���0���°���p���ð������ˆ���H���È���(���¨���h���è������˜���X���Ø���8���¸���x���ø������„���D���Ä���$���¤���d���ä������”���T���Ô���4���´���t���ô��� ���Œ���L���Ì���,���¬���l���ì��� ���œ���\���Ü���<���¼���|���ü������‚���B���Â���"���¢���b���â������’���R���Ò���2���²���r���ò���
+���Š���J���Ê���*���ª���j���ê������š���Z���Ú���:���º���z���ú������†���F���Æ���&���¦���f���æ������–���V���Ö���6���¶���v���ö������Ž���N���Î���.���®���n���î��� ���ž���^���Þ���>���¾���~���þ���������A���Á���!���¡���a���á������‘���Q���Ñ���1���±���q���ñ��� ���‰���I���É���)���©���i���é������™���Y���Ù���9���¹���y���ù������…���E���Å���%���¥���e���å������•���U���Õ���5���µ���u���õ���
������M���Í���-������m���í��� ������]���Ý���=���½���}���ý������ƒ���C���Ã���#���£���c���ã������“���S���Ó���3���³���s���ó��� ���‹���K���Ë���+���«���k���ë������›���[���Û���;���»���{���û������‡���G���Ç���'���§���g���ç������—���W���×���7���·���w���÷���������O���Ï���/���¯���o���ï��� ���Ÿ���_���ß���?���¿������ÿ��€���€€��€@��€À��€ ��€ ��€`��€à��€��€��€P��€Ð��€0��€°��€p��€ð��€��€ˆ��€H��€È��€(��€¨��€h��€è��€��€˜��€X��€Ø��€8��€¸��€x��€ø��€��€„��€D��€Ä��€$��€¤��€d��€ä��€��€”��€T��€Ô��€4��€´��€t��€ô��€ ��€Œ��€L��€Ì��€,��€¬��€l��€ì��€ ��€œ��€\��€Ü��€<��€¼��€|��€ü��€��€‚��€B��€Â��€"��€¢��€b��€â��€��€’��€R��€Ò��€2��€²��€r��€ò��€
+��€Š��€J��€Ê��€*��€ª��€j��€ê��€��€š��€Z��€Ú��€:��€º��€z��€ú��€��€†��€F��€Æ��€&��€¦��€f��€æ��€��€–��€V��€Ö��€6��€¶��€v��€ö��€��€Ž��€N��€Î��€.��€®��€n��€î��€ ��€ž��€^��€Þ��€>��€¾��€~��€þ��€��€��€A��€Á��€!��€¡��€a��€á��€��€‘��€Q��€Ñ��€1��€±��€q��€ñ��€ ��€‰��€I��€É��€)��€©��€i��€é��€��€™��€Y��€Ù��€9��€¹��€y��€ù��€��€…��€E��€Å��€%��€¥��€e��€å��€��€•��€U��€Õ��€5��€µ��€u��€õ��€
��€��€M��€Í��€-��€��€m��€í��€ ��€��€]��€Ý��€=��€½��€}��€ý��€��€ƒ��€C��€Ã��€#��€£��€c��€ã��€��€“��€S��€Ó��€3��€³��€s��€ó��€ ��€‹��€K��€Ë��€+��€«��€k��€ë��€��€›��€[��€Û��€;��€»��€{��€û��€��€‡��€G��€Ç��€'��€§��€g��€ç��€��€—��€W��€×��€7��€·��€w��€÷��€��€��€O��€Ï��€/��€¯��€o��€ï��€ ��€Ÿ��€_��€ß��€?��€¿��€��€ÿ��@���@€��@@��@À��@ ��@ ��@`��@à��@��@��@P��@Ð��@0��@°��@p��@ð��@��@ˆ��@H��@È��@(��@¨��@h��@è��@��@˜��@X��@Ø��@8��@¸��@x��@ø��@��@„��@D��@Ä��@$��@¤��@d��@ä��@��@”��@T��@Ô��@4��@´��@t��@ô��@ ��@Œ��@L��@Ì��@,��@¬��@l��@ì��@ ��@œ��@\��@Ü��@<��@¼��@|��@ü��@��@‚��@B��@Â��@"��@¢��@b��@â��@��@’��@R��@Ò��@2��@²��@r��@ò��@
+��@Š��@J��@Ê��@*��@ª��@j��@ê��@��@š��@Z��@Ú��@:��@º��@z��@ú��@��@†��@F��@Æ��@&��@¦��@f��@æ��@��@–��@V��@Ö��@6��@¶��@v��@ö��@��@Ž��@N��@Î��@.��@®��@n��@î��@ ��@ž��@^��@Þ��@>��@¾��@~��@þ��@��@��@A��@Á��@!��@¡��@a��@á��@��@‘��@Q��@Ñ��@1��@±��@q��@ñ��@ ��@‰��@I��@É��@)��@©��@i��@é��@��@™��@Y��@Ù��@9��@¹��@y��@ù��@��@…��@E��@Å��@%��@¥��@e��@å��@��@•��@U��@Õ��@5��@µ��@u��@õ��@
��@��@M��@Í��@-��@��@m��@í��@ ��@��@]��@Ý��@=��@½��@}��@ý��@��@ƒ��@C��@Ã��@#��@£��@c��@ã��@��@“��@S��@Ó��@3��@³��@s��@ó��@ ��@‹��@K��@Ë��@+��@«��@k��@ë��@��@›��@[��@Û��@;��@»��@{��@û��@��@‡��@G��@Ç��@'��@§��@g��@ç��@��@—��@W��@×��@7��@·��@w��@÷��@��@��@O��@Ï��@/��@¯��@o��@ï��@ ��@Ÿ��@_��@ß��@?��@¿��@��@ÿ��À���À€��À@��ÀÀ��À ��À ��À`��Àà��À��À��ÀP��ÀÐ��À0��À°��Àp��Àð��À��Àˆ��ÀH��ÀÈ��À(��À¨��Àh��Àè��À��À˜��ÀX��ÀØ��À8��À¸��Àx��Àø��À��À„��ÀD��ÀÄ��À$��À¤��Àd��Àä��À��À”��ÀT��ÀÔ��À4��À´��Àt��Àô��À ��ÀŒ��ÀL��ÀÌ��À,��À¬��Àl��Àì��À ��Àœ��À\��ÀÜ��À<��À¼��À|��Àü��À��À‚��ÀB��ÀÂ��À"��À¢��Àb��Àâ��À��À’��ÀR��ÀÒ��À2��À²��Àr��Àò��À
+��ÀŠ��ÀJ��ÀÊ��À*��Àª��Àj��Àê��À��Àš��ÀZ��ÀÚ��À:��Àº��Àz��Àú��À��À†��ÀF��ÀÆ��À&��À¦��Àf��Àæ��À��À–��ÀV��ÀÖ��À6��À¶��Àv��Àö��À��ÀŽ��ÀN��ÀÎ��À.��À®��Àn��Àî��À ��Àž��À^��ÀÞ��À>��À¾��À~��Àþ��À��À��ÀA��ÀÁ��À!��À¡��Àa��Àá��À��À‘��ÀQ��ÀÑ��À1��À±��Àq��Àñ��À ��À‰��ÀI��ÀÉ��À)��À©��Ài��Àé��À��À™��ÀY��ÀÙ��À9��À¹��Ày��Àù��À��À…��ÀE��ÀÅ��À%��À¥��Àe��Àå��À��À•��ÀU��ÀÕ��À5��Àµ��Àu��Àõ��À
��À��ÀM��ÀÍ��À-��À��Àm��Àí��À ��À��À]��ÀÝ��À=��À½��À}��Àý��À��Àƒ��ÀC��ÀÃ��À#��À£��Àc��Àã��À��À“��ÀS��ÀÓ��À3��À³��Às��Àó��À ��À‹��ÀK��ÀË��À+��À«��Àk��Àë��À��À›��À[��ÀÛ��À;��À»��À{��Àû��À��À‡��ÀG��ÀÇ��À'��À§��Àg��Àç��À��À—��ÀW��À×��À7��À·��Àw��À÷��À��À��ÀO��ÀÏ��À/��À¯��Ào��Àï��À ��ÀŸ��À_��Àß��À?��À¿��À��Àÿ/rust/deps/miniz_oxide-0.7.1/src/inflate/output_buffer.rs������� �
+� �
������ �#�+�3�;�C�S�c�s�ƒ�£�Ã�ã���������� �
���!�1�A�a��Á� 0@`�€�€���
+
/rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/core/src/ops/function.rs/rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/core/src/escape.rsErrorEmptyInvalidDigitPosOverflowNegOverflowParseIntError/rust/deps/rustc-demangle-0.1.23/src/legacy.rs::C,(><&*@/rust/deps/rustc-demangle-0.1.23/src/v0.rs`fmt::Error`s should be impossible without a `fmt::Formatter`punycode{-}0internal error: entered unreachable code: str::from_utf8( was expected to have 1 char, but chars were foundstri8i16i32i64isizeu8u16u32u64usizef32f64!_...{recursion limit reached}?'> , []::{closure# const ; + unsafe " fn( = false{ { }0x.llvm./rust/deps/rustc-demangle-0.1.23/src/lib.rs{size limit reached}`fmt::Error` from `SizeLimitedFmtAdapter` was discardedSizeLimitExhausted���������� ������� ������� ��������������zýÿÿýÿÿ‹ýÿÿ–ýÿÿtÝÿÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������called `Option::unwrap()` on a `None` value/rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/core/src/io/borrowed_buf.rs/rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/alloc/src/collections/btree/navigate.rs/rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/core/src/slice/iter.rsIndex out of bounds()/rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/core/src/str/pattern.rsreentrant init/rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/core/src/cell/once.rs��������������attempt to divide by zeroassertion failed: mid <= self.len()/rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/core/src/slice/sort.rsassertion failed: end >= start && end <= lenassertion failed: offset != 0 && offset <= lencalled `Result::unwrap()` on an `Err` value�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������internal error: entered unreachable code/rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/alloc/src/vec/mod.rs/rust/deps/gimli-0.28.0/src/read/line.rs�����attempt to calculate the remainder with a divisor of zero/rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/core/src/num/mod.rs/rust/deps/gimli-0.28.0/src/read/dwarf.rs/rust/deps/gimli-0.28.0/src/read/index.rs.debug_abbrev.debug_addr.debug_aranges.debug_cu_index.debug_info.debug_line.debug_line_str.debug_loc.debug_loclists.debug_ranges.debug_rnglists.debug_str.debug_str_offsets.debug_tu_index.debug_types.debug_abbrev.dwo.debug_info.dwo.debug_line.dwo.debug_loc.dwo.debug_loclists.dwo.debug_rnglists.dwo.debug_str.dwo.debug_str_offsets.dwoInvalid ELF section size or offsetOkErr/rust/deps/addr2line-0.21.0/src/lib.rs/rust/deps/addr2line-0.21.0/src/function.rsfatal runtime error: unwrap failed: CString::new("main") =
+library/std/src/rt.rsfatal runtime error: initialization or cleanup bug
+fatal runtime error: drop of the panic payload panicked
+AccessErroruse of std::thread::current() is not possible after the thread's local data has been destroyedlibrary/std/src/thread/mod.rsfailed to generate unique thread ID: bitspace exhaustedstream did not contain valid UTF-8failed to write the buffered datalibrary/std/src/io/buffered/bufwriter.rs/library/std/src/io/buffered/linewritershim.rspermission deniedconnection refusednetwork unreachableconnection abortednot connectedaddress in useaddress not availablenetwork downbroken pipeentity already existsoperation would blocknot a directoryis a directorydirectory not emptyread-only filesystem or storage mediumfilesystem loop or indirection limit (e.g. symlink loop)stale network file handleinvalid input parameterinvalid datatimed outwrite zeroseek on unseekable filefilesystem quota exceededfile too largeresource busyexecutable file busycross-device link or renametoo many linksargument list too longoperation interruptedunsupportedunexpected end of fileout of memoryother erroruncategorized error (os error )library/std/src/io/stdio.rscannot access a Thread Local Storage value during or after destructionlibrary/std/src/thread/local.rsfailed printing to : stdoutlibrary/std/src/io/mod.rsfailed to write whole bufferformatter errorlibrary/std/src/panic.rslibrary/std/src/path.rs.library/std/src/sync/once.rslock count overflow in reentrant mutexlibrary/std/src/sync/remutex.rsfile name contained an unexpected NUL bytestack backtrace:
+note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.
+__rust_begin_short_backtrace__rust_end_short_backtrace [... omitted frame ...]
+s<unknown>fatal runtime error: assertion failed: thread_info.stack_guard.get().is_none() && thread_info.thread.get().is_none()
+�memory allocation of bytes failed
+fatal runtime error: Rust panics must be rethrown
+fatal runtime error: Rust cannot catch foreign exceptions
+library/std/src/panicking.rsBox<dyn Any><unnamed>' panicked at :
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+
+panicked after panic::always_abort(), aborting.
+thread panicked while processing panic. aborting.
+thread caused non-unwinding panic. aborting.
+fatal runtime error: failed to initiate panic, error library/std/src/../../backtrace/src/symbolize/mod.rs - :fatal runtime error: thread local panicked on drop
+strerror_r failurelibrary/std/src/sys/unix/os.rs/dev/null�
+thread '' has overflowed its stack
+fatal runtime error: stack overflow
+failed to set up alternative stack guard page: library/std/src/sys/unix/stack_overflow.rsfailed to allocate an alternative stack: library/std/src/sys/unix/thread.rsfatal runtime error: assertion failed: signal(libc::SIGPIPE, handler) != libc::SIG_ERR
+too many active read locks on RwLocklibrary/std/src/sys/unix/locks/futex_rwlock.rsassertion failed: is_unlocked(state)Once instance has previously been poisonedinternal error: entered unreachable code: state is never set to invalid valueslibrary/std/src/sys/unix/thread_local_key.rsfatal runtime error: assertion failed: key as usize != KEY_SENTVAL
+library/std/src/../../backtrace/src/symbolize/gimli/stash.rslibrary/std/src/../../backtrace/src/symbolize/gimli.rslibrary/std/src/../../backtrace/src/symbolize/gimli/elf.rs/usr/lib/debug/.build-id/insufficient perms������������������ÿ›ðá�»��» ÑïüãÉ ‚Õž��ó =ð
ù¦
Ì��ò é¼ ±ãï© ”ÕÑþ ô¨Å"Ñ•ð³ïÕÑ° Û É¢Ñ¸Ä"ð軾Ñ툒¥¯¾Ü‚ëŠ ¶É
æÖ~��Ôçì„ ô�����}���������ÿ›94�Ú��Úã�‰Í�Ž€��Ž Ò�œ
«�Úáð®õ@��������ÿÿ"�Ë��Ë
¹�‘
´�žƒ��¡¹�²*����ÿÿ,�½��½®�Ì5��®�˜°�¨9��á°�ó]��ÿ› /9������ÿÿH›*�£"��³&*�Ì&¿)�å&¸)�ù&¿)�–'.½)�É'ò(�Ú'.÷(�Š(Ô(�Í(Ø(�Ò(ä��ÿ›�e��ev�y™1�������ÿ› ������ÿÿ?�L��ÿ› [<VgÆ¡¿�}��������ÿ› âã å…
+��������ÿ›;R�’ §��������ÿ›O�$8��\ka��������ÿÿ4`�;L��ÿÿ�»��»é�À7��ÿÿ (�
8��ÿ› ع·£ÊÒ¹�������ÿÿ}±�„•�“9��ÿ›! ”0¿�Äg��«Á�Ä ÙÏ��������ÿ›!z[u¥„ßý�}�����������ÿÿ�ô��ô
+Ò
+�þó�����ÿÿ�r��r…�ƒ ����ÿ›¨ �Ð��ÐĬ�Õÿ��ÔÓª�6µª�Å”��Ù
+©©�á
+õ ��Ö('µª�‘)-Óª�¾)ô'��²Q
©�¿QB��Rì©�‰R¬ ��µ[:ô¥�ï[Ö
��Åi®«�Úiƒ��Ýj5®«�Ék
ˆª�ªl®«�él–«�ÿpù��øuÙî«�óyÅ©�ÏzÞî«�}— ��ĉƒª�¸Š‘¬�˜Œ0†«�ÈŒŒ��Ô’µª�ë’:��¥“µª�ç“Ï¥�¼”'µª�¡•cÏ¥�„–;��¿–¯¥�Ó–h��»—X¯¥�“˜ ��³™D¯¥�¬š±¥�ÀšJ��Š›£±¥�%��ÒM±¥�¾ž’¥�Ð b��²¡X¥�Š¢0��º¢+¥�£Ž«�Ù£$��ý£Ž«�—¤œª�¬¤ü¥�½¤ì¥�Фϥ�פ‘¥�è¤'¥�”¥
¦¥¦
ا°¦Ö§î§õ§©
¢©´©¾©Ó©
å©ï©ü©Ÿª
®ªØ«
ç«Õ¬Âå¬d����������ÿ›ys�æ��æ-Ë$ü¨%½ Í$Ñ KÇ$Õ
+Žá$ÿ Å$º
$Í
˜��åÇ$í‘��þÃ
É$ò ˜$‚ °��²#¨%É#¯$î#Ç$€$–$´$¾$�������ÿÿ T�ˆ�����ÿÿ�ü��üž�2��ÿÿÏþ
+�ë
�ø ³����ÿÿ � �� Ôœ�ÛCž�¶œ�Åy�����ÿÿp$õ�”„�Ûl½�ýb›�ß…��ä aì�Å
+2��÷
+"ì�ƒ ½�à �õ Š�µ
�Á%Â�¦>„�äÂ��¦�À½�Ö›�êï��ÿÿR�¯��¯œ’ �Ë)��ôÖ �ÆÄÿ �Š5��¿’ �„ î �¾
+’ �È ¬��ô
+&’ �œ 1ÿ �Ï ’ �Ô ^����ÿ›ÈÃ/öÐ�¼ ù†�µÙ��Ž‘}�“¿��Ò
þ~�Ø}�Ïù~�×Ù ��°&ã�'
å}�ò*Ý}�‡+ë��ò,”|�¦/¬ Ãz�µ=
¡z�Ï>
Ãz�œAÁz�¿B
Èz�ÌB¢��îC¥z�þC¿��½I
Ÿz�ºL
z�øM‚}�»Ní|�ÅQ‰~�ÍQü ��É^
–|�€_¬~�²`
Á{�£b¡}�¶b;��ñbÔ|�câ��ãd›{�¶e
õz�°fÒž|�Ïh
å}�Ïiºž|�çtræ€�®v2¦€�åvKæ€�µw¦€�Òw3æ€�ŠxŽ~�¯x¦€�Ìxí}�àx1¦€�–yØ}�°y„}�Êy‚}�äyÌ|�þy £z�¨z
ºzãz
߀øz
”{…{ ‚ž{
º{ã{ ‚º|
É×|
æ|¤}
Ñ}´}
‚ð}
‚~‘~
¥~µ~ò~ª
ÉõŸ€½€
߀¤
‚±v�������ÿÿµÂL€Z�‹
žX�‚€Z�º
¾X�Ç£��ê¶X�Š ÓX�’ Þ ��ð'
°Y�á(
ØX�î(Š��ø;”ÆX�ÜBÎX�äB™ ��ýK
ŠX�³M
ðW�ÀMæ��¦S/ÉZ�¬T5…Z�æTÉZ�ƒU…Z�·UÉZ�åUN…Z�¸V1ÉZ�éV ��ˆW¶X�¢W®X�¼WÆX�ÖW¦X�îW™����ÿ›-)�Ü��ܵ¹ �ž
+· �‘ Ó �Ÿ » �ê ü ò �������ÿ›#i�(K��s…{�������ÿ› P�%E��jyo��������ÿÿ
+J=Ç�‡]����ÿ›id�Ë��ËŒC�œ ŽC�‡C�†¦��¬ŒC�±Ý ��Ž&
·B�ï&…C�¶+öA�î,øA�ó3ÕA�ø:íA�¡A²B�»AïA�§CÃC¬C ��������ÿ› f�;a�}¢‚3����������ÿÿ3�Ÿ��Ÿ
„�¬n��š
ì�§‰��°„�·ì�¾Ô�ÒR���ÿÿr�¨��¨½=�á ¸=�Ø
¡=�« Ç>�ä">�ì"Õ ��Á."ˆ>�û. ã=�¢/ >�1*Ÿ>�à1
Š>�Ë2
á=�Ð7
Â=�±:Ç>�—;º®>�ë<ƒ>�…=
”=�’=õ����ÿÿ"�…��…¯�¥
+—�µ•�Õ
+†�ßp����ÿÿ�ƒ��ƒ·�› ��ÿ›A:œ Õ�¡ ·�̵�á°��‘"õ�³¤��×ÚìE��± Ó¼%����������ÿ›)"š#¿�½Ä��ñ9��É êÔ$����������ÿÿ ý
+‰�‡¢��ÿÿ
�Q��Q µ�\t�����ÿ›|� ²��Òëá��������ÿÿ3� ,��ÿ›0g�u¤…&����������ÿ›ZŽ�_Š��éð������ÿÿ3� ,��ÿ›4i�x¥ˆ$����������ÿ›)%ˆ�V¬�[J��¥‚ȉï‚÷�������ÿ› P�%5��Zlb��������ÿ›V€�•Ã¤&��������ÿÿ�×��×û�èù�÷&����ÿÿ �]��]�k2��ÿ› .������ÿÿ&�Í��ÍPÊ�?��ÜÊ�ê!��‹=Ê�È����ÿÿ �#��#:�( ��ÿÿ�×��×î�Ü ��ÿ›! ÿ
†�Œó��ÿ†�¦ ¼²�������ÿÿ ›
Ó�ð ï���ºÙØ�“����ÿÿ�½��½ †�Û>��ÿÿ�Ÿ��Ÿzû�™ô�����ÿÿ;g�CF��ÿ›d¦�z9��³Â¸��������ÿ›7†dœ�������ÿ›7†dœ�������ÿ› ‹
ž�˜‰��¡ ´ª���������ÿÿ���ž�œ'��ÿ›ib�æ��æÍ �üž��šR˜ �ªý�À ��Þ%˜ �ƒb��åG˜ �Šä�º˜ �Á„��Ř �Š ‘ ¸ Æ Ú é ß ����������ÿÿ)¯�žÁ�:��ÿÿ$V�5A��;D ��g�� l��` ��$l��°@��/z��ˆB��è}��x ��ø}�� ��8~��° ��È~��� ��Ø~�� ��h€��h ��(��˜ ��è��È ��h‚��ð ��¨‚��
��Ȃ��
��ˆƒ��P
��„��hC��x†��x
��8‡��ÀC��ˆ‰��¨
��¨‰��À
��è‰��Ø
��hŠ��ð
��èŠ����ø‹��(��(����“��È��x“����ø“��0��—��˜��h—��°��è˜��È��™��à��™��ø��(™����8›��`��H��€��È��˜��è��°��Hž��È��Ÿ��è��( �����(¢��0��˜¤��€��ø¤��Ð��¥��è��˜¥�����(¦����8§��8��¨§��P��(©��D��h©�� ��x©��¸��Ø©��Ð��8ª��è��ت����èª�� ��8¬��h��h��¨��˜��À��¨��Ø��h®����د��8��è¯��P��(´��h��Hµ��À��ȵ��ø��·����¸��@��8¹��€��º��˜��»��À��H»��Ø��È»��ð��¼����Á��X��ÈÂ��€��hÃ�� ��Ä��À��ØÅ��ð��Ç��0D��HÜ����Ý��H��XÝ��`��èÿ��°��H����8�(��X �h��(
�ˆD��Ø
�ÀD��ø
�ØD��h�€��x�Ð��ˆ�è��(�8��X�P��x�°���è��è����ø �0��$� ��X$�¸��H)� ��Ø)�X��è*�ˆ��Ø1�Ø��È2�0 ��˜4�x ��86�° ��È6�Ø ��X8� ��è:�€ ��˜=�� ��(>�8 ��È>�p ��HA�À ��F�ø ��ÈF�( ��ØF�@ ��øF�X ��ØG�p ��xH�° ��èK� ��˜P�h ��¨R�È ��8T��!��èT�!��ˆU�P!��hX� !��XZ�ð!��¨\�0"��¨a� "��Èa�¸"��ˆm�#��xz�X#��˜z�p#��Øz�ˆ#��Ø{�¨#��è{�E��¸|�XE��¨‚�À#��˜ƒ�¨E��H„�àE��È„�F��X…�ð#��h…�$��x…�XF��x†� $��8‡�8$��H‡�P$��8ˆ�¨F��ˆˆ�€$��¨ˆ�˜$��؈�°$��èˆ�È$��øˆ�à$��è‰�%��ø‰� %��Š�8%��Š�P%��(Š�h%��hŠ�èF��(�0G��ø�ˆ%��HŽ� %��XŽ�¸%��¨Ž�Ð%��ˆ�pG��è�ð%��H‘� &��˜‘�8&��¸’�ÀG��È“�h&��¸”�&��X•�Ð&��ˆ•�è&��H–�'��h–�0'��¨–�H'��È–��H��Hœ�`'��hœ�x'��˜œ�ˆH��8�˜'��X�°'�� ��(��ø¡�h(��¨¤�¸(��¨�)��è¨�8)��Ȫ�€)��(¬�˜)���È)��È�ø)��X®�(*��(¯�X*��h¯�¸H��8�I��è�hI��ˆ�˜I��H�àI��ø �x*��h"�0J��(%�€J��ˆ0�È*��Ø1�+��(5�X+��ø7�¨+��Ø9�à+��È:�ðJ��A�HK��8‚��,��ø‚�P,��ȃ�x,��8‡� K��Hµ�M��X»�èM��è»�(N��h¼�hN��X½�È,��(¾�ø,��˜Á�P-��ˆÌ�ÀN��Xî�Ð-��¨ï�O��hð�(.��ˆð�XO��¸ô�°O��H�@.��ø�.��È�¸.��˜�è.��ø�/��Ø�(/��¸�X/��ˆ�ˆ/��ø�P��È �Ø/��8 �(0��˜ �x0��è �0��( �¨0��ˆ �`P��È#�°P��80�Q��82�È0��x5�1��˜I�h1��ØM�`Q��Q� 1��h\�¸1��8]�è1��˜]��2��ø]�2��X^�02��Ø_�H2��¸`�`2��Xb�°Q��(c�x2��øc�Ð2��d�è2��èd�3��Èe�83��èk�€3��ˆz�Ð3��h{��4��|�P4��Œ�È4��(�ø4���85��H”�˜5��È•�À5��¨–�ð5��˜�@6��¸š�x6��x›�˜6��Hœ�ðQ��H�È6��Ø�0R��(ž�7��8Ÿ�`R��èŸ�ÈR��ø �(7��È¡�0S��¢�`S��È¢�X7��¨®�ÈS��¸¯�T��8°�XT��±�Ð7��ȱ��8��ø±�8��(³�`8��¨³� 8��ˆ´�°T��¨Á�Ð8��ØÃ�ð8��¸Å�9��HÊ�X9��(Ë�x9��¨Ë��U��HÌ�9��¸Í�à9��ˆÎ�:��øÎ�`:��ÈÏ�:��øÏ�°:��xÑ�Ø:��Ò�ð:��¨Ò�;��8Ó�8;��¸Ó�x;��˜Ô�PU��ØÔ�°;��(Ö�ø;��èÖ� <��XÞ�p<��Hß� <��hß�¸<��Xà�=��¸à�pU��ã�(=��˜ã�ÀU��èã�ðU��èä�`=��øä�x=��xå� V��Èç�=��Øç�`V��xë�¨=��ˆë�¸V��¨ì�W��8ï�À=��Xö�>��ˆ÷�@>��ú�>��8ú�€W��Èú�ÀW��˜û�èW��Hü��X��øü�¨>��þ�Ø>��¨þ�X��èÿ�ð>��8��?��H��PX���pX��� ?��(�¨X���ØX��˜�8?��¸�P?���?��H �Ð?��X �è?��x ��@��È �0@��Ø �H@��ø �`@��
+�x@�������������zR�x ����� ���·`������AC����4���hr������������� ���L���`r��6����I_JC���L���l���€r��…����BBB A(A0ƒŒŽ^(A BBBA0J(A BBB���������¼���Àr������A����L���Ô���¸r��ƒ���ABB B(B0A8A@ƒŒŽ†B8A0B(B BBAA@����,���$��øs��µ����BADPƒŽžABAP�����,���T��ˆt��µ����BADPƒŽžABAP�����$���„��u��{����BAA ƒŽsAB���¬��pu��@����D@�������Ä��˜u������A����,���Ü�� u��µ����BADPƒŽžABAP�����$��� ��0v��‡����BAA ƒŽAB,���4��øx��µ����BADPƒŽžABAP��������d��Ø{����������������|��à{��6����D0�������”��|��s����Dp�������¬��p|��s����Dp���� ���Ä��Ø|�����D0�������d���ä��È}��$���ABB B(B0A8D`ƒŒŽ†°8A0B(B BBAB`O8A0B(B BBA�����4���L��€��î���SBB A(ƒŒŽ BBB���L���„��H„��\����BBB A(A0ƒŒŽ}(A BBBB0F(A BBB����������Ô��X„��s����Dp����d���ì��À„�����ABB B(B0A8DPƒŒŽ†Q8A0B(B BBABP¢8A0B(B BBA���������T��x‡��D����DP�������l��°‡��r���Gà������„��‰����������������œ�� ‰����������������´��‰�������������L���Ì��‰��
���ABB B(B0A8D€ƒŒŽ†ô8A0B(B BBA������ ��� ��Њ��
+���GïA�����<��ÀŒ��s����Dp�������T��(����������������l��0��Z����DP���� ���„��x��Î����D ³A ��������¤��(Ž������������,���¼�� ��ó���ABA ƒŽ†ëBA�����L���ì��ð��n���ABB B(B0A8D`ƒŒŽ†U8A0B(B BBA�������L���<��“��_����BBB A(A0ƒŒŽq(A BBBA0U(A BBB����������Œ�� “����������������¤��“��„����D€������¼��“������D0Š ���Ô��”�����D0����������ô��ø”��d����D`����L��� ��P•��r���ABB B(B0A8D ƒŒŽ†Y8A0B(B BBA���������\��À–������A�������t��¸–��U����DP�������Œ���—��X����DP���� ���¤��H—�� ����G…A������Ä��È—������A����D���Ü��À—��F���BBB B(A0D ƒŒŽ^0A(B BBBA ����<���$��Ș��0���BBB A(DƒŒŽY(A BBBA�������d��¸™��%��������������|��Й�������������,���”��È™��¹����BBA D@ƒŽª ABB,���Ä��Xš��b���AAD0ƒ†YAA����������ô��˜›������A������� ��›��7���Gà���T���$ ��¸Ÿ�����ABB B(A0D@ƒŒŽ†f0A(B BBAA@¾0A(B BBAB@4���| ��€ ��u����BADPƒŽWABAPKAB���� ���´ ��È ��;���A÷A�����$���Ô ��è¡������AHAoA…���<���ü ��À¢��%���BBB A(A0ƒŒŽÓ(A BBBA0��������<
+��°£��Ñ����\´$���T
+��x¤��â����BAƒŽÜB���������|
+��@¥��@����D@�������”
+��h¥��w����Dp�������¬
+��Ð¥��@����D@����L���Ä
+��ø¥�����ABB B(B0A8DPƒŒŽ†ž8A0B(B BBAAP����$��� ��¸ª��°���NAƒ†—AÃÆ��� ���< ��@¬��ž����GƒA��� ���\ ��À¬��ž����GƒA���,���| ��@��Å���AAD`ƒ†bAAA`����$���¬ ��à®��+���AD@ƒ$A�������,���Ô ��(Å��Ç����BADPƒŽ°ABAP�������� ��ÈÅ��;����b����L��� ��ðÅ��Š"���ABB B(B0A8G€ƒŒŽ†, 8A0B(B BBAA€��L���l ��0è��R���ABB B(B0A8GðƒŒŽ†Þ8A0B(B BBAAð��$���¼ ��@í��í���AkASEwF<���ä ��ï�����BBB A(D`ƒŒŽ©(A BBBA`�������$
��èò��Ê����������L���<
��àõ�����ABB B(B0A8DPƒŒŽ†é8A0B(B BBA����������Œ
�� ÷�������������L���¤
��˜÷��’���ABB B(B0A8D€ƒŒŽ†y8A0B(B BBA���������ô
��èø��,�����������\��� ���ù�� ���ABB B(A0DƒŒŽ†ž0A(B BBAE0A(B BBAA��4���l��Àÿ��—���AAD@ƒ†ÇAAE@¹AAA@���¤��(�Ê�����������,���¼��à����AƒrABALA�����l���ì��À����ABB B(B0A8G°ƒŒŽ†M8A0B(B BBAB°.8A0B(B BBAA°����������\��` �I�����������d���t��˜ �å���ABB B(B0A8DPƒŒŽ†�8A0B(B BBAEP)8A0B(B BBAAP��4���Ü�� �‰����BBB A(A0ƒŒŽy(A BBB,�����x����AƒLEME–AG���L���D��X�ä���ABB A(D@ƒŽ†½(A BBAE@H(A BBAA@��T���”��ø�ç����ABB B(A0D@ƒŒŽ†d0A(B BBAA@S0A(B BBAE@D���ì���Í���ABB B(A0D@ƒŒŽ†0A(B BBAA@����4���4���—���AAD@ƒ†ÇAAE@¹AAA@$���l��€�‹����AkALA�������<���”��è����BBB A(G°ƒŒŽz(A BBBA°���d���Ô��8�Š���ABB B(B0A8DpƒŒŽ†=8A0B(B BBAApU8A0B(B BBABp����|���<��` �¯���ABB B(B0A8DpƒŒŽ†B8A0B(B BBABpG8A0B(B BBAEpH8A0B(B BBAAp���4���¼�� �Ž����BBB A(A0ƒŒŽ~(A BBB4���ô��è �˜����BBB A(A0ƒŒŽˆ(A BBBL���,��P �€���ABB B(B0A8D€ƒŒŽ†8A0B(B BBAA€��4���|��€"�Ï���ABA G°ƒŽ†ä ABAA°��,���´��'�¦����AAD0ƒ†€AAA0��������ä��˜'���������������ü��'�����������������˜'�Õ�����������<���,��`(�ž����BBB B(A0DPƒŒŽ‡0A(B BBBd���l��À(�d���ABB B(B0A8DƒŒŽ†k8A0B(B BBAA8A0B(B BBAB�L���Ô��È+�§���ABB B(B0A8D€ƒŒŽ†Ž8A0B(B BBA������\���$��(0����ABB B(A0ƒŒŽ†(B BBAE0D(B BBAE0Ö(B BBA4���„��Ø1�‹���AAD@ƒ†ÉAAE@«AAA@���¼��03�¥�����������4���Ô��È3�“����BBB A(A0ƒŒŽƒ(A BBBL��� ��04�Ó���ABB B(A0ƒŒŽ†þ(B BBAE0¹(B BBA��L���\��À6�ì���ABB B(B0A8D€ƒŒŽ†Ï8A0B(B BBAA€��<���¬��`8�P���ABB A(DPƒŽ†f(A BBAAP�����l���ì��p:�ù���ABB B(B0A8GàƒŒŽ†g8A0B(B BBAEàM8A0B(B BBAAà����������\���?������������L���t��?�· ���ABB B(B0A8G€ƒŒŽ†‘
+8A0B(B BBAA€��L���Ä��xJ�â ���ABB B(B0A8D°ƒŒŽ†U 8A0B(B BBAA°�������W���������������,�� W�3����������� ���D��HW�÷����A’Ab����d��(X������������,���|��à^�ä����AAD`ƒ†zAAA`��������¬��`a� ����A�������Ä��Xa���������������Ü��Pb�¼����Aº���ô��øb������������,��� ��ðb�ã����AƒsA˜ACA����������<���d���������������T��d�,����D �������l�� d�
+��������������„��d������������$���œ��d�ï����GUEºA�������Ä��Ød� ��������������Ü��Ðd� ��������������ô��Èd� �������������� ��Àd� ����������� ���$��¸d�6����AƒmFA����D��hh�J����AH���\�� h�����A�������t��˜h�B����D@���� ���Œ��Ðh�Ô����AƒÁA���,���¬��ðj�Q����BAA ƒŽuABA ���������Ü�� k�B����D@����,���ô��Xk����BAA ƒŽûABA �����$���$��Xm�å����BAD@ƒŽÚAB<���L�� n�ž����BBB B(A0DPƒŒŽ‡0A(B BBB���Œ��€n�'�����������,���¤��˜n�À����GREJEA��������Ô��(o���������������ì��0o�@����D@������� ��Xo��������������� ��àt������������ ���4 ��èt�'����AKA���������T ��˜u������������L���l �� u�·���ABB B(B0A8GЃŒŽ†a8A0B(B BBAAÐ��d���¼ ��x�Ó���ABB B(B0A8D ƒŒŽ†8A0B(B BBAE š8A0B(B BBA����L���$ ��ˆy�¡���ABB B(B0A8G ƒŒŽ†…8A0B(B BBA������L���t ��è{�j���ABB B(B0A8DPƒŒŽ†b8A0B(B BBAAP����,���Ä ���Ê����BAA ƒŽµABA �����D���ô ��¨�Ù���BBB B(A0G°ƒŒŽš0A(B BBBA°�����< ��@�[���H��,���T ��ˆ‚�×����BAA ƒŽµABA �����,���„ ��8ƒ�µ����BADPƒŽžABAP�����,���´ ��ȃ�„����BBA ƒŽpBBA ���,���ä ��(„�Ä����BBA ƒŽBBA ���� ��� ��È„�:����ARA������L���4 ��xö�i���NBB B(B0A8ƒŒŽ†E0B(B BBAÃÌÍÎÏÆ�������<���„ ��¸�A���BBB A(GÀƒŒŽ$(A BBBAÀ��L���Ä ��È�L���ABB B(B0A8GЃŒŽ†ý8A0B(B BBAAÐ��L��� ��È �Ä���ABB B(B0A8GÀƒŒŽ†¤8A0B(B BBAAÀ��4���d ��H �à���BBA G°ƒŽÎ ABB������ ���œ ��ð
�ë����V€Ï�������L���¼ ��0V�¸����BBB B(A0ƒŒŽ—(B BBBF0A(B BBB����$��� !�� V�Ð����AD@ƒ½AA@�����L���4!��HW�k���ABB B(B0A8G ƒŒŽ†18A0B(B BBAA ��,���„!��ˆ�Ä����BADPƒŽABAP�����T���´!��(‘�o���ABB B(B0A8G¸ O¸@OðVƒŒŽ†þ8A0B(B BBAAðV���|��� "��@”�é
+���JBB B(B0A8GàƒŒŽ†FÃÆÌÍÎÏHàƒ†ŒŽ«8A0B(B BBAÃÌÍÎÏÆAàƒ†ŒŽ������T���Œ"��€À�E���BBB B(A0DƒŒŽ0A(B BBBFD0A(B BBB���ä"��8Â� �����������L���ü"���æ�¤����BBB B(A0ƒŒŽ€(B BBBA0D(B BBB����$���L#��`æ�Ã����NƒŸÃDƒQÃ����,���t#��ç�Ä����BADPƒŽABAP����� ���¤#��¨ç�W����AƒNFA ���Ä#��èç�Þ����D ¿A �����,���ä#��¨è�Ó����BADPƒŽ¼ABAP�����,���$��Xé�Ä����BADPƒŽABAP�����L���D$��øé�m����BBB B(A0ƒŒŽL(B BBBF0A(B BBB����L���”$��èì�m����BBB B(A0ƒŒŽL(B BBBF0A(B BBB����L���ä$��í�X����BBB A(A0ƒŒŽw(A BBBF0D(A BBB����������4%��í�L��������������L%��Pí�1���������� ���d%��xï�\����AƒSFAL���„%��h�8���ABB B(B0A8D ƒŒŽ†)8A0B(B BBAA ��L���Ô%��X� ���ABB B(B0A8GÀƒŒŽ†8A0B(B BBAAÀ��4���$&��(�>���BAA ƒŽúABA tAB������\&��` �\ ����������,���t&��¨*�Ä����BADPƒŽABAP��������¤&��H+�V��������������¼&��+�V��������������Ô&��Ø+�Y��������������ì&�� ,�r�������������'��ˆ-�Ô�������������� '��P.�›����������T���4'��¨0�Á����ABB B(B0A8G¸ O¸@OÀVƒŒŽ†‡8A0B(B BBA����������Œ'�� 1������������,���¤'��(1�Å����BADPƒŽ®ABAP����� ���Ô'��È1�Ü����D ½A �����D���ô'��ˆ2����ABB B(B0A8ƒŒŽ†t0B(B BBAA8��L���<(��`8� ���ABB B(B0A8D ƒŒŽ† 8A0B(B BBAA ��,���Œ(��°F�Ó����BADPƒŽ¼ABAP�����L���¼(��`G�”����BBB B(A0ƒŒŽs(B BBBF0A(B BBB����t��� )��°G����ABB B(B0A8GàƒŒŽ†²èGðIàå èGðGøG€IàÃ8A0B(B BBAAà������,���„)��HW�
���BAA ƒŽëABA �����<���´)��(X�Ù���ABB A(A0ƒŽ†Ë(A BBA�������\���ô)��ÈZ�9���ABB B(B0A8G€ƒŒŽ†
+8A0B(B BBAA€ˆAI€����$���T*��¨^�v���AƒˆAAA©,���|*���`�Ò����BADPƒŽ»ABAP�����L���¬*��°`�X���ABB B(B0A8GÀƒŒŽ†<8A0B(B BBA������4���ü*��Àa�¢���ABB A(ƒŽ† BBAA(�� ���4+��8d�¾����A¢A�����,���T+��Ød�Í����BADPƒŽ¶ABAP�����<���„+��xf�‚����BBB A(GÀƒŒŽl(A BBB������� ���Ä+��g����D ãA �����,���ä+��Èi�Í����BADPƒŽ¶ABAP�����t���,��hk�Ñ ���FBB B(B0A8ƒŒŽ†lÃÆÌÍÎÏD8ƒ†ŒŽ•0B(B BBAÃÌÍÎÏÆA8ƒ†ŒŽ�������,���Œ,��0y�µ����BADPƒŽžABAP��������¼,��Ày�(����Af�D���Ô,��Øy�/���BBA GÀƒŽy ABBFÀÙ ABB�������<��� -��Àz�z����BBB A(DPƒŒŽB(A BBBAP�����,���\-���{�Ó����BADPƒŽ¼ABAP����� ���Œ-��Ј�%���D ÕA ���� ���¬-��àŠ�Õ���D ¦A ����D���Ì-�� Œ�‹���BBB B(A0DPƒŒŽ<0A(B BBBAP���� ���.��è�Ü����D ½A ��������4.��¨‘�v�����������L���L.��°’�o���ABB B(B0A8A@ƒŒŽ†N8A0B(B BBAA@����,���œ.��Г�Ç����BADPƒŽ°ABAP�����L���Ì.��p”�m����BBB B(A0ƒŒŽL(B BBBF0A(B BBB����,��� /��”�Ç����BADPƒŽ°ABAP����� ���L/��0•�(����Aƒ_FA�$���l/��@•�x���PAƒ†[AÃÆ������”/��˜–� ��������������¬/�� —�Œ�����������,���Ä/��˜—�ˆ����BBA DpƒŽy ABB<���ô/��ø—�v����BBB A(A0ƒŒŽ_(A BBBA0�����4���40��8˜�Ò����BBA G ƒŽ· ABBA ���D���l0�� ™�C���ABB B(A0D`ƒŒŽ†õ0A(B BBAA`�����$���´0��(š�·����Aƒ”FAA�����L���Ü0��Àš�f���ABB B(B0A8G ƒŒŽ†#8A0B(B BBAA ��,���,1��à¡�á����AAG°ƒ†ÂAAA°������\1�� ¢������������L���t1��¨¢�í����ABB B(B0A8A@ƒŒŽ†Ã8A0B(B BBAA@����� ���Ä1��H£�S����AxFAA4���ä1��è¥�w����BBB A(A0ƒŒŽg(A BBB��� 2��€§���������������42��x§�r����DP�������L2��0ª�����A�������d2��È������������L���|2��p±����ABB B(B0A8G€ƒŒŽ†z8A0B(B BBAA€��,���Ì2��@¸�$���HƒIÃOƒPÃPƒcÃ�L���ü2��@¹����ABB B(B0A8D`ƒŒŽ†<8A0B(B BBAA`�������L3��€»������������,���d3��H¾����BAD€ƒŽ
+AB���������”3��8¿�ƒ����Dp~���¬3��ðÀ�C����D �������Ä3��(Á�����A�������Ü3��àÆ���������������ô3��XÈ������������<��� 4��`È�\����BBB A(A0ƒŒŽx(A BBBA0������<���L4��€È�$���ABB A(A0ƒŽ†(A BBAA0�������Œ4��pÉ���������������¤4��hÉ������������,���¼4��pÉ�I����BAA ƒŽpABA ���������ì4��É� ��������������5��ˆÉ��������������� 5��É�
����A�������45��ˆÉ�����A���� �������zPLR�x›í� ��Ô��$���l+�� ��«¯ÿÿABB B(B0A8GƒŒŽ†c˜Ao˜Ac˜AU˜Ac˜AU˜AB˜Aj˜Ac˜Ac˜AU˜AB˜B|˜Ai˜AQ˜Ag˜AL˜AO˜AB˜B_˜A^˜A|˜Aç˜A¤8A0B(B BBAAB˜AP˜BB˜Bs˜A~˜BB˜Ba˜BB˜Bj˜Aƒ˜AL˜Bw˜AÞ˜AB˜AB˜Av˜A^˜Aö˜AA˜B;˜A½˜AB˜Aú˜Ar˜A�Ü���ü��Ÿ7��µ��Ë®ÿÿABB B(B0A8GЃŒŽ†eØAÐBØBÐBØAÐBØBйØAÐTØAÐGØAÐIØAÐŽØAÐBØAÐW8A0B(B BBAAÐ[ØAÐ}ØAÐmØAÐQØAÐTØAÐOØAÐBØAÐ��T���Ü��¨@��\��+®ÿÿABB B(B0A8DƒŒŽ†º8A0B(B BBAA������T���4��pC��P��ûÿÿABB B(B0A8D ƒŒŽ†8A0B(B BBAA ���������Œ��e��@���ÓÿÿD0T���¤��Ђ��6��ËÿÿABB B(B0A8GƒŒŽ†|8A0B(B BBAA������4���ü��˜È��°���¿ÿÿBBA ƒŽVBBF ����������4��É�����£ÿÿA<���L��É��f���›ÿÿBBB A(A0ƒŒŽj(A BBBF0��<���Œ��È6�Í���gÿÿBADPƒŽFABFPbABAP�����L���Ì��X7�ê��KÿÿABB B(B0A8DpƒŒŽ†¼8A0B(B BBAAp4��� ��è=�®���ÿÿBBA D0ƒŽM ABBA0�$���T��`>�r���÷¬ÿÿAD ƒHAA �L���|��¸>�‡���ë¬ÿÿBBB A(A0ƒŒŽX(A BBBA0k(A BBBF0L���Ì��?�÷���§¬ÿÿABB B(B0A8A@ƒŒŽ†¿8A0B(B BBAA@�<��� ��ˆA�E���k¬ÿÿBBA ƒŽSBBF ABBA ����D���\��xC�À��7¬ÿÿBBB A(DƒŒŽ\(A BBBA������<���¤��ðE�Ì���¬ÿÿBBB A(A0ƒŒŽm(A BBBA0�L���ä��H�`��ã«ÿÿABB B(B0A8A@ƒŒŽ†8A0B(B BBAA@<���4��ðJ� ��»«ÿÿBADPƒŽeABFPAABAP����„���t��ÀN�q��£«ÿÿABB B(B0A8GƒŒŽ†l8A0B(B BBAEY8A0B(B BBAB“8A0B(B BBAA����,���ü��T� ���3«ÿÿBADPƒŽ~ABAP��T���,��¨f�ÉV��«ÿÿABB B(B0A8G€ƒŒŽ†ðH8A0B(B BBAA€������T���„�� ½�¯��ï¬ÿÿABB B(B0A8GðƒŒŽ†8A0B(B BBAAð������,���Ü��xÏ�›���ÿÿBAA ƒŽHABE �D��� ��èÏ�³��÷¬ÿÿABB A(GðƒŽ†Š(A BBAAð������L���T ��`Ñ�«��ìÿÿABB B(B0A8D°ƒŒŽ†Z8A0B(B BBAA°L���¤ ��0Ø�¾��‹¬ÿÿABB B(B0A8D`ƒŒŽ†m8A0B(B BBAA`l���ô �� Ú�Y ��_¬ÿÿABB B(B0A8G
+ƒŒŽ†)8A0B(B BBAA
+æ8A0B(B BBAF
+���T���d
+��Ðï�2��c¬ÿÿABB B(B0A8G ƒŒŽ†B8A0B(B BBAA ������T���¼
+��¸õ�'A��c¬ÿÿABB B(B0A8GàƒŒŽ†�8A0B(B BBAAà������ì�� ��;�.��ÛÿÿABB B(B0A8G°ƒŒŽ†1.�G.�S.�g.�G.�‘.�¶.�¿.�{.�·.�p.�ˆ.�û.�K.�M.�P.�M.�m.�].�Ö.�R.�m.�\.�l.�M.�‚.�Ð.�Ù.�Q.�~.�X.�W.�E.�U.�W.�@.�.�P.�e.�¡8A0B(B BBAA°
.�‰.�D.�P.�[.�P.�@.�Z.X¸GÀI°ƒ. r¸AÀBÈGÐI°z.�M.�Z.�V.�e.�.�g.�i.�L.�X.�X.�ƒ.�º.�ù.�L.�{.�X.�f.�s.�].�Y.�b.�[.�.�….�J.�Q.�k.�J.�T.�\.�].�t.�n.�].�\.�Z.�_.�W.�Z.�Z.�Z.�Z.�].�Z.�N.�C.�M.�u.�M.�E.�V.�I.�Z.�a.�N.�c.�k.�I.�B.�O.���T���
��°g���§¬ÿÿABB B(B0A8GðƒŒŽ†f8A0B(B BBAAð������<���\
��hm�Œ���ƒ¬ÿÿBAA ƒŽTABF DABA �����<���œ
��¸m�€���_¬ÿÿBAA ƒŽ|ABE DABA ������T���Ü
��øm�ä���;¬ÿÿBBB B(A0ƒŒŽ¦(B BBBF0A(B BBBA0�����T���4��À}�Ê!��ó«ÿÿABB B(B0A8G ƒŒŽ†8A0B(B BBAA ������<���Œ��ˆ �µ��� ¬ÿÿBBA ƒŽLBBF ABBA ���T���Ì��(¡�$��ë«ÿÿABB B(B0A8GЃŒŽ†8A0B(B BBAAÐ������T���$���¥�‡ ��Ë«ÿÿABB B(B0A8GÀƒŒŽ†U8A0B(B BBAAÀ������T���|��èÉ�Ï��ë«ÿÿABB B(B0A8DƒŒŽ†Î8A0B(B BBAA������L���Ô�� Ð�;��»«ÿÿABB B(B0A8A@ƒŒŽ†ß8A0B(B BBAA@T���$��Ó�a ��«ÿÿABB B(B0A8GàƒŒŽ†ñ 8A0B(B BBAAà������T���|��(ß�ø��o«ÿÿABB B(B0A8GЃŒŽ†~8A0B(B BBAAÐ�������L���Ô��pü�)��G«ÿÿABB B(B0A8DpƒŒŽ†š8A0B(B BBAAp<���$�� �Ð���«ÿÿBBB A(A0ƒŒŽ(A BBBA0�<���d��PJ�ò���ÛªÿÿBAA ƒŽ^ABA NABE �����,���¤�� K�L���»ªÿÿBAA ƒŽgABE ��d���Ô��ÐL�«���—ªÿÿABB B(B0A8A@ƒŒŽ†}8A0B(B BBAF@D8A0B(B BBAA@��d���<��M���KªÿÿABB B(B0A8A@ƒŒŽ†d8A0B(B BBAF@D8A0B(B BBAA@�,���¤��N�L���ÿ©ÿÿBAA ƒŽgABE ��d���Ô��°N�¬���Û©ÿÿABB B(B0A8A@ƒŒŽ†8A0B(B BBAF@D8A0B(B BBAA@��L���<��ØZ���©ÿÿABB B(B0A8A@ƒŒŽ†n8A0B(B BBAE@�<���Œ��˜[�s���o©ÿÿBAA ƒŽ|ABE DABA ������T���Ì��Ø[�Ê���K©ÿÿBBB B(A0ƒŒŽ_(B BBBF0A(B BBBA0�����L���$��Ð_�
��©ÿÿABB B(B0A8GÀƒŒŽ†m8A0B(B BBAAÀL���t�� v����Û¨ÿÿBBB A(DPƒŒŽ{(A BBBFPd(A BBBAP ���Ä��@�5���›¨ÿÿD0iA0��L���ä��@‹�X��‹¨ÿÿABB B(B0A8A@ƒŒŽ†ç8A0B(B BBAA@,���4��Ð�H���g¨ÿÿBAA ƒŽrABA ��,���d��ð�ü���G¨ÿÿBAA ƒŽæABA �<���”��P�C��+¨ÿÿBBA G ƒŽ* ABBA ������T���Ô��p‘�’��¨ÿÿABB B(B0A8GðƒŒŽ†¼8A0B(B BBAAð������L���,��È”���ߧÿÿBBB B(A0GÀƒŒŽì0A(B BBBAÀ�������t���|��˜•���£§ÿÿBBB B(A0G°ƒŒŽÎ.�u.�L.�^.R¸AÀI°U0A(B BBBA°.�w.�k.�e.�D.��������<���ô��°¢�‰���C§ÿÿABB A(DPƒŽ†V(A BBAAP�$���4���£�É���§ÿÿADpƒŸAAp����\��¨£�£���§ÿÿDP���t��@¤�£��� §ÿÿDP4���Œ��ˆ¦�;��§ÿÿABA DpƒŽ†Þ ABAAp� ���Ä��ð§�Ã���û¦ÿÿAD0ƒ���4���ä�� ¨�ð��ï¦ÿÿABB B(B0A8GÀƒŒŽ†�,��� ��x�ç���'§ÿÿBADPƒŽ“ABAP�$���L��8®�v��� §ÿÿAD0ƒOAA0���������UH‰åAWAVAUATSHƒìI‰þH‹ HcÃL<ÇIƒÇHgæ�Hƒ8�uL‰8IƒÆ…Û~*I‹H…Àt"H
÷å� €����H‰HƒÀ¶Pÿ€ú/tð„ÒuïHƒ=¬Ó��t
+H‰÷è
+¡�ë{L‰}ÐH‰]ÈL‹-™Ó�L;-šÓ�sVL‹%‘Ó�ë €����IƒÅM9ås=¸���¢‰×‰Î1À¢»����¹����ƒør 1ɸ���¢Aƒ}%uÉM‹}�‰ÚAÿUI‰ëºè¥ �H‹]ÈL‹}ЉßL‰öL‰úè ���‰ßL‰öL‰úèÓ��‰ÇèŒ �f. „�����fUH‰åAWAVAUATSPHƒ=âÒ��…å���I‰ÖI‰÷A‰üH=ä���è/ �L-¨þÿÿH
¡þÿÿL)éHAH…ÉH‰ÊHHÐHÁút;H…ÉHIÁHÁøHƒø»���HCØë
+IƒÅHƒÃÿtI‹E�HƒørìD‰çL‰þL‰òÿÐëßè–Ÿ�L-K°�H
L°�L)éHAH…ÉH‰ÊHHÐHÁútFH…ÉHIÁHÁøHƒø»���HCØëf. „�����IƒÅHƒÃÿtI‹E�HƒørìD‰çL‰þL‰òÿÐëßHƒÄ[A\A]A^A_]ÃUH‰åAVSL5ÂýÿÿH»ýÿÿL)ðHXH…ÀH‰ÁHHËHÁùu [A^]é÷ž�H…ÀHIØHÁûëf. „����� @�H…Ût×I‹DÞøHƒÃÿHƒørìÿÐëèÌÌÌÌÌÌÌÌUH‰åSPHƒ=‚Ñ��t H‹=‘ã�èôž�H 5¯�f. „����� �H‹HHHƒùrÿÐHƒÃëëHƒÄ[]à @�UH‰åHƒ=<Ñ��tHƒ=ú®��t
H=ñ®�]é«ž�]ÃPÿ×XÃUAWAVAUATSHìØ���Hl$PHƒe��foÁ0ÿÿóEH‹ õÐ�H‰ïj^1ÒÿÓƒøÿ…´���ÿäÐ�‹�ƒøtàƒø tƒøt ƒø#…:��j^1ÿ1ÀÿÅÐ�ƒøÿu(ÿ²Ð�ƒ8 u H=*€ÿÿj^1Ò1Àÿ©Ð�ƒøÿ„���j_‰þ1Àÿ‹Ð�ƒøÿu(ÿxÐ�ƒ8 u H=ðÿÿj^1Ò1ÀÿoÐ�ƒøÿ„Æ��j_j^1ÀÿPÐ�ƒøÿuyÿ=Ð�ƒ8 tQëlöD$V t H=¬ÿÿj^1Ò1Àÿ+Ð�ƒøÿ„‚��öD$^ t H=ˆÿÿj^1Ò1ÀÿÐ�ƒøÿ„^��öD$f t H=dÿÿj^1Ò1ÀÿãÏ�ƒøÿ„:��j
_jA\L‰æÿÒÏ�HL$H‰Œ$˜���HƒøÿH‰¬$ ���„ß��fïÀH\$0fCfj _1öH‰Úÿ›Ï�Hƒ;�H ˆ �u!Ht$0ÇFA���H‰ j _1ÒÿtÏ�Æ=â�j
+_L|$01öL‰úÿZÏ�Iƒ?�u!Ht$0ÇFA���H‰ j
+_1Òÿ:Ï�Æâ�Šýá�„À„³���fïÀHœ$€���fHƒc�E1ö1ÿH‰Þÿ
+Ï�öC„‰���j/_ÿÿÎ�H°�ˆ��jZjÿAX1ÿ¹��E1ÉÿéÎ�Hƒøÿ„Ý��I‰Åj/_ÿËÎ�L‰ïH‰Æ1ÒÿÍÎ�…À…��j/_ÿ¬Î�IÅHœ$€���L‰+HÇC�ˆ��ƒc�H‰ß1öÿÎ�L‹3ëE1öL‰50á�j/_ÿoÎ�H‰0á�L‹5)á�M…ö„Ñ��I‰ÄH|$ Hƒ'�ÿ^Î�‰D$0…À…Î��ÿTÎ�Ll$ H‰ÇL‰îÿKÎ�‰Å…ÀtH|$ ÿBÎ�‰D$0…À…²��ëcH´$€���Hƒ&�HT$0Hƒ"�H|$ ÿ Î�‰D$…À…¹��H‹œ$€���H|$ ÿõÍ�‰D$0…À…e��H‰Ø1ÒI÷öI)ÖH…ÒLDòIÞMôL‰l$H5IHÿÿH\$0jZH‰ßè ��L‹l$0M…í…;��H‹|$8H‹t$@è �I‰ÇH‰D$ ès!�H…À„«��L‰¼$€���Hƒ8�…ç��Hƒx�…Ü��…íufInÄfInÎflÈHÇ����óHL‰xH=» ��è¦ûÿÿ1ÀH‰D$‹ ß�ƒøuH‹D$HÄØ���[A\A]A^A_]Ãj]L5 .ÿÿL%ñÞ�jA]jA_H‹ þÌ�‹ÜÞ�ƒø‡��‰ÀIc†Lðÿà1Àð±-¾Þ�uàë;‰èjYð±
Þ�uÏ‹¥Þ�ƒøu¾L‰çD‰îL‰ú1ÉE1ÀÿÓ…Àyªÿ2Ì�ƒ8tÖ답Þ�jA]jA^ƒø„Û���‹žÞ�ƒø„Ì���L5Š-ÿÿjA_jA\‹€Þ�ƒø‡§��‰ÁIc ŽLñÿáð±-dÞ�uâë?‰èjYð±
SÞ�uÑ‹KÞ�ƒøuÀH=?Þ�D‰þL‰â1ÉE1ÀÿÓ…Ày¨ÿ˜Ë�ƒ8tÒë›fïÀóÝÝ�HÇâÝ����óâÝ�ÆëÝ��Hƒ%ëÝ��D‰è‡êÝ�ƒø…=��H=ÚÝ�j^ºÿÿÿé ��jA^èŒ �H‰ÁH…À„@��H‹yÝ�H9Èu%‹¢Ý�ÿÀu6H=\vÿÿHÃ�j&^èä4��éB��1ÀðD±5tÝ�…Ò���H‰
7Ý�D‰ð‰bÝ�HÇD$P���fïÀóD$XÆD$h�Hƒ=Ý��…ì��Hƒ
Ý�ÿ€=!Ý��uH=�Ý�èË �H…ÀtH‰Çèþ�Hƒ=îÜ��t
H‹=ÝÜ�ÿçÊ�óoD$PóoL$`ó
ÓÜ�ó»Ü�Hÿ¬Ü�ÿ
ÒÜ�u0HÇ‘Ü�����1À‡¹Ü�ƒøuH=Ü�j^jZ1ÉE1Àÿ„Ê�H‹ õÜ�H…ÛtHH|$PHƒ'�A¾�ˆ��L‰wÇG���1öÿÊ�L‹=Ê�j/]‰ïAÿ×H)ÉïAÿ×IÆH‰ßL‰öÿ@Ê�D‡-
Ü�Aƒý…êüÿÿH=üÛ�j^ºÿÿÿ1ÉE1ÀÿÊ�éËüÿÿÿÊ� H¹Æ�H‰D$PH¥gÿÿH‰„$˜���ë H¬Æ�H‰D$PH‹¼$ ���HÇG���H‹„$˜���H‰GfïÀóGH5³½�è†��ét��H"Â�H”$¨���H‰HÇB���HD$H‰BfïÀóBH|$0H‰Hƒg�H5á»�è¼$��H‹|$8„À„Õ��H…ÿH]¿�HEÇH‰Çè9�éÍ��HÅ�H”$¨���H‰HÇB���HD$H‰BfïÀóBH|$0H‰Hƒg�H5t»�èO$��H‹L$8„À„[��H…ÉH=ð¾�HEùéW��H=QBÿÿHÅ�j ^è "��é‡��H´$¨���Hƒ&�HáÄ�éM��H´$¨���Hƒ&�H±Ä�é5��HD$H‰H‰D$ HX¼�H”$¨���H‰HŽ�HÇB���Hƒb �H‰D$(HD$ H‰BHÇB���H¼$€���HD$H‰Hƒg�H5Ÿº�èz#��H‹¼$ˆ���„À„™��H…ÿH¾�HEÇH‰Çèô�éˆ��ðIÿu
+H‹|$ è?�H=¡qÿÿH
¸�L½�jF^HT$èý.��é‹��HÄ�H|$PH‰HÇG���HD$H‰GfïÀóGH5¿�jA^è_��éM��H…ÿ„
+��èl�é���H´$¨���Hƒ&�HdÃ�L|$L‰ÿè'�é��ÿÄÆ�‹�HÁà HƒÈHL$H‰HD$ H‰H
Ã�H¼$¨���H‰L‰gHƒg �H
� �H‰HH‰GL‰gH5åÂ�èÈ��é¶���ÿeÆ�‹�HÁà HƒÈHL$H‰HD$ H‰H
|Â�H¼$¨���H‰L‰gHƒg �H
¡ �H‰HH‰GL‰gH5^Â�èi��ëZH…ÉtH‰Ïèz
�1ÿèƒ�ë
+H…ÿtèg
�èò
� H="pÿÿH
·�L›»�jF^HT$è~-��ëD‰óH=R»�èM&�� D‰óI‰ÆHƒ=Ø��t
H‹=Ø�ÿÆ�óoD$PóoL$`ó
ú×�óâ×�HÿÓ×�ë-I‰ÆH|$Pèœ�H…ÀtH‰ÇèÏ �Hƒ|$X�t H‹|$Pÿ¼Å�ÿ
Ê×�…‚��HÇ…×�����1À‡×�ƒø…f��H=×�j^jZ1ÉE1ÀÿtÅ�éI��Hƒ|$X�„£���H‹|$Pÿ`Å�é“���I‰ÄH‹|$èN �éy��I‰ÄH‹|$è< �ég��ëmI‰ÄëOI‰ÄH‹¼$ˆ���H…ÿ„��è �é��ëHI‰ÄH‹|$8H…ÿ„/��èú �é%��ë+I‰ÄH‹|$8H…ÿtèá �ðIÿ…��H„$€���H‰D$ëèÓ1�� I‰ÄðIÿ…ä���H‹D$H‹8è�éÒ���H‰Çèj
+�I‰ÇH‰ÓH‰ÇÿjeXH‰D$Hƒ{�„4÷ÿÿL‰ÿÿsÄ�é&÷ÿÿI‰ÄHƒ{�t L‰ÿÿ[Ä�L‰çè#
+�H‰T$H…À„ýöÿÿèÐ� é™���é”���D‰óI‰Æ‡ Ö�ƒûukH=øÕ�j^ºÿÿÿ1ÉE1ÀÿÄ�ëOI‰ÄH‹|$0H…ÿt
+Hƒ|$8�uë M…ítH‹|$8Æ�Hƒ|$@�t ÿÕÃ�ëI‰ÄL‰çè˜ �H…À„döÿÿëëI‰ÆL‰÷è€ �H…À„jöÿÿè"� è;/�� UAWAVAUATSHì˜���HÑ �H‰D$8HÇD$@���H$aÿÿH‰D$HWÀD$PH›mÿÿH‰D$(HÇD$0���‹\Õ�ƒø„��‹MÕ�ƒø„ô���L%M$ÿÿj[jA]j]jA_L‹5Ã�‹"Õ�ƒø‡Ð��‰ÁIc ŒLáÿáð± Õ�uâë=‰ØðD±-÷Ô�uÓ‹ïÔ�ƒøuÂH=ãÔ�‰îL‰ú1ÉE1ÀAÿÖ…Àyªÿ<Â�ƒ8tÒëŠÔ�¿���ÿ´Â�H…À„��WÀiÔ�H‰rÔ�HÇoÔ����Hƒ%oÔ��ÆpÔ��Hƒ%pÔ��jX‡oÔ�ƒøuH=cÔ�j^ºÿÿÿ1ÉE1Àÿ0Â�è�H…À„,��H‰ÃH‹�Ô�H9Øu"‹-)Ô�ÿÅu2H=ãlÿÿH›¹�j&^èk+�� j]1Àð±-üÓ�…¤���H‰ ¿Ó�‰-íÓ�H²Ó�H‰ãH‰H|$hH‰ Hƒg�H5˜´�HT$8è ��H‹|$p„ÀtH…ÿL5³·�LE÷ë
H…ÿtè‹�E1öH‹<$ÿO4u&HÇ����1À‡G0ƒøuHƒÇ0j^jZ1ÉE1ÀÿQÁ�M…öuxHĘ���[A\A]A^A_]ÃH=KÓ�èÆ1�éKÿÿÿHú½�H|$hH‰HÇG���H‰àH‰GWÀGH5…¸�èà �� H=ÀjÿÿH
±�L9¶�jF^H‰âè (�� HD$ L‰0HL$(H‰ $H
ä��H‰L$H‰D$H¶�H|$hH‰jXH‰GHƒg �H
˜�H‰L$H‰_H‰GH5 ¶�è_ ��ë
j_¾���èP�� H‰ÃjX‡zÒ�ƒøuhH=nÒ�j^ºÿÿÿëLH‰Ãë#H‰ÃH‹|$ è:�ëCëKH‰ÃH‹|$pH…ÿtè$�H‹<$ÿO4u&HÇ����1À‡G0ƒøuHƒÇ0j^jZ1ÉE1Àÿí¿�H‰ßèýŒ� èö,�� ÌÌÌÌé7îÿÿÌÌÌÌÌÌÌÌÌÌÌH‰úH9þv!PHÇ$����H‰ç¾���ÿÑ¿�…ÀuH‹$YÃH‰×ÿ%¶¿�1ÀYÃÌÌÌÌÌÌÌÌÌÌAWAVATSPI‰ÎH‰ûH9Êv[I‰÷HÇ$����H‰ç¾���L‰òÿ¿�‰Á1À…Éu+L‹$$M…ät"M9÷MB÷L‰çH‰ÞL‰òÿb¿�H‰ßÿ1¿�L‰àHƒÄ[A\A^A_ÃH‰ßL‰öHƒÄ[A\A^A_ÿ%;¿�ÌÌÌÌÌÌÌÌÌÌÌPè:‹� ÌÌÌÌÌÌÌÌUAWAVAUATSPH‰ÓI‰÷I‰þH…Ò„›���A¶ƒø/tƒø\u_E1íH…Û™Àˆ5��AˆÅ¶„Ð�H‰ßL‰îèÑþÿÿH…À„ ��I‰ÄH‰ÇL‰þH‰Úÿ®¾�Iƒ~�t I‹>ÿv¾�M‰&I‰^I‰^é¿���Hƒûr(A€À|!Hƒûv A€À}ëuA·G=:\��„sÿÿÿI‹>M‹fM…ät
+€?\u
+@µ\ë/E1äëT@µ/Iƒür!€À|Iƒüv€À}ë
u ·G=:\��tÌA:l<ÿt#M;fuL‰÷L‰æè;��I‹>M‹fBˆ,'IÿÄM‰fI‹FL)àH9Ør%LçL‰þH‰ÚÿÖ½�IÜM‰fHƒÄ[A\A]A^A_]ÃL‰÷L‰æH‰Úè*���I‹>M‹fëÄè �� L‰ïH‰ÞèO�� ÌÌÌÌÌÌÌÌÌÌÌÌÌAVSHƒì8HÖ‚ƒ���H‰ûH‹GH �H9ñHGñHƒþ A¾���LCöL‰öH÷ÖHÁî?H…ÀtH‹ H‰L$HÇD$���H‰D$ë HÇD$����H|$ HL$L‰òè��Hƒ|$ �H‹|$(tH¸������€H9ÇtH…ÿuèh�� H‰;L‰sHƒÄ8[A^ÃH‹t$0è�� ÌÌÌÌÌÌÌÌÌÌÌAVSHƒì8HÿÆ„ƒ���H‰ûH‹GH �H9ñHGñHƒþ A¾���LCöL‰öH÷ÖHÁî?H…ÀtH‹ H‰L$HÇD$���H‰D$ë HÇD$����H|$ HL$L‰òèN���Hƒ|$ �H‹|$(tH¸������€H9ÇtH…ÿuè¨��� H‰;L‰sHƒÄ8[A^ÃH‹t$0èÍ��� ÌÌÌÌÌÌÌÌÌÌÌAVSPH‰ÓI‰þH…öt/Hƒy�t7H‹qH…öt.H‹9º���H‰Ùè!üÿÿH…Àu2IÇF���ëIÇF����¸���ë ¶dÍ�¾���H‰ßè¯ûÿÿH…ÀtÎI‰F1ÀI‰^I‰HƒÄ[A^ÃÌÌÌÌÌHƒì8Hµ˜�H‰D$HÇD$���HøXÿÿH‰D$WÀD$ H5œ˜�H|$è�� PH‰øH‰÷H‰Æèüÿÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌAVSHƒì8HÖ‚ƒ���H‰ûH‹GH �H9ñHGñHƒþ A¾���LCöL‰öH÷ÖHÁî?H…ÀtH‹ H‰L$HÇD$���H‰D$ë HÇD$����H|$ HL$L‰òèN���Hƒ|$ �H‹|$(tH¸������€H9ÇtH…ÿuèÿÿÿ H‰;L‰sHƒÄ8[A^ÃH‹t$0è-ÿÿÿ ÌÌÌÌÌÌÌÌÌÌÌAVSPH‰ÓI‰þH…ötOHƒy�t H‹qH…ötH‹9º���H‰ÙèúÿÿH…Àu>ë H…Ût2¶ÖË�¾���H‰ßè!úÿÿH…Àu IÇF���ëIÇF����¸���ë ¸���I‰F1ÀI‰^I‰HƒÄ[A^ÃÌÌÌÌÌÌÌÌÌUAWAVAUATSHƒìXI‰ÔIÿÄ”À„Ñ��ˆD$™ÀˆÞ��I‰ÖI‰õH‰û¶è¶KË�L‰çH‰îè˜ùÿÿH…À„¾��I‰ÇH‰ÇL‰îL‰òÿu¹�Iƒþs1M…öt@1À1Òfffff. „�����A€|��t@HÿÂI9ÖuðL‰òH…Àu ë81ÿL‰îL‰òèY5��H…Àu ë$1Ò1ÀH…ÀtL‰cL‰sH‰Séù���¸���H…ÀuåL‰|$L‰d$L‰t$ M9ôu`€|$�t HÇD$0����ëL‰|$(HÇD$0���L‰d$8H|$@HL$(¾���L‰âèNþÿÿHƒ|$@�H‹|$H„ ���H¸������€H9Ç…Ö���M9ôu H|$L‰öè��L‹t$ L‹|$L‹d$CÆ7�IÿÆM9ôv/M…öt/º���L‰ÿL‰æL‰ñè”øÿÿH…Àu%¿���L‰öèòüÿÿé���L‰øëL‰ÿÿÿ·�¸���H‰CL‰sE1ÿL‰;HƒÄX[A\A]A^A_]ÃH‰|$L‰d$I‰ÿM9ô„bÿÿÿéyÿÿÿH=sUÿÿH<•�¾+���èú�� èCüÿÿ H‰ïL‰æèvüÿÿ H…ÿuè*üÿÿë
+H‹t$Pè^üÿÿ H‰ÃëH‰ÃHƒ|$�tL‹|$L‰ÿÿ^·�H‰ßèf„� ÌÌÌÌAVSHƒì8HÿÆ„ƒ���H‰ûH‹GH �H9ñHGñHƒþ A¾���LCöL‰öH÷ÖHÁî?H…ÀtH‹ H‰L$HÇD$���H‰D$ë HÇD$����H|$ HL$L‰òèžüÿÿHƒ|$ �H‹|$(tH¸������€H9ÇtH…ÿuèXûÿÿ H‰;L‰sHƒÄ8[A^ÃH‹t$0è}ûÿÿ ÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHƒìhH‰ÕH‰ûH‰t$(H‰T$0H|$8Ht$(è³9��L‹l$8M…ítJL‹d$@Hƒ|$P�tGH…íH‰\$ tQ™ÀˆÐ��¶Ø¶È�H‰ïH‰ÞèTöÿÿI‰ÆH…Àu1H‰ßH‰îèñúÿÿ L-ÀSÿÿE1äL‰kL‰cHÇ����éy��A¾���L‰t$H‰l$HÇD$����I9ìv H|$1öL‰âèÄúÿÿL‹|$L‹t$H‹l$ëE1ÿK<>L‰îL‰âÿȵ�MçL‰|$L)ýHƒýw H|$º���L‰þè}úÿÿL‹t$L‹|$CÆD>½fCÇ>ï¿IƒÇL‰|$D$(D$XLl$Xë"fff. „�����CÆD>½fCÇ>ï¿IƒÇL‰|$H|$8L‰îèm8��H‹\$8H…Û„���H‹l$@L‹d$PH‹D$L)øH9èsH|$L‰þH‰êèèùÿÿL‹t$L‹|$K<>H‰ÞH‰êÿö´�IïL‰|$M…ät—H‹D$L)øHƒø‡oÿÿÿº���H|$L‰þèùÿÿL‹t$L‹|$éNÿÿÿH‹D$H‹L$ H‰AD$HƒÄh[A\A]A^A_]Ãèùÿÿ ë�H‰ÃHƒ|$�t H‹|$ÿJ´�H‰ßèR� H‹ffff. „�����ëþÌÌÌÌÌÌÌÌÌÌÌÌÌÌHƒì(HÍQÿÿH‰$H"’�H‰D$H‰|$H‰t$fÇD$ �H‰çè v� ÌÌÌÌÌÌÌÌÌÌHƒìhH‰|$H‰t$HD$H‰D$Há���H‰D$ HL$H‰L$(H‰D$0HF“�H‰D$8HÇD$@���HÇD$X����HD$H‰D$HHÇD$P���H|$8H‰ÖèOÿÿÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌHƒìhH‰|$H‰t$HD$H‰D$Ha���H‰D$ HL$H‰L$(H‰D$0HŽ‘�H‰D$8HÇD$@���HÇD$X����HD$H‰D$HHÇD$P���H|$8H‰ÖèÏþÿÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌHƒì(H‹¸'���H=k-ÿÿHù'��‚¥���A¹'���I¸KY†8ÖÅm4H‰ÈI÷àHÁê iÂ'��A‰ÊA)ÂEiÚ{��AÁëAkÃdA)ÂE·ÒIAüF· _fF‰\ ýF·WfF‰T ÿI‰ÁHùÿàõH‰Ñw«Hƒúcv)·ÊÁéiÉ{��ÁéDkÁdD)·ҷWf‰TÿHƒÀþH‰ÊHƒú
+s€Â0ˆHÿÈëH‰ÊHƒúcw½ëä· Wf‰LÿHƒÀþLIÿÀA¹'���I)ÁH¤OÿÿH‰÷¾���1Éè
���HƒÄ(ÃÌÌÌÌÌÌÌÌUAWAVAUATSHƒì(L‰ÍM‰ÇI‰ÌI‰Õ…öt?‹G4‰Áƒáº���¾+���Dò‰t$ Hé¨t2L‰æM…ä„.��Iƒü…œ���1ö1Òé��HM‹G4ÇD$ -���¨uÎE1íHƒ?�„��L‰|$ L‹I)Ïv,¨…7��H‰l$¶o8HiÿÿHc ¨HÁÿáL‰ýE1ÿé’��H‹_ L‹w(H‰ßL‰ö‹T$ L‰éM‰àèL��A´„ÀH‹t$ ….��I‹FH‰ßéÇ���L‰âHƒâþfïÀ1öfo
;ÿÿfosÿÿ �E·D5�fAnØfdÙf`ÛòpÛÔfpÛÔfÛÚfÔÃHƒÆH9òuÒfpÈîfÔÈfH~ÎL9ât'ffffff. „�����E1ÀA€|�ÀAÀLÆHÿÂI9ÔuèHñHƒ?�…øþÿÿH‹_ L‹w(H‰ßL‰ö‹T$ L‰éM‰àè~��A´„À…e��I‹FH‰ßL‰þH‰êHƒÄ([A\A]A^A_]ÿà‹G0‰D$ÇG00���¶G8ˆD$ ÆG8L‹w H‰|$H‹_(L‰÷H‰Þ‹T$ L‰éM‰àè��A´„À…��IÿÇfff. „�����IÿÏ„´���L‰÷¾0���ÿS „ÀtèéÕ���L‰ýHÑíIÿÇIÑïL‹w H‹_(‹G0‰D$HÿÅ D��L‰÷HÿÍt‹t$ÿS „ÀtíA´é—���H‰Þ‹T$ L‰éM‰àè“��A´„À…z���L‰÷H‹t$ H‹T$ÿS„ÀufM‰ýI÷ÝIÇÄÿÿÿÿ €����K,Hƒøÿt>L‰÷‹t$ÿS IÿÄ„Àtåë.L‰÷H‹t$ H‰êÿS„Àu#H‹D$‹L$‰H0¶L$ ˆH8E1äë
+M‰üM9üA’ÄD‰àHƒÄ([A\A]A^A_]ÃÌÌÌÌÌÌÌÌÌÌÌÌLOIƒáøL‰ÈH)øH)ƉðƒàL‰ÉH)ùu1Òé’���Hƒùs1ÒE1Àën·WfnÂfo
ÎÿÿfdÁf`ÀòpÀÔfpÀÔfoôÿÿfÛ·fnÚfdÙf`ÛòpËÔfpÉÔfÛÊfÔÈfpÁîfÔÁfH~ÂA¸���t f „�����E1ÒB€<ÀAÂLÒIÿÀL9ÁuéH…À„���H‰÷Hƒçø1ÉA€<9ÀÁƒøt{E1ÀA€|9ÀAÀLÁƒøtfE1ÀA€|9ÀAÀLÁƒøtQE1ÀA€|9ÀAÀLÁƒøt<E1ÀA€|9ÀAÀLÁƒøt'E1ÀA€|9ÀAÀLÁƒøt1ÀA€|9ÀÀHÁë1ÉAWAVATSHÑHÁîI»ÿÿÿÿÿÿÿH¿ÿ�ÿ�ÿ�ÿ�Hº����fvÀfo
7 ÿÿë8 D��1ÉO ÐL)ÖD‰ÓƒãI‰ÎI!þHÁéH!ùLñH¯ÊHÁé0HÁH…Û…��H‰ÈH…ö„��M‰ÈHþÀ���AºÀ���LBÖIƒúr§E‰ÑAÁéO4M!Þ„ð���IÿÆM‰÷IƒçþL‰ûHÁãfïÛL‰ÁM‰ü „�����óoóoi foâflåfoôfïðfsÖfsÔfëæfÛáfÔãóoYóoq0fmÕfoëflîfmÞfoòfïðfsÖfsÒfëÖfÛÑfoõfïðfsÖfsÕfëîfÛéfÔêfÔìfoÓfïÐfsÒfsÓfëÚfÛÙfÔÝHƒÁ@IƒÄþ…OÿÿÿfpÓîfÔÓfH~ÑM9þ„ªþÿÿLÃë1ÉL‰ÃIÁáMÁ €����óoóo[foâfïàfoëfïèfsÕfsÔfsÓfëÝfsÒfëÔfÛÙfÛÑfÔÓfpÚîfÔÚfI~ÞLñHƒÃ L9Ëu¥é2þÿÿH¾Aâü���K‹ÐI‰ÁI÷ÑIÁéHÁèL ÈH!ðƒût=O‹LÐM‰ËI÷ÓIÁëIÁéM ÙI!ñLȃût O‹DÐM‰ÁI÷ÑIÁéIÁèM ÈI!ðLÀH‰ÆH!þHÁèH!øHðH¯ÂHÁè0HÈ[A\A^A_ÃÌÌAWAVATSPL‰ÃI‰ÎI‰ôI‰ÿú���tL‰ÿ‰ÖAÿT$ ‰Á°„Éu"M…ötI‹D$L‰ÿL‰öH‰ÚHƒÄ[A\A^A_ÿà1ÀHƒÄ[A\A^A_ÃÌÌÌÌHƒìhH‰|$H‰t$HD$H‰D$HQ÷ÿÿH‰D$ HL$H‰L$(H‰D$0HÖ‰�H‰D$8HÇD$@���HÇD$X����HD$H‰D$HHÇD$P���H|$8H‰Öè¿õÿÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHƒìI‰ÔI‰öI‰ÿH‹H‹OH‰ÂH Ê„ ��H…É„D��I‹K4&HÿÇ1ÉL‰òë%ff. „�����LRH)ÑLÑL‰ÒAø���„
��HÿÏ„’���H9ò„û���D¶E„ÀyËE‰ÁAƒá ¶Zƒã?A€øßvFD¶ZÁãAƒã?A ÛA€øðrDD¶BAƒáAÁáAÁãAƒà?E ØE ÈAø���„¡���LRéuÿÿÿLRAÁáA ÙE‰ÈébÿÿÿLRAÁá E ËE‰ØéOÿÿÿH9òtm¶2@„öy@@€þàr:@€þðr4¶zƒç?D¶BAƒà?¶RƒæÁæÁç AÁàA øƒâ?D  òú���t%H…ÉtL9ás A€<À}1ÒëuúL‰òH…ÒLEáLEòH…À„É���M‹oIƒü sL‰àM…ä„‹���Iƒüu1À1ÉëjL‰÷L‰æèƒùÿÿërL‰áHƒáþfïÀ1Àfo
|ÿÿfo´ÿÿ @�A·fnÚfdÙf`ÛòpÛÔfpÛÔfÛÚfÔÃHƒÀH9ÁuÔfpÈîfÔÈfH~Èë1ÒA€<ÀÂHÐHÿÁI9ÌuëI)Åv#A¶G8H
êÿÿHcHÈL‰d$ÿàL‰l$1Ûë?I‹ I‹G(H‹@L‰öL‰âHƒÄ[A\A]A^A_]ÿàL‰ë1ÀH‰D$ëL‰ëHÑëIÿÅIÑíL‰l$M‹g M‹o(A‹o0HÿÃf „�����L‰çHÿËt‰îAÿU „Àtî°ëSL‰öH‹T$AÿU‰Á°„Éu?L‹t$I÷ÞHÇÃÿÿÿÿ €����I HƒøÿtL‰ç‰îAÿU HÿÄÀtæëH‹\$H;\$’ÀHƒÄ[A\A]A^A_]ÃÌÌÌÌÌÌÌÌHƒìHH‰|$H‰t$HD$H‰D$HÇD$ ���H@DÿÿH‰D$(WÀD$0H|$H‰ÖèNòÿÿ ÌÌÌÌÌÌÌÌÌÌÌÌHìØ���H‰<$H>—�H‰D$H‰t$H‰D$H= ÿÿH‰D$ HÇD$(���Hƒ:�uxHD$ H‰D$0H3��H‰D$8H‰àH‰D$@H?��H‰D$HHT$H‰T$PH‰D$XHl„�H‰D$pHÇD$x���HÇ„$�������HD$0H‰„$€���HÇ„$ˆ������é¯���JR )”$À���)Œ$°���)„$ ���HD$ H‰D$0H˜���H‰D$8H„$ ���H‰D$@H¯���H‰D$HH‰àH‰D$PH‹���H‰D$XHT$H‰T$`H‰D$hHèƒ�H‰D$pHÇD$x���HÇ„$�������HD$0H‰„$€���HÇ„$ˆ������H|$pH‰ÎèÐðÿÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌÌH‰ðH‹7H‹WH‰ÇéþúÿÿÌÌÌÌÌÌÌÌÌÌÌÌÌÌH‹H‹OH‹IH‰ÇÿáH‰úH‹~ H‹v(é����UAWAVAUATSHƒìHHÇD$8 ���ÆD$@HÇD$����HÇD$����H‰|$(H‰t$0L‹b M…äH‰$„��H‹B(H…À„p��L‹*H‹jIƒÅLkð81ÛE1ÿf D��I‹U�H…ÒtH‹|$(H‹D$0I‹uøÿP„À…f��A¶D 0ˆD$@I‹D (H‰D$8I‹L I‹D H…Ét#ƒùuHÁàH
›ïÿÿH9Lt1Éë
H‹D�H‹�¹���H‰L$H‰D$I‹ I‹D H…Ét#ƒùuHÁàH
[ïÿÿH9Lt1Éë
H‹D�H‹�¹���H‰L$H‰D$ I‹D HÁàH‹|�Ht$ÿT„À…²���IƒÅHƒÃ8IÿÇI9Þ…ÿÿÿëmH‹ZH…ÛtaL‹bHÁãLãL‹*1íE1ÿ „�����I‹T-H…ÒtH‹|$(H‹D$0I‹t-�ÿP„ÀuXM4,I‹>Ht$AÿV„ÀuDHƒÅIƒÆIÿÇI9Þu¼ëE1ÿH‹$L;xs)H‹$H‹�IÁçH‹|$(H‹L$0J‹48J‹T8ÿQ„Àt°ë1ÀHƒÄH[A\A]A^A_]ÃÌÌÌHìˆ���H‰ù‹F4¨…Ý���¨ …��¸'���Hù'��‚s��A¹'���H¿KY†8ÖÅm4Lè ÿÿf. „�����H‰ÈH÷çHÁê iÂ'��A‰ÊA)ÂEiÚ{��AÁëAkÃdA)ÂE·ÒIAüG· XfF‰\ G·PfF‰T I‰ÁHùÿàõH‰Ñw«Hƒúcv.·ÊÁéiÉ{��Áékùd)ú·ÒH=e ÿÿ·Wf‰THƒÀþH‰ÊHƒú
+ƒÑ���€Â0ˆTHÿÈéÖ���º���¸0���I‰ÈH‰×IÁè‰Ê€â€ú
+A¹W���DBÈA�ÑDˆL<HWÿHƒùL‰ÁsÒë>º���¸0���I‰È �H‰×IÁè‰Ê€â€ú
+A¹7���DBÈA�ÑDˆL<HWÿHƒùL‰ÁsÒHƒÇþHÿ€���w|A¹���I)ÑL<IƒÀH=ÿÿ¹���H‰÷¾���ëHH‰ÊHƒúc‡üþÿÿé%ÿÿÿH
sÿÿ· Qf‰LHƒÀþLIƒÀA¹'���I)ÁHh>ÿÿH‰÷¾���1ÉèÑîÿÿHĈ���ÃHº�¾€���è¨ìÿÿ ÌÌÌÌÌÌHƒìhH‰|$H‰t$HD$H‰D$HíÿÿH‰D$ HL$H‰L$(H‰D$0H&€�H‰D$8HÇD$@���HÇD$X����HD$H‰D$HHÇD$P���H|$8H‰Öèïëÿÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌH‹~ H‹F(H‹@H5Íÿÿº���ÿàÌÌÌÌÌÌHƒìHH‰þHD$H‰D$HÈÿÿÿH‰D$H”}�H‰D$HÇD$ ���HÇD$8����HD$H‰D$(HÇD$0���H|$èhëÿÿ ÌÌÌÌÌÌHƒìÆD$�fÇD$��ÆD$}‰ñÁéƒáHìþþÿ¶ ˆL$‰ñÁéƒá¶ ˆL$‰ñÁé ƒá¶ ˆL$‰ñÁéƒá¶ ˆL$‰ñÁéƒá¶ ˆL$‰ñƒá¶ˆD$ƒÎ½Æƒð ÁèHƒÀþHƒø s)ÆD{fÇD\u·L$f‰OH‹L$H‰ˆG
+ÆG
+HƒÄÃHÁ€�¾
+���H‰ÇèÔêÿÿ ÌÌHƒúw!1É „�����€<�„Â���HÿÁH9Êuîé¨���HFHƒàøH)ðt)t'1É „�����€<�„’���HÿÁH9ÈuîHJðH9ÈvëPHJð1ÀfoµýþÿI¸€€€€€€€€ff. „�����óo foÑfÔÐfßÊfpÑîfëÑfI~ÑM…Áu HƒÀH9ÈvÓI‰ÐI)ÀtL 1É D��A€< �tHÿÁI9ÈuñHÇG���ë&HÁHAH9ÐuH‰wH‰W1ÀH‰ÃHÇG����H‰O¸���H‰ÃÌÌÌÌÌÌÌÌUAVS1ÉH‰ÐHƒèHCÈH…Ò„ª��LFIƒàøI)ð1ÀLÅÿÿI»€€€€€€€€ëf D��IÿÆL‰ðH9Ѓu��¶ „ÛxYE‰ÁA)ÁAöÁtHÿÀëÞ „�����HƒÀH9ÈsL‹LL M…ÙtéH9Ðsº @�€<�x°HÿÀH9Âuòé!��ffff. „�����B¶,A±ƒýt-ƒýtVƒý…
+��LpI9Öƒø���B€<6¿³Ž[ÿÿÿéñ���LpI9ÖƒÙ���B¶,6Hûð���tAûô���uH@€ý~Pé½���LpI9Öƒ«���B¶,6Hûà���tUûí���uY@€ýŸ~ké���@€Åp@€ý0ré€���€Ã€ûwx@€ýÀ}rHXH9Ósd€< ¿NLpI9ÖsUB€<6¿ŽºþÿÿëQ@€åà@€ý tëADs A€þ r€ãþ€ûîu/@€ýÀ})LpI9ÖsB€<6¿Ž€þÿÿ³ëH‰wH‰W1ÀëE1Éë³ë³H‰GDˆOˆ_¸���H‰[A^]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHƒì(H‰4$H‹GH‰D$H‹H‰D$H‹GH‰D$1ífo*úþÿfo ÒúþÿI¼€€€€€€€€E1íE1öH‰T$ ëGff. „�����€|2ÿ
+”ÀH‹L$ˆH‹|$H‹D$ÿPM‰ý„Àfo×ùþÿfo úþÿH‹T$ …Á��E„ö…´��H9Õv"I‰ïéQ��fffff. „�����L‰ýI9ׇ7��H‰ÑH)éH‹$HèHƒùs1H9ê„��1öf D��€<0
+„Ù���HÿÆH9ñuîéù���f „�����L@IƒàøI)Àt3t11öffffff. „�����€<0
+„™���HÿÆI9ðuîHqðë „�����HqðE1Àë €����I9ðw;óBo�foÈfïÊfÔËfßÁfpÈîfëÈfH~ÏL…çuIƒÀëÌfff. „�����I9Èt[LÀH‰ÑL)ÁH)é1öffff. „�����€<0
+t
+HÿÆH9ñuòë0LÆL<.IÿÇHõH9ÕƒÚþÿÿH‹$€<(
+…ÌþÿÿE1öL‰ýL‰ûëI‰×A¶L‰ýM‰ïH‰ÓI9ÕtEH‹D$€8�t º���H‹|$H5ÿÿH‹D$ÿP„Àu"H‰ÚL)êH‹$J4(L9ë…þÿÿ1Àéþÿÿ1Àë°HƒÄ([A\A]A^A_]ÃÌÌAWAVATSP‰óL‹A€?�L‹7L‹gt&H5Jÿÿº���L‰÷AÿT$„Àt°HƒÄ[A\A^A_Ãû
+A”I‹D$ L‰÷‰ÞHƒÄ[A\A^A_ÿàÌH‰òH5¾w�é!ôÿÿÌHƒìxH‰|$H‰t$H‰T$H‰L$ HD$H‰D$(H·óÿÿH‰D$0HD$H‰D$8HÁóÿÿH‰D$@HÝ’�H‰D$HHÇD$P���HÇD$h����HD$(H‰D$XHÇD$`���H|$HL‰Æè äÿÿ ÌÌÌÌÌÌÌÌÌÌÌÌHƒì(@¶Ï€ùdr,‰ ÁÁé kÁd@(Ç@¶ÇH§ÿÿ·Bf‰D$&¸$���‰Ïë ¸&���@€ÿ
+s @€Ï0@ˆ|ëHxÿÿ·Hf‰D$&¸%���LIÿÀA¹'���I)ÁHm5ÿÿH‰÷¾���1ÉèÖåÿÿHƒÄ(ÃÌHƒì(‹¸'���H=,ÿÿHù'��‚¦���A¹'���I¸KY†8ÖÅm4H‰ÈI÷àHÁê iÂ'��A‰ÊA)ÂEiÚ{��AÁëAkÃdA)ÂE·ÒIAüF· _fF‰\ ýF·WfF‰T ÿI‰ÁHùÿàõH‰Ñw«Hƒúcv)·ÊÁéiÉ{��ÁéDkÁdD)·ҷWf‰TÿHƒÀþH‰ÊHƒú
+s€Â0ˆHÿÈëH‰ÊHƒúcw½ëä· Wf‰LÿHƒÀþLIÿÀA¹'���I)ÁHd4ÿÿH‰÷¾���1ÉèÍäÿÿHƒÄ(ÃÌÌÌÌÌÌÌÌHƒìXH‰|$H‰t$HD$H‰D$H‘ñÿÿH‰D$ H-‹�H‰D$(HÇD$0���HÇD$H����HD$H‰D$8HÇD$@���H|$(H‰Öèâÿÿ ÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHƒìhI‰üL‹v L‹~(M‹oH5üÿÿº ���L‰÷AÿÕ³„À…(��I‹D$HHH‰$HƒÀHïðÿÿH‰T$H‰L$H
þÿÿH‰L$H‰D$ H‰L$(Hs�H‰D$8HÇD$@���HÇD$X����H‰àH‰D$HHÇD$P���HT$8L‰÷L‰þèÐðÿÿ„À…©���I‹l$H…ítHH5Bÿÿº���L‰÷AÿÕ„À……���E�MU )T$ )L$)$H‰âL‰÷L‰þè|ðÿÿ„ÀtWëWM‹<$I‹D$L‰ÿÿPH¹dï±�¼ýH1ÑHºÁ{ ͜ȢÁH1ÂH Êu'H57Bÿÿº���L‰÷AÿÕ„ÀuI‹7I‹WL‰÷AÿÕ„Àu1Û‰ØHƒÄh[A\A]A^A_]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌHƒì(HM2ÿÿH‰$H¢r�H‰D$H‰|$H‰T$ÆD$ �@ˆt$!H‰çè‰V�ëè��� Pè
+��� ÌÌÌÌÌÌÌÌHƒìHH�ÿÿH‰D$HÇD$&���HD$H‰D$HÇD$ ���HÕ1ÿÿH‰D$(WÀD$0HAr�H|$1öè]ÿÿÿ ÌÌÌÌÌÌÌÌÌÌÌHƒìHHÆ
ÿÿH‰D$HÇD$$���HD$H‰D$HÇD$ ���Hu1ÿÿH‰D$(WÀD$0Hùq�H|$¾���èúþÿÿ ÌÌÌÌÌÌÌÌHìˆ���H‰øº���¹0���I‰øf „�����H‰×IÁè‰Â€â€ú
+A¹W���DBÉA�ÑDˆL<HWÿHƒøL‰ÀsÒHƒÇþHÿ€���w2A¹���I)ÑL<IƒÀH2/ÿÿ¹���H‰÷¾���è;áÿÿHĈ���ÃH$r�¾€���èßÿÿ Pèúþÿÿ ÌÌÌÌÌÌÌÌAWAVAUATSHƒìpH‰û€�L‹/°tˆCIÿÅL‰+H‰ØHƒÄp[A\A]A^A_ÃI‰ÖI‰÷L‹cA‹D$4¨u>1ÒM…íH<-ÿÿH5e.ÿÿHDð•ÂHÿÂI‹|$ I‹D$(ÿP‰Á°„Éu¡L‰ÿL‰æAÿVë•M…íu*I‹|$ I‹D$(H5Å ÿÿº���ÿP‰Á°„É…kÿÿÿA‹D$4ÆD$AD$ )D$PHL$H‰L$`A‹L$0A¶T$8‰D$D‰L$@ˆT$HA$)D$AD$)D$ HD$PH‰D$0HÌp�H‰D$8Ht$L‰ÿAÿV„Àt°éóþÿÿH‹|$0H‹D$8H5& ÿÿº���ÿPéÕþÿÿÌÌÌÌÌÌÌÌÌÌAWAVATSHƒìhH‰û°€�tˆCÆC H‰ØHƒÄh[A\A^A_ÃI‰ÖI‰÷L‹#A‹D$4¶K ¨u0„Ét!I‹|$ I‹D$(H5-ÿÿº���ÿP‰Á°„Éu¯L‰ÿL‰æAÿÖ뤄Éu*I‹|$ I‹D$(H5?6ÿÿº���ÿP‰Á°„É…{ÿÿÿA‹D$4ÆD$AD$ )D$PHL$H‰L$`A‹L$0A¶T$8‰D$D‰L$@ˆT$HA$)D$AD$)D$ HD$PH‰D$0H‘o�H‰D$8Ht$L‰ÿAÿÖ„Àt°éÿÿÿH‹|$0H‹D$8H5ì
+ÿÿº���ÿPéæþÿÿ@„öt°ÃH‹G H‹O(H‹IH5(,ÿÿº���H‰ÇÿáÌÌÌÌÌÌÌÌÌÌÌé‹ëÿÿÌÌÌÌÌÌÌÌÌÌÌAWAVSHƒì L‰ÃI‰ÎI‰ÿH‹ I‹G(ÿPL‰|$ˆD$HÇD$����ÆD$�H|$L‰öH‰ÚèüüÿÿH‹D$¶L$H…ÀtU³„ÉuQL‹t$Hƒøu)€|$�t"AöF4uI‹~ I‹F(H5N*ÿÿº���ÿP„Àu I‹~ I‹F(H519ÿÿº���ÿP‰Ãë‰Ë„Û•ÀHƒÄ [A^A_ÃÌÌÌÌÌÌÌUSHƒì‰õH‰ûƒþ'w ‰èH
£ðþÿHcHÈÿàfÇ\0é!��ƒý\uFfÇ\\é��fÇ\té��fÇ\néþ���fÇ\réô���÷Â���tfÇ\"éâ���÷Â���…Ñ���öÂt ‰ïèÝ��„Àu‰ïè��„Àt Æ€‰ké¾���ÆD$�fÇD$��ÆD$}‰éÁéƒáH3îþÿ¶ ˆL$‰éÁéƒá¶ ˆL$‰éÁé ƒá¶ ˆL$‰éÁéƒá¶ ˆL$‰éÁéƒá¶ ˆL$‰éƒá¶ˆD$ƒÍ½Åƒð ÁèHHþÆD{fÇD \u·D$f‰CH‹D$H‰ˆK
+ÆC
+ëfÇ\'HÇC����fÇC
+�HƒÄ[]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌPè
+��� ÌÌÌÌÌÌÌÌHìØ���H‰”$À���H‰Œ$È���Hþ��rT¸���€¿���¿.¸ÿ���€¿ÿ���¿ ¸þ���€¿þ���¿¸ý���€¿ý���¿ŽÝ��H‰|$H‰D$¸���L
á
+ÿÿëH‰|$H‰t$L
+ÿÿ1ÀL‰Œ$ ���H‰„$¨���H9ò‡¡���H9ñ‡˜���H9ʆ ��H„$À���H‰D$PH:ÚÿÿH‰D$XHŒ$È���H‰L$`H‰D$hHD$H‰D$pHèÿÿH‰D$xHŒ$ ���H‰Œ$€���H‰„$ˆ���H–m�H‰D$ HÇD$(���HÇD$@����HD$PH‰D$0HÇD$8���é���H9òHGÊH‰Œ$°���H„$°���H‰D$PHœÙÿÿH‰D$XHD$H‰D$`H†çÿÿH‰D$hHŒ$ ���H‰L$pH‰D$xH m�H‰D$ HÇD$(���HÇD$@����HD$PH‰D$0HÇD$8���H|$ L‰Æèñ×ÿÿ H…Òt H9òs€<À|H‰ÊH‰”$Ð���H‰ðH9òƒ���1ÉH‰ÐHƒèHCÈHBH9ÁvHSm�H‰ÏH‰Æè@ëÿÿ tnL HøL)È€<¿~HÿÈëY¹ý���1Òè«ýÿÿ H9ÑtFHú€zÿ¿~HƒÀþë7LRÿM9Ñt.€zþ¿~HƒÀýë"LRþM9Ñt€zý¿~HƒÀüë
HƒÂýI9ÑtHƒÀûHÈH…ÀuH‰ñë H‰ñH)Áv€<¿H‰ÂH‰ñè8ýÿÿ uñH…ÉuH=Ð(ÿÿ¾+���L‰Âè[äÿÿ ¶„Òx‰T$ ¹���é…���‰Ñƒá D¶LAƒá?€úßv3¶tAÁáƒæ?D ΀úðr)¶TƒáÁáÁæƒâ? ò Êú���tëÁáD ɉÊëÁá Ήò‰T$ ¹���ú€���r ¹���ú���rú���¹���HƒÙ�HÁH‰„$°���H‰Œ$¸���H„$Ð���H‰D$PHg×ÿÿH‰D$XHD$ H‰D$`H‘���H‰D$hH„$°���H‰D$pH˜��H‰D$xHD$H‰„$€���H åÿÿH‰„$ˆ���HŒ$ ���H‰Œ$���H‰„$˜���Hàj�H‰D$ HÇD$(���HÇD$@����HD$PH‰D$0HÇD$8���é‹ýÿÿÌÌÌÌÌÌÌÌÌUAWAVATSHƒìI‰þH‹^ H‹F(H‹@ H‰ß¾'���I‰ÄÿЄÀt°HƒÄ[A\A^A_]ÃA‹6H‰çº��èõùÿÿ€<$€uW@µ€ë*f. „�����‹t$ÇD$����HÇ$����1íH‰ßAÿÔ„Àu¬@€ý€tÚD¶t$
+D:t$ sWAFˆD$
+A€þ
+sbB¶44ëÎD¶|$ D¶t$
+fff. „�����M9þs%AFˆD$
+Iƒþ w0B¶44H‰ßAÿÔIÿÆ„ÀtÛéBÿÿÿH‰ß¾'���L‰àHƒÄ[A\A^A_]ÿàH®j�¾
+���L‰÷è)Õÿÿ ÌÌÌÌÌÌÌAVSHƒì8H‰óI‰þH‹?èÛåÿÿ„Àu?H(f�H‰D$HÇD$���H&ÿÿH‰D$WÀD$ H‹{ H‹s(HT$èŒãÿÿ„Àt
+°HƒÄ8[A^ÃI‹~H‰ÞHƒÄ8[A^é{åÿÿÌÌÌÌÌÌÌÌÌÌÌP‰þÁæ ¸!���1ÒH
ø ÿÿA¸ÿ���A¹!���ëfffff. „�����I‰ÁH)Ðv<HÑèHÐD‹ AÁã E1ÒA9óA•ÂEBÐA€útÖA¶ÒHÿÀúÿ���uH‰ÂL‰ÈëÂH‰ÂHƒú ‡¥���‹‘ÁèHƒú u º ���¾×��ë‹t‘ÁîH…ÒtWHÿÊA¸ÿÿ �D#‘H‰ÁH÷ÑHñt;D)ÇHÿÎ1ÉLÇ ÿÿH‰Â @�HúÖ��w%F¶ DÉ9ùw
HÿÂH9ÖuãH‰ðëH‰Ð$YÃE1Àë±H=Ø��¹×��HBÁHÔh�¾×��H‰ÇèÓÿÿ H¦h�¿!���¾!���ègÓÿÿ ÌÌÌÌÌPƒÿ s1ÀYðƒÿr÷ÿ���s*HÇ$/��H5ÂÿÿH
ÿÿL
# ÿÿº(���A¸ ��ë0ÿ���s/HÇ$Â��H5²ÿÿH
ÿÿL
Àÿÿº,���A¸Ä���èˆ���YÃfnÇfpÀ�fþçþÿfïýäþÿfo
EæþÿffÈPÉ1À…É…\ÿÿÿµìüÿƒù‚MÿÿÿPÜüÿùPÝ
+�‚;ÿÿÿ‰ùƒáàùà¦�„*ÿÿÿ‰ùƒáþù ¸�„ÿÿÿÇ��ïÿÿðýÿ’ÀYÃAWAVATSPL‹\$0‰ûÁëHV1ÀI‰÷D¶vHƒÆN0A8 uCL9Ї���M9‡¸���HÈE1ÿff. „�����M9þt MgB8<8M‰çuîëofff. „�����wL‰ÐH9ÖužMË·Ï°fffff. „�����IqA¶„ÒxI‰ñ)Ñy'ë0ff. „�����L9ÞtVA¶qIƒÁƒâÁâ ò)Ñx 4M9Ùu¿ë1À$HƒÄ[A\A^A_ÃHŽf�H‰ÇL‰ÖèKäÿÿ Hzf�L‰×L‰ÆègÚÿÿ H=f"ÿÿHGf�¾+���èíÝÿÿ ÌÌÌÌÌÌÌÌÌÌÌH‹H F‹uH‹~ H‹N(H‹I ‰ÆÿáPÇD$����=€���sˆD$º���é†���‰Á=���sÁé€ÉÀˆL$$? €ˆD$º���ëd=���s(Áé €ÉàˆL$‰ÁÁé€á?€É€ˆL$$? €ˆD$º���ë5Áé€ÉðˆL$‰ÁÁé €á?€É€ˆL$‰ÁÁé€á?€É€ˆL$$? €ˆD$º���HD$H‰÷H‰ÆèñÙÿÿYÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌAVSLFIƒàøI)ðt-I9ÐLCÂM…Àt!1Éf@8<„¬���HÿÁI9ÈuîHBðI9Àv ëgHBðE1ÀH¹ÿþþþþþþþD¶×I¹M¯ÊIº€€€€€€€€f D��N‹ M1ËI I÷ÓI!ÛJ‹\L1ËL4 H÷ÓL!óL ÛL…Óu IƒÀI9ÀvÌI‰ÑM)Áu1ÀH‰Ñë(LÆ1À1Éf D��@8<t
HÿÁI9ÉuòH‰ÑëLÁ¸���H‰Ê[A^ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌHƒì8Hµb�H‰D$HÇD$���HX ÿÿH‰D$WÀD$ H5te�H|$èbÎÿÿ HƒìhH‰|$H‰t$HD$H‰D$HÏÿÿH‰D$ HL$H‰L$(H‰D$0HVb�H‰D$8HÇD$@���HÇD$X����HD$H‰D$HHÇD$P���H5i�H|$8èëÍÿÿ ÌÌÌÌÌÌÌÌÌHƒì8H5b�H‰D$HÇD$���H˜ ÿÿH‰D$WÀD$ H5Tl�H|$è¢Íÿÿ UAWAVAUATSHƒìL‰ÃI‰ÌI‰þIƒøH‰t$…€���A½���1À1í¹���H9èHGèLFéI‰ßI)ï‚‘��L‰îHî‚‘��H‰T$H9Þ‡”��K4,L‰çH‰êÿ‚�…À„R��L9ýLGýHCÿ‰ÙƒáHƒøƒÊ��1À1ÒL‹T$é
+��A¸���1ÉA½���1ÀAº���E1Éë+ffffff. „�����K<
+HÿÇI‰ýI)ÅE1ÉNI‰úI9ØsVI<H9߃¾��A¶<<C8<rÌu*IÿÁM9éM‰ÈLDÁLEÉL‰ÏL×M‰Áë¾fffff. „�����IzA½���E1ÉL‰ÐëžA¹���E1Ò¹���1íA¸���1öë# @�I<0HÿÇH‰ùH)é1öL 7I‰øI9Ùƒ¶þÿÿH<.H9߃+��A¶<<C8< wÉu'HÿÆH9ÎI‰ñMDÊIEòH‰÷LÇL‰Îëºff. „�����Ix¹���1öL‰Å럾���1ÒE1ÀA¹���1Éë$fff. „�����OIÿÂL‰ÖH)ÎE1ÀM‰ÑL9îtuKH9ØslL‰ÈH÷ÐH‰ßL)ÇHÇH9߃—��L‰ÀH÷ÐHØH)ÈH9؃‹��MQA¶A8<r£u!IÿÀI9ðL‰ÀHDÂLEÂM‰ÂMÊI‰Àë• D��¾���E1ÀL‰ÉëƒA¸���1ÒE1ÉAº���1öë&fffff. „�����O IÿÃM‰ØI)ðE1ÉM‰ÚM9ètvK
+H9ØsmL‰ÐH÷ÐH‰ßL)ÏHÇH9߃ç��L‰ÈH÷ÐHØH)ðH9؃Û��MZA¶A8<w£u!IÿÁM9ÁL‰ÈHDÂLEÊM‰ËMÓI‰Áë• D��A¸���E1ÉL‰Öë‚H9ñHGñH‰ÙH)ñM…í„¥���D‰êƒâIƒýL‹T$ƒ¡���1À1ÿéÞ���H‰ÞHƒæü1À1ÒL‹T$fffff. „�����A¶<E¶DH«øL«ÀA¶|H«øA¶|H«øHƒÂH9ÖuÐH…ÉtLâ1öf D��¶<2H«øHÿÆH9ñuðIÿÇHÇÆÿÿÿÿHÇÂÿÿÿÿM‰ýH‰éë1öH‰Ú1ÀE1íL‹T$ënL‰îHƒæü1À1ÿff. „�����E¶<E¶L<L«ÀL«ÈE¶D<L«ÀE¶D<L«ÀHƒÇH9þuÐH…Òt Lç1öE1À �F¶ L«ÈIÿÀL9Âuïë1öH‰ÚH‹|$I‰~HM‰VPM‰fXI‰^`IÇ���I‰nI‰NM‰nI‰F IÇF(����M‰V0I‰v8I‰V@HƒÄ[A\A]A^A_]ÃH‚]�ëH‘]�ë
+H ]�H‰ÇH‰Þè…Éÿÿ H,]�H‰ïëH8]�L‰ïèHÜÿÿ H']�H‰÷H‰ÞèdÒÿÿ ÌÌH‹NH…É„›��USH‹1ÒL
èøþÿL�úþÿëA€ãà€û …R��LBI9ÈL\MCÚE¶A€ãÀA€û€…0��HƒÂI‰ÐL‰ÂI9ȃ ��D¶ LBE„ÛyæC¶ ƒût1ƒûtVƒû…÷���N �I9ÈMCÚE¶A€ãÀA€û€…Ú���HƒÂë¨J �I9ÈICÚ¶Iûð���tBAûô���uC€û~Méª���J �I9ÈICÚ¶Iûà���„1ÿÿÿAûí���ui€ûŸŽ+ÿÿÿë{€Ãp€û0rëqA€ÃA€ûwg€ûÀ}bLBI9ÈL\MCÚE¶A€ãÀA€û€uDLBI9ÈL\MCÚE¶A€ãÀA€û€u&HƒÂéñþÿÿAk @€ý r
+A€ãþA€ûîu €ûÀŒ®þÿÿN �L)ÁL‰H‰NI)ÐH‰HÐH‰WH‰GL‰G[]ÃHÇ����ÃHìˆ���‰øº���¹0���A‰Àf. „�����H‰×‰Â€âAÀè€ú
+A¹7���DBÉA�ÑDˆL<HWÿ<D‰ÀsÔHƒÇþHÿ€���w2A¹���I)ÑL<IƒÀH¤ÿÿ¹���H‰÷¾���èÈÿÿHĈ���ÃH–Y�¾€���è„Æÿÿ ÌÌHìˆ���‰øº���¹0���A‰Àf. „�����H‰×‰Â€âAÀè€ú
+A¹W���DBÉA�ÑDˆL<HWÿ<D‰ÀsÔHƒÇþHÿ€���w2A¹���I)ÑL<IƒÀHÿÿ¹���H‰÷¾���è
ÈÿÿHĈ���ÃHöX�¾€���èäÅÿÿ ÌÌUSHƒìH‰L$Aþƒø#ƒU��I‰ÐH…Òt¶ƒø-tƒø+uIÿÈtwHÿÆëÆG�é"��IƒøtcA‰ÉƒùwdIƒøs^1Òƒù
+†ž���AºÿÿÿÿE1Ûë „�����M¯Ù‰ØLØHÿÂI‰ÃI9Є—���¶XЃû
+rÜƒÈ ƒÀŸƒÀ
+AB‰Ã9ÈrÉÆGé°���E1Òƒù
+voA»ÿÿÿÿ1ÀM9ÐtZB¶ I÷áÂkЃý
+rƒË ƒÃŸƒÃ
+ABÛ‰Ý9Ës¼„Òum‰êIÿÂHÐsÇëaE1Òf¶ƒÀÐ9ÈsœM¯Ñ‰ÀLÐHÿÂI‰ÂI9ÐuáH‰G1Àë;1À €����M9ÐtêF¶ I÷áÂAƒÃÐA9˃Zÿÿÿ„Òu D‰ÚIÿÂHÐsÔÆG°ˆHƒÄH[]ÃHD$H‰D$H¤àÿÿH‰D$HØU�H‰D$HÇD$ ���HÇD$8����HD$H‰D$(HÇD$0���H5·U�H|$èÝÃÿÿ ÌÌÌÌÌÌÌÌÌÌÌSHƒì0HcH‰ÈH÷ØH…ÉA‰ÈLHÀH‰÷¸'���H5gòþÿIø'��‚³���Aº'���I¹KY†8ÖÅm4fff. „�����L‰ÀI÷áHÁê iÂ'��E‰ÃA)ÃAiÛ{��ÁëkÃdA)ÃE·ÛIBü· ^fB‰\F· ^fF‰\I‰ÂIøÿàõI‰Ðw®Hƒúcv-D·ÂAÁèEiÀ{��AÁèEkÈdD)Ê·Ò·Vf‰THƒÀþL‰ÂHƒú
+s€Â0ˆTHÿÈëL‰ÂHƒúcw¸ëã·Vf‰THƒÀþLIƒÀ A¹'���I)Á÷ÑÁé HŒÿÿ‰Î1ÉèûÄÿÿHƒÄ0[ÃÌÌÌÌÌUAWAVAUATSHìX��I‰õL‹f`It$ÿH;ws'Iƒ}��³„T��Iƒ}�„I��I‹}ÿ{v�é:��H‰û…ˆ���Hƒ{(�„«��H‹CH…À„ž��H‹K ºÿ���D·€2��N Å����HÇÇÿÿÿÿ D��M…Ét/E1ÒL9¤øà��A•ÂDGÒHÿÇIƒÁøA€útÛE¶ÂE…À„>��ëL‰ÇHƒé‚8��H‹„ø8��ë™L‹CM…À„}���L‹K ¸ÿ���L‰ÉL‰ÇL¿Ø��D··2��Jõ����HÇÅÿÿÿÿff. „�����H…Òt)1öM9dï@•ÆGðHÿÅHƒÂø@€þtà@¶Ö…Ò„×þÿÿëL‰õHƒé‚=��H‹¼ï8��ë’M‹}�I‹mM‹u¶ ‡�¿8��ÿUu�H…À„§��HÇ€Ð������AEAM(AU8A]H@H(P8XHAEX@XI‹MhH‰HhfÇ€2���L‰ Ø��L‰8H‰hL‰pH‰CHÇC ����HÇC(���é‚���H…À…þÿÿM‹}�M‹eM‹uH;su H‰ßè ��H‹sIƒÅH‹HkÎpL‰<L‰dL‰tAE�AMAU A]0DL(T8\HAE@DXI‹UPH‰ThHÿÆH‰s1Û‰ØHÄX��[A\A]A^A_]ÃI‹M�I‹EH‰D$ I‹UIƒÅfAƒþ
+H‰|$v6A¶HƒýL‰„$ð��L‰Œ$è��H‰T$(H‰L$0ƒÊ���¸���H‰D$é¨��L‰ðI4ïH)è†Ï���I<ïHƒÇH‰T$(HÅ����L‹=ås�H‰L$0H‰D$Aÿ×H‹D$L‰¤èØ��I‹EPH‰„$���AE@)„$€���AE�AMAU A]0)\$p)T$`)L$P)D$@HkÅpH‹L$H4H‹L$H<HƒÇpHkT$pAÿ×H‹L$0H‹T$(H‹|$ëh„Ï���Hƒý…Ì���¸���H‰D$E1ö1íéÉ���L‰&I‹EPH‰„$���AE@)„$€���AE�AMAU A]0)\$p)T$`)L$P)D$@AÿÆHkÅpH‰ H‹L$ H‰LH‰T(D$@(L$P(T$`(\$pDL(T8\H(„$€���DXH‹Œ$���H‰LhfD‰·2��HÿC(éþÿÿH‰l$ëHƒÅù¸���H‰D$E1ö¶úƒ�¿8��ÿ/r�H…À„��L‰´$ ���HÇ€Ð������H‹t$·¾2��L‹D$M‰ÁI÷ÑIùH‰D$fD‰ˆ2��J‹„ÆØ��H‰„$¸���IkÈpH‹H‰„$¨���H‹DH‰D$8H‹DH‰„$˜���H‹ThH‰”$���DX)„$€���DH)D$pD8)D$`D()D$PD)D$@Iƒù ‡k��MpL)÷L9ÏL‰D$…l��H‹D$H¸Ø��K4÷JÍ����M‰ÏÿCq�IköpL‹t$LöIk×pL‹|$L‰ÿÿ%q�M‰ðH‹D$fA‰†2��(D$@(L$P(T$`(\$p)„$��)Œ$ ��)”$°��)œ$À��(„$€���)„$Ð��H‹„$���H‰„$à��€¼$ ����M‰þMEðA·¾2��I‰ÿI4îHÆØ��I)���I†Ø��H‰|$H<èHƒÇJý����ÿ‰p�M‰¤îØ��I‹EPH‰„$���AE@)„$€���AE�AMAU A]0)\$p)T$`)L$P)D$@HkÅpI4I<HƒÇpIk×pÿ&p�H‹|$L‹D$ëDL‰&I‹EPH‰„$���AE@)„$€���AE�AMAU A]0)\$p)T$`)L$P)D$@L‹¼$˜���H‹T$(H‹L$0ÿÇHkÅpI‰ H‹L$ I‰LI‰T(D$@(L$P(T$`(\$pADAL(AT8A\H(„$€���ADXH‹Œ$���I‰LhfA‰¾2��H‹„$à��H‰„$€��(„$Ð��)„$p��(„$��(Œ$ ��(”$°��(œ$À��)œ$`��)”$P��)Œ$@��)„$0��L‹¤$¨���IƒüL‹¬$¸���„k��H‹„$€��H‰„$��(„$p��)„$���(„$0��(Œ$@��(”$P��(œ$`��)œ$ð���)”$à���)Œ$Ð���)„$À���I‹€Ð��H…À„Ý��1ÉH‰Œ$°���M‰êL‰çL‰úH‹t$L‰ÁE· 0��·¨2��Hƒý H‰D$H‰”$ ���H‰|$(H‰t$0H‰¬$(��‚±��A·A¾���fAƒüL‰”$ ��sL‰d$ë:IƒütAƒüu A¾���E1ÿ1ÀH‰D$ë L‰d$M‰æëIƒÄùL‰d$A¾���E1ÿ¶W�¿˜��ÿŒm�H…À„
+��I‰ÅL‰¼$ø��H‰ÁIÇ…Ð������H‹t$·†2��M‰ôI÷ÔIÄL‰l$fE‰¥2��J‹ŒöØ��H‰Œ$¸���IkÎpH‹H‰”$¨���H‹TH‰T$ H‹TH‰”$˜���H‹ThH‰”$���DX)„$€���DH)D$pD8)D$`D()D$PD)D$@Iƒü ‡9 ��M~L)øL9à…V ��H†Ø��I½Ø��J4øJå����H‹-¤l�ÿÕIk÷pHt$IkÔpL‹d$L‰çÿÕH‹L$fD‰±2��(D$@(L$P(T$`(\$p)„$��)Œ$ ��)”$°��)œ$À��(„$€���)„$Ð��H‹„$���H‰„$à��E·¤$2��I|$Iƒü ƒÝ��H‹”$(��L)òH9ú…¬��Hÿ„$°���I½8��J4ùHÆ8��HÁâÿÚk�1ÀH‹t$ff. „�����H‰ÁL9àHƒÐ�H‹”Î8��H‰²Ð��f‰Š0��L9ásL9àvÖH‹„$à��H‰„$€��(„$Ð��)„$p��(„$��(Œ$ ��(”$°��(œ$À��)œ$`��)”$P��)Œ$@��)„$0��€¼$ø���LEl$E·½2��L‹L$MaJ4ÍØ��LîM9üvdH‹„$ ��H‰H‹„$��H‰„$���(„$���)„$€���(„$À���(Œ$Ð���(”$à���(œ$ð���)\$p)T$`)L$P)D$@é¦���I…Ø��J<àM‰þM)ÎJõ����H‹-£j�ÿÕH‹D$H‹Œ$ ��I‰ŒÅØ��H‹„$��H‰„$���(„$���)„$€���(„$À���(Œ$Ð���(”$à���(œ$ð���)\$p)T$`)L$P)D$@Hkt$pLîIküpLïIkÖpÿÕL‹L$H‹L$8H‹”$ ���H‹t$(IkÁpI‰t�I‰LI‰T(D$@(L$P(T$`(\$pADAL(AT8A\H(„$€���ADXH‹Œ$���I‰LhMwIAL9ðs$I8��J4áH<ÁL‰úL)ÊHÁâÿ…i�L‹L$AGH‹L$0K‰ŒÍ@��fA‰…2��M9ôL‹D$H‹l$ ƒµ���D‰øD)ÈÿÀƒàt.JÍ@��Lê1ÉH‹4ÊL‰®Ð��A< f‰¾0��HÿÁH9ÈuâIÌM)ÏIƒÿrqK‹„å8��L‰¨Ð��fD‰ 0��K‹„å@��L‰¨Ð��AL$f‰ˆ0��K‹„åH��L‰¨Ð��AL$f‰ˆ0��K‹„åP��L‰¨Ð��AL$f‰ˆ0��IƒÄM9ôuH‹„$€��H‰„$P��(„$p��)„$@��(„$0��(Œ$@��(”$P��(œ$`��)œ$0��)”$ ��)Œ$��)„$���L‹¤$¨���Iƒü„¶��H‹„$P��H‰„$��(„$@��)„$���(„$���(Œ$��(”$ ��(œ$0��)œ$ð���)”$à���)Œ$Ð���)„$À���I‹€Ð��L‹¬$¸���M‰êL‰çH‰l$8L‹¼$˜���L‰úL‹t$L‰öH…À…=ùÿÿë1ÀH‰„$°���H‹l$8L‹t$¶y�¿˜��ÿGg�H…À„p��HÇ€Ð������fÇ€2����H‹”$ð��H‰8��H‹´$è��HNH‰‚Ð��fÇ‚0����H‰CH‰K H;´$°���…,��·ˆ2��Hƒù ƒ5��Qf‰2��L‰¬ÈØ��HkñpL‰$0H‰l0L‰|0(„$À���(Œ$Ð���(”$à���(œ$ð���D0L0(T08\0H(„$���D0XH‹¼$��H‰|0hL‰´È@��I‰†Ð��fA‰–0��HÿC(éðñÿÿI‰ÀDmM|$J4àHÆØ��fA9ìƒÁ���I€Ø��J<øI‰îM)æJõ����D‰íM‰Õÿ(f�H‹D$N‰¬àØ��A‰íH‹„$��H‰„$���(„$���)„$€���(„$À���(Œ$Ð���(”$à���(œ$ð���)\$p)T$`)L$P)D$@IkôpHt$IkÿpH|$IkÖpÿ¨e�H‹|$(H‹”$ ���H‹¬$(��L‹D$ëWL‰H‹„$��H‰„$���(„$���)„$€���(„$À���(Œ$Ð���(”$à���(œ$ð���)\$p)T$`)L$P)D$@H‹L$8IkÄpLuI‰<�I‰L�I‰T�(D$@(L$P(T$`(\$pAD�AL�(AT�8A\�H(„$€���AD�XH‹Œ$���I‰L�hfA9ìs(I€8��J4øJ<àHƒÇH‰êL)âHÁâÿªd�L‹D$H‹D$0K‰„à@��fE‰¨2��M9÷ƒþÿÿ‰èD)àÿÀL)åƒàt.KàHÂ@��1ÉH‹4ÊL‰†Ð��A<f‰¾0��HÿÁH9ÈuâIÏHƒý‚ÉýÿÿK‹„ø8��L‰€Ð��fD‰¸0��K‹„ø@��L‰€Ð��AOf‰ˆ0��K‹„øH��L‰€Ð��AOf‰ˆ0��K‹„øP��L‰€Ð��AOf‰ˆ0��IƒÇM9÷u’éVýÿÿH‰l$ ¿���¾8��èY¨ÿÿé��HåE�¾ ���L‰çè¹ÿÿéí���¿���¾˜��è,¨ÿÿéÙ���H=2ëþÿH™E�¾(���è¼ÿÿé¼���H=ëþÿH|E�¾(���èb¼ÿÿéŸ���H–E�¾ ���謸ÿÿé‰���¿���¾8��èȧÿÿëxHWE�¾ ���L‰Ï肸ÿÿëbH=»êþÿH"E�¾(���è¼ÿÿëH¿���¾˜��臧ÿÿë7H‰l$ HÉD�¾0���H=OêþÿëH‰l$ HÇD�¾ ���H=œÛþÿè¾»ÿÿ H‰ÃM…ä„È���M…ÿ…´���éº���H‰Ãë/H‰ÃHƒ¼$¨����tHƒ¼$˜����t H‹|$8ÿ%b�H‹|$ÿb�Hƒ|$0�t~Hƒ|$(�ukëtH‰Ãë1ë�H‰ÃHƒ¼$¨����tHƒ¼$˜����t H‹|$ ÿÝa�H‹|$ÿÒa�Hƒ|$(�t6H‹D$8H‰D$ Hƒ¼$ ����uë ëL‰d$ H‰ÃM…ÿtM…öt H‹|$ ÿ”a�H‰ßèœ.� ÌÌÌÌÌÌÌÌÌÌAVSHƒì8HÿÆ„•���H‰ûH‹GH �H9ñHGñHƒþA¾���LCöH¹%I’$I’$1öI9Î@’ÆIkÖpHÁæH…Àt H‹ HkÀpH‰L$HÇD$���H‰D$ë HÇD$����H|$ HL$èüÐ��Hƒ|$ �H‹|$(tH¸������€H9ÇtH…ÿuèv¥ÿÿ H‰;L‰sHƒÄ8[A^ÃH‹t$0蛥ÿÿ ÌÌÌÌÌÌÌÌÌHƒ?�t H‹WH‹GÃH‹WHƒúsHƒÇH‰øÃPHGC�¾���H‰×H‰Âè'¶ÿÿ ÌÌÌÌÌUAWAVAUATSHìÈ���L‰D$(I‰ÏH‰ÕI‰óH‰¼$���H
+D¶®é*��H‹†à(��‹Žè(��‹– )��H‰$‰L$H‹†)��H‰D$ ‰T$H† )��H‰D$@H†€ ��H‰D$xH† ��H‰D$pH†À'��H‰„$¨���H†
��H‰„$À���H†€
��H‰„$¸���E1ÒH‰¬$°���H‰\$8H‰t$ L‰L$E‰ìAµÿA€ü‡Â ��A¶ÄH
ˆÁþÿHcHÈÿàfïÀf$HÇD$����Iǃì(������Aǃô(�����Aǃ�)�����Aµë¤fA½�#I‰èA¿Í·Ö ÊL‰Å„Ò…=��‹|$A‹“)��A‹ƒ)��Ð9Çsg‹D$Hƒøƒ��H‰ÙH)éHƒù‡��H‹$‰Ñáÿ��E¿„K@��E…Àˆý��A·Èù���‚.��AÁè D9Àƒð���é ��f „�����9Ç…K��ú!��ƒÝ ��I‰ÝL‰ûE‰çM‰ÔH‹|$xH‹t$@ÿ¨^�H‹D$ ‹)��Hú!��ƒ² ��‹°)��29Ƈº ��=É��‡Ã ��H)ðH9Ð…Í ��Ht$@H‹|$pÿX^�L‹t$ AÿŽü(��H‰æL‰÷è9 ��M‰ó‰ÂM‰âL‹L$E‰üI‰ßL‰ëA‰Å„Ò„Éþÿÿé
�� �H‹$ë ·U�‰ÁHÓâH $HƒÅH‰$ƒÀ‰D$‰Ñáÿ��E¿„K@��E…ÀxD‰ÁÁé Aàÿ��ë1¹
+��� @�A÷ÐH£ÊAƒÐ�Aø?��‡k ��G¿„C@#��ÿÁE…ÀxØf¾�…É„!þÿÿHÓêH‰$)ȉD$D‰D$ Aƒøs(ÿÉ��ƒ- ��Eˆ„; )��G‰D$E1íI‰è1öééýÿÿH…ÿufA½� Aƒø„ÒýÿÿH¸������H‰D$HÇD$P���D‰ÀHxðHƒÿ‡ô ��‹D„‰D$fA½� é˜ýÿÿƒø r<¹ ��� @�qÿA÷ÐH£òAƒÐ�Aø?��‡V ��G¿„C@#��E…À‰ÕþÿÿÿÁ9ÈsÍf¾�fA½�üH9Ýt4D¶E�‰ÁIÓàLML ÂH‰$H‰ÁHƒÁ‰L$ƒøvL‰Í‰ÈL‹L$éþÿÿI‰ØéýÿÿM‰ÖA‰ÐAàÿ��G¿„C@��E…Àx(E·ÐAú���r]AÁè D9ÁrTL‰Í‰ÈM‰òL‹L$éBþÿÿƒør=Aº ���EZÿA÷ÐL£ÚAƒÐ�Aø?��‡Š ��L‹\$ G¿„C@#��E…Ày´AÿÂD9ÑsÉI‰ØI9ÙM‰òL‹L$„wüÿÿ¶uHƒÅHÓæH òéÎýÿÿ €����‹L$H‹$Hƒùs*fH9Ý„â��¶U�HÿÅHÓâH ÐH‰$HƒÁ‰L$HƒùrØH‰ÂHÁêH‰$ƒÁý‰L$‰ÁƒáA‰‹ø(��ÑèƒàA‰ƒü(��ƒø…ü��H¸ �� ���I‰ƒ)��( »þÿH‹D$x€€���@p@`@P@@@0@ @�(;»þÿH‹„$À���@`@P@@@0@ @�H¸H‹Œ$¸���H‰A(«¹þÿH¸I‰ƒ˜
��foo¹þÿH‹D$pó@ó�H‰æL‰ßM‰Öè“ ��L‹L$M‰òL‹\$ „À„¾þÿÿ‰Áá� ��¶Àƒø„��éª�� D��Aǃ)�����H‰æL‰ßM‰ÖèG ��L‹L$M‰òL‹\$ A‰ÅE„í…‰���‹|$A;»)��sÁ‹L$H‹$Hƒùs+ �H9Ý„J��¶U�HÿÅHÓâH ÐH‰$HƒÁ‰L$HƒùrØH‰ÂHÁêH‰$ƒÁý‰L$ƒÿƒº��H
>óþÿ¶ $Aˆ„ À'��G‰D$E1íE„í„wÿÿÿA¶Åé��M‰ÖD‹D$‹T$H‹<$‹t$D‰Àƒà?IÇÁÿÿÿÿ‰ÁIÓáI÷Ñ �A‰ÒE)ƒg��H9Ý„ç��D¶U�HÿʼnÑIÓâL ×H‰<$ƒÂ‰T$ëÎM‰ÖD‹D$‹T$H‹<$‹t$ D‰Àƒà?IÇÁÿÿÿÿ‰ÁIÓáI÷Ñ D��A‰ÒE)ƒ$��H9Ý„��D¶U�HÿʼnÑIÓâL ×H‰<$ƒÂ‰T$ëÎH9Ý„��¶E�HÿÅA‰ƒì(��AµéøøÿÿH9Ý„ñ��A‹“ì(��‰ÐÁèƒÀƒà0‰ÑƒáƒñÁâ¶u�HÿÅA‰³ð(�� òHiú…BHÁï A‰ÐA)øAÑèAøAÁèD‰ÇÁçA)øAЃæ ÆD Æ Î¸ ���A½���DEèé}øÿÿ‹D$‰Á€áHÓ,$ƒàø‰D$ÇD$����AµéYøÿÿ‹D$‹t$H‹<$ƒøº���CÐH9Ðt~…ötT‰öHƒþs3 „�����H9Ý„"��D¶E�HÿʼnñIÓàL ÇH‰<$HƒÆ‰t$HƒþrÕAˆ¼ )��HÁïH‰<$ƒÆø‰t$ë1öH9Ý„Y��¶M�HÿÅAˆŒ )��HÿÀ‰D$H9Ðu‚A·ƒ )��A·‹ )��÷щD$Aµ f9È…÷ÿÿAµf…À„‘÷ÿÿ…ö¸���A½���DDèé{÷ÿÿ1ÀM9Ñ•Àƒ|$�D€A½���DEè„Z÷ÿÿM9Ñ…Q÷ÿÿé%��D‰áI‰ÜH‰èI)ì„��L‰ËL)ÓL9ãICÜD‹l$L9ëICÝI‰ÞMÖ‚j��M9·u��LT$(L‰×H‰îH‰ÚÿÇV�HCÿHÝHÿÍHÿÅI9ÄH‹D$8HFèA)ÝH‰ÃD‰l$AµM‰òL‹\$ L‹L$é¿öÿÿM‰Ô‹|$‹D$H‹4$‹\$‰úƒâ?IÇÀÿÿÿÿ‰ÑIÓàI÷ÐD‹L$ E‰ÊAƒâ �A‰ÃA)ûƒŒ��H;l$8„â��D¶]�HÿʼnÁIÓãL ÞH‰4$ƒÀ‰D$ëÌE‰àL‹$$‹t$H‰ØH)èHƒøƒ¹��ƒþ‡µ
��Hƒøƒy��D‰à%ÿ��A¿<C…ÿˆý ��·Ç=���‚$
��Áï 9þƒ}
��é
��‹D$Aµ=ÿ���‡âõÿÿM9Ñ„��†'��H‹L$(BˆIÿÂAµ é¿õÿÿ‹D$H‹$Hƒø‡2��H‰ÙH)éHƒùƒ��‰Ñáÿ��A¿¼K
��…ÿˆ ��·Ïù���‚© ��Áï 9øƒï��é™ ��‹L$H‹$Hƒùs6fffff. „�����H9Ý„Ï��¶U�HÿÅHÓâH ÐH‰$HƒÁ‰L$HƒùrØH‰ÂHÁêH‰$ƒÁø‰L$¶À‰D$ Aµé�õÿÿM9Ñ„è��†E��¶D$ H‹L$(BˆIÿƒ|$�¸���A½���DDèÿL$DDèé¿ôÿÿAµAƒ»ø(���„®ôÿÿH‹$‹L$‰ÈƒàøH)ÝLý‰ÎÁî9îCõDõ����D)À‰D$H)õL9ý‡õ��€áHÓê$8HÇÆÿÿÿÿ‰ÁHÓæH÷ÖH!ÖH‰4$H¬$°���ÇD$����Aµé@ôÿÿ‹D$‰Ááÿ��‰L$Aµù���„!ôÿÿAµ!ù ��‡ôÿÿ(r´þÿD$Xfo%´þÿóD$HÿÈƒà ¶LH…ÉA”ʼnL$H
–ìþÿ·A‰D$A€ÍéÌóÿÿ‹t$‹D$L‹$ƒþ¿���CþH9þ„œ���H¹������H‰L$HÇD$P���‹T´H9Ðs, @�H9Ý„p ��D¶M�HÿʼnÁIÓáM ÈL‰$ƒÀ‰D$9ÐrØM‰Á‰ÑIÓéL‰ $)ЉD$M‰ÖIÇÂÿÿÿÿIÓâA÷ÒE!ÐM‰òH
kìþÿ· qDÁA‰Œ³)��HÿƉt$M‰ÈH9þ…dÿÿÿº ��H‹¼$¨���1öM‰ÖÿçR�M‰òL‹\$ ÇD$����AµA»)�� ��L‹L$‡ÏòÿÿAƒ»)�� ¸ ���A½���DBèé³òÿÿ‹\$ D‹d$L‰ÈL)Є٠��L‰ÒH)ÚE‰æL9ðLBðH‹|$(L‰ÎL‰ÑM‰ðM‰ÕèŽ��L‹L$M‰êMòAµ E)ôD‰d$u¶éµ��‹L$ Aµ L‰ÐH)È‚GòÿÿD‹D$K L9ËwL9Ђ¢��H‰ÈH÷ØL9Àƒ“��M…À¸ ���A½���DDèH‹\$8éòÿÿ‹D$‹t$L‹$A‹“ô(��ƒø¿���Cø9ø„Œ���…öt\‰öHƒþs5f. „�����H9Ý„°
+��D¶M�HÿʼnñIÓáM ÈL‰$HƒÆ‰t$HƒþrÕA¶ÈIÁèL‰$ƒÆø‰t$Áâ ÊL‹L$ë1öH9Ý„ó��¶M�HÿÅÁâ ÊA‰“ô(��ÿÀ‰D$9ø…tÿÿÿAµéKñÿÿ¶Âƒø…Q
+��AÁíé6ñÿÿA!ùDΉÁHÓïH‰<$D‰T$‰t$AµëA!ùDΉÁHÓïH‰<$D‰T$‰t$ AµM‰òL‹L$éñðÿÿH‰ð‰ÑHÓèH‰$D‰\$HÇD$H���HÇD$P���HÇD$X ���Aƒú„‚��N‹tÔHAƒùH‹D$ …��H{ÿHÿÈ��L‹L$‡p��M‰â¶Œ8 )��é‘��D‹t$‹L$ ‰L$0‹T$ €����L‰ÉL)ÑHƒù‚ úÿÿHù��r
+Hƒø
‡â��ƒþ s‹E�HƒÅ‰ñHÓàI ÄL‰$$ƒÆ ‰t$D‰à%ÿ��E¿4CE…öxA·Æ=���‚õ��D‰ñÁé ë-¹
+���A÷ÖI£ÌAƒÖ�Aþ?��‡ö��G¿´s���ÿÁE…öxØD‰t$IÓìL‰$$)Ήt$A÷Æ���…B��D‰à%ÿ��A¿<C…ÿx·Ç=���‚Š��‰ùÁé ë7¹
+���fffff. „�����÷×I£Ìƒ×�ÿ?��‡]��A¿¼{���ÿÁ…ÿxÜIÓìL‰$$)Ήt$M9ц“��H‹D$(Fˆ4IB÷Ç���…��L9ȃ‡��H‹D$(Bˆ|IƒÂH‰ØH)èHƒøƒ–þÿÿéÀøÿÿ1ÉM‰âL‹L$L!ÆIöL‰ðHØ‚q��H=É��‡t��M…öt H‹D$@H<¶ñL‰òÿ§N�L‹L$M‰âAÞD‰t$Aµ
+H‹\$8L‹\$ é–îÿÿ·u�‰ÁHÓæH òHƒÅH‰$ƒÀ‰D$‰Ñáÿ��A¿¼K
��…ÿx
‰ùÁé çÿ��ë4¹
+���ff. „�����÷×H£Êƒ×�ÿ?��‡-��A¿¼{ ��ÿÁ…ÿxÜAµ#…É„îÿÿHÓêH‰$)ȉD$Aµ"ƒÿ îÿÿ(qþÿD$Xfo4þÿóD$Hƒç ¶D<H…À‰D$HËæþÿ·x‰D$ ¸���A½���DDèé¶íÿÿAµé®íÿÿ·E�‰ñHÓàI ÄHƒÅL‰$$ƒÆ‰t$é��H‹|$(L‰ÎL‰Òè¥��L‹L$L‹\$ Aµ I‰ÚH‹\$8édíÿÿH‰ØH)è± ‰L$4Hƒø‚��ƒþ w‹E�‰ñHÓàHƒÅI ÄƒÆ D‰à%ÿ��A¿C…Àx·Èù���‚· ��‰ÁÁé A‰Æë<¹
+���A‰Æfff. „�����A÷ÖI£ÌAƒÖ�Aþ?��‡ö ��G¿´s���ÿÁE…öxØIÓì)ÎA÷Æ���…Á���D‰à%ÿ��A¿<C…ÿx·Ç=���‚@ ��‰ùÁé ë4¹
+���ff. „�����÷×I£Ìƒ×�ÿ?��‡m ��A¿¼{���ÿÁ…ÿxÜIÓìM9ʃ ��)ÎH‹D$(Fˆ4IB÷Ç���u>L9ȃ£ ��H‹D$(Bˆ|IƒÂL‰ÈL)ÐH=��‚æ��H‰ØH)èHƒøƒ»þÿÿéÑ��I‰ÂA‰þD‰ð%ÿ��=���„¬��= ��‡@ ��(@¬þÿD$Xfoó«þÿóD$HAÿÎAƒæ B¶T4HHkäþÿF·4pƒþ w&H‰ñH‰ÞH)îHƒþ†C
��‹E�H‰ÎHÓàHƒÅI ÄƒÆ …Òt HÇÀÿÿÿÿ‰ÑHÓà÷ÐD!àIÓì)ÖDðA‰ÆD‰à%ÿ��A¿¼C
��…ÿx·Ç=���‚ß
+��‰ùÁé ë)¹
+���÷×I£Ìƒ×�ÿ?��‡ ��A¿¼{ ��ÿÁ…ÿxÜIÓìçÿ��)΃ÿ ‡y ��(kªþÿD$Xfo.ªþÿóD$H¶T<HHÎãþÿ·x‰D$0…ÒtIƒþ s&H‰ñH‰ÞH)îHƒþ†_ ��‹E�H‰ÎHÓàHƒÅI ÄƒÆ HÇÀÿÿÿÿ‰ÑHÓà÷ÐD!àIÓì)ÖD$0‰D$0‹L$0I9Ê‚ø
+��E‰ðL‰„$˜���H‹|$(H‰´$ ���L‰Î‰ÐL‰Ò‰„$Œ���L‰T$hèi��‹”$Œ���H‹´$ ���L‹L$L‹T$hL‹\$ L”$˜���L‰ÈL)ÐH=��ƒ¦üÿÿéÒ��ƒø r4¹ ���qÿ÷×H£òƒ×�ÿ?��‡‚
+��A¿¼{ ��…ÿ‰WûÿÿÿÁ9ÈsÑAµüH9Ý„U��¶}�‰ÁHÓçHuH úH‰$H‰ÁHƒÁ‰L$ƒøv4‰ÈH‰õéûÿÿ…À„â��ƒø…ß��ÇD$����f¹�éÒ��Aµéhéÿÿ‰×çÿ��A¿¼{
��…ÿˆN��D·ÇAø���‚z��Áï 9ù‚o��‰ÈH‰õL‹L$é©úÿÿ‰|$I‰ÂAµééÿÿƒþ r0¸ ���Hÿ÷×I£Ìƒ×�ÿ?��‡’ ��A¿¼{���…ÿyjÿÀ9ÆsÕAµüH9Ý„ ��HE¶U�‰ñHÓâI ÔL‰$$N‰L$ƒþw3D‰ââÿ��A¿<S…ÿˆ ��I‰ö·×ú���‚3��Áï 9ù‚(��‰ÎH‰ÅD‰à%ÿ��A¿<C…ÿx
‰ùÁé çÿ��ë)¹
+���÷×I£Ìƒ×�ÿ?��‡=��A¿¼{���ÿÁ…ÿxÜAµ#…É„*èÿÿIÓìL‰$$)Ήt$‰|$Aµ
éèÿÿAµ#é èÿÿAµ#éèÿÿƒør8A¸ ���EHÿ÷×L£Êƒ×�ÿ?��‡|��A¿¼{ ��…ÿ‰™þÿÿAÿÀD9ÁsÎH9Þ„®���¶6HÓæH òL‹L$é ùÿÿf¹�ëf¹�D·ééVöÿÿI‰öƒþr4º ���rÿ÷×I£ôƒ×�ÿ?��‡��A¿¼{���…ÿ‰ÞþÿÿÿÂ9ÑsÑH9Ø„‹��¶�HÓàI ÄL‰öéùÿÿ°‰D$4A¾���L‰$$‰t$‹D$0‰D$ D‰t$‰T$D‹l$4éçÿÿAµü1öH‰ÝL‹L$éÕ���Aµüé‹���fA½üH‰ÝAÁíA€ý”Àt A¶Íùü���uq1öA€ý„‹���é›���AµA´1ÀM‰ÊH‹\$8L‹\$ ëIAµüA´ëAµüA´1öH‰ÝM‰òL‹L$ëgAµü1öH‹\$8H‰ÝL‹\$ M‰âA´ L‹L$ëHAµüA´1öH‰Ýë;D‰ù)Ùé‹T$‰ÖÁî9ÎCñ õ����)ʉT$„ÀtM9Ê•ÀA€ü”ÁÁAµA(Í‹L$HÇÀÿÿÿÿHÓàH÷ÐH#$Eˆ£é*��A‰‹è(��H‹L$ I‰‹)��‹L$A‰‹ )��I‰ƒà(��E„íx}M9ʇ��A‹ƒ�)��D·ðA‰ÁAÁéD‰ÐƒàH‰D$L‰ÑHƒáüL‰ÐHÁèHº·˜c»¦ºyH÷âHÑêLiÚÀV��I‰ÌM)ÜIûÀV��L‰¼$€���L‰T$hD‰l$4s 1ÒfïäfïÒ1Àé��H‹„$���é²��L‰d$pH‰l$@D‰t$xEiæÀV��fïÀE1öA½q€€fo%¤þÿfo }¤þÿE1ÒM‰ØH‹|$(1À1ÒfïäfïÉf D��HÇÃ@©ÿÿf „�����D¶¼ ÀV��AǶ¬ ÁV��DÕ·„ ÂV��fnèf`èfaèfþìDúAîfþͶ„ ÄV��D¶” ÅV��DøAê·¬ ÆV��fnåf`àfaàfþåÂEÖfþÌHƒÃu‰HÇÀV��IÀ@©ÿÿEá‰ÃI¯ÝHÁë/iÛñÿ��)ØD‰ÓI¯ÝHÁë/iÛñÿ��A)ÚfoìfôêfpíífpôõfôòfpöífbîfrÕfpõõfôëfpíèfôófpöèfbîfúå‰ÓI¯ÝHÁë/iÛñÿ��)ÚD‰óI¯ÝHÁë/iÛñÿ��A)ÞfoéfôêfpíífpñõfôòfpöífbîfrÕfpõõfôëfpíèfôófpöèfbîfúÍL‰ËI¯ÝHÁë/iÛñÿ��A)ÙIøÀV��ƒuþÿÿfAnÒfsò flÔfAnæfsô fláH‹l$@D‹t$xL‹d$pfnÀfoÊóÈfnÚfoÄóÃM…äH‹\$(„���fpÚUfA~ØfpÜUf~ßfpÚîfpÔîfïä �F¶DÐF¶TEÐF·TfAnêf`ìfaìfþÝÂDÇfþÓIƒÃL9ÙuÆfAnàÌËfnßÉÇA¸q€€I¯øHÁï/iÿñÿ��)ø‰×I¯øHÁï/iÿñÿ��)úE¯æEáfpÑUfA~Ò¿q€€M‰ÐL¯ÇIÁè/EiÀñÿ��E)ÂfpÑîfA~ÓM‰ØL¯ÇIÁè/EiÀñÿ��E)ÃfpÉÿfA~ÈL‰ÃH¯ßHÁë/iÛñÿ��A)ØfpÈUf~ËE‰÷I‰ÞL¯÷IÁî/Eiöñÿ��D)ófpÈîfA~ÎM‰ôL¯çIÁì/Eiäñÿ��E)æfpÀÿfA~ÄM‰åL¯ïIÁí/Eiíñÿ��E)ìAÔºñÿ��D)ÂRM‰ÍL¯ïIÁí/Eiíñÿ��E)éG ±E ™C ZA)ÙG ¡DÊÂÓÿ�DøDÐEØAÀL‹L$M…Ét7L‹\$(A¶ AÀDÂAƒùH‹\$8M‰ÎL‹L$ L‹T$hD‹l$4u(L‹¼$€���ëDH‹\$8L‹L$ L‹T$hD‹l$4L‹¼$€���ë&A¶D AÀDÂAƒþL‹¼$€���t A¶D AÀDÂD‰ÀH¯ÇHÁè/iÀñÿ��A)À‰ÐH¯ÇHÁè/iÀñÿ��)ÂÁâD ÂA‰‘�)��E„íH‹„$���uA;‘ô(��A”ÅE�íA€ÅþHÞI)÷IïDˆhL‰8L‰PHÄÈ���[A\A]A^A_]ÃAµüH‰ÝéMúÿÿH#�¾@��L‰Çè©Œÿÿ ±#L‰$$‰t$‹D$0‰D$ D‰t$‰T$1ÀA‰Ìé×ùÿÿA´1ÀE1íéÊùÿÿ1ÀéÃùÿÿM‰Êé5ùÿÿ1öAµüH‰ÝA‰ÌéæùÿÿAµA´ë8H§"�¾@��è=Œÿÿ D·ééýøÿÿH‹"�¾@��L‰÷è Œÿÿ AµA´
1ÀM‰Êéaùÿÿ1öH‰ÝE‰ÄéùÿÿHˆ"�é=ÿÿÿHl&�L‰×ë±!A‰Æé8ÿÿÿHV&�H‰ÇL‰ÎèË‹ÿÿ ±"é ÿÿÿ± éÿÿÿH$'�¾É��誋ÿÿ H1"�éUÿÿÿHí&�ë HÌ&�¾���è‚‹ÿÿ H'�¿���¾���èj‹ÿÿ H'�ë«H&�ëH&�¾ ��H‰×H‰ÂèO”ÿÿ H&�H‰÷H‰Æè žÿÿ H&�¾É��H‰Çè%”ÿÿ H‰×H‰Æèè»ÿÿ H'&�L‰×L‰Îè”ÿÿ Hƒ%�L‰×L‰öèÀÿÿ Ho%�L‰÷H‹t$èÚ“ÿÿ HÑ%�H‰ïL‰þè6Šÿÿ He&�H‰ßérÿÿÿHV&�éwÿÿÿH
+!�¿���蘓ÿÿ ÌÌÌÌÌÌUAWAVAUATSHì¸���H‰t$I‰þ‹¿ü(��Hƒÿ‡y��L‰´$¨���ffffff. „�����Hiß
��M$ E‹¼¾)��WÀ)D$P)D$@)D$0)D$ HÇD$`����º€ ��L‰ç1öÿ¥=�Iÿ!��ƒ¬��M…ÿ„‡���I H€ ��1Éff. „�����¶<Hƒÿƒ<��ÿD¼ HÿÁI9ÏuæD‹\$$‹|$(D‹t$,‹\$0‹D$4H‰$D‹l$8D‹D$<‹D$@H‰D$D‹T$DD‹L$H‹L$L‹D$PH‰D$‹t$T‹T$X‹D$\ë6 @�1À1Ò1ö1ÉH‰L$1ÉE1ÉE1Ò1ÿH‰|$E1ÀE1í1ÿH‰<$1ÛE1ö1ÿE1ÛC,‰l$hH‰¼$°���B,_<m����‰|$lA<n,?‰l$p<{,?‰l$tH‹,$|}�,?‰l$xA|}�,?‰l$|A<x,?‰¬$€���H‹l$|}�,?‰¬$„���A<z,?‰¬$ˆ���A<y,?‰¬$Œ���<y,?‰¬$���H‹l$|}�,?‰¬$”���<~,?‰¬$˜���<z,?‰¬$œ���<xÿ‰¼$ ���ÿ���t8EÞœ$°���DóD,$EèAØDT$EÑDÉDÁt$òÐȃø‡Q��E…ÿL‹´$¨���H BÄþÿ„��f¾ÿÿ1Àë5‰ÎD‰×÷×Aºáfƒ×�H¿ÿ·Ïù@��ƒŒ��fA‰”|���L9øƒÇ��H‰ÂHÿÀF¶„"€ ��fE…ÀtâA·øA€ø‡1��D‹T¼`‰ùöٶɃá A¹ÿÿÿÿIÓéEZD‰\¼`E!ÑAù���sF‹ ‹AÓéé���ff. „�����E1É@€ÿrV‰ù€áüE1Éffffff. „�����E‰ÓAƒãAÁãG ËE‰ÓAƒãE ËE‰ÑAÁéAƒáE ÙE‰ÓAÁëAƒãG KAÁê€ÁüuÁ‰ù€át f. „�����E‰ÓAƒãG KAÑêþÉuîA€ø s>Aùÿ��‡ûþÿÿ‰ùÁá ÊA¸���‰ùIÓàD‰Éf D��fA‰LLÁHù���rïéÊþÿÿD‰Éáÿ��E·LfE…Òt‰ñë fA‰4LNþA‰òAÁé @€ÿ ‚mþÿÿA€Àõë' �I4|HÆ���f‰qþAÑé‰ÏA‰Ê‰ñAþÈ„EþÿÿA÷ÒAºáfAƒÒ�I¿ú·÷þ@��ƒ¼���E·”|���fE…Òt‰ÎD‰Ñë·f D��A‹¾ü(��…ÿt0ƒÿt=ÿÏA‰¾ü(��ƒÿ‚žûÿÿH �¾���èÍ…ÿÿ f¸� ë"H‹D$Ç@����f¸� ëH‹D$Ç@����f¸�
+·À%� ��ƒÈHĸ���[A\A]A^A_]ÃHŸ �¾���èu…ÿÿ HD �¾���èb…ÿÿ Ha �¾@��èO…ÿÿ H6 �ëëHý�¾ ��L‰ÿè@Žÿÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌÌPI‰ÑH)ÊIƒøu`H9Ö†ì���L9Άì���¶BˆHBH9ðƒà���IAH9ðƒÜ���¶Lˆ HƒÂH9òƒØ���IƒÁI9ñƒß���¶BˆXÃL9Êr H‰ÈH÷ØL9Àr?I9Èw:JH9ðs1L9Ês5L)΂º���L9Æ‚Á���H9‡Á���L9ȇÏ���IùHúë6L‰ÉXé+��H)Ö‚É���L‰ÀLÈ‚×���H9Їâ���L9Æ‚ð���HúIùL‰ÏH‰ÖL‰ÂXÿ%¦7�Hw �ë*H† �ë5H• �ëH¤ �H‰Çèôƒÿÿ H« �H‰×H‰Âèàƒÿÿ H¯ �L‰Ïèσÿÿ H=ïÖþÿH÷ �ëBH �ëwH
�H‰×H‰ÆH‰Êè–ÿÿ Hþ �H‰ÇL‰Î蛌ÿÿ H=«ÖþÿHk �¾#���è!ÿÿ Hp �L‰ÏH‰Æè=–ÿÿ H
\ �H‰ÇH‰ÖH‰ÊèVŒÿÿ H] �L‰ÇèEŒÿÿ ÌÌÌAWAVATSHƒì8M‰ÇH‰óI‰þH‰ÖH)ÎH‰ÈH)ÐHBÆv`HƒøuZHyÿH9߃Ó��L‰úHƒâüI‰ÔIÌ‚¨��I9܇³��H…ÒtI<A¶tÿÿn6�IT$ÿAƒçHv˜þÿJc4¸HÆL‰áÿæH9ÊsgHƒøvaIƒÿ‚@��L‰øHÁèH{üf. „�����HrHÿÆ„Ì��H9ò‡Ê��H9Þ‡Õ��H9Ï‚à��A‹4A‰4HƒÂHƒÁHÿÈuÃéé���Iƒÿ‚ß���L‰þHÁîN2IƒÀN 1IƒÁ1Àff. „�����H<H9߃��H<H9߃‹��A¶|�ýAˆ|ýH<HÿÇH9߃y��H<HÿÇH9߃r��A¶|�þAˆ|þH<HƒÇH9߃_��H<HƒÇH9߃W��A¶|�ÿAˆ|ÿH<HƒÇH9߃D��H<HƒÇH9߃<��A¶<�Aˆ<HƒÀHÿÎ…KÿÿÿHÂHÁAƒçH
+—þÿJc4¸HÆÿæH9Úƒ ��H9Ù‚¦���Hh�H‰Ïéò���H9Úƒ��H9Ùƒ��A¶AˆHÿÂH9Úƒ��HÿÁH9ÙrhHŠ�H‰Ïé´���H9ÚƒÐ���H9ÙƒÜ���A¶AˆHzH9߃Û���HyH9߃×���A¶DAˆ>HƒÂH9ÚƒÉ���HƒÁH9ÙƒÓ���A¶AˆHƒÄ8[A\A^A_ÃHÕ�ë=Hä�ë4Hó�ë+H�ë"H�ëH �ëH/�ëH>�H‰Þè&€ÿÿ HU�ëíH<�ëLHc�ëCHº�ë:Hi�H‰ÏëÆH½�H‰ÏëºHi�ëHÀ�ë¨HÏ�ëŸHÞ�H‰×H‰ÞH‰Âè¸ÿÿ Hß�H‰ÏéyÿÿÿèB°ÿÿ Há�H‰×H‰Âèn’ÿÿ HÍ�H‰÷H‰Þ芈ÿÿ H©�H‰D$HÇD$���HtÐþÿH‰D$WÀD$ H5�H|$è~~ÿÿ H…�H‰ÏL‰æè
+’ÿÿ Hq�L‰çëšÌÌÌÌÌÌÌÌÌÌÌÌH9Ñ’ÀH9ñ@—Æ@ÆH×1À@„öHEøH)Ñ„��@„ö…��H4Hƒùw1ÀH‰ú �€:�t*HÿÂH9òróéî���óofïÉftÈf×Á…Àtó¼Ðéö���H)úéî���H‰úHƒâðHƒÂHƒù@rjHFÀH9ÂwafïÒff. „�����fo"foZfoJ foB0foìftêfoóftòfëõfoéftêfoøftúfëýfëþfD×ÇE…ÀuXHƒÂ@H9Âv®HFðH9Âw fïÀóo
+ftÈfD×ÁE…ÀuHHƒÂH9ÂvåH9òs óoFðfïÉftÈf×Ñ…Òt H)øó¼Òë$1ÀÃfïÒH)úftâf×Ä…Àt ó¼ÀëH)úóA¼ÀHÂ1ÀH9ÊHGøH‰øÃftÚf×Ã…Àt
ó¼ÀHÂHƒÂëÚftÊf×Á…Àt
ó¼ÀHÂHƒÂ ëÁftÂHƒÂ0fqðf×À…Àtó¼À‰À롸 ���‰Àë˜ÌÌÌÌÌÌAWAVSÿVH‰ÃI‰Ö¶cB�¿8���ÿ˜0�H…Àt@H¹TSUR�ZOMH‰H
w���H‰HWÀ@H
ÇþÿH‰H H‰X(L‰p0H‰Ç[A^A_ÿ%‹0�¿���¾8���è uÿÿ I‰ÇH‰ßAÿIƒ~�t H‰ßÿ0�L‰ÿèý� Iƒ~�t H‰ßÿ÷/�èÿÿ PH‰÷è���è²í� è{›ÿÿ ÌÌÌÌÌÌÌÌÌAWAVATSPH‰ûL‹w(L‹g0L‰÷Aÿ$Iƒ|$�t L‰÷ÿ¥/�H‰ßHƒÄ[A\A^A_ÿ%‘/�I‰ÇIƒ|$�t L‰÷ÿ}/�H‰ßÿt/�L‰ÿè|ü� ÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHƒìL‹fH‹n1ÀL‰âH)ê‚Ì��I‰öH‹NH‰L$I9̇·��H‰<$M‹.L‰îHîIF(H‰D$M‹~ Iƒÿ†Õ���ëL‰îHîL‰âH)ê‚x��H‹D$B¶D8ÿHƒús-1ÉH…Òtf D��8t1HÿÁH9ÊuóH‰Ñ1ÀHƒøt8é1�� �¶øèøªÿÿH‰ÑHƒøt é��¸���Hƒø… ��ff. „�����HÍHÿÅI‰nL9ý‚mÿÿÿH;l$‡bÿÿÿHƒ!�¾���L‰ÿèþƒÿÿ fff. „�����L‰îHîL‰âH)ꂸ���H‹D$B¶D8ÿHƒús-1ÉH…Òtf D��8t.HÿÁH9ÊuóH‰Ñ1ÀHƒøt(ëtf D��¶øè8ªÿÿH‰ÑHƒøtë[¸���HƒøuPfHÍHÿÅI‰nH‰ëL)û‚zÿÿÿH;l$‡oÿÿÿJ<+H‹t$L‰úÿÕ-�…À…UÿÿÿH‹<$H‰_H‰o¸���ëM‰f1ÀH‹<$ëH‹<$1ÀH‰HƒÄ[A\A]A^A_]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHƒìHI‰õI‰þL‹~ L‹f(I‹l$H5‰Çþÿº
���L‰ÿÿÕ³„À…E��AöE4uzH5Éþÿº���L‰ÿÿÕ„À…%��H59§þÿº���L‰ÿÿÕ„À… ��H5×þÿº���L‰ÿÿÕ„À…ó���L‰÷L‰þL‰âè��„À…Ý���H5¨Èþÿº���L‰ÿAÿT$éÂ���H5ø¦þÿº���L‰ÿÿÕ„À…«���ÆD$M‹} óAoE fD$0fD$HD$H‰D$ H5š¦þÿH|$º���èÿÿ„ÀulH5eÖþÿH|$º���èuÿÿ„ÀuRH �Ht$L‰÷è]���„Àu:H5q¦þÿH|$º���èCÿÿ„Àu fpD$0îfH~ÀH5óÆþÿº���L‰ÿÿP‰Ã‰ØHƒÄH[A\A]A^A_]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌH‰ñ¶7H;ÈþÿH‹ðH=XÈþÿHc4·HþL‹BH‰ÏH‰ÂAÿàÌÌÌÌUAWAVATSHƒì`H‰ûH‹H…É„r��‹CÿÀ‰C=õ��szA‰÷H‹sH‹CH9ðƒG��D¶$HPH‰SA|$¾ƒÿ‡,��L€þÿIc<¸LÇÿçH9òƒ_��€<s…U��HxH‰{H9÷ƒ2��€<9_…(��HƒÀH‰Cé-��H‹{ H…ÿt H5Æþÿº���èâ€ÿÿ@µ„À…ê��HÇ����ÆCéØ��A¶÷H‰ßè;��@µé‰��H‰çH‰ÞèÈ��€<$�„&��D¶t$H‹{ E„ö„×��H…ÿ„ï��H5Æþÿº���éÎ��A¶÷H‰ßèÅþÿÿ@µ„À…m��E„ÿt"H‹{ H…ÿtH5ÁÄþÿº���è;€ÿÿ„À…F��H‹{ H…ÿtH5¥Äþÿº���è€ÿÿ„À…$��H‰ßèY��H…À…��é·��H‰ßè��I‰ÆAöÆ…Ú���A¶÷H‰ßè:þÿÿ@µ„À…â��Hƒ;�„‚��H‰çH‰ÞèÚ��€<$�…ÿÿÿHƒ;�„“��L‹|$H‰çH‰Þè†��Hƒ<$�„=��IÁî $L$)L$0)D$ Aþ���…‰��H‹D$(H D$8„1��H‹{ H…ÿ„$��H5¿Ãþÿº���è9ÿÿ„À…D��H‹s H…ö„þ��H|$ è ��éë��L‹s é_��H‹{ Aæ���…x��H…ÿ„��H5ë‡þÿº���éo��1ÀA¸>���H9÷ƒµ��¶9€ú_„Ú��DJÐA€ù
+r#DJŸA€ùs€Â©ëDJ¿A€ùƒ��€ÂãA‰ÑHÿÇH‰{I÷à€k��A¶ÑHÐs¤é]��Hƒ;�„[��L‹t$H‰çH‰ÞèN��Hƒ<$�„��$L$)L$P)D$@H‹s H…ö„
��H|$@è)��@µ„À…1��H‹C H…À„ë��ö@4…á��H‹x H‹@(H5ªÃþÿº���ÿP„À…û��H‹s L‰÷è ”ÿÿ„À…ç��H‹C H‹x H‹@(H5tÃþÿº���ÿPéŠ��H…ÿt H5¨†þÿº���èž}ÿÿ@µ„À…¦��HÇ����Dˆsé”��H…ÿt H5
+Ãþÿº���èm}ÿÿ@µ„À…u��AÁîHÇ����Dˆsé_��D¶t$é«üÿÿH‹{ H…ÿ„G��H5«Áþÿº���è%}ÿÿ„À…0��Hƒ;�…NýÿÿH‹{ H…ÿ„��H5«Âþÿº���HƒÄ`[A\A^A_]éé|ÿÿHÿÇH‰{HÿÀ„¾���Hƒøÿ„´���L‹s HÇC ����H‰ß1öèûÿÿ„À… ��L‰s M…öt H5#Áþÿº���L‰÷è”|ÿÿ@µ„À…œ���H‰ßèá ��@µ„À…‰���A€üMt,H‹{ H…ÿtH5˜ þÿº���èV|ÿÿ„ÀueH‰ß1öè¨úÿÿ„ÀuWH‹{ H…ÿtH5µÀþÿº���è*|ÿÿ„Àu9Hƒ;�t1ÿKë,H‹{ H…ÿtH5 …þÿº���è|ÿÿ@µ„Àu
HÇ����ÆC�1í‰èHƒÄ`[A\A^A_]ÃH‹{ H…ÿtH5‚Áþÿº���èÄ{ÿÿ„ÀuÓAƒþCt AƒþSu3H‹{ H…ÿtGH5ìŸþÿº���ëH‹{ H…ÿt0H5DÁþÿº���èƒ{ÿÿëH‹s D‰4$H…ötH‰çè¬ ÿÿ„À…wÿÿÿH‹D$(H D$8H‹{ u\H…ÿ„%ÿÿÿH5Áþÿº���è:{ÿÿ„À…EÿÿÿH‹s L‰<$H…ö„ûþÿÿH‰çè rÿÿ„À…$ÿÿÿH‹{ H…ÿ„ÞþÿÿH5ô¿þÿéÄþÿÿH…ÿ„ÉþÿÿH5`Óþÿº���èÞzÿÿ„À…éþÿÿH‹s H…ö„£þÿÿH|$ è¿��„À…ÊþÿÿH‹{ H…ÿ…_ÿÿÿéþÿÿH=N¿þÿH
'
�L �H‰â¾=���è“‹ÿÿ ÌUSHƒì(H‰ûL‹M…À„›���L‹KH‹{L9ÏsA€<8_uHGH‰C1Àé¨���1ÀA»>���I‰úffff. „�����±M9ʃæ���C¶€ú_tojÐ@€ý
+r$jŸ@€ýs €Â©ë @�j¿@€ýƒ´���€Âã‰ÕIÿÂL‰SI÷〟���@¶ÕHÐs¥é‘���H‹{ H…ÿ„Ê���H5h¿þÿº���HƒÄ([]é¬yÿÿIÿÂL‰SHÿÀtaHÿÏH9øsW‹KÿÁùõ��ƒ—���Hƒ{ �„ƒ���K)L$)$H‰C‰K1À@„ö•ÀH‰ß‰Æè³÷ÿÿ($(L$KëJ±1íH‹{ H…ÿt0‰È4¶ÀHÀHƒÂH ‚þÿH5ª¾þÿ„ÉHEðè yÿÿ‰Á°„Éu
HÇ����@ˆk1ÀHƒÄ([]Ã@µ1Éë¬ÌÌÌÌÌÌÌÌÌH‹NH‹FH9Ès*L‹A€<�su LHL‰NI9És C€<_uHƒÀH‰F1Àë|HÇG����1ÀˆÃ1ÀAº>��� @�I9ÉscC¶€ú_tHDZÐA€û
+r'DZŸA€ûs
€Â©ë „�����DZ¿A€ûs.€ÂãA‰ÓIÿÁL‰NI÷âp A¶ÓHÐs«ëIÿÁL‰NHÿÀtHÿÀu ÆG�°ˆÃH‰GéuÿÿÿÌÌÌÌÌÌSI‰ñH‹vI‹IH9ñs I‹€<uuHÿÁI‰IA°H9ñré‰��E1ÀH9ñƒ}��M‹A¶
+PÆ€úö‚i��HÿÁI‰IÐtI¶ÀA»
+���fffff. „�����H9ÎtiA¶
+SÆ€úör"HÿÁI‰II÷ã€%��€ÃжÓHÐsÓé��1ÀH9ñsA€<
+_uHÿÁI‰IHÈ‚÷���I‰AH9ð‡ê���H9ñsA€<
+À}éê���H‰ñHÈsÚéÌ���…×���H…ÀtH9ðs A€<¿ŽÂ���M
+H‰ÆH)ÎE„ÀtCLÐL)ÈNIÿÈH
o¾þÿ €����H…Àt?H‰ÂHÿÈA€<_uîH…Àt8H9ðs,A€<¿,é›���L‰H‰wH2¾þÿH‰GHÇG����[Ã1Àë)uyH…ÒtEH‰ñH)Ñv A€<¿ëOuMH‰òH‰ÎLÊL‰ÉI‰ÑH…ötH‰H‰GL‰OH‰w[ÃÆG�HÇ����[Ã1ÒëÐL‰ �L‰×H‰ÊH‰Áè’ÿÿ L¢ �L‰ÏH‰ñèÿ‘ÿÿ Lv �L‰Ï1ÒëÔÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHìx��H‰óI‰ýH|$xº���1öÿï �I‹MH‰ÈH‰L$PH…É„��H‰\$@I‹EH‰D$8D¶�I‹M�I‹EH…ÀH‰L$hH‰D$p„ÿ���HÈE1Òffffff. „�����¶„ÒxHÿÁIú€���…™���é�� @�‰Öƒæ D¶IAƒá?€úßvE¶yAÁáƒç?D Ï€úðrL¶QƒæÁæÁçƒâ? ú òú���„‡���HƒÁIú€���u=é#��HƒÁÁæD ΉòIú€���u#é ��HƒÁÁæ ÷‰úIú€���„ñ��f D��B‰T”xIÿÂH9Á…?ÿÿÿë*I‹u�I‹UH‹{ H‹C(H‹@HÄx��[A\A]A^A_]ÿàE1ÒH‹D$PL‹|$8LøH‰D$XIBÿH‰D$`J•���H‰D$ N ”IƒÃxL‰ÐH÷ØH‰D$0L‰ÐH÷ÐH‰D$(IBH‰$¸¼��H‰D$A¼H���A½€���¾���H»ê ê ê1ÀH‰D$1ɺ$���L)â¸����HCÂHƒøHƒÐ�HƒøA¾���HCÆAPŸ€úrAPЀú ‡õ��A€ÀêD‰ÂIÿǶòH9ðv8Hñ‚Ú��IjH‰ÈH èHÁè „·���H‰È1ÒH÷õH‰×é¯���ff. „�����¿$���H)ǽH��� �H‰èL)àA¹����LCÈIƒùIƒÑ�IƒùMCÎL;|$X„p��A¶PŸ€úrPЀú ‡X��ê‰ÂD¶ÂL‰ÀH÷ç€D��HÆ‚;��IÿÇM9Á‡Lÿÿÿº$���L)ÊHƒÅ$H‰øH÷âH‰Çyÿÿÿé��‰È1Ò÷õ‰×IÅ’ÀH‹T$HICÕH‰T$HL‰êHÁê …æ��„À…Þ��Aý���„Ñ��D‰è5�Ø���øÿÿ=ÿ÷�‡¹��Iƒú‡¯��I9úv/D‰Ð)ø¨L‹t$tuH‰ÈL‹$L ÀHÁè t$H‰È1ÒI÷ðë! €����Hÿ€���L‹t$rzéB��‰È1ÒA÷ðH¯D$(HÁ1Àff. „�����A‹TƒüA‰ƒHÿÈD‰Ò(ʶ҃âHÂuäH+D$0I‰ÂH‹D$`LðH)øHƒør#ff. „�����BD”hBD”lIBüI‰ÂH9øwèD‰l¼xL;|$X„‚��E¶H‰ðHÁè tH‰ð1ÒH÷t$H‰Æë
+‰ð1Ò÷t$‰ÆL‹$H‰ðH èHÁè t
H‰ð1ÒH÷õH‰Áë‰ð1Ò÷õ‰ÁHñE1ÉHùÈ��r+H‰Îff. „�����H‰ðH÷ãH‰ÑHÁéIƒÁ$HþW>��H‰ÎwãHÿÇ����ÀƒÁ&1Òf÷ñD·àMÌIÿÆL‰t$HƒD$ IƒÃHÿL$0HÿL$(IÿÂL‰$¸���H‰D$I‰êL‹l$HH‰ù¾���éÎüÿÿH‹D$@L‹` H‹@(H‹@H5ºµþÿº ���L‰çH‰ÃÿÐAµ„ÀuGH‹T$pH…Òt'L‰çH‹t$hI‰ÞÿÓ„Àu,H5µþÿº���L‰çAÿÖ„ÀuL‰çH‹t$8H‹T$PI‰ÞÿÓ„ÀtD‰èHÄx��[A\A]A^A_]ÃH5Mµþÿº���L‰çL‰ðéûÿÿH\$ L‹t$@L|$xL‹d$ fA‹‰D$ H‰ßL‰öè^•ÿÿA‰Å„Àu¥IƒÇIƒÄüuÝë™Hd�¾€���èjfÿÿ ÌÌÌÌÌÌÌÌH‹OH;OsH‹¶HÿÁH‰OH¿€ùs
1Éë ¹���1Àë…1Ò1É<æ’Á¸���HBÂHÁà H ÈÃÌÌÌÌÌÌÌUAWAVAUATSHƒìH‰ûL‹'M…ä„Ô���L‹kL‹sM9îƒå��G¶<4InH‰kAGŸ<w¶À¹¿û¼£Á‚ý���‹CÿÀ‰C=ô��‡¶���AG¿ƒø‡Ù��H
Å{þÿHcHÈÿàH‹{ H…ÿtH5¾´þÿº���èoÿÿ±„À…˜��H‰ßèPÿÿÿ±„À…†��AƒÿA…C��H‹{ H…ÿ„ ��H5Ž´þÿº���è¾nÿÿ„À„��±éO��H‹{ H…ÿ„@��H5G´þÿº���HƒÄ[A\A]A^A_]éƒnÿÿH‹{ H…ÿtH5´þÿº���èinÿÿ±„À…ÿ��HÇ����ÆCéí��H‹{ H…ÿ„à��H
[�H‹4ÁH
è´þÿH‹Áë”L‹s M…ö„��H5š²þÿº���L‰÷è nÿÿ±„À…Ÿ��AƒÿP…"��H5®³þÿº���é ��H‹{ H…ÿtH5W²þÿº���èÊmÿÿ±„À…`��L9íƒ~��A€<,L…s��IƒÆL‰sH|$H‰Þè×-��€|$�„��¶l$ H‹{ @„í„��H…ÿ„¦��H5ý²þÿº���é†��H‰ßè,��éL��L‰sH‰ß1öè¥ëÿÿé9��H‹{ H…ÿtH58‘þÿº���è&mÿÿ±„À…¼���H‰ßè¤.��±„À…ª���H‹ H…ÉtuH‹CH;Csk€<LueHÿÀH‰CH|$H‰Þè -��€|$�…GÿÿÿL‹t$M…ö„È��H‹{ H…ÿtH5}²þÿº���è«lÿÿ„À…íýÿÿH‰ßL‰öèx
+��„À±u2é��H‹{ H…ÿtH5}uþÿº���èslÿÿ±„Àu
HÇ����ÆC�1ɉÈHƒÄ[A\A]A^A_]ÃH‰ßèç(��é;��H‹{ H…ÿtH5²°þÿº���è(lÿÿ±„ÀuÂH‰ßè
+-��±H…Àu³Hƒúu$H‹{ H…ÿ„��H5x°þÿº���èïkÿÿ±„Àu‰H‹{ H…ÿ„ß���H5R¿þÿëNH5èþÿº���L‰÷è¿kÿÿ„À±…Uÿÿÿé¡���H‰ß¾���è“��„À±…9ÿÿÿH‹{ H…ÿ„���H58±þÿº���è{kÿÿërH‹t$H…öt6H‰ßèG ��±„À…ýþÿÿH‹{ H…ÿtH5 ±þÿº���èCkÿÿ±„À…ÙþÿÿAƒÿRt$H‹{ H…ÿtH5?þÿº���èkÿÿ±„À…¯þÿÿH‰ßègûÿÿ±„À…þÿÿHƒ;�„‘þÿÿÿKé‰þÿÿH…ÿtH5ßsþÿº���èÕjÿÿ±„À…kþÿÿHÇ����@ˆkéYþÿÿÌÌÌÌÌÌÌÌÌÌÌAWAVATSPH‹H…ÀtVI‰þ1ÛL=D°þÿE1äI‹NI;Ns€<EtAIƒìrI‹~ H…ÿtº���L‰þèdjÿÿ„ÀuL‰÷è8���„ÀuI‹H…Àu¼ë1Ûë»���ë HÿÁI‰N1ÛH‰ØHƒÄ[A\A^A_ÃÌÌÌÌÌÌÌSH‰ûH‹H…Ét=H‹sH‹CH9ðs0¶ƒúKt0ƒúLu"HxH‰{H9÷s0€<9_u*HƒÀH‰C1Àé²���H‰ß[é.úÿÿHÿÀH‰CH‰ß1ö[é¬���1ÀA¸>��� @�H9÷sU¶9€ú_t@DJÐA€ù
+r DJŸA€ùs€Â©ë
DJ¿A€ùs)€ÂãA‰ÑHÿÇH‰{I÷àpA¶ÑHÐs´ë HÿÇH‰{HÿÀu1H‹{ H…ÿtH5Frþÿº���è<iÿÿ‰Á°„Éu
HÇ����ÆC�1À[ÃH‰ßH‰Æ[éù��ÌÌÌÌÌÌÌÌÌUAWAVSHƒìH‰ûH‹H…É„•��H‹{H‹CH9øƒ��D¶4HPH‰SD‹CAÿÀD‰CAøô��wEF¿Aƒø8‡Ò��L
uþÿOcMÈAÿàH9ús3€<nu-HƒÀH‰CH‹{ H…ÿt H5yþÿº���èyhÿÿ@µ„À…2��H‰ßD‰öè3��@µ„À… ��Hƒ;�„��ÿKé��H‹{ H…ÿt H5Éþÿº���è,hÿÿ@µ„À…å��HÇ����ÆCéÓ��@„ö„à��E1ÿé5��@¶öH‰ßè”��ëH9ús€<euHƒÀH‰CH‰ßèÇ��éoÿÿÿ@„ö„C��E1ÿé`��@„ö„Á��E1ÿé7��@„ö„á��E1ÿé¹��H|$H‰ÞèÒ ��H‹|$H…ÿ„/��H‹t$èJ
+��Hƒø…‹���Hƒú„Á��H…Òu|H‹{ H…ÿ„üþÿÿH5'þÿº���éi��H|$H‰Þèv ��H‹|$H…ÿ„Ó���H‹t$èî ��H…Àt4H‰ÐHÁè u+‰Ð5�Ø����ïÿ=�ïÿrú���tH‹{ ‰ÖèJ ��é‚þÿÿH‹{ H…ÿt H5Õoþÿº���èËfÿÿ@µ„À…„��HÇ����ÆC�ér��@„ö„��E1ÿés��H‹{ H…ÿ„:þÿÿH5¬þÿé§��H‹{ H…ÿ„��H5Q¬þÿº���èhfÿÿA·@µ„À„ù���é��D¶t$H‹{ E„ö„C��H…ÿ„[��H5Å«þÿº���é:��H‹{ H…ÿ„M��H5ó«þÿº���è
+fÿÿA·@µ„À„1��é»��H‹{ H…ÿ„n��H5«þÿº���èÙeÿÿA·@µ„À„R��éŠ��H‹{ H…ÿ„Ð��H5‘«þÿº���è¨eÿÿA·@µ„À„´��éY��H‹{ H…ÿ„Y��H5`«þÿº���èweÿÿA·@µ„À…-��é8��A·H‹{ H…ÿt H5Ô©þÿº���èGeÿÿ@µ„À…���AƒþRt%H‹{ H…ÿt H5B‰þÿº���è eÿÿ@µ„À…Õ��H‰ß¾���èôûÿÿéü��H…ÿt H5ómþÿº���èédÿÿ@µ„À…¢��HÇ����Dˆsé��A·H‹{ H…ÿt H5mªþÿº���è±dÿÿ@µ„À…j��H‰ßè>��@µH…À…V��H‹{ H…ÿ„‰��H51ªþÿë|A·H‹{ H…ÿt H5é¨þÿº���è_dÿÿ@µ„À…��H‰ßè|��@µH…À…��Hƒúu&H‹{ H…ÿ„1��H5¥¨þÿº���è dÿÿ„À…Ø���H‹{ H…ÿ„ ��H5}·þÿº���èöcÿÿ„À…²���éí���A·H‰ß¾���è9âÿÿ@µ„À…’���H‹H…ÀtdH‹KH;Kƒè���¶HÿÁH‰KƒøS„��ƒøU„Ÿ���ƒøT…Â���H‹{ H…ÿtH5¨þÿº���èxcÿÿ„Àu8H‰ßè
��H…Àu+éNÿÿÿH‹{ H…ÿtH5þ¨þÿº���HƒÄ[A^A_]é>cÿÿ1í‰èHƒÄ[A^A_]ÃA·H‹{ H…ÿtH5 §þÿº���ècÿÿ@µ„ÀuÏH‰ßèó ��@µ„ÀuÀE„ÿ„›úÿÿH‹{ H…ÿ„ŽúÿÿH5Ö§þÿº���èÕbÿÿémúÿÿH‹{ H…ÿ„üÿÿH5¼kþÿº���è²bÿÿ„À„êûÿÿéiÿÿÿH‹{ H…ÿ„@úÿÿH5±†þÿº���ë°H‹{ H…ÿtH5Z¨þÿº���èpbÿÿ„À…,ÿÿÿH‰ßè0
��H…À…ÿÿÿH‹{ H…ÿ„NÿÿÿH5&¨þÿº���è9bÿÿ„À…õþÿÿé0ÿÿÿÌÌÌÌÌÌÌÌÌÌÌÌUAWAVATSHƒìH‹_ H…ÛtSI‰÷I‰þH5«§þÿº���H‰ßèñaÿÿ@µ„Àu4M…ÿt>E‹f(M)üsUH5Õjþÿº���H‰ßèÈaÿÿ„ÀuIÇ����AÆF�1í‰èHƒÄ[A\A^A_]ÃH5/§þÿº���H‰ßHƒÄ[A\A^A_]é‡aÿÿIƒüsAƒÄaD‰d$H|$H‰Þ諆ÿÿ‰Åë±H5ï¦þÿº���H‰ßèSaÿÿ„Àu™L‰d$H|$H‰Þè-Xÿÿ‰ÅëƒÌÌÌÌÌÌÌÌÌUAWAVATSHƒìI‰þL‹?M…ÿ„Ý���‰óI‹vI‹VH‰× „�����H9÷ƒ‰���H‰ùA¶?HÿÇI‰~D@ÐA€ø
+rÞD@ŸA€ørÔ<_ubI‰ÌI)Ô‚6��H…Òt A€<¿Ž&��I×L‰ÿL‰æèv��H…À„‡���M‹v H‰T$M…ö„ì���H|$L‰öènWÿÿ@µ„À„“���éÑ���I‹~ H…ÿt H5^iþÿº���èT`ÿÿ@µ„À…¬���IÇ����AÆF�é™���I‹~ H…ÿ„Œ���H5Ð¥þÿº���è`ÿÿ‰ÅëyM‹v M…ötnH5ë¥þÿº���L‰÷èù_ÿÿ@µ„ÀuUL‰÷L‰þL‰âèä_ÿÿ„ÀuCAöF4u:€ÃŸ€ûsT¶Ã¹¿û¼£ÁsGH
u¦þÿH‹ÁH
Òö�H‹4ÁL‰÷è¦_ÿÿ@µ„Àu1í‰èHƒÄ[A\A^A_]ÃL·õ�L‰ÿè_{ÿÿ H=þ¦þÿH/ö�¾+���è…bÿÿ ÌÌÌUSHƒì(H‰ûL‹M…À„›���L‹KH‹{L9ÏsA€<8_uHGH‰C1Àé¨���1ÀA»>���I‰úffff. „�����±M9ʃæ���C¶€ú_tojÐ@€ý
+r$jŸ@€ýs €Â©ë @�j¿@€ýƒ´���€Âã‰ÕIÿÂL‰SI÷〟���@¶ÕHÐs¥é‘���H‹{ H…ÿ„Ê���H5H¤þÿº���HƒÄ([]éŒ^ÿÿIÿÂL‰SHÿÀtaHÿÏH9øsW‹KÿÁùõ��ƒ—���Hƒ{ �„ƒ���K)L$)$H‰C‰K1À@„ö•ÀH‰ß‰Æè#õÿÿ($(L$KëJ±1íH‹{ H…ÿt0‰È4¶ÀHÀHƒÂHþfþÿH5Š£þÿ„ÉHEðèì]ÿÿ‰Á°„Éu
HÇ����@ˆk1ÀHƒÄ([]Ã@µ1Éë¬ÌÌÌÌÌÌÌÌÌPI‰ðH‹VH‹H‹vI‰Òfffff. „�����I9òsHL‰ÑF¶ IÿÂM‰PEYÐA€û
+râEYŸA€ûrØA€ù_u I‰ÈI)Ðr$H…Òt€<À|HÐH‰L‰GXÃÆG�HÇ����XÃLoó�H‰Çèyÿÿ ÌÌÌÌÌAWAVATSHìˆ���H‰óI‰þH
¢þÿL|$ A¸���L‰ÿL‰öH‰Úè …ÿÿLd$ €����L‰çL‰þèÕ��H‹D$Hƒøt
+ƒøuåH‰ÙëH‹L$H‰ØH)ÈHƒøv1Àë ¸���H9Ëu1ÒHĈ���[A\A^A_ÃLóLñ1Ò¾ÿÿÿÿëH‰×HÁçD‰ÂH úH9Ùt϶9@„ÿxHÿÁéŽ���fffff. „�����A‰øAƒà D¶QAƒâ?@€ÿßvAD¶IAÁâAƒá?E Ñ@€ÿðr;¶yAƒàAÁàAÁáƒç?D ÏD Çÿ���„`ÿÿÿHƒÁë)HƒÁAÁàE ÐD‰ÇëHƒÁAÁà E ÁD‰Ïff. „�����DGÐAƒø
+‚BÿÿÿƒÏ ƒÇŸƒÇ
+BþA‰øƒÿ‚*ÿÿÿH=;£þÿH$ñ�¾+���èÂ^ÿÿ UAWAVAUATSHƒì8H…ÿ„(��A‰÷H‰ûH‹ H‹C(¾'���ÿP ±„À…��L56iþÿ‰D$$H‰D$0H‰D$(‰D$ Aƒÿ"u*H‹{ H‹C(¾"���ÿP A¿���„ÀtàéÎ��ff. „�����Aƒÿ'w D‰øIc†Lðÿà@¶fA½\�°01ÒéÑ���Aƒÿ\„¸���Aÿ���„œ��D‰ÿè®|ÿÿ„ÀufD‰ÿèâ}ÿÿfA½€�„ÀtU‹D$$H‹T$0¶t$H‹|$(D‹D$ é…���@¶1ÒfA½\�°tëo@¶1ÒfA½\�°nëa@¶1ÒfA½\�°rëS@¶1ÒfA½\�°'ëEH|$D‰þè·dÿÿD·l$D‰èÁèH‹|$I‰ÿIÁïH‰úHÁê0D¶D$¶t$ë@¶1ÒfA½\�°\E1ÿ1ÿE1ÀD‰D$ ‰D$$¶ÀÁàA¶Í Áf‰L$H‰T$0·ÂHÁà0D‰ùHÁáH‰|$(·×H ÂH ÊH‰T$@ˆt$@ˆt$A‰öD‰Áë9 D��ÇD$����HÇD$����1íE1öE1äE1íH‹{ H‹C(D‰þÿP A‰ïD‰á„Àu?A€ý€tÆD8ñs DaDˆd$¶ù€ù
+sWD‰ý¶D<A‰Çë¿A¿���L5:gþÿéþÿÿ1É뱉ÈHƒÄ8[A\A]A^A_]ÃH‹{ H‹C(H‹@ ¾'���HƒÄ8[A\A]A^A_]ÿàHzë�¾
+���èˆOÿÿ ÌÌÌÌÌÌUAWAVAUATSHƒì8I‰þL‹?M…ÿ„m��I‹vI‹VH‰× „�����H9÷ƒ#��H‰ùA¶?HÿÇI‰~D@ÐA€ø
+rÞD@ŸA€ørÔ<_…ø���I‰ÍI)Õ‚
+��H…Òt A€<¿Žú��AöÅ…Ò���I×IƒåþK,/L‰|$L‰l$H‰l$ HÇD$(����HÇD$0���H\$ D��H‰ßè˜��=���rñ=��…‚���M‹f M…ä„Ë���I‹|$ I‹D$(¾"���ÿP ³„À…±���L‰|$L‰l$H‰l$ HÇD$(����HÇD$0���H|$è2��=��…Œ���I‹|$ I‹D$(H‹@ ¾"���HƒÄ8[A\A]A^A_]ÿàI‹~ H…ÿtH5¤`þÿº���èšWÿÿ³„Àu8IÇ����AÆF�ë(I‹~ H…ÿt H5"þÿº���HƒÄ8[A\A]A^A_]é^Wÿÿ1Û‰ØHƒÄ8[A\A]A^A_]ÃLt$I‰ç=���„³���ƒø'u*I‹|$ I‹D$(¾'���ÿP „ÀuÁL‰÷èe��=��uËé2ÿÿÿL‰ÿ‰Æè ��¶,$ë+‹t$ÇD$����HÇ$����1íI‹|$ I‹D$(ÿP „À…rÿÿÿ@€ý€t϶|$
+@:|$ sŸGˆD$
+@€ÿ
+s¶4<ëÆHúè�¾
+���èMÿÿ L¿ì�L‰ÿègrÿÿ H=â þÿH
'é�L°è�H‰â¾+���èsgÿÿ ÌAWAVATSPH‹H…Àt[I‰þ1ÛL=ô›þÿE1äI‹NI;Ns€<EtFIƒìrI‹~ H…ÿtº���L‰þèVÿÿ„Àu L‰÷¾���èóìÿÿ„ÀuI‹H…Àu·ë1Ûë»���ë HÿÁI‰N1ÛH‰ØHƒÄ[A\A^A_ÃÌÌAWAVATSPH‹H…Àt]I‰ÿE1öL%c›þÿ1ÛI‹OI;Os€<EtLH…ÛtI‹ H…ÿtº���L‰æè…Uÿÿ„Àu%L‰ÿ¾���èdìÿÿ„ÀuHÿÃI‹H…Àuµë1ÛE1öëA¾���ë
+HÿÁI‰OE1öL‰ðH‰ÚHƒÄ[A\A^A_ÃÌÌÌÌÌÌÌÌUAWAVAUATSHƒìHH‹H…É„��H‰ûA½>���I‰æL|$ E1äH‹sH‹CH9ðs
+€<E„ ��M…ät6H‹{ H…ÿt-º���H5šþÿèÌTÿÿ„À…��H‹ H…É„ª���H‹sH‹CH9ðƒç���€<s…Ý���HxH‰{H9÷s€<9_u
HƒÀH‰Cé½���1Àff. „�����H9÷ƒ"��¶9€ú_„|���DBÐA€ø
+r$DBŸA€øs€Â©ëDB¿A€øƒí���€ÂãA‰ÐHÿÇH‰{I÷å€×���A¶ÐHÐs£éÉ���H‹{ H…ÿ„ì���½���º���H5œ™þÿèëSÿÿ„À„���éË���HÿÇH‰{HÿÀ„‰���Hƒøÿ„��� @�L‰÷H‰Þè¥ÛÿÿHƒ<$�„©���$L$)L$0)D$ H‹k H…ít'L‰ÿH‰îèƒÝÿÿ„ÀuXº���H‰ïH5§þÿèkSÿÿ„Àu@H‰ß¾���èJêÿÿ„Àu/H‹ IÿÄH…É…Eþÿÿë0H‹{ H…ÿt H55\þÿº���è+Sÿÿ„Àt½���ë
HÇ����ÆC�1íH‰èHƒÄH[A\A]A^A_]öl$H‹{ @„ít H…ÿt1H5z˜þÿº���ëHÿÀH‰CëÂH…ÿtH5Ë[þÿº���èÁRÿÿ„Àu–HÇ����@ˆkë›UAVSHì���H‹OH‹W ¸��H)Ñ‚Ç��H‹H4H‰7H‰OHƒú…î��D¶�¶PA@Ѓø
+r AƒÈ AƒÀŸAƒÀ
+¸ÿÿÿÿACÀƒøƒ¥��DJÐAƒù
+r ƒÊ ƒÂŸƒÂ
+A¹ÿÿÿÿDCÊAƒùƒ~��ÀàAÁxMDˆL$fÇD$��ÆD$�HD$H‰D$HÇD$���º���H\$ Ht$H‰ßè^ÿÿHƒ|$ �t8¸���é��¸���A€ùÀ‚õ��A€ùàrSA€ùðƒ¢���º���A°1Àé§���H‹|$(H‹D$0H‰|$PH‰D$XH4H…Àt¶„Àx"HOé9��¸���H‰ùé,��º���E1À1Àëa‰Âƒâ D¶OAƒá?<߆ï��D¶GAÁáAƒà?E È<ð‚å��HO¶GƒâÁâAÁàƒà?D À ÐéÓ��A€ùøƒ9��º���°E1ÀDˆL$fÇD$��ÆD$�LT$L‰T$H‰T$Hƒù‚÷þÿÿL^LQþL‰ L‰WD¶6¶^E^ÐAƒû
+r AƒÎ AƒÆŸAƒÆ
+A»ÿÿÿÿECÞAƒû‡é��kЃý
+rƒË ƒÃŸƒÃ
+½ÿÿÿÿCëƒý‡Ç��AÀãDÝ@ˆl$A€ùà‚dþÿÿIƒú‚tþÿÿLVLIüL‰L‰O¶^D¶^DSÐAƒú
+r ƒË ƒÃŸƒÃ
+AºÿÿÿÿDCÓAƒú‡h��A[Ѓû
+r AƒË AƒÃŸAƒÃ
+»ÿÿÿÿACÛƒû‡A��AÀâDÓˆ\$E„À…àýÿÿIƒù‚ðýÿÿLFHƒÁúL‰H‰O¶~¶vOЃù
+rƒÏ ƒÇŸƒÇ
+¹ÿÿÿÿCσù‡ê���~Ѓÿ
+rƒÎ ƒÆŸƒÆ
+¿ÿÿÿÿCþƒÿ‡È���„À„§���Àá@Ï@ˆ|$écýÿÿHOÁâD ʉÐë
HOÁâ A ÐD‰ÀH9ñt^¶„Ò‰¹���€úà‚°���€úð‚§���D¶AAƒà?D¶IAƒá?¶IƒâÁâAÁà AÁáE Áƒá?D É Ñù���”Á=���u ëf±=���t]„ÉtYHÄ���[A^]ÃHÍä�¿���H‰ÖH‰ÂèEÿÿ H=$–þÿH=ä�¾+���è«Qÿÿ H=šþÿH ä�¾(���è‘Qÿÿ èj��H‰D$HD$H‰D$ H4��H‰D$(HD$PH‰D$0H¾��H‰D$8HD$H‰D$@HEÿÿH‰D$HHÜã�H‰D$`HÇD$h���HÇ„$€�������H‰\$pHÇD$x���H5íã�H|$`è“Cÿÿ ÌUSHƒì‰õH‰ûƒþ'w‰èH
;\þÿHcHÈÿàfÇ\0ëKƒý\ufÇ\\ë?‰ïètoÿÿ„ÀuI‰ïè©pÿÿ„Àt>Æ€‰kë/fÇ\tëfÇ\nëfÇ\rë fÇ\"ëfÇ\'HÇC����fÇC
+�HƒÄ[]ÃH|$ ‰îè›Wÿÿ‹D$‰CH‹D$ H‰ëÜÌÌÌÌÌÌÌÌÌÌÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌH‰÷H5Ü•þÿº���é MÿÿÌÌÌÌÌÌÌÌÌÌÌÌH‰ðH)þHƒþ ƒ HÿÿH9øtHƒþs 1À1Ééœ���1ÀÃH‰ñHƒáüfïÀ1ÀfoWþÿfo <WþÿfïÉ „�����·fnâ·Tfnêfdâf`äòpäÔfpäÔfÛãfÔÄfdêf`íòpåÔfpäÔfÛãfÔÌHƒÀH9Áu²fÔÈfpÁîfÔÁfH~ÀH9ñt ff. „�����1Ò€<ÀÂHÐHÿÁH9ÎuìÃÌÌÌÌÌÌÌÌÌÌÌAWAVAUATSHƒì H‰óL‹'L‹oH‹~ H‹F(H5¬‘þÿº���ÿPH‰\$ˆD$ÆD$�M…ítDH 8M��Lt$L|$fffff. „�����L‰d$IÿÄL‰÷L‰þH‰ÚèêcÿÿIÿÍuåH‹\$¶D$¶ðH‰ßè�eÿÿHƒÄ [A\A]A^A_ÃÌÌUAWAVAUATSHƒìXL‹7L‹H‹^ L‹f(I‹D$ H‰ß¾"���I‰ÅÿЄÀt°HƒÄX[A\A]A^A_]ÃM…ÿ„\��L‰d$0L‰|$K>H‰D$PE1ÿL‰ñE1äL‰t$Hë#MçL‹t$HH‹D$(I)ÄH‹L$ IÌH;L$P„L��¶)@„íH‰L$(xHAH‰D$ ëu D��‰èƒà ¶Qƒâ?@€ýßv@Hq¶IÁâƒá? Ñ@€ýðr<¶.ƒàÁàÁáƒå? Í Åý���„è��H‹D$(HƒÀë¢HƒÁH‰L$ Áà ЉÅë H‰t$ Áà Á‰ÍH|$<‰îº��è¿dÿÿ€|$<€„<ÿÿÿ¶D$G*D$F<„+ÿÿÿL‰âL)ú‚Ø��M…ÿtL;|$s C€<>À} éÀ��…º��M…ätL;d$s C€<&¿ é¢��…œ��M÷H‰ßL‰þH‹D$0ÿP„À……þÿÿ‹D$D‰D$H‹D$<H‰D$<€ulA¶€ë- €����‹t$ ÇD$����HÇD$����E1öH‰ßAÿÕ„À…=þÿÿA€þ€tÔD¶|$D:|$sgAGˆD$A€ÿ
+ƒ���B¶t<ëÅffff. „�����D¶t$D¶|$ @�M9÷s+AGˆD$Iƒÿ ‡Ä���B¶t<H‰ßAÿÕIÿÇ„ÀtÖéÄýÿÿA¿���ý€���‚îýÿÿA¿���ý���‚Üýÿÿý���A¿���Iƒß�éÇýÿÿE1ÿ1ÒMþH‰ßL‰öAÿT$„À…oýÿÿH‰ß¾"���L‰èHƒÄX[A\A]A^A_]ÿàM…ÿt H‹L$H‰ÈL)øL‹d$0vC€<>¿~PH‰Âë¬E1ÿH‹T$L‹d$0ëu:I‰ÏH‰Âë“HFÔ�¾
+���L‰ÿèÁ>ÿÿ LpÑ�L‰÷H‹t$L‰úL‰áèdÿÿ L<Ñ�L‰÷H‰ÎL‰úèþcÿÿ ÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHƒìHHƒ>�„:��H‹V(H‹FPH9„/��H‰|$ L‹VHL‹N`J
+HÿÉI‰ÀH9Áƒñ��H‹n8L‹vXMYÿL‹f L‹nH‹~M‰ÈI)øL‰D$0N
+L‰D$L‰\$@MÃM‰ØL‰\$I9ÃA“ÀM…ÉA•ÃH×H‰|$8H‰×L)ïHÿÇH‰|$(EÃDˆ\$M<I‰ëI‰ÐHƒýÿtRL9Â…p��A¶
+I£ÌL‰Û‚¡���L‹D$L‰F(HÇF8����€|$�…Û��H‹L$A¶
+I£ÌƒÓ��1ÛE1ÛëjH9D$rL9Â…��A¶
+I£ÌrMé¿��L9Â…þ��A¶
+A¸���IÓàM…Ét
+M…àu'éÜ��M…àu H‹L$H‰N(H‹L$A¶
+I£ÌƒÕ���1ÛL‰çM9ÝL‰ÙIGÍHƒýÿIDÍI‰ÈL9És&f D��N$I9ăj��G¶$G:$u^IÿÀM9ÁuàL‰éffff. „�����H9˃(��HÿÉL9Ƀ��LI9Àƒ��E¶$G:$tÓL‹D$8L‰F(H‹L$0HƒýÿI‰üuëLD$(L‰F(HƒýÿI‰üt 1ÉH‰N8I‰ËH‹L$@LÁH9Á‚yþÿÿH‰Áéø��f D��ëþ€~�t HÇ���é4��D¶FD‰À4ˆFH‹VH‹FHH‹NPH…Ò„«���I‰ÉI)ц²���€<¿Ž®���M…É„˜���¶ „ɉÃ���A‰ÉAƒá D¶\Aƒã?€ù߆“���D¶TAÁãAƒâ?E Ú€ùð‚…���¶LAƒáAÁáAÁâƒá?D ÑD ÉësH‹D$H‰F(HƒýÿtHÇF8����H‹L$ HÇ����H‰QH‰Aég��I‰ÉM…É…hÿÿÿE„Àu7ëQ„RÿÿÿLŸá�H‰ÇH‰Îè”`ÿÿ AÁáE ÙD‰Éë
+AÁá E ÊD‰ÑE„ÀtH‰WH‰WHÇ����é ��ù���u ÆFéºþÿÿ¸���ù€���r ¸���ù���rù���¸���HƒØ�HÐH‰Fé¶���H‰ÁH9D$r]ëcH‰V(ffff. „�����ëþI‰ÀëCHBÜ�H‰ÏL‰Îèw:ÿÿ HFÜ�L‰ÇëHÑH9ÈHGÈHHÜ�H‰ÏH‰ÆèM:ÿÿ L‹D$M…Àt,L‰ÁI‰ÉH‹|$ ë @�t)IÿÁt I9ÁsôC€<
+¿~ïI‰ÈL‰Èë1ÀH‹|$ ë
+I‰È1ÀëI‰ÈL9ÀLGÀL‰F(H‰WH‰GHÇ���HƒÄH[A\A]A^A_]ÃÌÌÌÌÌÌÌÌÌUAWAVATSH‰ûH‹H…É„Ù���H‹sH‹CH9ðs1€<Gu+HxH‰{H9÷ƒë���€<9_…á���HƒÀH‰CE1öéA��E1öH‹{ H…ÿ„±���M…ö„��H5gþÿº���èáBÿÿ@µ„À…C��ÿC(¾���H‰ßè¦àÿÿ„À…+��L=gˆþÿM‰ôëfÿC(¾���H‰ßè€àÿÿ„À…��IÿÌ„���H‹{ H…ÿtÖº���L‰þèyBÿÿ„ÀtÅéÝ���H‹{ H…ÿ„Î���H5ˆþÿº���[A\A^A_]éJBÿÿH‰ß[A\A^A_]éê
+��E1öA¸>���H9÷sj¶9<_tMDHÐA€ù
+r&PŸ€ús©ëffff. „�����P¿€ús7ãA‰ÁHÿÇH‰{L‰ðI÷àp#I‰ÆA¶ÁIÆs¨ëHÿÇH‰{IÿÆt IÿÆ…¹þÿÿH‹{ H…ÿtH5±Jþÿº���è§Aÿÿ@µ„Àu
HÇ����ÆC�1í‰èë*H‹{ H…ÿtH5-‡þÿº���èuAÿÿ„ÀuÞH‰ßè
+��D)s([A\A^A_]ÃÌÌÌÌÌÌÌÌÌÌÌÌUSHƒì(H‰ûH‹?H…ÿ„���L‹CH‹sL9Æs€<7_uHFH‰C1Àé«���1ÀAº>���I‰ñfffff. „�����±M9ÁƒÚ���B¶€ú_tqDZÐA€û
+r%DZŸA€ûs€Â©ëfDZ¿A€ûƒ§���€ÂãA‰ÓIÿÁL‰KI÷‑���A¶ÓHÐs£éƒ���H‹{ H…ÿ„¼���H56†þÿº���HƒÄ([]éz@ÿÿIÿÁL‰KHÿÀtSHÿÎH9ðsI‹KÿÁùõ��ƒ‰���Hƒ{ �tyK)L$)$H‰C‰KH‰ßèÐÿÿ($(L$KëJ±1íH‹{ H…ÿt0‰È4¶ÀHÀHƒÂHúHþÿH5†…þÿ„ÉHEðèè?ÿÿ‰Á°„Éu
HÇ����@ˆk1ÀHƒÄ([]Ã@µ1Éë¬ÌÌÌÌÌL‹L‹NH‹NL9ÉsA€<_uHÿÁH‰NHÇG����ëx1ÀAº>���L9És^A¶€ú_tHDZÐA€û
+r'DZŸA€ûs
€Â©ë „�����DZ¿A€ûs)€ÂãA‰ÓHÿÁH‰NI÷âpA¶ÓHÐs«ë HÿÁH‰NHÿÀu ÆG�°ˆÃH‰G1ÀˆÃÌÌÌÌÌÌÌÌÌÌÌAWAVATSPH‹H…ÀtXI‰ÿE1öL%£„þÿ1ÛI‹OI;Os€<EtGH…ÛtI‹ H…ÿtº���L‰æèÅ>ÿÿ„Àu L‰ÿèÏÿÿ„ÀuHÿÃI‹H…Àuºë1ÛE1öëA¾���ë
+HÿÁI‰OE1öL‰ðH‰ÚHƒÄ[A\A^A_ÃÌÌÌÌÌÌÌÌÌÌÌÌÌUAWAVATSH‰ûH‹H…É„Ù���H‹sH‹CH9ðs1€<Gu+HxH‰{H9÷ƒ8��€<9_….��HƒÀH‰CE1öé§��E1öH‹{ H…ÿ„���M…ö„ì��H5#bþÿº���èñ=ÿÿ@µ„À…>��ÿC(¾���H‰ßè¶Ûÿÿ„À…&��L=wƒþÿM‰ôëfÿC(¾���H‰ßèÛÿÿ„À…���IÿÌ„k��H‹{ H…ÿtÖº���L‰þè‰=ÿÿ„ÀtÅéØ��H‹{ H…ÿtsH5 ƒþÿº���[A\A^A_]é^=ÿÿE1ÿL5 ƒþÿ @�H‹CH;Cs
+€<E„®���Iƒïr H‹{ H…ÿtº���L‰öè =ÿÿ„À…‚���H‰ßè€��„ÀuvH‹ H…Éu´1íéU��E1öA¸>��� @�H9÷ƒ|���¶9<_t_DHÐA€ù
+r"PŸ€ús
©ëf „�����P¿€úsMãA‰ÁHÿÇH‰{L‰ðI÷àp9I‰ÆA¶ÁIÆs¨ë+@µéæ���HÿÀH‰C1íéØ���HÿÇH‰{IÿÆt IÿÆ…SþÿÿH‹{ H…ÿt H5[Eþÿº���èQ<ÿÿ@µ„À…ž���HÇ����ÆC�1íéŒ���H‹{ H…ÿtH5Òþÿº���è<ÿÿ„ÀunH‹H…Àt`E1äL=Ìþÿ @�H‹KH;Ks€<Et;IƒìrH‹{ H…ÿtº���L‰þèÔ;ÿÿ„ÀuH‰ßè8���„Àu
+H‹H…Àu¼ë @µë HÿÁH‰K1íD)s(‰è[A\A^A_]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHƒìHI‰þèÚ��³<„·��A‰ÇI‰äLl$ H-þÿë fff. „�����L‰÷è¨Ëÿÿ„À…‡��I‹H…É„ ��I‹FI;Fƒý���€<p…ó���HÿÀI‰FI‹~ AöÇtH…ÿt;º���H‰îèù:ÿÿ„Àt*é7��H…ÿ„“���º���H5]þÿèÖ:ÿÿA·„À…#��Iƒ>�tzL‰çL‰öèªÂÿÿHƒ<$�„¬���$L$)L$0)D$ I‹v H…ö„?ÿÿÿL‰ïè‡Äÿÿ„À…Æ���I‹~ H…ÿ„"ÿÿÿº���H5=€þÿèa:ÿÿ„À„ ÿÿÿé›���A·Iƒ>�u†I‹~ H…ÿ„ƒ���H5ãþÿº���è-:ÿÿ‰ÃëpAöÇthI‹~ H…ÿt_H5”~þÿº���è :ÿÿ„ÀtJëJ¶l$I‹~ @„ítH…ÿt*H5|þÿº���ëH…ÿtH5ÖBþÿº���èÌ9ÿÿ³„Àu
IÇ����Aˆn1Û‰ØHƒÄH[A\A]A^A_]óëëÌÌÌÌUAWAVSHƒì(H‰ûH‹?H…ÿtFL‹CH‹sL9Æs9¶7ƒøItLƒøBu+LNL‰KM9Áƒä���B€<_…Ù���HFH‰C1Àé:��H‰ß1öè›·ÿÿ‰Å@�í‰èHƒÄ([A^A_]ÃHÿÆH‰sH‰ß1öèx·ÿÿ„À…“��H‹{ H…ÿtH5‚}þÿº���èö8ÿÿ„À…q��H‹@µH…ÀtE1ÿL5‰~þÿf „�����H‹KH;Ks
+€<E„`��Iƒïr H‹{ H…ÿtº���L‰öè 8ÿÿ„À…��H‰ßèpÎÿÿ„À… ��H‹H…Àu°éEÿÿÿ1ÀAº>��� �±M9Áƒ±���B¶€ú_tDDZÐA€û
+r#DZŸA€ûs€Â©ëDZ¿A€ûƒ€���€ÂãA‰ÓIÿÁL‰KI÷âpnA¶ÓHÐs©ëcIÿÁL‰KHÿÀtWH9ðsP‹KÿÁùô��‡’���Hƒ{ �„€���K)L$)$H‰C‰KH‰ßè+þÿÿ($(L$Ké‚þÿÿ±1íH‹{ H…ÿt4‰È4¶ÀHÀHƒÂH“@þÿH5 }þÿ„ÉHEðè7ÿÿ„Àt@µé?þÿÿHÇ����@ˆk1íé-þÿÿ@µ1ÉëªHÿÁH‰KéþÿÿUAWAVAUATSHì¨���H‰ûH‹H…É„U��H‹SH‹CH9Ðs€<UuHÿÀH‰C@µH9Ðr ë71íH9Ðs0€<Ku*HpH‰sH9ÖsY€<1CuSHƒÀH‰CA¼���L=U{þÿën@„í„ñ��E1ÿH‹{ H…ÿt H5„|þÿº���è¯6ÿÿ‰Á°„É… ��M…ÿu<é¾��H‰çH‰Þè~¾ÿÿL‹<$M…ÿ„È���L‹d$M…䄶��Hƒ|$�…ª��@„íu™L‹s M…öt H5
+^þÿº���L‰÷èE6ÿÿ‰Á°„É…¶��HÇD$H����L‰d$PHt$XL‰|$XL‰d$`HÇD$h����L‰d$pHÇD$x���H¸_���_���H‰„$€���fÇ„$ˆ����H‰çèQ°ÿÿHƒ<$�tMH‹T$H‹D$H‹L$HIÏH)ÊH‰D$HM…öunë{¶l$H‹{ @„í„ù��H…ÿ„��H5*{þÿº���éð��€¼$‰����…��Æ„$‰���€¼$ˆ����L‹|$HH‹T$Pu L9ú„é��L)úL|$XM…ötL‰÷L‰þèB5ÿÿ„Àu\H‹„$ˆ���H‰D$@D$HL$XT$h\$x)\$0)T$ )L$)$€|$A�„x��M…öt H5Åzþÿº���L‰÷èæ4ÿÿ„Àt°éX��H‹{ H…ÿt H5Ÿzþÿº���èÁ4ÿÿ‰Á°„É…2��H‹H…ÀtYL5VzþÿE1ÿ �H‹KH;Ks
+€<E„Ã���IƒïrH‹{ H…ÿtº���L‰öèp4ÿÿ„ÀuŠH‰ßèÄÄÿÿ„À…zÿÿÿH‹H…Àu´1ÀH‹{ H…ÿt H5¿‡þÿº���è84ÿÿ‰Á°„É…©��H‹H…Àt H‹KH;Ks€<uu HÿÁH‰Kéƒ��H‹{ H…ÿt H5øWþÿº���èî3ÿÿ‰Á°„É…_��H‰ßHĨ���[A\A]A^A_]é)ÄÿÿHÿÁH‰KékÿÿÿH‹{ H…ÿt H5<þÿº���è£3ÿÿ‰Á°„É…��HÇ����ÆC�é��L¤$���L‰õë
1í€|$A�…nþÿÿL‹l$L‰çHt$èËÿÿHƒ¼$����t%L‹¼$˜���H‹„$ ���H‹ $IÍI)ÏH‰$H…íu<ë±€|$A�…!þÿÿÆD$A€|$@�L‹,$L‹|$u M9ï„þÿÿM)ïLl$H…í„wÿÿÿº���H‰ïH5ØwþÿèÝ2ÿÿ„À…óýÿÿM…ö„RÿÿÿL‰÷L‰îL‰úè¾2ÿÿL‰õ„À„;ÿÿÿéÌýÿÿH…ÿtH5¢;þÿº���è˜2ÿÿ‰Á°„Éu
HÇ����@ˆk1ÀHĨ���[A\A]A^A_]ÃH=òyþÿH É�¾+���èy5ÿÿ ÌÌÌÌÌÌÌH‹~ H‹F(H‹@H5Rvþÿº���ÿàÌÌÌÌÌÌUAWAVAUATSHìÈ���I‰ÔI‰öH‰¼$˜���H
ñwþÿH|$(A¸���è
+ZÿÿHƒ|$(�L‰t$„*��L‹D$PH‹t$xH‹„$ˆ���J<�HÿÏH9÷ƒl��H‹T$`L‹L$pL‹”$€���LXÿL‹|$HL‹l$0H‹L$@H‰ÃH‰Œ$¨���H)ËH‰œ$ ���H,EÿÿÿÿI‰ÖH‰T$L‰d$ H‰”$���Hƒúÿt A¶ 9I£Ïs>L‰t$L‰ÁL‹t$L‰óé‰���L‰Áf D��A¶<9I£ÿrPH<)HÁI H9óråé”��IÀK<L‰ÁH9÷ƒŠ ��ffff. „�����E¶9M£Çr HÁHÇH9÷rêéo��L‰t$1ÛL‹t$ë1ÿH‰|$1ÛE1öff. „�����M9õL‰t$MGõHƒúÿM‰ìMDõI9Æs5M, L‰÷ffff. „�����L9I9ðƒ, ��A¶:A:T=�utHÿÇH9øußM‰åL‰çH‹”$���L‹d$ fff. „�����H9ûƒÃ���HÿÏH9ǃÂ��LI9ðƒÆ��E¶4:G:4tÓHŒ$¨���H‹¼$ ���I‰ÈHƒúÿL‹t$u ë&M‰åM)àIÿÀH‹”$���Hƒúÿt!1ÿL‹d$ I‰þH‰|$K<H9÷‚aþÿÿéH��L‹d$ L‹t$ëâL¼$°���Ll$(fL‰ÿL‰îè•çÿÿH‹„$°���HƒøtçH…À…3��H‹Œ$¸���ëL‹t$H‰ÊL‰àHƒÂt L‰àH)ÐvA€<¿L5Æ�éŸ��uòLòHÐH9„¡���¶2@„öxHÿÂëzf. „�����‰÷ƒç D¶JAƒá?@€þßv:D¶BAÁáAƒà?E È@€þðr2¶rƒçÁçAÁàƒæ?D Æ þþ���tBHƒÂë"HƒÂÁçD ωþëHƒÂÁç A øD‰Æ €����~Àƒÿ‚dÿÿÿƒÆЃþ
+‚XÿÿÿëKH…Ét!L9ás;A€<¿Ž¶��I‰Ìë1L‰D$PL‰t$`ë½���éÖ��HÇD$`����H‰L$PL‹t$ë…€��Iƒüs6½���Iƒü…¦��L‹t$A·=ZN��…Ù��A¿���E1í¾���é‰���A·5_Z��A¶NƒñNf Át0A·=ZN��tEA¿���Iƒü‚6��A>__ZN„Ý���M‰çé!��¾���Iƒür/A€~¿Žþ��Ml$ýM‰çë#A€~¿ŽÅ��Ml$þ¾���M‰çë E1íA¿���LöN.1Àffff. „�����I9Åt€<�H@yñé®���M…í„¥���¶„ÉxH~‰ÊƒúE…ƒ���éh��‰Êƒâ D¶NAƒá?€ùßvX¶FAÁáƒà?D È€ùð‚*��H~¶NƒâÁâÁàƒá? Á Ñ묾���Iƒü‚ó��A€~¿Žc��Ml$üM‰çéGÿÿÿH~ÁâD ʃúE„ê��ú���… ��Iƒÿr_A·=_R��„ƒ���A€>Rt_½���Iƒÿ†ô��H‹L$·5__��¶IƒñRf Á…×��H‹|$¶G<¿ŽÎ��LoIÇÄýÿÿÿëKA¿���A€>R½���…¤��H‹|$¶G<¿Ž÷��LoIÇÄÿÿÿÿëA¶F<¿Žë��MnIÇÄþÿÿÿ¿½���<‡_��Mü1Àf. „�����I9ÄtA€|��H@yïé:��L‰l$(L‰d$0HÇD$8����ÇD$@����HÇD$H����ÇD$P����H|$(1öèªÿÿ„À…ˆ��H‹|$(H…ÿ„ì��¶D$0¶L$7Áá·T$5 ÊHÁâ ‹L$1H ÑH‹T$8HÁáH ÁH9ʃ‚���¶¿<sxòD$@H‰|$(H‰L$0H‰T$8D$@HÇD$H����ÇD$P����H|$(1öèw©ÿÿ„À…ý��H‹|$(H…ÿ„a��¶D$0¶L$7Áá·T$5 ÊHÁâ ‹L$1H ÑH‹T$8HÁáH ÁH…Ò„ž��I‰ÈI)І—��€<¿“��é ��E1äA¹
+���BЃø ‡ßýÿÿL‰Ñ1Àë"HƒÇÁâ Úffff. „�����ú���„¶ýÿÿI‰ÊDZÐAƒû
+ƒ���I÷áH‰ÁÃI@ÊD‰ØHȒ„ۅ‡ýÿÿ„Ò…ýÿÿL9Ç„výÿÿD¶ E„ÛxHÿÇD‰Úë£D‰Úƒâ ¶_ƒã?A€û߆vÿÿÿD¶WÁãAƒâ?A ÚA€ûðr D¶_HƒÇƒâÁâAÁâAƒã?E ÓA Óë°HƒÇÁâ A ÒD‰ÒéFÿÿÿH…ÀuIÿăúE… ÿÿÿéÓ��HÿÇHÿÈtçL9Ç„áüÿÿ¶„Òyè‰Ñƒá ¶_ƒã?€úßv<D¶_ÁãAƒã?A Û€úðr5¶WƒáÁáAÁãƒâ?D Ú Êú���„“üÿÿHƒÇëžHƒÇÁá Ù‰Êë‘HƒÇÁá A ËD‰Úë‚I‰Èë…{��H×1öM…À„E��½���€?.…h��JA±.H¹���~���H‰úE„Éx ffffff. „�����HÿÂE¶Éé„��� @�E‰ÊA€â E¶Ò¶Zƒã?A€ùßvCD¶ZÁãAƒã?A ÛA€ùðr>D¶JAƒâAÁâAÁãAƒá?E ÙE ÑAù���„���HƒÂë%HƒÂAÁâA ÚE‰ÑëHƒÂAÁâ E ÓE‰Ù €����EQßAƒúr!E‰ÊAƒâßAƒÂ¿AƒúrEQÆAƒú&w L£ÑsH9ÂtRD¶
+E„ɉ3ÿÿÿé>ÿÿÿAƒÁAƒùüsßëbE1íA¿���é^úÿÿH~Áâ ЉƒúE…ûÿÿE1äI)øM…À…»þÿÿE1ÀH‹Œ$˜���H‰qL‰iL‰aH‹D$H‰A L‰y(H‰y0L‰A8½���H‹„$˜���H‰(HÄÈ���[A\A]A^A_]ÃL‰D$PéùÿÿH¢¿�H‰ÆèÚ ÿÿ H©¿�L‰ÇèÉ ÿÿ IÎL9öLGöH¦¿�L‰÷è® ÿÿ L5¼�º���ëL?¼�º���L‰÷L‰þL‰ùèôBÿÿ H=»kþÿH
”¹�L-¼�H”$°���¾=���èû7ÿÿ Lº�º���ë"LĽ�L‰÷L‰æ1Òè§Bÿÿ Lº�º���L‰÷L‰æL‰áè‹Bÿÿ Lê»�H‰ÎèzBÿÿ Ly»�º���éhÿÿÿL ¹�º���ëÀÌÌÌÌÌÌÌÌÌUAWAVAUATSHƒìxI‰õH‹L‹0M…ö„ý
+��H‹pL‹`1ÀH‰D$A»
+���L‰l$L‰d$(ëAffffff. „�����L‹l$I‹} I‹E(L‰æL‰úÿPA»
+���„À‹\$$L‹d$(H‹t$…Û
+��H‹l$L9å•Ã„Ê
+��H…ö„Ò
+��HEH‰D$A¶>@¶Ç1ÒH‰ñ@„ÿ‰µ���ë, �Hƒù‚¤
+��A¶|@€ÿ¿ŽÚ
+��HÿÉHÿÂ@„ÿ‰‡���A‰øA€à E¶ÀE¶LAƒá?@€ÿßvLE¶TAÁáAƒâ?E Ê@€ÿðrEE¶LAƒàAÁàAÁâAƒá?E ÑE ÁAù���u4é)
+��ff. „�����AÁàE ÈE‰Áë @�AÁà E ÂE‰Ñë @�D¶ÏM<AƒÁÐAƒù †:ÿÿÿI‰ñI)Ét‚9
+��C€<¿Ž.
+��M…É„;
+��ƒø+„���ƒø-u
+Iƒù„È ��Iƒùƒx���1ÀE1äA¶ƒÂЃú ‡§ ��O¤‰ÒN$BHÿÀI9ÁuÝM…ät(H‰ÈL)àH‰D$†‡���C€<'¿‰���éê �� €����H‰L$év��f D��IÿÉ„O ��IÿÆIƒùrˆE1ÀE1ä „�����M9ÁtžG¶L‰àI÷ãÂAƒÂÐAƒú ‡ ��I‰Ä°„Ò… ��D‰ÒIÿÀIÔsÇéü��f…m ��1ÀH‰D$H‹D$(H9D$…ó���A‹E4ƒà„æ���@€ÿh…Ü���IƒürA€¿Ž¦ ��IL$ÿë1ÉIGLùHÿÁ „�����H9È„^��¶„ÒxHÿÀë{ff. „�����‰×ƒç D¶HAƒá?€úßv=D¶@AÁáAƒà?E È€úðr6¶PƒçÁçAÁàƒâ?D  úú���„ý��HƒÀë HƒÀÁçD ωúëHƒÀÁç A øD‰Â D��zЃÿ
+‚dÿÿÿƒÊ ƒÂŸƒú‚Uÿÿÿ D��H…ít I‹} I‹E(º���H53gþÿÿP„À…™��‰\$$L‰ãL‰ýIƒür,A·L‰ãL‰ý=_$��uA€¿Ž”��IoI\$ÿ €����M‰þMæI‰ìI‰ßH…ÛtA¶$ƒø$„‘��ƒø.ulIƒÿ‚���A¶D$<¿Ž��„Àˆð��ƒø.…†��I‹} I‹E(º���H5‹fþÿÿP„À…ï��Iƒÿ‚?��A€|$ÀŒR��IƒÇþL‰ûé)��fK<1öL‰áë' D��Hyƒú$„³���H‰îH)ÎHþH‰ùƒú.„ž���H9Á„…ûÿÿH‰õ¶„Òyˉփæ D¶IAƒá?€úßvBD¶AAÁáAƒà?E È€úðrD¶QƒæÁæAÁàƒâ?D  òú���„1ûÿÿHyƒú$u…ë6HyÁæD Ήòƒú$…nÿÿÿë HyÁæ A ðD‰Âƒú$…Vÿÿÿf „�����H…ítjL‰ûH)ëL‹l$†|���A€<,¿Ž™��I‹} I‹E(L‰æH‰êÿP„À…Á��A€<,Àx���é™��f D��Iƒÿ‚š���A€|$¿Ž˜��IGÿé‡���L‹l$I‹} I‹E(L‰æ1ÒÿP½����„Àt3éi��…"��M…ä„��I‹} I‹E(L‰æL‰úÿP„À…A��L‰ýI‰ßIìL‰ûL‰åéØýÿÿI‹} I‹E(º���H5ºtþÿÿP„À…��1Ûé¬��1ÀMl$L‰l$0H‰D$8HÇD$@����H‰D$HHÇD$P���H¸$���$���H‰D$XH|$`Ht$0èFšÿÿHƒ|$`�„ªùÿÿH‹L$hHƒùÿ„~��HAIƒÿr A€}�ÀŒ ��L9øsA€<ÀŒ
��Hië…��H‰ÍL‰ûL‰àHƒÅt9L‰ûH)ëv A€<,À} é1��…+��LåHƒùt6Hƒù„W��H‰èH…É„"ùÿÿA€|$uH‰Å…ùÿÿA€|$¿Ž ��HÿÉë A¶E�H5•cþÿƒøC„¯��ƒøu…äøÿÿ1ÉID$I HƒÂH‰ÆfH9Ö„½���¶>@„ÿxHÿÆé‡��� €����A‰øAƒà D¶VAƒâ?@€ÿßv=D¶NAÁâAƒá?E Ñ@€ÿðr7¶~AƒàAÁàAÁáƒç?D ÏD Çÿ���tYHƒÆë-HƒÆAÁàE ÐD‰Çë HƒÆAÁà E ÁD‰Ïffffff. „�����DGÐAƒø
+‚RÿÿÿƒÇŸƒÿ‚Fÿÿÿ²H…Éué
+øÿÿ1ÒH…É„ÿ÷ÿÿ¶0ƒþ-„'��ƒþ+…(��HÿÉ„á÷ÿÿID$é��A·E�H5pbþÿ=SP��„‚���A·E�H5Xbþÿ=BP��toA·E�H5Dbþÿ=RF��t\A·E�H50bþÿ=LT��tIA·E�H5 bþÿ=GT��t6A·E�H5bþÿ=LP��t#A·E�H5òpþÿ=RP��tA€}�u„0þÿÿé>÷ÿÿL‹l$I‹} I‹E(º���ÿP„À„×úÿÿé'��‰Áƒá A¶t$ƒæ?<߆y��A¶T$Áæƒâ? ò<ð‚«��A¶D$ƒáÁáÁâƒà? Рȃø.„ÎúÿÿéO��Hƒù„Âöÿÿ1ÿ1öHƒù ‚æ��� @�H9ùtLD¶8EHÐAƒù
+r#AƒÈ AƒÀŸAƒÀ
+A¹ÿÿÿÿEBÁE‰ÁAƒø‡yöÿÿþÿÿÿ‡möÿÿÁæD ÎHÿÇH9ùu´‰ð5�Ø����ïÿ=�ïÿ¸���Bðþ���”ÀÂ…5öÿÿ‰t$0‰ðÁà =��ˆƒq��ƒþ L‹l$‚öÿÿƒÆƒþ!‚öÿÿH|$0L‰îèZAÿÿ„À„¨ùÿÿéø���ffff. „�����ÁæD ÎHÿÇH9ù„oÿÿÿD¶8EHÐAƒù
+rßAƒÈ AƒÀŸAƒÀ
+A¹ÿÿÿÿEBÁE‰ÁAƒøvÀé›õÿÿ1ÛIƒÄL‰åéCùÿÿÁá ñ‰Èƒø.„zùÿÿI‹} I‹E(º���H5pþÿÿP„ÀumA€|$ÀŒ¾��IÿÏL‰ûIÿÄL‰åéûøÿÿÁá ʉЃø.„2ùÿÿë¶@D$0HÇD$@����ÇD$H����L‰l$PÇD$X����H|$0¾���è}™ÿÿ‰Ãë1Û볉ØHƒÄx[A\A]A^A_]ÃH=ƒbþÿHt®�¾+���è
+ ÿÿ °ˆD$0H=?eþÿH
¤�L•®�HT$0¾+���èÎ+ÿÿ LM®�º���L‰ÿH‰Îè…6ÿÿ LL®�L‰÷1ÒL‰Éèo6ÿÿ 1Àë£LÚ®�º���L‰çL‰þH‰ÁèO6ÿÿ LF®�L‰ÿH‰ÎL‰âè86ÿÿ L_®�L‰çL‰þ1ÒH‰éè 6ÿÿ èBÿÿ LŸ®�ëLN®�L‰çL‰þH‰êëuL´®�ëaLK®�ëXLŠ®�º���L‰ïéHÿÿÿLV�ëLÝ�º���L‰ÿL‰æL‰áè²5ÿÿ Hi¥�¿���¾���è*ÿÿ L®�º���L‰çL‰þL‰ùè~5ÿÿ LM®�º���ëâÌÌÌÌÌÌÌÌÌÌÌÌÌÌH‹~ H‹F(H‹@H5Ð_þÿº���ÿàÌÌÌÌÌÌHƒ?�t
+HÇ���°Ã1ÀH)W’ÀH‰s°ÃH‹GH‹x H‹@(H‹@ÿàÌÌÌÌÌÌÌÌÌÌÌÌÌPÇD$����þ€���s@ˆt$º���Hƒ?�uhé«���‰ðþ���s#Áè ÀˆD$@€æ?@€Î€@ˆt$º���Hƒ?�u8ë~þ���s9Áè àˆD$‰ðÁè$? €ˆD$@€æ?@€Î€@ˆt$º���Hƒ?�tHHÇ���°YÃÁè$ ðˆD$‰ðÁè $? €ˆD$‰ðÁè$? €ˆD$@€æ?@€Î€@ˆt$º���Hƒ?�u¸1ÀH)W’ÀH‰°rH‹GH‹x H‹@(Ht$ÿPYÃÌÌÌÌÌÌÌÌÌH‰òH5«�éA ÿÿÌAVSHƒì8I‰þH‹ H‹;H…ÿu H‰ßè£��H‰Ç¾���ÿ
Â�L‰÷ÿ¬Á�H‹;H…ÿu H‰ßè|��H‰Ç1öHƒÄ8[A^ÿ%âÁ�H‰Ãë H‰ÃL‰÷ÿyÁ�H‰ßèA��H…ÀuHƒÄ8[A^ÃHU¼�H‰D$HÇD$���H‰çH‰|$WÀD$ Ht$èµ��H…ÀtH‰Çè(��è³�� è¼,ÿÿ èµ,ÿÿ ÌÌÌUAWAVAUATSHƒì8¸���ƒÿ…ª��L‰Ã‰t$H‰L$L‰D$ L‰Çÿ:Á�I‰ÇÇD$����Ht$H‰ßÿ)Á�I‰Åƒ|$IƒÝ�H‰ßÿ Á�I‰ÄHD$ H‰D$(H‰D$0M…ÿ„â��A¶/Mwýÿ���t2‰èÁèƒàƒø‡7��H
%þÿHcHÈM‰ðÿàH|$(HY»�ë!M‰àé��M‰àM…äu é��H|$0Hf»�ÿP(I‰ÀH…Àt3‰èƒàƒø ‡Ü��H
j%þÿHcHÈÿàI‹GIƒÇ é³���IƒÆIƒæø@öÅ…��M‹IƒÆé›���1À1Éf D��A¶‰ÖƒæHÓæIÿÆH ðHƒÁ„ÒxæërA·GIƒÇëdA‹GëZ1À1Éffffff. „�����A¶‰ÖƒæHÓæIÿÆH ðƒÁ„ÒxçHÇÆÿÿÿÿHÓæ1ÿöÂ@HD÷ƒù@HC÷H ðëI¿GIƒÇëIcGIƒÇM‰þIÀ@„íyM‹�IFA€>ÿL‰D$t „�����HP€8�H‰ÐxôëH‰Â¶HÿÂ1É1ö D��H‰×D¶E‰ÁAƒáIÓáHÿÂL ÎHƒÁE„Àxà<‡š��H÷HÿÇA‰À¾���f. „�����H9úƒ
+��ƒø ‡u��L
7$þÿKc LÉÿáL‹2HƒÂL‹HƒÂL‹:HƒÂé$��E1ö1Éffffff. „�����D¶E‰×AƒçIÓçHÿÂM þHƒÁE„ÒxãëD·2HƒÂD·HƒÂD·:HƒÂéÔ���D‹2HƒÂD‹HƒÂD‹:éº���E1ö1Éf „�����D¶E‰×AƒçIÓçHÿÂM þƒÁE„ÒxäIÇÇÿÿÿÿIÓçAöÂ@A¹����MDùƒù@MCùM þƒø ‡��L
†#þÿKc LÉÿáE1Ò1É @�D¶:D‰ýƒåHÓåHÿÂI êHƒÁE„ÿxäéÌ���L¿2HƒÂL¿HƒÂL¿:HƒÂëLc2HƒÂLcHƒÂLc:HƒÂ1É1ífff. „�����D¶
+E‰ËAƒãIÓãHÿÂL ÝHƒÁE„ÉxãK 4I9Í‚y��MÖMæM9õƒWþÿÿéê���E1Ò1Éffff. „�����D¶:D‰ýƒåHÓåHÿÂI êƒÁE„ÿxåHÇÅÿÿÿÿHÓåAöÇ@A¹����IDéƒù@ICéI ê< ‡‚���L
¬"þÿKc LÉÿáE1ÿ1ÉD¶D‰ÝƒåHÓåHÿÂI ïHƒÁE„Ûxäé%ÿÿÿE1ÿ1ÉD¶D‰ÝƒåHÓåHÿÂI ïƒÁE„ÛxåHÇÅÿÿÿÿHÓåAöÃ@A¹����IDéƒù@ICéI ïéÞþÿÿH…ö~
+¸���éå���¾���ë{M…ÿttH‹D$LøH…íH‰D$„Ù���H/HÿÊ1À1Éf¶2‰÷ƒçHÓçHÿÂH øƒÁ@„öxçHÇÂÿÿÿÿHÓâ1ÿ@öÆ@HD׃ù@HC×1ÉH‰ÆH ÖŸÁHƒñH ¾���HEñë1ö‹T$öÂuP¸���H=Ä!þÿHc ·HùÿáöÂu@L‹5û»�H‰ß1öH‹T$AÿÖH‰ß¾���1ÒAÿÖH‰ßH‹t$ÿÛ»�¸���ë
+HÝmþÿ‹°HƒÄ8[A\A]A^A_]ø���ëê¾���ë€èÈ&ÿÿ ÌÌÌÌÌÌUSHƒìHH‰ûH‹wÇD$ ����H|$ ÿˆ»�‰D$…Àu[‹l$ …íu/H‹sÇD$ ����H|$ ÿa»�‰D$…Àu4‹l$ 1ÿÿU»�…ítEHcÍ1ÀðH± tH‰Ã‰ïÿ:»�H‰ÙH‰ÈHƒÄH[]ÃHÇD$����Hm·�H|$Ht$è^�� Hm·�H‰D$HÇD$ ���H|$H‰|$(WÀD$0Ht$èË���H‰ÇèS��èÎ�� ÌÌÌÌÌÌÌÌÌÌÌÌAWAVSHƒìH¸TSUR�ZOMH9uDHƒ7þÿH9G u=L‹w(H‹_0ÿý¹�ðHÿ
EÌ�èp��H…Àt$HÿÆ@�L‰ðH‰ÚHƒÄ[A^A_Ãÿfº�èIx� H=‰cþÿH
iª�L¯�HT$¾F���èã ÿÿ I‰ÇL‰÷H‰Þè��L‰ÿ蛆� è”&ÿÿ ÌÌSHƒìH‰òH‰<$HÇD$����H5ä«�H‰çè¼ÿÿH‹|$„ÀtH…ÿHa¯�HEÇë H…ÿtè9���1ÀHƒÄ[ÃH‰ÃH‹|$H…ÿtè ���H‰ßè'†� è &ÿÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌÌAWAVATSP‰øƒàHHþHƒùrH…Àu HƒÄ[A\A^A_ÃH_ÿL‹wÿL‹gL‰÷Aÿ$Iƒ|$�t L‰÷ÿ´¸�H‰ßHƒÄ[A\A^A_ÿ% ¸�I‰ÇIƒ|$�t L‰÷ÿŒ¸�H‰ßÿƒ¸�L‰ÿè‹…� ÌÌÌÌÌÌÌÌÌPÿy¸� ÌÌÌÌÌÌÌH‹H…ÿ…SÿÿÿÃÌÌUAWAVAUATSPH…Ò„Ž���I‰ÖI‰÷H‰ûI½ÿÿÿÿÿÿÿH‹-¸�L‹%£·�ff. „�����L‰òM9îrL‰ê¿���L‰þÿÕHƒøÿt%H…ÀtFL‰ñH)ÁrmIÇI‰ÎH…ÉuÍë-ff. „�����AÿÔ‹�H‰ÇHÁç HƒÏƒøuè¶þÿÿL‰ñH…Éuž1Àë L5‹�ëI‰þH‹{H…ÿtèþÿÿL‰s°HƒÄ[A\A]A^A_]ÃHt�H‰ÇL‰öè‰ÿÿ L‰sH‰Çèk„� ÌÌÌÌÌÌÌÌÌPÇD$����þ€���s@ˆt$º���é���‰ðþ���s Áè ÀˆD$@€æ?@€Î€@ˆt$º���ëiþ���s*Áè àˆD$‰ðÁè$? €ˆD$@€æ?@€Î€@ˆt$º���ë7Áè$ ðˆD$‰ðÁè $? €ˆD$‰ðÁè$? €ˆD$@€æ?@€Î€@ˆt$º���Ht$èFþÿÿYÃÌÌÌÌH‰òH5©�éáÿÿÌSH‹=È�H…ÿuH=È�èGûÿÿH‰Çÿ·�Hƒør
Hƒx�tHƒÀ[ÃH‹=ÜÇ�H…ÿuH=ÐÇ�èûÿÿH‰ÇÿÒ¶�HƒøtrH‰ÃH…ÀuP¶íÇ�¿ ���ÿ"¶�H…ÀtWH‰ÃH“Ç�H‰HÇC����H‹=Ç�H…ÿuH=uÇ�è¸úÿÿH‰ÇH‰Þÿ$¶�HÇC���HCHÇC����ÆC�[Ã1À[ÿ���¾ ���èúþÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌAWAVSI‰öH‰ûÿIƒ~�tH‰ß[A^A_ÿ%nµ�[A^A_ÃI‰ÇIƒ~�t H‰ßÿUµ�L‰ÿè]‚� ÌÌÌÌÌÌÌÌÌÌÌH‹~ H‹F(H‹@H5äZþÿº ���ÿàÌÌÌÌÌÌHƒìH‰ÑH‰òH‰|$H^/þÿH‰D$H|$Ht$è–ÿÿ ÌÌÌÌH…ÿ…çûÿÿÃÌÌÌÌÌÌÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌHìˆ���H‹?‹F4¨u¨ uJHĈ���é¿<ÿÿ‹º���¸0���A‰ÈH‰×AÁè‰Ê€â€ú
+A¹W���DBÈA�ÑDˆL<HWÿƒùD‰ÁsÓë>‹º���¸0���A‰ÈfH‰×AÁè‰Ê€â€ú
+A¹7���DBÈA�ÑDˆL<HWÿƒùD‰ÁsÓHƒÇþHÿ€���w2A¹���I)ÑL<IƒÀH#Pþÿ¹���H‰÷¾���è,ÿÿHĈ���ÃH“�¾€���è�ÿÿ ÌH‹H‹8ÿ%„´�ÌÌÌÌH‹H‹8ÿ%t´�ÌÌÌÌH‹H‹8ÿ%l´�ÌÌÌÌH‹H‹8ÿ%\´�ÌÌÌÌSH‰ûH‹H…ÿtHƒ{ �Æ�tÿƒ³�HƒûÿtðHÿKu
+H‰ß[ÿ%l³�[ÃÌÌÌÌÌÌÌÌÌÌAWAVATSHƒìhI‰ö‰ûH‹=ñÄ�H…ÿuH=åÄ�èøÿÿH‰Çÿ׳�HƒørI‰ÇHƒx�t IƒÇéÃ���H‹=·Ä�H…ÿuH=«Ä�èÞ÷ÿÿH‰Çÿ³�Hƒø„Ò���I‰ÄH…ÀuV¶´Ä�¿0���ÿé²�H…À„2��I‰ÄHfÄ�I‰$IÇD$����H‹=RÄ�H…ÿuH=FÄ�èy÷ÿÿH‰ÇL‰æÿå²�M|$I‹|$(Iƒ|$�IÇD$���WÀAD$AD$ tH…ÿt ðHÿuè³þÿÿIƒ�tIƒ?�u ë+1ÿè��I‰ÄIƒ�uaM‰gIƒ?�tI‹FI9GwI9Gw(WÀ)D$ )D$Ht$‰ß1Òÿ¥±�HƒÄh[A\A^A_ÃèŒ��H‰ÃH‹@H…Àu[¹ ���HÛ]þÿëTHs �H‰D$HÇD$���HnOþÿH‰D$ WÀD$(H5Z �H|$èxýþÿë¿���¾0���ègöþÿ H‹K HÿÉH‰D$XH‰L$`HD$XH‰D$HHƒ ÿÿH‰D$PHç¬�H‰D$HÇD$���HÇD$0����HD$HH‰D$ HÇD$(���Lt$Ht$L‰÷è›÷ÿÿH…ÀtH‰ÇèøÿÿðHÿ uH‰ßè`ýÿÿH©¬�H‰D$HÇD$���L‰t$ WÀD$(Ht$L‰÷èQ÷ÿÿH…ÀtH‰ÇèÄ÷ÿÿèOøÿÿ ðIÿ $uL‰çèýÿÿèI ÿÿ èB ÿÿ AWAVATSPI‰ôI‰ÿ¶cÂ�¿0���ÿ˜°�H…Àt_H‰ÃHÇ����HÇ@���L‰xL‰` H‹²Â�f. „�����H‰ÁHÿÁt%ðH±
—Â�uíH‰KÇC(����H‰ØHƒÄ[A\A^A_Ãè¾��ë¿���¾0���èíôþÿ I‰ÆM…ÿt%AÆ�M…ät L‰ÿÿñ¯�ëI‰ÆðHÿ uH‰ßè¾��L‰÷èæ|� ÌÌÌÌPH‰ðHƒ?�t H‰<$H5bTþÿL¢�H‰áº���ëH‰<$H5DTþÿLØ¡�H‰áº���H‰Çèh ÿÿYÃÌÌÌÌÌÌPèú�� ÌÌÌÌÌÌÌÌHƒì8H•£�H‰D$HÇD$���H‰çH‰|$WÀD$ Ht$è½õÿÿH‰ÇèEúÿÿèÀöÿÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌÌSH‹=ÐÀ�H…ÿuH=ÄÀ�èçóÿÿH‰Çÿ¦¯�Hƒør
H‰Ã€x�…���H‹=œÀ�H…ÿuH=À�è³óÿÿH‰Çÿr¯�Hƒøt`H‰ÃH…ÀuL¶À�¿���ÿ®�H…ÀtHH‰ÃHSÀ�H‰ÆC�H‹=EÀ�H…ÿuH=9À�è\óÿÿH‰ÇH‰ÞÿÈ®�fÇC�HƒÃ ë1ÛH‰Ø[ÿ���¾���è.óþÿ ÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSPL‹gM…ä„®���H‰ûE1öH³¢�H‰$ë D��ÆC�H…Àuléµ���fÆCM‰åM)õ‚Û���H‹+M<.HºÿÿÿÿÿÿÿI9ÕIBÕ¿���L‰þÿj®�Hƒøÿu´ÿF�‹�H‰ÇHÁç HƒÏƒø uè§ôÿÿÆC�L‰èH…ÀtNIÆM9ær“ëÆC�H‰øHÁè ƒøu0è|ôÿÿëâ1ÀëRE1í¸����H‰$M9ôs9Hžž�L‰÷L‰æèÿÿ H‰<$M…öt HÇC����M9ôtH‰ïL‰þL‰êÿl�L‰kH‹$HƒÄ[A\A]A^A_]ÃH¾¡�L‰÷L‰æè#ùþÿ ë�I‰ÇH‰ßL‰öè���L‰ÿèùy� èòÿÿ AVSPH…öt,H‰ûH‹GI‰ÆI)ör%HÇC����tH‹;HþL‰òÿï¬�L‰sHƒÄ[A^ÃHÜ�H‰÷H‰ÆèAÿÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌHƒì8H• �H‰D$HÇD$���H‰çH‰|$WÀD$ Ht$èÍòÿÿH‰ÇèU÷ÿÿèÐóÿÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌÌAVSPH‹=ͽ�H…ÿuH=Á½�èôðÿÿH‰Çÿ³¬�HƒørI‰ÆHƒx�t IƒÆéº���H‹=“½�H…ÿuH=‡½�èºðÿÿH‰Çÿy¬�Hƒø„Œ���H‰ÃH…ÀuP¶½�¿0���ÿÅ«�H…Àt{H‰ÃHF½�H‰HÇC����H‹=4½�H…ÿuH=(½�è[ðÿÿH‰ÇH‰ÞÿÇ«�LsH‹{(Hƒ{�HÇC���WÀCC tH…ÿtðHÿu
+è÷ÿÿëE1öL‰ðHƒÄ[A^ÿ���¾0���èþïþÿ ÌÌÌÌÌÌÌÌÌÌÌÌAVSHƒì8H‰ûL‹7I‹>H…ÿu L‰÷èÓïÿÿH‰Ç¾���ÿ=«�Hƒ{�tH‹C(H…ÀtðHÿu H‹{(è&÷ÿÿH‰ßÿ½ª�I‹>H…ÿu L‰÷èïÿÿH‰Ç1öHƒÄ8[A^ÿ%óª�I‰Æë+I‰ÆHƒ{�tH‹C(H…ÀtðHÿu H‹{(èÔöÿÿH‰ßÿkª�L‰÷è3ðÿÿH…ÀuHƒÄ8[A^ÃHG¥�H‰D$HÇD$���H‰çH‰|$WÀD$ Ht$è§ðÿÿH…ÀtH‰Çèñÿÿè¥ñÿÿ è®ÿÿ è§ÿÿ ÌÌÌÌÌAVSHƒì(H‰óH‹L‹0L‰t$ IƒÆH‹~ H‹F(H5 'þÿº���ÿPH‰\$ˆD$HÇD$����ÆD$�H²›�H\$H‰ßL‰öèÂÿÿH»›�Ht$ H‰ßè®ÿÿH‹D$¶L$H…ÀtU³„ÉuQL‹t$Hƒøu)€|$�t"AöF4uI‹~ I‹F(H5�Dþÿº���ÿP„Àu I‹~ I‹F(H5ãRþÿº���ÿP‰Ãë‰Ë„Û•ÀHƒÄ([A^ÃÌÌÌÌÌÌÌÌÌÌÌAWAVAUATSHƒì H‰óH‹L‹ L‹hH‹~ H‹F(H5ÉDþÿº���ÿPH‰\$ˆD$ÆD$�M…ítAH U���Lt$L|$ff. „�����L‰d$IÿÄL‰÷L‰þH‰Úè
+ÿÿIÿÍuåH‹\$¶D$¶ðH‰ßè ÿÿHƒÄ [A\A]A^A_ÃÌÌH‹‹N4öÁu¶�¶øöÁ „&ÿÿéQ-ÿÿ¶8éé-ÿÿÌÌÌÌÌÌÌÌÌHìˆ���‹F4¨u¨ uHĈ���éBõþÿH‹?HĈ���éƒÿÿH‹º���¸0���I‰È �H‰×IÁè‰Ê€â€ú
+A¹7���DBÈA�ÑDˆL<HWÿHƒùL‰ÁsÒHƒÇþHÿ€���w2A¹���I)ÑL<IƒÀHÂCþÿ¹���H‰÷¾���èËõþÿHĈ���ÃH´†�¾€���è¢óþÿ H‰÷H5lFþÿº���éœýþÿÌÌÌÌÌÌÌÌÌÌÌÌHƒì8H›�H‰D$HÇD$���HøDþÿH‰D$WÀD$ H5”›�H|$èóþÿ Hƒÿÿt
ðHÿOuÿ%
§�ÃÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHìØ���H‰óH‹?‰øƒàH
þÿHcHÈÿàH‹7H‹WH‰ßHÄØ���[A\A]A^A_]éäüþÿH‹GÿH‹OH‹I H‰ÇH‰ÞHÄØ���[A\A]A^A_]ÿáHÁï ‰|$ WÀ)„$À���)„$°���)„$ ���)„$���)„$€���)D$p)D$`)D$PHt$Pº€���ÿý¦�…ÀˆD��L|$PL‰ÿÿï¦�Lt$ L‰÷L‰þH‰Âè„ïþÿHƒ|$ �t=H‹D$0H‰D$D$ )$éŠ���HÁï H9 þÿHc ¸HÁÿáH9þÿ¹���éh��L‹d$(L‹|$0M…ÿt3™Àˆ��¶è¶…·�L‰ÿH‰îèÒåþÿI‰ÅH…ÀuH‰ïL‰þèoêþÿ A½���L‰ïL‰æL‰úÿ ¥�L‰,$L‰|$L‰|$H‰àH‰D$ HÛ��H‰D$(HD$ H‰D$0HU-ÿÿH‰D$8H)š�H‰D$PHÇD$X���HÇD$p����L‰t$`HÇD$h���H‹{ H‹s(HT$PèÒÿÿ‰ÃHƒ|$�„ï��H‹<$ÿê¤�éà��HëKþÿ¹���ém��HëKþÿ¹���é\��H\þÿ¹���éK��H‹þÿ¹���é:��HÊKþÿé)��HÑKþÿ¹���é ��HÒKþÿ¹
���é ��HÎKþÿ¹���éû��HËKþÿ¹���éê��HÏKþÿ¹ ���éÙ��HÊKþÿ¹ ���éÈ��HÄKþÿ¹���é·��HÈKþÿ¹���é¦��HÌKþÿ¹���é•��HÊKþÿ¹���é„��HÇKþÿés��HÎKþÿ¹&���ég��HãKþÿ¹8���éV��H
+Lþÿ¹���éE��HLþÿ¹���é4��HLþÿ¹ ���é#��HLþÿ¹ ���é��H Lþÿ¹
+���é��HQþÿ¹���éð���HóKþÿ¹���éß���HùKþÿ¹���éÎ���HLþÿ¹���é½���HþKþÿ¹
���é¬���HúKþÿ¹���é›���HË þÿ¹���éŠ���HìKþÿ¹���ë|HùKþÿ¹���ënH.þÿ¹���ë`HëKþÿ¹���ëRHóKþÿ¹���ëDHúKþÿ¹ ���ë6H÷Kþÿ¹���ë(HÿKþÿ¹
���ëHþKþÿ¹ ���ë HûKþÿ¹���H‰D$ H‰L$(HD$ H‰$HmýþÿH‰D$H —�H‰D$PHÇD$X���HÇD$p����H‰àH‰D$`HÇD$h���H‹{ H‹s(HT$Pè×ÿÿ‰Ã‰ØHÄØ���[A\A]A^A_]ÃHR�H‰D$ HÇD$(���H?þÿH‰D$0WÀD$8H59�H|$ è—íþÿ èPæþÿ H‰ÃHƒ|$�t
+H‹<$ÿ™¡�H‰ßè¡n� ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌH‰ðH‹7H‹WH‰Çéž÷þÿÌÌÌÌÌÌÌÌÌÌÌÌÌÌPè*���H…ÀtYÃH=GþÿH…•�¾^���è«
+ÿÿ ÌÌÌÌÌÌÌÌÌAVSHƒì8èôôÿÿH…Àt+I‰ÆH‹XH…Ûu1ÿèlðÿÿH‰ÃIƒ~�uI‰^ðHÿ 1ÛH‰ØHƒÄ8[A^ÃHˆ�H‰D$HÇD$���Hƒ>þÿH‰D$WÀD$ H5o�H|$èìþÿ I‰ÆðHÿ uH‰ßèúìÿÿL‰÷è¢m� Hƒ�t H‹?ÿ%€ �ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHì˜���H‰óI‰þH‹Hƒø…ˆ���M‹~HM…ÿ„8��M‹v@ff. „�����H|$L‰öL‰úè€ÿÿHƒ|$�„ó��H‹l$D¶d$D¶l$º���H‰ßH5yLþÿè öþÿ„À…Ü��AöÄ„Ö��LíI9ï‚Þ��IîI)ïu™é½��H…À„„���IFöC4H‰$HÇD$@����HÇD$H@B�H‰\$PH‰à…‚���H‰D$XHCÏÿÿH‰D$`H?”�H‰D$HÇD$���HÇD$(����HD$XH‰D$HÇD$ ���H5fˆ�H|$@HT$éÂ���I‹v I‹V(L‹{ H‹C(H‹XL‰ÿÿÓ‰Á°„É„â���é��H‰„$ˆ���H¾ÎÿÿH‰„$���HÇD$���HÇD$���HÇD$(����H¸ ������H‰D$0ÆD$8Hˆ“�H‰D$XHÇD$`���HD$H‰D$xHÇ„$€������H„$ˆ���H‰D$hHÇD$p���H5Ÿ‡�H|$@HT$XèÐùþÿH‹L$@„Àt"H…Ét H‹{ H‹C(H5›:þÿº���ÿP„Àt ë:„Àu6H…Éu]L‹{ H‹C(H‹XI‹v0I‹V8L‰ÿÿÓë H‹t$H‹T$H‰ßè?ôþÿ„Àt°ë1ÀHĘ���[A\A]A^A_]ÃH<˜�H‰ïL‰þèêþÿ H=4:þÿH
q†�L‹�HT$¾7���èûÿÿ ÌÌÌÌÌÌÌÌÌUAWAVAUATSHƒìhH‰ûHƒ>�tA¾ ���L=“Iþÿ„Òu\ë L‹~L‹v„Òt
+M…öuIéÏ���M…ö„Æ���H…Ét6A€?/u0H‹H‹IL‰ÿL‰öèz��H…ÀtH|$H‰Æè˜ÿþÿHƒ|$�„·���L‰|$8L‰t$@H|$Ht$8èc ÿÿH‹t$H…ötaL‹s L‹k(L|$Ld$8 €����H‹T$Hƒ|$ �taL‰÷AÿU@µ„À…ã���L‰÷¾ýÿ��AÿU „À…Ï���L‰ÿL‰æè ÿÿH‹t$H…öu¸1íé³���H5R:þÿH‰ß1ÒHƒÄh[A\A]A^A_]é²òþÿH‰ßèªòþÿé…���H‹D$H‹L$H‰D$XH‰L$`HÊþÿH‰D$8H¾ÿÿH‰D$@HD$XH‰D$HHX÷þÿH‰D$PH””�H‰D$HÇD$���HÇD$(����HD$8H‰D$HÇD$ ���H‹{ H‹s(HT$èÀ ÿÿ‰Å‰èHƒÄh[A\A]A^A_]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHìh��H…öt€?/A”ÀH…Ét€:/”Àë
+E1ÀH…Éuð1ÀH‰”$(��H‰Œ$0��Æ„$8��ˆ„$b��fÇ„$`���LT$aA±±1ÒA€ùt(H‹D$?H‰„$¯���D$ L$0)Œ$ ���)„$���H‰|$H‰|$PI‰õH‰t$XE‰ÎDˆL$`H‹„$¯���I‰B („$���(Œ$ ���AJL‰ÓAE‰ÇDˆ„$Š���‰Õˆ”$ˆ���A‰ÌˆŒ$‰���H¼$���Ht$Pè§��H¼$È���H´$(��è’��¶„$È���€¼$���
+„‰���<
+„…���H¼$���H´$È���èÏ��„À„¦���H‹|$PH‹t$XD¶L$`I‰ÚK)D$ )L$0H‹C H‰D$?¶”$ˆ���¶Œ$‰���D¶„$Š���¶C.ˆD$‹C*‰D$A€ù…¸þÿÿéÚþÿÿ<
+u>H‹D$?H‰„$ ��(D$ (L$0)Œ$��)„$���‹D$‰D$¶D$ˆD$ A€ÿu1Àé‰���H‹„$ ��H‰„$À���(„$���(Œ$��Œ$±���„$¡���‹D$‰„$Ë���¶D$ ˆ„$Ï���H‹D$H‰„$���L‰¬$˜���Dˆ´$ ���@ˆ¬$È���Dˆ¤$É���Dˆ¼$Ê���H¼$���èa��HÄh��[A\A]A^A_]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHƒìD¶^8A€û„L��H‰ó¶n9@€ý„;��A8ë‡2��L‹H‹K¶S1Àƒú“ÀD@‰D$D¶c:H‹C0HpH…ÀHDðH‹C LD0L‰D$HÆHƒÆH‰4$HƒÀA‰ÖL-‡ÿýÿH‰Îë$L‹D$M…À…��ÆC8A³M‰ÐM‰ÂA8뇳��E„ÛteE¶ÃAƒøu{ÆC8E„ä…x��A³ƒúr̓útȃú…#��H…ö„ ��E¶Hƒþ„��A€ø.…ø���A€z/u—é���ff. „�����OcLµ�MéI‰ÀAÿáL‹$é`ÿÿÿf „�����H…ö„ ��E1É @�C€<
+/t4IÿÁL9ÎuñE1ÀI‰ñM…Éu,H‰ñL)Á‚��MÐL‰H‰KA³H‰Îé ÿÿÿA¸���M…ÉtÔA· IƒùtL‰ÑD‹\$Iƒùtë A€:.uIJA³€9.E¶û¹ ���DEùMÈH‰ñL)Á‚8��MÐL‰H‰KA³H‰ÎA€ÿ
+„µþÿÿé���1öé¦þÿÿHƒþ…œþÿÿA€ø.…’þÿÿH…É„C��HÿÉIÿÂL‰H‰KÆë<ÆC8H5õýýÿNc¶IðAÿàI‰ÀëYH…É„ù���HÿÉIÿÂL‰H‰KÆëÆC8Æ
+HƒÄ[A\A]A^A_]ÃDˆ?L‰WL‰OëäL‹$ëA¸���ë
L‹D$ëA¸���I9Èw|H5™ýýÿNc ¶IñAÿáH‹$ë¸���ë H‹D$ë¸���H‰ÎH)Ær^LÐH‰H‰sH‹C0H‰G CK!OGˆL‰W(L‰G0éaÿÿÿÆéYÿÿÿH&�L‰Çè âþÿ HµŒ�L‰ÇH‰Îèšëþÿ H¹Œ�H‰ÇH‰Îèöáþÿ HÕŒ�¿���1öèááþÿ H¨Œ�ëéÌÌÌÌÌÌAVSPI‰öH‰û¶Aú¶ðHV1À@€þHCÐA¶6~úD¶ÇMHA€øLCÈL9Êux°H…Òt$ƒúulH‹SI;Vu`I‹vH‹{ÿ‡•�…À”ÀëM@€ÿrG@8ñu@HvüýÿHc ˆHÁÿáH‹SI;Vu&I‹vH‹{ÿM•�…ÀuH‹S I;V u
+I‹vH‹{ë¨1ÀHƒÄ[A^öCA:F”ÀëëÌÌÌÌÌÌAWAVAUATSHì€���H‹ L‹w¶O€ùtH‹G0H‰D$_GO!)L$P)D$@¶W:¶w8¶G9H‰ $L‰t$ˆL$(D$@(L$PD$L$!H‹|$_H‰|$0ˆT$:@ˆt$8ˆD$9@€þ…¸���M…ö„��€ùr{f „�����1ÿfffff. „�����€<;/tHÿÇI9þuò1ÉL‰÷H…ÿuëf D��¹���H…ÿt HƒÿuX€;.uSHÏI9þ‚×���HûI)þu§E1öë:fº���H…Éu.HÓI)Ötç1Éfff. „�����€< /tÚHÿÁI9Îuò1ÒL‰ñH…ÉtÒH‰ $L‰t$<uUH‰çè“���I9ÆvHL|$@I‰äf D��L‰ÿL‰æèÕ��€|$H
+u(M‰õL+l$@r8L‰l$L‰çèW���M‰îI9ÅwÏë
+E1ö<t«M‰õH‰ØL‰êHÄ€���[A\A]A^A_ÃH͉�L‰ïL‰öèÊèþÿ H¡‰�L‰öè)ßþÿ ÌÌÌÌÌÌ̶G81É<@•Æº����Ò@ò¶ò@€þÿt…öu~¶O:€úÿt…öuq„Ét±ëiD¶GAHû€ùwYH‹H‹w1Ò„ÀuA€øtº���Hƒþ‚ß���H9òt2HÎLIÿÀI9ð@”ƶ @öÆ…‘���€ù.…ˆ���A€8/„”���1É1Ò„Àu
+¶GHƒøu 1ÀH¶ÁHÐÃH5”ùýÿHc†HðÿàH‹G HƒÀëÜH‹G H‹w0H~H…öHDþHøHƒÀëÀ¸���ë¹H‹G H‹w0H~H…öHDþHøHƒÀë¸���ë–€ù.•Á@öÖ@Î@öÆ…lÿÿÿº���1É„À…oÿÿÿé`ÿÿÿPHù‡�¿���èÇÝþÿ ÌÌÌÌÌAVSPI‰öH‰ûH‰÷èŽþÿÿI‹vH9ð‡ž���I‹>H L 7I)ÉL7IÿÈ1Òf. „�����M…Ét#M‰ÊIÿÉA€8/M@ÿuëLÐH9ðwiHǺ���H‰ùH)Æt%° Hƒþt!Hƒþu)€9.u$1ÀA€~“À@ƒÀë°
+ë€9.u €y.”À4 HòH‰ˆCH‰KH‰sHƒÄ[A^ÃHT‡�ëH3‡�H‰ÇèëÜþÿ ÌÌÌÌÌÌÌÌÌAVSHƒì8HÖ‚ƒ���H‰ûH‹GH �H9ñHGñHƒþ A¾���LCöL‰öH÷ÖHÁî?H…ÀtH‹ H‰L$HÇD$���H‰D$ë HÇD$����H|$ HL$L‰òèN���Hƒ|$ �H‹|$(tH¸������€H9ÇtH…ÿuèÈÔþÿ H‰;L‰sHƒÄ8[A^ÃH‹t$0èíÔþÿ ÌÌÌÌÌÌÌÌÌÌÌAWAVSH‰ÓI‰þH…ötPI‰÷Hƒy�t"H‹qH…ötH‹9L‰úH‰Ùè?ÐþÿH…Àu"M‰~ë,H…Ût9¶¡�H‰ßL‰þèÝÏþÿH…ÀtÞI‰F1Àë
IÇF����¸���I‰^I‰[A^A_ÃL‰øH…ÀuÖë²ÌÌÌÌÌÌÌÌÌÌÌÌAWAVSH‰û‹ƒøu#¹ÿÿÿfff. „�����ó‹ƒøu Q…ɉÑuî…Àu¹���1Àð± u[A^A_ÃL‹5�L‹=¡Ž�f „�����ƒøt ¸���‡…ÀtÓ‹ƒøu!º���H‰ß¾���1ÉE1ÀAÿÖ…ÀyAÿ׃8tØ‹ƒøuÁ¹ÿÿÿfff. „�����ó‹Qƒøu¤…ɉÑuîëœÌÌÌÌÌÌÌÌÌÌÌÌPèØÿÿH…Àt Hƒ8�”ÀYÃH=N8þÿH
.�Lǃ�HT$¾F���è¨õþÿ ÌÌÌÌÌÌUAWAVAUATSHìH ��H‰´$¨��H‹GHƒ?�u H‰Çÿ�HHÿH…ÀHDÈH‰L$pH‹¥ �H…À…c��¶åŸ�¿ ��ÿŽ�H…À„…Q��H‰ÃHÇ„$Ð������WÀ„$Ø���H=HV��H´$Ð���ÿ¢Ž�„$Ð���)„$�
+��H‹„$à���H‰„$
+��L‹5+ �M…ö„§���L‹=+ �M…ÿt8Mf L‹-ƒ�ë
+IƒÄ8IÿÏt!Iƒ|$è�tI‹|$àAÿÕIƒ<$�tàI‹|$øAÿÕëÖHƒ=ÞŸ��t L‰÷ÿC�L‹=ÜŸ�L‹-åŸ�IIÿÅfffff. „�����IƒýtL§H��IÿÍè+h��L‰çëæHƒ=¦Ÿ��t L‰ÿÿóŒ�H‹„$
+��H‰|Ÿ�(„$�
+��]Ÿ�H‰ nŸ�HÇkŸ����HÇhŸ�����H‹9Ÿ�H‹5BŸ�H…ö„;G��HkÎ8HÁ1ÿH‰ÂL‹BL‹Z(H‹j0HƒÂ8IÁãM…Ût+M‰ÁIƒÀM‹IêIƒÃðL;T$pwãMQL;T$pvØëf D��HÿÇH9Êu³éÝF��L‹5ìž�M…öt0H‹ О�IiÎH��1ÒE1ÿ @�H9<„®��IÿÇHÂH��H9ÑuçH9þ†-G��H‰¼$@ ��HkÏ8L‹4L‹|H¼$Ð���L‰öL‰úè–g��Hƒ¼$Ð����„ ��H‹´$Ø���H‹œ$à���HÇ„$@�����WÀ„$H��HÇ„$X�����„$`��H¼$Ð���H‰´$ ��H‰Úèôh��L‹¤$Ð���M…ä„·��„$8��„$( ��„$(��„$ ��„$��„$ ��„$Ø���Œ$è���”$ø���œ$��œ$ø��”$è��Œ$Ø��„$È��L‰¤$À��H¼$À��èn��H…ÀH‰œ$À��tFH¼$H ��H‰Æèao��Hƒ¼$H ���t+H¼$Ð���HŒ$H ��L‰öL‰úèûq��¶„$Ð���<…��L‰d$hL‰|$@L‰t$HH‰¬$ ��L‹¼$Ø��M…ÿ„Y��H‹œ$à��H…Û„1��H‹¬$Ð��L‹´$è��L‹¤$ð��L‹¬$ø��IÁçëfff. „�����HƒÅ@IƒÇÀ„��‹U�LârêH‰ßL‰öL‰éèŒWÿÿH…Àt×HƒúuÑH‹Hº.gnu_debH1ÑH‹@HºebuglinkH1ÐH Èu«ƒ}„·��H‹Œ$È��H‹UH‹E H)Ñ@’ÆH‹|$hH×H9Á’ÁE1ÿ@ñLDÿ…‚��H…À„y��E1íC€</�„HD��IÿÅL9èuíé^��M…ÿ„€$��MiçH��I‰ÝLãH¼$�
+��ºH��H‰Þÿd‰�K4,HÆH��I÷×M÷Ii×H��H‰ßÿ[‰�I^ÿH‰ À›�H; ±›�uH‰ßè/Î��L‹-˜›�I½H��HiÓH��L‰îÿ!‰�H´$�
+��ºH��L‰ïÿóˆ�L‰5t›�L‰ëéÝ#��³€û…ÿ��éFC��±€ù„Ï��(„$���(Œ$��(”$ ��)”$ð���)Œ$à���)„$Ð���€ù…Á��„$@��Œ$P��”$`��)”$Ð��)Œ$À��)„$°��H‰”$˜��H‹Œ$`��H‰òH‰þL‰ÇM‰ÈM‰ÑM‰ÚM‰óM‰þM‰çM‰ìL‹¬$X��H‹„$P��H‰„$X��H‹„$H��H‰„$P��H‹„$@��H‰„$H��H‹„$8��H‰„$@��H‹„$0��H‰„$8��H‹„$(��H‰„$0��H‹„$ ��H‰„$(��H‹„$��H‰„$ ��H‹„$��H‰„$��H‹„$��H‰„$��H‹„$���H‰„$��H‹„$ø��H‰„$���H‹„$ð��H‰„$ø��H‹„$è��H‰„$ð��H‹„$à��H‰„$è��H‹„$Ø��H‰„$à��H‹„$Ð��H‰„$Ø��H‹„$È��H‰„$Ð��H‹„$8��H‰„$È��H‹„$À��H‰„$8��H‹„$¸��H‰„$À��H‹„$°��H‰„$¸��H‹„$¨��H‰„$°��H‹„$ ��H‰„$¨��H‹„$˜��H‰„$ ��H‹„$��H‰„$˜��H‹„$ˆ��H‰„$��H‹„$€��H‰„$ˆ��H‹„$x��H‰„$€��H‹„$p��H‰„$x��H‹„$h��H‰„$p��H‹„$`��H‰„$h��H‹„$X��H‰„$`��H‹„$P��H‰„$X��H‹„$H��H‰„$P��H‹„$@��H‰„$H��H‹„$8��H‰„$@��H‹„$0��H‰„$8��H‹„$(��H‰„$0��H‹„$ ��H‰„$(��H‹„$��H‰„$ ��H‹„$��H‰„$��H‹„$��H‰„$��H‹„$���H‰„$��H‹„$ø��H‰„$���H‹„$ð��H‰„$ø��H‹„$è��H‰„$ð��H‹„$à��H‰„$è��H‹„$Ø��H‰„$à��H‹„$Ð��H‰„$Ø��H‹„$È��H‰„$Ð��H‰œ$��H‹„$ ��H‰„$È��¶\$'€û…ú��éA?��L‰¬$p��L‰¤$x��L‰¼$€��L‰´$ˆ��L‰œ$0��L‰”$ ��L‰Œ$h��L‰„$(��I‰þI‰ôI‰×¶D$H‹”$8��HÁâH ÂH‰”$8��(„$Ð���(Œ$à���(”$ð���)”$Ð��)Œ$À��)„$°��A‰Íé„��ˆ„$0��¶„$×���Áà·Œ$Õ��� ÁHÁá ‹„$Ñ���H ÈH‰„$˜��¶„$ß���Áà·Œ$Ý��� ÁHÁá ‹„$Ù���H ÈH‰„$(��¶„$ç���Áà·Œ$å��� ÁHÁá ‹„$á���H ÈH‰„$`��¶„$ï���Áà·Œ$í��� ÁHÁá ‹´$é���H ζ„$÷���Áà·Œ$õ��� ÁHÁá ‹¼$ñ���H ϶„$ÿ���Áà·Œ$ý��� ÁHÁá D‹„$ù���I ȶ„$��Áà·Œ$�� ÁHÁá D‹Œ$��I ɶ„$��Áà·Œ$
�� ÁHÁá D‹”$ ��I ʶ„$��Áà·Œ$�� ÁHÁá D‹œ$��I ˶„$ ��Áà·Œ$ �� ÁHÁá D‹´$��I ζ„$'��Áà·Œ$%�� ÁHÁá D‹¼$!��I ϶„$/��Áà·Œ$-�� ÁHÁá D‹¤$)��I ̶„$7��Áà·Œ$5�� ÁHÁá D‹¬$1��I Ͷ„$?��Áà·Œ$=�� ÁHÁá ‹„$9��H ÈH‰„$X��¶„$G��Áà·Œ$E�� ÁHÁá ‹„$A��H ÈH‰„$P��¶„$O��Áà·Œ$M�� ÁHÁá ‹„$I��H ÈH‰„$H��¶„$W��Áà·Œ$U�� ÁHÁá ‹„$Q��H ÈH‰„$@��¶„$_��Áà·Œ$]�� ÁHÁá ‹„$Y��H ÈH‰„$8��¶„$g��Áà·Œ$e�� ÁHÁá ‹„$a��H ÈH‰„$0��¶„$o��Áà·Œ$m�� ÁHÁá ‹„$i��H ÈH‰„$(��¶„$w��Áà·Œ$u�� ÁHÁá ‹„$q��H ÈH‰„$ ��¶„$��Áà·Œ$}�� ÁHÁá ‹„$y��H ÈH‰„$��¶„$‡��Áà·Œ$…�� ÁHÁá ‹„$��H ÈH‰„$��¶„$��Áà·Œ$�� ÁHÁá ‹„$‰��H ÈH‰„$��¶„$—��Áà·Œ$•�� ÁHÁá ‹„$‘��H ÈH‰„$���¶„$Ÿ��Áà·Œ$�� ÁHÁá ‹„$™��H ÈH‰„$ø��¶„$§��Áà·Œ$¥�� ÁHÁá ‹„$¡��H ÈH‰„$ð��¶„$¯��Áà·Œ$�� ÁHÁá ‹„$©��H ÈH‰„$è��¶„$·��Áà·Œ$µ�� ÁHÁá ‹„$±��H ÈH‰„$à��¶„$¿��Áà·Œ$½�� ÁHÁá ‹„$¹��H ÈH‰„$Ø��¶„$Ç��Áà·Œ$Å�� ÁHÁá ‹„$Á��H ÈH‰„$Ð��¶„$Ï��Áà·Œ$Í�� ÁHÁá ‹„$É��H ÈH‰„$È��¶„$×��Áà·Œ$Õ�� ÁHÁá ‹„$Ñ��H ÈH‰Á„$à��Œ$ð��”$���)”$ ��)Œ$��)„$���¶„$Ø���ˆD$'¶„$à���ˆD$¶„$è���ˆD$¶„$ð���ˆ„$��¶„$ø���ˆ„$È���¶„$���ˆ„$ ���¶„$��ˆ„$���¶„$��ˆ„$˜���¶„$��ˆ„$€���¶„$ ��ˆ„$À���¶„$(��ˆ„$¸���¶„$0��ˆD$x¶„$8��ˆD$P¶„$@��ˆD$8¶„$H��ˆD$(¶„$P��ˆD$@¶„$X��ˆD$0H‹„$Ø��H‰„$À��H‹„$à��H‰„$¸��H‹„$è��H‰„$°��H‹„$ð��H‰„$¨��H‹„$ø��H‰„$ ��H‹„$���H‰„$˜��H‹„$��H‰„$��H‹„$��H‰„$ˆ��H‹„$��H‰„$€��H‹„$ ��H‰„$x��H‹„$(��H‰„$p��H‹„$0��H‰„$h��H‹„$8��H‰„$`��H‹„$@��H‰„$X��H‹„$H��H‰„$P��H‹„$P��H‰„$H��H‹„$X��H‰„$@��H‹„$`��H‰„$8��H‹„$h��H‰„$0��H‹„$p��H‰„$(��H‹„$x��H‰„$ ��H‹„$€��H‰„$��H‹„$ˆ��H‰„$��H‹„$��H‰„$��H‹„$˜��H‰„$���H‹„$ ��H‰„$ø��H‹„$¨��H‰„$ð��H‹„$°��H‰„$è��H‹„$¸��H‰„$à��H‹„$À��H‰„$Ø��H‹„$È��H‰„$Ð��H‹„$Ð��H‰„$È��H‹„$Ø��H‰„$��¶„$`��ˆD$¶„$h��ˆD$¶„$p��ˆD$¶„$x��ˆD$¶„$€��ˆD$¶„$ˆ��ˆD$¶„$��ˆD$`¶„$˜��ˆ„$¨���¶„$ ��ˆ„$°���¶„$¨��ˆ„$ˆ���¶„$°��ˆD$X¶„$¸��ˆD$¶„$À��ˆD$h¶„$È��¶”$Ð��ˆT$ˆD$HH‰Œ$8��Hƒ¼$ ���„½/��H‰¼$h��H‹¼$� ��L‰¼$€��H‰óL‰¤$x��M‰ÄL‰¬$p��M‰ÍL‰”$ ��L‰´$ˆ��M‰Þÿƒz�M‰óL‹´$ˆ��L‹”$ ��M‰éL‹¬$p��M‰àL‹¤$x��H‹¼$h��H‰ÞH‹œ$À��H‹”$(��L‹¼$€��¶Œ$0��€ù„T ��é€ñÿÿIÁçffff. „�����IƒÇÀuúH¼$@��HŒ$@��H‹t$HH‹T$@H‹œ$À��èãv��H‹¬$ ��HÇ„$H ������H¼$Ð���H´$@��H”$À��HŒ$H ��L„$@��èâ|��¶„$Ð���ˆD$'<u±€ù…æðÿÿé°��¶„$×���Áà·Œ$Õ��� ÁHÁá ‹”$Ñ���H ʶ„$ß���Áà·Œ$Ý��� ÁHÁá ‹„$Ù���H ÈH‰„$`��¶„$ç���Áà·Œ$å��� ÁHÁá ‹´$á���H ζ„$ï���Áà·Œ$í��� ÁHÁá ‹¼$é���H ϶„$÷���Áà·Œ$õ��� ÁHÁá D‹„$ñ���I ȶ„$ÿ���Áà·Œ$ý��� ÁHÁá D‹Œ$ù���I ɶ„$��Áà·Œ$�� ÁHÁá D‹”$��I ʶ„$��Áà·Œ$
�� ÁHÁá D‹œ$ ��I ˶„$��Áà·Œ$�� ÁHÁá D‹´$��I ζ„$ ��Áà·Œ$ �� ÁHÁá D‹¼$��I ϶„$'��Áà·Œ$%�� ÁHÁá D‹¤$!��I ̶„$/��Áà·Œ$-�� ÁHÁá D‹¬$)��I Ͷ„$7��Áà·Œ$5�� ÁHÁá ‹„$1��H ÈH‰„$X��¶„$?��Áà·Œ$=�� ÁHÁá ‹„$9��H ÈH‰„$P��¶„$G��Áà·Œ$E�� ÁHÁá ‹„$A��H ÈH‰„$H��¶„$O��Áà·Œ$M�� ÁHÁá ‹„$I��H ÈH‰„$@��¶„$W��Áà·Œ$U�� ÁHÁá ‹„$Q��H ÈH‰„$8��¶„$_��Áà·Œ$]�� ÁHÁá ‹„$Y��H ÈH‰„$0��¶„$g��Áà·Œ$e�� ÁHÁá ‹„$a��H ÈH‰„$(��¶„$o��Áà·Œ$m�� ÁHÁá ‹„$i��H ÈH‰„$ ��¶„$w��Áà·Œ$u�� ÁHÁá ‹„$q��H ÈH‰„$��¶„$��Áà·Œ$}�� ÁHÁá ‹„$y��H ÈH‰„$��¶„$‡��Áà·Œ$…�� ÁHÁá ‹„$��H ÈH‰„$��¶„$��Áà·Œ$�� ÁHÁá ‹„$‰��H ÈH‰„$���¶„$—��Áà·Œ$•�� ÁHÁá ‹„$‘��H ÈH‰„$ø��¶„$Ÿ��Áà·Œ$�� ÁHÁá ‹„$™��H ÈH‰„$ð��¶„$§��Áà·Œ$¥�� ÁHÁá ‹„$¡��H ÈH‰„$è��¶„$¯��Áà·Œ$�� ÁHÁá ‹„$©��H ÈH‰„$à��¶„$·��Áà·Œ$µ�� ÁHÁá ‹„$±��H ÈH‰„$Ø��¶„$¿��Áà·Œ$½�� ÁHÁá ‹„$¹��H ÈH‰„$Ð��¶„$Ç��Áà·Œ$Å�� ÁHÁá ‹„$Á��H ÈH‰„$È��¶„$Ï��Áà·Œ$Í�� ÁHÁá ‹„$É��H ÈH‰„$8��¶„$Ø���ˆD$¶„$à���ˆD$¶„$è���ˆ„$��¶„$ð���ˆ„$È���¶„$ø���ˆ„$ ���¶„$���ˆ„$���¶„$��ˆ„$˜���¶„$��ˆ„$€���¶„$��ˆ„$À���¶„$ ��ˆ„$¸���¶„$(��ˆD$x¶„$0��ˆD$P¶„$8��ˆD$8¶„$@��ˆD$(¶„$H��ˆD$@¶„$P��ˆD$0¶„$X��ˆD$H‹„$Ð��H‰„$À��H‹„$Ø��H‰„$¸��H‹„$à��H‰„$°��H‹„$è��H‰„$¨��H‹„$ð��H‰„$ ��H‹„$ø��H‰„$˜��H‹„$���H‰„$��H‹„$��H‰„$ˆ��H‹„$��H‰„$€��H‹„$��H‰„$x��H‹„$ ��H‰„$p��H‹„$(��H‰„$h��H‹„$0��H‰„$`��H‹„$8��H‰„$X��H‹„$@��H‰„$P��H‹„$H��H‰„$H��H‹„$P��H‰„$@��H‹„$X��H‰„$8��H‹„$`��H‰„$0��H‹„$h��H‰„$(��H‹„$p��H‰„$ ��H‹„$x��H‰„$��H‹„$€��H‰„$��H‹„$ˆ��H‰„$��H‹„$��H‰„$���H‹„$˜��H‰„$ø��H‹„$ ��H‰„$ð��H‹„$¨��H‰„$è��H‹„$°��H‰„$à��H‹„$¸��H‰„$Ø��H‹„$À��H‰„$Ð��H‹„$È��H‰„$È��¶„$`��ˆD$¶„$h��ˆD$¶„$p��ˆD$¶„$x��ˆD$¶„$€��ˆD$¶„$ˆ��ˆD$`¶„$��ˆ„$¨���¶„$˜��ˆ„$°���¶„$ ��ˆ„$ˆ���¶„$¨��ˆD$X¶„$°��ˆD$¶„$¸��ˆD$h¶„$À��ˆD$H¶„$È��ˆD$±€ù…1èÿÿL‰¬$p��L‰¤$x��L‰¼$€��L‰´$ˆ��L‰œ$0��L‰”$ ��L‰Œ$h��L‰„$(��I‰þI‰ôI‰×AµH¼$@��èé´��H‹¼$ ��H‰Þÿpp�¶D$HˆD$¶D$hˆD$H¶D$ˆD$h¶D$XˆD$¶„$ˆ���ˆD$X¶„$°���ˆ„$ˆ���¶„$¨���ˆ„$°���¶D$`ˆ„$¨���¶D$ˆD$`¶D$ˆD$¶D$ˆD$¶D$ˆD$¶D$ˆD$¶D$ˆD$¶D$0ˆD$¶D$@ˆD$0¶D$(ˆD$@¶D$8ˆD$(¶D$PˆD$8¶D$xˆD$P¶„$¸���ˆD$x¶„$À���ˆ„$¸���¶„$€���ˆ„$À���¶„$˜���ˆ„$€���¶„$���ˆ„$˜���¶„$ ���ˆ„$���¶„$È���ˆ„$ ���¶„$��ˆ„$È���¶D$ˆ„$��¶D$ˆD$¶D$'ˆD$D‰ëL‰ùH‹”$`��L‰æL‰÷L‹„$(��L‹Œ$h��L‹”$ ��L‹œ$0��L‹´$ˆ��L‹¼$€��L‹¤$x��L‹¬$p��€û„L)��(„$°��(Œ$À��(”$Ð��”$°��Œ$ ��„$��ˆœ$€��H‹œ$˜��H‰ØHÁè0ˆ„$‡��‰œ$��HÁë f‰œ$…��¶D$ˆ„$ˆ��H‰ÈHÁè0ˆ„$��‰Œ$‰��HÁé f‰Œ$��¶D$ˆ„$��H‰ÐHÁè0ˆ„$—��‰”$‘��HÁê f‰”$•��¶„$��ˆ„$˜��H‰ðHÁè0ˆ„$Ÿ��‰´$™��HÁî f‰´$��¶„$È���ˆ„$ ��H‰øHÁè0ˆ„$§��‰¼$¡��HÁï f‰¼$¥��¶„$ ���ˆ„$¨��L‰ÀHÁè0ˆ„$¯��D‰„$©��IÁè fD‰„$��¶„$���ˆ„$°��L‰ÈHÁè0ˆ„$·��D‰Œ$±��IÁé fD‰Œ$µ��¶„$˜���ˆ„$¸��L‰ÐHÁè0ˆ„$¿��D‰”$¹��IÁê fD‰”$½��¶„$€���ˆ„$À��L‰ØHÁè0ˆ„$Ç��D‰œ$Á��IÁë fD‰œ$Å��¶„$À���ˆ„$È��L‰ðHÁè0ˆ„$Ï��D‰´$É��IÁî fD‰´$Í��¶„$¸���ˆ„$Ð��L‰øHÁè0ˆ„$×��D‰¼$Ñ��IÁï fD‰¼$Õ��¶D$xˆ„$Ø��L‰àHÁè0ˆ„$ß��D‰¤$Ù��IÁì fD‰¤$Ý��¶D$Pˆ„$à��L‰èHÁè0ˆ„$ç��D‰¬$á��IÁí fD‰¬$å��¶D$8ˆ„$è��H‹Œ$X��H‰ÈHÁè0ˆ„$ï��‰Œ$é��HÁé f‰Œ$í��¶D$(ˆ„$ð��H‹Œ$P��H‰ÈHÁè0ˆ„$÷��‰Œ$ñ��HÁé f‰Œ$õ��¶D$@ˆ„$ø��H‹Œ$H��H‰ÈHÁè0ˆ„$ÿ��‰Œ$ù��HÁé f‰Œ$ý��¶D$0ˆ„$���H‹Œ$@��H‰ÈHÁè0ˆ„$��‰Œ$��HÁé f‰Œ$��¶D$ˆ„$��H‹Œ$8��H‰ÈHÁè0ˆ„$��‰Œ$ ��HÁé f‰Œ$
��¶D$ˆ„$��H‹Œ$0��H‰ÈHÁè0ˆ„$��‰Œ$��HÁé f‰Œ$��¶D$ˆ„$��H‹Œ$(��H‰ÈHÁè0ˆ„$ ��‰Œ$��HÁé f‰Œ$ ��¶D$ˆ„$ ��H‹Œ$ ��H‰ÈHÁè0ˆ„$'��‰Œ$!��HÁé f‰Œ$%��¶D$ˆ„$(��H‹Œ$��H‰ÈHÁè0ˆ„$/��‰Œ$)��HÁé f‰Œ$-��¶D$ˆ„$0��H‹Œ$��H‰ÈHÁè0ˆ„$7��‰Œ$1��HÁé f‰Œ$5��¶D$`ˆ„$8��H‹Œ$��H‰ÈHÁè0ˆ„$?��‰Œ$9��HÁé f‰Œ$=��¶„$¨���ˆ„$@��H‹Œ$���H‰ÈHÁè0ˆ„$G��‰Œ$A��HÁé f‰Œ$E��¶„$°���ˆ„$H��H‹Œ$ø��H‰ÈHÁè0ˆ„$O��‰Œ$I��HÁé f‰Œ$M��¶„$ˆ���ˆ„$P��H‹Œ$ð��H‰ÈHÁè0ˆ„$W��‰Œ$Q��HÁé f‰Œ$U��¶D$Xˆ„$X��H‹Œ$è��H‰ÈHÁè0ˆ„$_��‰Œ$Y��HÁé f‰Œ$]��¶D$ˆ„$`��H‹Œ$à��H‰ÈHÁè0ˆ„$g��‰Œ$a��HÁé f‰Œ$e��¶D$hˆ„$h��H‹Œ$Ø��H‰ÈHÁè0ˆ„$o��‰Œ$i��HÁé f‰Œ$m��¶D$Hˆ„$p��H‹Œ$Ð��H‰ÈHÁè0ˆ„$w��‰Œ$q��HÁé f‰Œ$u��¶D$ˆ„$x��H‹Œ$È��H‰ÈHÁè0ˆ„$��‰Œ$y��HÁé f‰Œ$}��H‹„$8��H‰„$€��H‹„$À��H‰„$ˆ��H‹„$¸��H‰„$��H‹„$°��H‰„$˜��H‹„$¨��H‰„$ ��H‹„$ ��H‰„$¨��H‹„$˜��H‰„$°��H‹„$��H‰„$¸��H‹„$ˆ��H‰„$À��H‹„$€��H‰„$È��H‹„$x��H‰„$Ð��H‹„$p��H‰„$Ø��H‹„$h��H‰„$à��H‹„$`��H‰„$è��H‹„$X��H‰„$ð��H‹„$P��H‰„$ø��H‹„$H��H‰„$���H‹„$@��H‰„$��H‹„$8��H‰„$��H‹„$0��H‰„$��H‹„$(��H‰„$ ��H‹„$ ��H‰„$(��H‹„$��H‰„$0��H‹„$��H‰„$8��H‹„$��H‰„$@��H‹„$���H‰„$H��H‹„$ø��H‰„$P��H‹„$ð��H‰„$X��H‹„$è��H‰„$`��H‹„$à��H‰„$h��H‹„$Ø��H‰„$p��H‹„$Ð��H‰„$x��H‹„$È��H‰„$€��H‹„$��H‰„$ˆ��L‹5Ÿx�IƒþuPHÇŽx����H‹ x�¾Ø��H5kx�H¼$Ð���ºH��ÿàe�€¼$Ø���t
H¼$Ø���èÁ@��A¾���ëH‹ :x�L¤$Ø���H´$€��º@��L‰çÿœe�H‹„$@ ��H‰„$Ð���I9ÞuH‰ß自��H‹ ðw�M…ötKH»H��IiÖH��H‰Þÿte�H´$Ð���ºH��H‰ßÿFe�IÿÆL‰5Äw�u3H[b�1ÿ1ö袱þÿ H´$Ð���ºH��H‰ßÿe�HÇw����H‹D$pH)èH‰D$pLxL‹£`��H‹³h��1ÿH…ötb¹ÿ���H‰ðH‰òëfff. „�����H‰ÂH)øvAHÑèHøI‰ÁIÁáE1ÀO9< A•ÀDBÁA€øtÖA¶øHÿÀÿÿ���u
H‰ÇH‰ÐH)øwÄëH‰ÇH9÷‡Ì'��¸���H…ÿH‰œ$ˆ���„«��HSH‹��H‰L$(HÃX��HÁçN,'IƒÅàH÷ßH‹L$pëff. „�����IƒÅàHƒÇ „]��I9M†A��I9MvâM;}�vÜH‰”$��I‹}H‹„$ˆ���H‹°x��H9÷ƒa ��Li÷��L°p��H¼$�
+��L‰öH‰Úè—©��L‰´$H ��H‹D$pH‰„$X ��H‰œ$P ��Hƒ¼$0
+���„S��H„$0
+��„$�
+��Œ$
+��”$
+��)”$ð���)Œ$à���)„$Ð���H‹HH‰Œ$���H‹„$H ��H‰„$˜��H‹„$P ��H‰„$ ��H‹„$X ��H‰„$¨��)„$���H‹„$��H‰„$��H‹„$˜��H‰„$��H‹„$ ��H‰„$ ��H‹„$¨��H‰„$(��é¸��H‹œ$ˆ���ƒøuéÙ ��H‹œ$ˆ���ƒø„È ��H‹Œ$¸��H‰Œ$À���H‹Œ$À��H‰Œ$¸���Hýƒùº���BÑ…Ò„ ��‹´$„��D‹”$ˆ��D‹Œ$Œ��H‹¼$��H‰|$8H‹¼$˜��H‰|$H‹¼$ ��L‹„$¨��L‰„$ ���L‹„$°��L‰„$°���L‹„$È��L‰D$XL‹„$Ð��L‰D$PLG`L‰„$€���L‡¸��L‰„$���H‰|$0HÇÀ��H‰¼$¨���H»��H‰|$xƒúu_M‰ÌIÁä M ÔƒùH‰t$hL‰L$(¸���‚1��H‰D$H¸���H‰D$@Hƒ¼$¸����L‹l$0„"��H‹¼$À���ÿHa�é��1ÛéV��‰ÀI‰ôIÁä I ÄL‰ËHÁã L ÓH‹D$PH;D$X„Å���L‹høA‹E(A‹M,1ÒH‰T$HH‰D$h…À@•Å1ÀH‰D$@H‰L$(…ÉA•ÆIƒ}��„»��H‹„$€���ƒ8/„ª��I‹EH‰„$˜���H‹D$0Hƒ¸°���…4��H¼$Ð���H‹´$€���èV�L‹|$0H¼$�
+��H”$Ð���L‰þH‹Œ$ ���èa�Iƒ¿°���„Â��H¼$�
+��èÖ6�éÚ��L‰T$@L‰L$(H‰t$hH‹„$°���L‹p(M…ö„;��H‹P0H‹D$0·¨��é*��H¼$Ð���H´$H ��H”$�
+��èk©��HÇ„$�������H‹D$pH‰„$�
+��L‰´$
+��H‰œ$
+��H‰œ$
+��H‰„$
+��L‰¼$(
+��L‰¤$0
+��L‰¬$8
+��L‰¼$@
+��H‰„$H
+��Ƅ$P
+���H¼$€��H´$Ð���H”$�
+��èõÖ��€¼$0��H‹œ$ˆ���u‹„$€��ƒø…Ïüÿÿé’��¶K1ÀˆL$8€ùH‹Œ$��HDÈH‰L$`‹CXH‰„$À���ÿÈH‰D$HH‹CH‰D$@H‹CH‰D$hHƒ0��H‰„$¸���L‹5 _�f D��„$€��Œ$��”$ ��)”$`��)Œ$P��)„$@��ºˆ���H¼$H ��H´$°��AÿÖ€|$8„m��ƒ¼$À����„_��H‹œ$@��H‹Œ$H��H‰ÊHÁê H‹D$H!ÂHƒÊ‰ÆH‰È „�����#D$HH<Å����L‹D$@I)ø‚��Iƒø‚ ��L‹D$hI‹<8H9Ït ƒîA’ÀH…ÿ„î��HÐE„Àt¶éá��H‹L$`H‹I HÁàH)Á‚Ë��Hƒù‚Á��H‹L$`H‹I‹…À„��ÿÈH‹L$`;ALƒ��H‹t$`H‹N0‰Â‹~HH¯×HÁâH)Ñ‚~��H‹D$`H‹p@H)Ö‚l��ƒÿ ƒp!��H…ÿ„€��L‹L$`I‹A(LÏLIÿÀIQ8E1ÉE1ö1í1ÀE1íÇD$����ÇD$P����ÇD$0����ÇD$x����ÇD$X����Ç„$€�������Ç„$°�������Ç„$˜�������Ç„$�������Ç„$¨�������Ç„$ �������Ç„$È�������Hƒù‚Ò���Hƒþ†È���L‹”$��G¶<
+Iƒÿ‡–��G‹TˆÿF‹ ŠL%&ÄýÿOc<¼MçAÿçE‰ÝD‰Ðë[D‰\$PD‰T$ëOD‰œ$˜���D‰”$°���ë=D‰œ$€���D‰T$Xë.D‰œ$È���D‰”$ ���ë D‰\$xD‰T$0ëD‰œ$¨���D‰”$���A‰ëE‰òL‹´$��O<IÿÇIÿÁHƒÁüHƒÆüE‰ÖD‰ÝI9ÿ…)ÿÿÿé‹���A‰ëE‰òé€���Ç„$È�������Ç„$ �������Ç„$¨�������Ç„$�������Ç„$˜�������Ç„$°�������Ç„$€�������ÇD$X����ÇD$x����ÇD$0����ÇD$P����ÇD$����E1í1ÀE1ÛE1ÒH‹L$`H‹±¸���D‰ÑH)΂B��D‰ÚH9Ö‚6��H‹t$`H‹¾È���‰ÀH)Ç‚ ��D‰îH9÷‚��H‹|$`L‹‡Ø���‹|$I)ø‚ú���D‹L$PM9È‚ì���L‹D$`M‹˜��D‹D$0M)ÂÒ���D‹T$xM9Ó‚Ä���L‹\$`M‹»��D‹\$XM)ß‚ª���D‹´$€���M9÷‚™���L‹|$`M‹§ø���D‹¼$°���M)ü‚|���D‹¬$˜���M9ìroL‹d$`I‹¬$(��D‹¤$���L‰d$L)årPD‹¤$¨���L‰d$PL9år>H‹l$`H‹8��D‹¤$ ���L‰d$0L)år D‹¤$È���L‰d$xL9åƒ ��f. „�����HÇ„$°�����H„$¸��WÀ�L‹´$P��M…öL‹l$(L¤$�
+��tvH‹œ$X��H…Ût'ˆ] ��¶ºk�¾���H‰ßèšþÿI‰ÇH…Àu é* ��A¿���L‰ÿL‰öH‰ÚÿÛY�L‰¼$@��H‰œ$H��H‰œ$P��H¼$°��H´$@��è&Ø��L‹´$`��M…öt9H‹œ$h��H…Ût<ˆÚ ��¶7k�¾���H‰ßè‚™þÿI‰ÇH…Àu é§ �� D��E1íH¬$Ø���éW��A¿���L‰ÿL‰öH‰ÚÿCY�L‰¼$���H‰œ$��H‰œ$��H¼$°��H´$���èŽ×��H‹œ$°��H‹”$À��H¼$À��H‰ÞèŽ4��Hƒ¼$À���„ ��L‹¤$È��L‹¼$Ð��H‹„$ˆ���H‹°@��H;°8��u H‹¼$¸���èØ��H‹”$ˆ���H‹²@��ëH‹”$ˆ���H‹Š0��H‰ðHÁàL‰$L‰|HÿÆH‰²@��„ç��H‹Œ$¸���H‹ H‹4H‹TL¤$�
+��L‰çè¦5��Hƒ¼$�
+���„w��H‹„$@
+��H‰„$È���H‹„$H
+��H‰„$€���¹���L‰çL‰îHüýÿè@Ø��H‰T$H‰ÁH…ÀH‹D$HDÁH‰D$HxõýÿHDÈH‰Œ$°���¹���H¼$�
+��H‹t$(HÔûýÿèö×��H‰T$PH‰ÁH…ÀH‹D$PHDÁH‰D$PH.õýÿHDÈH‰Œ$˜���¹���H¼$�
+��H‹t$(Hûýÿè¬×��H‰T$0H‰ÁH…ÀH‹D$0HDÁH‰D$0HäôýÿHDÈH‰Œ$���¹���H¼$�
+��H‹t$(Hûýÿèb×��H‰T$xH‰ÁH…ÀH‹D$xHDÁH‰D$xHšôýÿHDÈH‰Œ$¨���¹���H¼$�
+��H‹t$(HÊúýÿè×��H‰T$XI‰ÇH…ÀH‹D$XIDÇH‰D$XHPôýÿLDø¹���H¼$�
+��H‹t$(H—úýÿèÖÖ��I‰ÆH‰ÓH…ÀHDØHôýÿLDð¹���H¼$�
+��H‹t$(H¤úýÿè Ö��I‰ÄI‰ÕH…ÀLDèHäóýÿLDà¹���H¼$�
+��H‹t$(H|úýÿèjÖ��H‰”$ ���H‰Å¹���H¼$�
+��H‹t$(HÖµýÿèAÖ��H…íH‰éH5ŒóýÿHDÎH‹¼$ ���HDýH‰ýH…ÀHDÐHDÆH‹´$@��L‹N L‹V(H‹¾À���L‹†È���H‹¶à���H…öt
+ðHÿŽJ��L‹œ$¨���L‰œ$à���L‹\$xL‰œ$è���L‰Œ$ð���L‰”$ø���L
óýÿL‰Œ$���HÇ„$������L‰¼$��L‹T$XL‰”$��L‰´$ ��H‰œ$(��L‰Œ$0��HÇ„$8������L‰¤$@��L‰¬$H��H‰Œ$P��H‰¬$X��H‰„$`��H‰”$h��H‹„$°���H‰„$p��H‹D$H‰„$x��H‹„$˜���H‰„$€��H‹D$PH‰„$ˆ��H‰¼$��L‰„$˜��H‹„$���H‰„$ ��H‹D$0H‰„$¨��H‰´$°��HÇ„$¸������Æ„$À��HÇ„$Ð������HÇ„$Ø������¶f�¿ø���ÿ<T�H…ÀH¬$Ø���„Ê��I‰Åºø���H‰ÇH´$Ð���ÿ"T�Hƒ¼$€����L¤$�
+��tH‹¼$È���ÿÙS�Hƒ¼$¸���tH‹¼$°��ÿÀS�H‹œ$@��ðHÿ H‹œ$ˆ���tBëM „�����Hƒ¼$¸���H¬$Ø���t H‰ßÿ„S�H‹„$@��ðHÿA½����H‹œ$ˆ���u
H¼$@��èëÐ��„$H ��Œ$X ��”$h ��)”$`��)Œ$P��)„$@��H‹„$X ��H‰„$ð��)„$à��L‹´$à��M¾���H„$è��H‰„$à ��L‰¬$è ��A¶†���<L…|���M…í„™���H‹œ$è��L‰¬$x��AE@„$°��HÇ„$À������H¼$Ð���H´$°��èeÖ��H‹„$Ð���E�)„$�
+��Hƒøuq(„$�
+��)„$Ð���éF��f D��M…í„m��ðIÿM�…^��H¼$è ��èÏÏ��éL��HÇ„$Ø�������Æ„$Ð���KA€?L„"��H¼$Ð���èï�é ��H‹M@H‰Œ$ð��EM U0)”$à��)Œ$Ð��)„$À��ƒøuHÇ„$Ø�������Æ„$Ð���Kéœ���(„$�
+��H”$H��H‹Œ$ð��H‰J@(„$À��(Œ$Ð��(”$à��R0J BIuH‰„$@��H¼$Ð���H”$@��èà��L‹¤$Ð���E�)„$Ð ��Iƒü…¹��(„$Ð ��)„$Ð���L¤$�
+��fðIÿM�H‹œ$ˆ���u
H¼$x��è”Î��A€?L…Þþÿÿ(„$Ð���AA¶<Ku&I‹†��H…ÀtLH‹HƒÁHƒÀ²ëVff. „�����I‹Ž���A¶–��A‹† ��‰„$
+��A‹† ��‰„$�
+��¾���ëH‹„$à��H‹Œ$ð��H‹ HƒÁ1Ò1ö‹¼$�
+��D‹„$
+��D‰E ‰} H‰´$Ð���H‰Œ$Ø���ˆ”$à���H‰„$è���L‰çH´$X��H”$Ð���è–™��HÇ„$0
+������HŒ$x ��H‹APH‰„$��A@)„$€��IQ Y0)œ$p��)”$`��)Œ$P��)„$@��H¼$Ð���L‰æH”$@��è3Ç��º¸���H¼$€��H´$Ð���L‹5¿O�AÿÖ€¼$0��…–ðÿÿé ðÿÿ·E@f‰„$0��EM U0)”$ ��)Œ$��)„$���·¬$��º4��H¼$�
+��H´$ ��ÿVO�H‹„$X��H‰D$0H‹„$h��H‰D$PH‹„$p��(„$Ð ��)„$ð ��H‹‹€��H‰L$XH‹‹��H‰L$xf‰l$fƒýsH‹ƒ ��(„$ð ��H‰ÃHŒ$Ø���A·„$0��f‰AH(„$���(Œ$��(”$ ��Q8I(Aº4��H¼$$��H´$�
+��H‹-—N�ÿÕL‰¬$Ð���L‰¤$Ø���·D$f‰„$"��H‹D$XH‰„$X��H‹D$0H‰„$`��H‹D$xH‰„$h��H‹D$PH‰„$p��H‰œ$x��¶å_�¿°��ÿN�H…À„Å��H‰Ãº°��H‰ÇH´$Ð���ÿÕH‰œ$Ø���Æ„$Ð���KH‹œ$ˆ���H¬$Ø���L¤$�
+��A€?L„¸üÿÿé‘ûÿÿH‹l$`H°���H…À���H½Ð���L…���L��L½ð���L‹d$L¥ ��L‰d$L‹d$0L¥0��L‰d$0L‹¥à���L‰¤$°���L‹¥è���L‰¤$˜���L‹c L‰¤$¨���L‹c(L‰¤$ ���L‹£À���L‰¤$€���L‹£È���L‰d$XL‹¥@��L‰¤$���H‹H��L‹£à���M…ät ðIÿ$Ž¦��H‰Œ$à���H‰”$è���H‹Œ$¨���H‰Œ$ð���H‹Œ$ ���H‰Œ$ø���H‹Œ$���H‰Œ$���H‰¬$��H‰„$��H‰´$��H‰¼$ ��L‰Œ$(��H‰Œ$0��H‰¬$8��H‹„$°���H‰„$@��H‹„$˜���H‰„$H��L‰¼$P��L‰¬$X��H‹D$0H‰„$`��H‹D$xH‰„$h��L‰„$p��L‰”$x��L‰œ$€��L‰´$ˆ��H‹„$€���H‰„$��H‹D$XH‰„$˜��H‹D$H‰„$ ��H‹D$PH‰„$¨��L‰¤$°��HÇ„$¸������Æ„$À��HÇ„$Ð������HÇ„$Ø������¶b]�¿ø���ÿ—K�H…À„m��I‰Åºø���H‰ÇH´$Ð���ÿ…K�H¬$Ø���L¤$�
+��é÷ÿÿH‰D$H¸���H‰D$@L‹l$0L‹|$H‹\$8H‹l$pH‹|$xH‰îèH"�I‰Æé<��¶Œ$0��H‹”$(��€ù„%ÚÿÿéQÂÿÿf½�Hƒ¼$¸����tH‹¼$À���I‰×ÿÒJ�L‰ú¸���H‰D$HL‹l$L‹|$8H‹D$XH‰D$PfƒýH‹l$ptéÍ���„$�
+��Œ$
+��H‹„$���H�ILJ°�����1ÉH‹„$���Hƒ8�HD„$¨���º���HDÊH…Ét
€8K…��H‹@H…Àt H‹”$˜���H;PsH‹HRH‹ÑH‹LÑë1ÀHƒD$PøH‹T$H@ˆêH‰T$HH‹T$@DˆòH‰T$@M‹uM…ö„��I‹U L‹l$L‹|$8H‰D$8H‰L$H‹l$pL‰¤$Ð���H‰œ$Ø���L‰¼$à���L‰¬$è���H‰¬$ð���L‰´$ø���H‰”$���H´$Ð���H‹¼$¨��ègø�L¤$Ð���ëmM‹g L‹|$H‹t$8H‰D$8H‰L$H‹l$pH‰œ$Ð���L‰¬$Ø���H‰´$à���L‰¼$è���H‰¬$ð���L‰´$ø���L‰¤$���H‹¼$¨��L¤$Ð���L‰æèð÷�H‹T$hH‹t$(H‹|$@L‹D$HAHýƒù¸���BÁƒø„ô���ƒø…ó��D‰ÀH‰ÓHÁã H ÉøI‰õIÁå I ÅH‹D$PH;D$X„��L‹xøA‹G(A‹O,1ÒH‰T$HH‰D$h…À@•Å1ÀH‰D$@H‰L$(…ÉA•ÆIƒ?�„H��H‹„$€���ƒ8/„7��I‹GH‰„$˜���H‹D$0Hƒ¸°���… ��L‰çH‹´$€���èøú��L‰âL‹d$0H¼$�
+��L‰æH‹Œ$ ���èÿ��Iƒ¼$°���„6��H¼$�
+��è| �éO�� €����‰øH‰óHÁã H ø���H‰D$HƒùH‰T$hH‰t$(¸���‚£���H‰D$@Hƒ¼$¸����„”���H‹¼$À���ÿ G�é���H‰|$@H‰t$(H‰T$hH‹„$°���L‹p(M…ö„���L‹`0H‹D$0·¨��Hƒ¼$¸����tH‹¼$À���ÿNG�¸���H‰D$HL‹|$H‹t$8H‹D$XH‰D$PfƒýH‹l$p…ÁýÿÿëH‰D$@L‹|$0H‹t$L‹l$8H‹l$pH‹|$xI‰öH‰îè& �L‰öI‰ÆI‰Ôéˆýÿÿf½�Hƒ¼$¸����…yÿÿÿë…„$�
+��Œ$
+��H‹„$���H�IÇ„$°�����H‹„$���Hƒ8�HD„$¨���¹����º���HDÊH…Ét €8KH‹”$˜���…4��H‹@H…Àuë4H‹”$˜���H…Àt'H;Ps!H‹HRH‹ÑH‹LÑëffffff. „�����1ÀHƒD$PøH‹T$H@ˆêH‰T$HH‹T$@DˆòH‰T$@M‹wM…ö…„üÿÿL‹|$H‹t$8H‰D$8H‰L$éÝþÿÿ³ƒùrHƒ¼$¸����tH‹¼$À���ÿÈE�„ÛH‹œ$ˆ���uVHÃ��H‰ßH‹t$pèØ �H…Àt=Ç„$Ð������H‰„$Ø���H‰”$à���H‹D$pH‰„$è���H´$Ð���H‹¼$¨��èFô�HÄH ��[A\A]A^A_]ÃL‹l$L‹|$8H‰D$8H‰L$éúÿÿ³éSÿÿÿ1ÛéLÿÿÿL‰éHƒáüHQHƒÁH9ʇ ËÿÿH9Á‡ËÿÿH¼$Ð���H‹t$HH‹T$@èµ7��L‹¤$Ð���M…ät%L‹´$à���M…öt*A€<$/”Àë"HB�èe‘þÿ H‹¼$Ø���趋ÿÿé§Êÿÿ1ÀH‹Œ$Ø���H‰L$hL‰¤$Ð���L‰´$Ø���Æ„$à���ˆ„$
+��fÇ„$���H¼$H ��H´$Ð���èt8��¶„$H ��<
+u1íHƒ|$h�t L‰çÿED�H…í„2ÊÿÿH‰¬$à��L‰´$è��H‰œ$ð��H¼$Ð���HŒ$à��H‹t$HH‹T$@H‹œ$À��è]+��H‹¬$ ��¶„$Ð���ˆ„$0��<…Û¿ÿÿéÏÉÿÿú<‡wÿÿÿ¶ÀHÿÈHƒø‡gÿÿÿH¼$Ð���èÒ®ÿÿH‰T$(L‰|$8H‰D$H…À„BÿÿÿH‹D$(J (HƒÃtBˆu��¶VU�¾���H‰ß衃þÿH‰ÅH…Àu%¿���H‰Þè<ˆþÿé†��HØ6�èëþÿ ½���H‰¬$@��H‰œ$H��HÇ„$P������H;\$(s&H¼$@��1öH‹T$(èM²ÿÿH‹¬$@��H‹œ$P��ë1ÛH<+H‹t$L‹|$(L‰úÿ
+C�LûH‰œ$P��t
+€|+ÿ/•Àë1ÀM…ítH‹L$8€9/u1Ûë>H‹Œ$H��„ÀtBH9Ùu%H¼$@��º���H‰ÞèбÿÿH‹¬$@��H‹œ$P��ÆD �/HÿÃH‰œ$P��H‹Œ$H��H)ÙL9ésH¼$@��H‰ÞL‰êè±ÿÿH‹œ$P��H‹„$@��H‰ÅH<H‹t$8L‰êÿPB�LëH‰œ$P��t €}�/”Àë1ÀH‰¬$H ��H‰œ$P ��Æ„$X ��ˆ„$‚ ��fÇ„$€ ���M…öt
+A€<$/”Àë1ÀL‰¤$Ð���L‰´$Ø���Æ„$à���ˆ„$
+��fÇ„$���H¼$H ��H´$Ð���èø8��„ÀuEH¼$Ð���H‰îH‰Úè±;��Hƒ¼$Ð����tH‹¼$Ø���èiˆÿÿë·„$à���%�ð��=�€��„j��HÇ„$P������H‹D$(H9„$H��s&H¼$@��1öH‹T$(è`°ÿÿH‹¬$@��H‹œ$P��ë1ÛH<+H‹t$L‹t$(L‰òÿ A�IÞL‰´$P��tJA€|.ÿ/tEL9´$H��u%H¼$@��º���L‰öè°ÿÿH‹¬$@��L‹´$P��BÆD5�/IÿÆL‰´$P��ëE1öH‹„$H��L)ðHƒøw%H¼$@��º���L‰ö赯ÿÿH‹¬$@��L‹´$P��fBÇD5ugBÇD5�.debL‰óHƒÃH‰œ$P��tH‹„$@��A€|/•Àë1ÀM…ítH‹L$8€9/u1Ûë=H‹Œ$H��„ÀtAH9Ùu H¼$@��º���H‰Þè5¯ÿÿH‹œ$P��H‹„$@��Æ/HÿÃH‰œ$P��H‹Œ$H��H)ÙL9ésH¼$@��H‰ÞL‰êèó®ÿÿH‹œ$P��L‹´$@��I< H‹t$8L‰êÿ¹?�LëH¼$Ð���L‰õL‰öH‰Úè¨9��Hƒ¼$Ð����tH‹¼$Ø���è`†ÿÿë·„$à���%�ð��=�€��„a��èQ;��„À„m��HÇ„$P������Hƒ¼$H��
w&H¼$@��º���1öèN®ÿÿH‹¬$@��L‹¼$P��ëE1ÿH¸ib/debugJ‰D=H¸/usr/libJ‰D=�MwL‰´$P��H§åýÿ¹���H‹|$H‹t$(èä¢ÿÿH‰D$(Hƒ|$(�„«��H‰ÓM…öt A€|/
/•Àë1ÀH…ÛtH‹L$(€9/uE1öë?H‹Œ$H��„ÀtCL9ñu%H¼$@��º���L‰öè”ÿÿH‹¬$@��L‹´$P��BÆD5�/IÿÆL‰´$P��H‹Œ$H��L)ñH9ÙsH¼$@��L‰öH‰ÚèPÿÿL‹´$P��H‹„$@��H‰ÅJ<0H‹t$(H‰Úÿ>�LóH‰œ$P��t
+€|+ÿ/•Áë1ÉM…ítH‹D$8€8/u1Ûë>H‹„$H��„ÉtBH9Øu%H¼$@��º���H‰ÞèÙ¬ÿÿH‹¬$@��H‹œ$P��ÆD �/HÿÃH‰œ$P��H‹„$H��H)ØL9ès#H¼$@��H‰ÞL‰êè–¬ÿÿH‹¬$@��H‹œ$P��I‰îH<+H‹t$8L‰êÿY=�LëH‰œ$P��H¼$Ð���H‰îH‰ÚèC7��Hƒ¼$Ð����tH‹¼$Ø���èûƒÿÿë-·„$à���%�ð��=�€��uL‹´$H��Hƒ|$h�…ƒøÿÿé‡øÿÿHƒ¼$H���t H‰ïÿ¸<�Hƒ|$h�„¢ÂÿÿL‰çÿ£<�é”Âÿÿ¿���H‰Þèqþÿé»���è'þÿé±���Hë/�è&’þÿ ¿���¾ ��èEþÿ H=ÚýÿHu9�¾+���蛕þÿëx¿���¾ø���èþÿëg ¿���¾°��èþÿëRH.�¾���è‘þÿë?è«€þÿë8¿���¾ø���èÚ€þÿë'H=…ÜýÿH
º,�Lc9�H”$Ð���¾+���è£þÿ I‰ÆH¼$Ð���èß¹��é$��èŨþÿ ëë�I‰ÆHƒ¼$H���tH‹¼$@��ÿ“;�ëI‰ÆHƒ|$h�„Z��L‰çÿy;�éL��I‰ÆéÖ��I‰Æé)��I‰ÆH‹„$Ð���ðHÿu
H¼$Ð���èÖ¸��H‹„$0��ðHÿu
H‹¼$0��è»ë��ƒ¼$8��/„®��Hƒ¼$���u&Hƒ¼$¨���u4Hƒ¼$À���uBHƒ¼$Ø���uTé}��H‹¼$ˆ��ÿÞ:�Hƒ¼$¨���tÌH‹¼$ ��ÿÅ:�Hƒ¼$À���t¾H‹¼$¸��ÿ¬:�Hƒ¼$Ø���„.��H‹¼$Ð��ÿ:�é��ë H‹„$0��ðHÿuH‹¼$0��èýê��ë�ƒ¼$8��/t:Hƒ¼$���u6Hƒ¼$¨���uDHƒ¼$À���uRHƒ¼$Ø���tH‹¼$Ð��ÿ':�è2§þÿ H‹¼$ˆ��ÿ:�Hƒ¼$¨���t¼H‹¼$ ��ÿù9�Hƒ¼$À���t®H‹¼$¸��ÿà9�Hƒ¼$Ø���u ë¬I‰ÆH¼$€��èã��é��èɦþÿ I‰ÆH¼$
+��èÇ��éú��è¦þÿ I‰ÆðIÿM�… ��H¼$x��è·��é ��膦þÿ I‰ÆL‰çè‰��é¼��èo¦þÿ é ��I‰ÆL‰çL‰þÿQ9�é•���I‰ÆH¼$Ð���èT·��ëeè=¦þÿ I‰ÆHƒ¼$ ���tH‹¼$� ��ÿ9�ë H‰œ$À��I‰ÆH¼$@��èe}��H‹¼$ ��H‹´$À��ÿç8�é2��I‰Æé—���ë I‰ÆHƒ¼$€����tH‹¼$È���ÿ´8�ëI‰ÆHƒ¼$¸���tH‹¼$°��ÿ–8�H‹„$@��ðHÿuH¼$@��è ¶��ë
+è„¥þÿ I‰Æ€¼$0��…¹���H¼$€��èôê��é§���I‰ÆH‹D$HƒÀýƒø‚“���Hƒ¼$¸����„„���H‹¼$À���ÿ 8�ëtI‰Æf „�����IÿÍtI¬$H��L‰çè��I‰ìëæHƒ=–J��t L‰ÿÿã7�H‹„$
+��H‰lJ�(„$�
+��MJ�H‰ ^J�HÇ[J����HÇXJ�����L‰÷è°� 詤þÿ ÌÌÌÌÌÌÌUAWAVAUATSHì¸��L‹M…ÿtOA€?�tIH‰ýI‰ÕL‰ÿÿ)8�I‰ÄH…À„ü���ˆq��¶ I�A¾���¾���L‰çèewþÿH…À…Ø���éP��¸���H‰„$À���Hƒz�t
+E1ä1Ûé��H‰”$���H‰¼$ˆ���L‹?HÇ„$È������WÀ„$Ð���Ç„$è�������fÇ„$ì���¶Ç„$î�������fÇ„$ò�����Æ„$î���H¸elf/mapsH‰„$7��H¸/proc/seH‰„$0��Æ„$?���H|$H´$0��º���躗þÿHƒ|$�t3H= .�ëQ¸���H‰„$À���H‰ÇL‰þL‰âÿe6�L‰ãL‰êH‰ïé8��H‹t$H|$PH”$è���è˜Ä�ƒ|$P�„¡��H‹|$XA¿���èý|ÿÿHƒ¼$Ð����t L‰ÿÿé5�(ò•ýÿ)„$0��HÇD$����H¼$0��HL$¾���1ÒE1ÀE1Éÿ‘6�ƒøÿtsL‹d$M…ätiˆ¾��¶mG�A¾���¾���L‰çè²uþÿH…À„¢��I‰ÇH¼$0��HL$¾���H‰ÂE1ÀE1Éÿ56�ƒøÿt"H‹\$H…ÛtHÿËL‰¼$À���ë2ÿ»4�D‹0ëÿ°4�D‹0L‰ÿÿ 5�IÁæ IƒÎL‰÷è |ÿÿE1ä1ÛH‹”$���H‹¼$ˆ���D·oM…ítHH‰”$���H‰¼$ˆ���H‹oM‰ïIÁ綣F�A¾���¾���L‰ÿèètþÿH…À„Û��Aƒýu 1ÉëT¸���ë~D‰êƒâþHpH}`1Éfffff. „�����L‹G°L‹OÈL‰FèL‰NðL‹GèL‹L‰FøL‰HƒÁHƒÆ HƒÇpH9ÊuÑAöÅtHkÑ8H‹tH‹T(HÁáH‰4H‰TH‹”$���H‹¼$ˆ���H‹H‹´$À���H‰´$0��L‰¤$8��H‰œ$@��H‰„$H��L‰¬$P��L‰¬$X��H‰Œ$`��H‹rH;ruH‰×H‰ÓèøÄ�H‹sH‰ÚH‹HkÎ8H‹¼$`��H‰|0„$0��Œ$@��”$P��T LHÿÆH‰r1ÀHĸ��[A\A]A^A_]Ë\$THÇ„$˜������WÀ„$ ���)„$��)„$€��)„$p��)„$`��)„$P��)„$@��)„$0��HÇ„$ ������H´$0��‰ßÿå3�ƒøÿ‰\$ L‰¼$���tcL‹´$x��‰ß1öº���ÿÅ3�HƒøÿtF1í»����I)ÆLBõv"H¼$˜���1öL‰òèí¡ÿÿH‹¬$ ���H‹œ$¨���IÆ���ƒÌ��°‰$ë ÿ 2�‹8HÁç HƒÏètyÿÿ°‰$1í1ÛE1íH1(�H‰D$@H‰l$HH‰\$hL‰l$pffff. „�����H9ëu%º ���H¼$˜���H‰îèf¡ÿÿH‹¬$ ���H‹œ$¨���L‹¤$˜���H‰èH)ØL9ðM‰õLBèI4 €<$�LEèHºÿÿÿÿÿÿÿI9ÕIBÕ‹|$ ÿÏ2�Hƒøÿu)ÿS1�‹�I‰ÇIÁç IƒÏƒø….��L‰ÿèxÿÿéhÿÿÿL‹|$pI9ÇLFøH…À„A ��M9ï‡Ô ��I)ÇHÃH‰œ$¨���H;l$HM‰ý… ÿÿÿH9ë…ÿÿÿWÀ)„$@��)„$0��º ���‹|$ H´$0��ÿ32�I‰ÇHƒøÿH‹\$HuDÿ¯0�‹�I‰ÇIÁç IƒÏƒø…Š���L‰ÿè xÿÿº ���‹|$ H´$0��ÿê1�Hƒøÿt¿I‰ÇM…ÿ„Ž
+��Iƒÿ ‡. ��H¼$˜���H‰ÞL‰úè ÿÿH‹¬$ ���H‹œ$¨���H‹¼$˜���HßH´$0��L‰úÿ¿0�LûH‰œ$¨���é5þÿÿA¾���I‰ÝH‰ÚH‹|$hH)ú‚¦
+��LçH‰þHœ$0��H‰ßè·’þÿHƒ¼$0���tM…öHÂ$�LDøëL‰¬$¨���M…ö„Œ���L‰ÿè#wÿÿE1íH…ítH‹¼$˜���ÿ
0�‹|$ ÿ1�L‹¼$È���M…í„õùÿÿI_L‹5ç/�ë D��HƒÃXIÿÍ„ÖùÿÿHƒ;�tíH‹{øAÿÖëäL‰ðH%ÿ ��„W ��¹� ��H)ÁIÎ’À‰$é4ýÿÿH‰œ$à���HÇ„$0������L‰¬$8��H´$@��L‰¤$@��L‰¬$H��HÇ„$P������L‰¬$X��HÇ„$`�����H¸
+���
+���H‰„$h��fÇ„$p����¹���E1íH|$H‰Œ$��H‹¬$@��èÿþÿHƒ|$�t H‹t$ H‹„$0��HÅH‰´$0��H)ÆëD€¼$q���…€��Æ„$q��€¼$p���H‹¬$0��H‹´$8��u H9î„U��H)îH¬$@��H‰ðHƒès1öë €|�
+uH…Àtð€|5þ
HNþHDÁH‰ÆH‰ïH‰t$hèžÀ�I‰ÇI‰ÖH‰D$H‰T$HÇD$ ����H‰T$(HÇD$0���H¸ ��� ���H‰D$8H|$PHt$èÉþþÿHƒ|$P�tFHÒËýÿH‰„$€���¸����H‰$M…ÿt>H‹D$XH‰D$hH‹D$`I)ÆL‰ùHÁH‰Œ$€���L‰ýL‰4$ëHŒËýÿH‰„$€���1ÀH‰$Hƒ|$h�„À��H‹¼$€���H‹4$èÙ¿�I‰ÇI‰ÖH‰D$H‰T$HÇD$ ����H‰T$(HÇD$0���H¸ ��� ���H‰D$8H|$PHt$èþþÿHƒ|$P�tFH
ËýÿH‰D$x¸����H‰D$pM…ÿt>H‹D$XH‰$H‹D$`I)ÆL‰ùHÁH‰L$xL‰¼$€���L‰t$pëHÇÊýÿH‰D$x1ÀH‰D$pHƒ<$�„þ��H‹|$xH‹t$pè¿�I‰ÇI‰ÖH‰D$H‰T$HÇD$ ����H‰T$(HÇD$0���H¸ ��� ���H‰D$8H|$PHt$èDýþÿHƒ|$P�tJHMÊýÿH‰„$¸���¸����H‰D$HM…ÿtBH‹D$XH‰D$pH‹D$`I)ÆL‰ùHÁH‰Œ$¸���L‰|$xL‰t$HëHÊýÿH‰„$¸���1ÀH‰D$HHƒ|$p�„6��H‹¼$¸���H‹t$HèN¾�I‰ÇI‰ÖH‰D$H‰T$HÇD$ ����H‰T$(HÇD$0���H¸ ��� ���H‰D$8H|$PHt$èyüþÿHƒ|$P�tMH‚ÉýÿH‰„$°���¸����H‰D$@M…ÿtEH‹D$XH‰D$HH‹D$`I)ÆL‰ùHÁH‰Œ$°���L‰¼$¸���L‰t$@ëH5ÉýÿH‰„$°���1ÀH‰D$@Hƒ|$H�„h��H‹¼$°���H‹t$@耽�I‰ÇI‰ÖH‰D$H‰T$HÇD$ ����H‰T$(HÇD$0���H¸ ��� ���H‰D$8H|$PHt$è«ûþÿHƒ|$P�t6H=´Èýÿ¾����M…ÿt.H‹D$XH‰D$@H‹D$`I)ÆL‰ÿHÇL‰¼$°���L‰öë H=~Èýÿ1öHƒ|$@�„¾��èã¼�H‰„$(��H‰”$ ��H‰l$H‹D$hH‰D$HÇD$ ����H‰D$(HÇD$0���H¸-���-���H‰D$8H|$PHt$èÿúþÿHƒ|$P�„Y��H‹T$XH‹\$`H|$H‰î¹���èw°þÿ€|$�…2��H‹T$hH)ÚHÝH‹D$H‰D$hH|$H‰î¹���èE°þÿ€|$�…���H‹l$H‹„$€���H‹ $HÁH‰D$PH‰L$XLt$L‰÷L|$PL‰þèw½�Hƒ|$�…Á��‹D$‰$L‰÷L‰þèY½�Hƒ|$�…£��‹D$‰„$€���L‰÷L‰þè7½�Hƒ|$�…��‹D$H‰„$��L‰÷L‰þè½�Hƒ|$�…^��‹\$L‰ÿ蜽�…À…J��H‰¬$��L‰÷H‹t$xH‹T$p¹���èe¯þÿ€|$�… ��H‹D$H‰D$pH|$H‹´$¸���H‹T$HèÙ½�H‹t$H…ö„ñ��H‹T$L‹t$ L‹|$(H|$P¹���è
¯þÿ€|$P�…È��H‹l$XH|$PL‰öL‰ú¹���èè®þÿ€|$P�…£��L‹t$XH|$H‹´$°���H‹T$@¹���è¼®þÿ€|$�…w��L‹|$H¼$è���H‹´$(��H‹”$ ��追�H‹„$è���H‰D$@H‹„$ð���H‰D$HH‹„$ø���H‰D$xL;¬$Ð���u"H¼$È���L‰îèþ·�H‹Œ$È���L‹¬$Ø���ëH‹Œ$��HÁã Hœ$��IkÅX‹$‰‹”$€���‰TH‰\H‹T$@H‰TH‹T$HH‰TH‹T$xH‰T H‹T$hH‰T(H‹”$��H‰T0H‹T$pH‰T8H‰l@L‰tHL‰|PIÿÅL‰¬$Ø���€¼$q���H´$@��H|$„8øÿÿH‹¬$È���H‹œ$Ð���Hƒ¼$ ����t L‰çÿ6'�‹|$ ÿ,(�H…í„:ñÿÿH‰¬$0��H‰œ$8��L‰¬$@��M…í„ý���IkÍX1Àë#H‹¬$ ���H…í…Îöÿÿé×öÿÿHƒÀXH9Á„���H‹”$���H9T(wäH‹”$���H9T0vÕL‹d M…ätˈ��L‹t¶u8�¾���L‰çèÀfþÿH‰„$À���H…À„ö���H‹¼$À���L‰öL‰âÿ“&�LuL‹=`&�ë%Ç$����éçóÿÿI‰ßL+|$hE1öéÁõÿÿIƒÆXIÿÍtEIƒ>�tñI‹~øAÿ×ëèLuL‹= &�ë IƒÆXIÿÍtIƒ>�tñI‹~øAÿ×ëèH…Û„ðÿÿH‰ïéðÿÿH…Ût H‰ïÿæ%�L‰ãé×ðÿÿèyjþÿë[M‰çL‰÷L‰þè©jþÿëKH`�L‰îèØqþÿë:Hg�H‰D$@ëA½ ���L‰ÿL‰îH‹T$@èB{þÿëè+jþÿë
¿���L‰æè\jþÿ ë|Hƒ|$H�tAH‹|$@ÿe%�ë4ë2M…öt-L‰ÿèTlÿÿë#è]’þÿ ëëëë7H¼$0��è6·�èÑþÿ Hƒ¼$ ����tH‹¼$˜���ÿ%�‹|$ ÿ &�H„$È���H‰„$à���H‹¼$à���诵�èŠþÿ èƒþÿ ÌAVSPH‰ûHÇP��è•�Hƒ»Ð���t
H‹»È��ÿ¶$�H‹»���H‹³��ÿª$�HÃ��H‰ßHƒÄ[A^éüh��I‰ÆHƒ»Ð���t
H‹»È��ÿr$�H‹»���H‹³��ÿf$�HÃ��H‰ßè¿h��L‰÷èWñ� ÌÌÌÌÌUAWAVSHìÈ��I‰ÖH‰ûÇD$ ����fÇD$¶ÇD$����fÇD$��ÆD$Hú��‡€���L|$@L‰ÿL‰òÿ$�BÆD4@�IÿÆH|$(L‰þL‰òè#…þÿHƒ|$(�t Ht�H‰D$ ÇD$���ƒ|$�u ëJH‹t$0H|$HT$ è²�ƒ|$�t/H‹|$ è‰jÿÿHÇ����éÍ���H|$HL$ L‰òèK±�ƒ|$�uÑ‹l$ WÀ)„$ ���)„$���)„$€���)D$p)D$`)D$P)D$@HÇ„$°�������Ht$@‰ïÿ�$�ƒøÿt?L‹´$ˆ���E1ÿ1ÿL‰öº���¹���A‰èE1Éÿ"�HƒøÿtH‰CL‰sA¿���L‰;ë ÿV"�‹8HÁç HƒÏè¿iÿÿHÇ����‰ïÿ°#�HÄÈ��[A^A_]ÃH‰Ã‰ïÿ—#�H‰ßèŸï� ÌÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHƒìxH‰û1ÉHƒú@HCÎsHÇ����HƒÄx[A\A]A^A_]Ã9ELFuâ€yuܶAþÈ<wÒ€y¸���HDÁuÀxt½I‰ÖI‰÷H‹H(LÇ¿ýÿH…É„Õ���D·H<·P:M…É„‡���fƒú@u‹L‰òH)ÊL‰ÎHÁæI9Î@’ÇLùH9ò@’ÆE1Ò@þLDÑ…]ÿÿÿ·@>=ÿÿ��u
Hƒú?†Hÿÿÿ‹A(…À„=ÿÿÿ‰ÀI9Á†2ÿÿÿHÁàE1ÛAƒ|t[LÐL‹XL‹` M‰ýMÜ‚ ÿÿÿëHfƒú@…�ÿÿÿL‰òH)Ê‚ôþÿÿHƒú@‚êþÿÿM‹L M…ÉtL‰ÎHÁî:…ÓþÿÿéIÿÿÿE1ÉE1ÛE1äE1íIJÀL‰ÈHÁàHÇÆÿÿÿÿ �H…À„ÿ���HÿÆHy@HƒÀÀƒyDH‰ùuãL‹GL‰ðL)À‚€þÿÿH‹O H9È‚sþÿÿMøHº«ªªªªªªªH‰ÈH÷âHÁêHÕ����H@H-/ÅýÿH9ÈIFè¸"���HF‡3þÿÿ‹O(I9Ɇ'þÿÿHÁáAƒ|
+…þÿÿLÑH‹QH‹y H‰ÑH‰T$H×H‰|$‚öýÿÿL‰ÉHÁá1Òë HƒÂ@H9Ñt,Aƒ|uïA‹|(H9þuåL‰÷I+|‚ÂýÿÿI;| sÐé¶ýÿÿL‰ùL‰|$H…À…õ���IJÀL‰ÈHÁàHÇÆÿÿÿÿH-§½ýÿH…À„¼���HÿÆHy@HƒÀÀƒyD H‰ùuãL‹GL‰ðL)À‚_ýÿÿH‹O H9È‚RýÿÿMøHº«ªªªªªªªH‰ÈH÷âHÁêHÕ����H@H-ÄýÿH9ÈIFè¸"���HF‡ýÿÿ‹O(I9ɆýÿÿHÁáAƒ|
+…öüÿÿLÑH‹QH‹y H‰ÑH‰T$H×H‰|$‚ÕüÿÿL‰ÉHÁá1Òé7��1ÀH‰D$1ÀH‰D$1ÀH‰D$1ÀL‰l$PHÁàH@L,(L‰L$pL‰T$hL‰\$`L‰d$XH…À„ ��H‰éHƒÅ¶Q€â€ÂýHƒÀè€úþrÝfƒy�tÖEð)D$@D‹e趈0�¿`���ÿ½ �H…À„‰��(D$@�D‰`H‰D$ HÇD$(���HÇD$0���A¼���H|$ L9í„«���H‰éHƒÅ¶Q€â€Âý€úþráfƒy�tÚEð)D$@‹Mè‰L$<L;d$(uL‰æè ”�H‹D$ H|$ K d(D$@È‹T$<‰TÈIÿÄL‰d$0ë’HƒÂ@H9Ñ„Ó���Aƒ|uëA‹|(H9þuáL‰÷I+|‚pûÿÿI;| sÌédûÿÿ½���E1íE1äë
+H‹l$ L‹l$(M…ät
+I½ÄHƒð?ë¸@���¹@���)ÁH‰ïL‰æ1ÒèH”�L‰;L‰sH‹D$hH‰CH‹D$pH‰CH‹D$PH‰C L‰s(H‹D$`H‰C0H‹D$XH‰C8H‰k@L‰kHL‰cPH‹D$H‰CXL‰s`H‹D$H‰ChH‹D$H‰CpéÄúÿÿL‰ùL‰|$é�þÿÿ¿���¾`���èäaþÿ H‰ÃHƒ|$(�tH‹l$ ëH‰ÃM…ít H‰ïÿß �H‰ßèçé� ÌÌÌÌÌH‹OH…É„Y��UAWAVAUATSH‹wHÁáHñH‹H‰D$øH‹ë
HƒÆ@H9΄ ��ƒ~uíH‹^L‹f H‰øH)Ø’ÂH\$øL9à’Àи����HEØuÄH‹F0A»���Hƒør A»���Hƒøu¨M…ät£Ms M‰ßI÷ßIÿËë @�M9Ív‹Iƒü r…M‰åH‰ØD‹IT$ôL9‚nÿÿÿK,L!ýM‰éI)é‚[ÿÿÿ‹PI9Ñ‚OÿÿÿM +IÑM!ùJ M‰êM)ÊA¼����MCâL‚¹ýÿIBÚf D��M‰ÂIƒèr‡B€| �tïIƒú…uÿÿÿD·@ AðGN��D¶PAƒòUfE Â…Vÿÿÿƒx…LÿÿÿHèë1À[A\A]A^A_]Ã1ÀÃÌÌÌÌÌÌÌUAWAVAUATSHƒì(Hƒús HÇ����éW��I‰ÖI‰÷H‰|$ è@��„ÀtJO$6IƒÄ tQˆB��¶í,�¾���L‰çè8[þÿH…À„,��H‰D$L‰d$HÇD$����Iƒüv&1öëBH‹D$ HÇ�����éè��HÇD$���WÀD$H|$º���1öèï‰ÿÿH‹t$H‹D$L‹d$ÍýÿD0 ïÌýÿ0HƒÆH‰t$E¶/D‰èÀèH0WA€ý ¶É¶ØBÙL9æuH|$L‰æè’�H‹t$H‹D$ˆ 0HÿÆH‰t$A€åAE0AMWA€ý
+¶À¶éBèH;t$uH|$èS�H‹t$H‹D$@ˆ,0HÿÆH‰t$H;t$uH|$è,�H‹t$H‹D$Æ0/HÿÆH‰t$A½���Ld$ë!f „�����H‹D$ˆ 0HÿÆH‰t$IÿÅM9îtpC¶,/‰èÀèH0W@€ý ¶É¶ØBÙH;t$u
L‰ç轌�H‹t$H‹D$ˆ 0HÿÆH‰t$@€åE0MW@€ý
+¶À¶ÙBØH;t$uŠL‰çè‚Œ�H‹t$éxÿÿÿH‹D$H)ðHƒøwH|$º���è[ˆÿÿH‹t$H‹D$fÇD0ugÇ0.debHƒÆH‰t$H‹D$ H‰pD$�HƒÄ([A\A]A^A_]Ãèu]þÿ ¿���L‰æè¦]þÿ ë�H‰ÃHƒ|$�t H‹|$ÿ¬�H‰ßè´å� ÌÌUAWAVAUATSHìè��I‰ÏI‰ÔI‰õH‰ýL‹1H‹YH¼$è��L‰öH‰Úè)ôÿÿHƒ¼$è���„Þ��L‰¬$���L‰¤$��L‹¬$ð��L‹¤$ø��HÇ„$�����fïÀó„$˜��HÇ„$¨�����ó„$°��H|$XL‰îL‰âè|õÿÿH‹D$XH‰„$���H…À„?��H‰¬$ø��L‰l$HL‰d$PL‰|$0L‰t$(L‹|$`H‹D$hH‰„$ø���H‹L$pL‹l$xH‹„$€���H‰„$��H‹¬$ˆ���H‹„$���H‰„$��H‹„$˜���H‰„$à���H‹„$ ���H‰„$è���„$¨���)„$��óo„$¸���f„$ ��H‹„$È���H‰„$0��E1äH‰Œ$ð���H…É„Á��M…털��L‰|$@L‹´$ð���IÁæE1äL‹¼$ø���ëf „�����IƒÇ@IƒÆÀt`A‹HêrîL‰ïH‹´$��H‹Œ$��èVäþÿH…ÀtÑHƒúuËóo�ftßvýÿ¶@fnÈft
výÿfÛÈf×Á=ÿÿ��u Aƒu.E1äL‹|$@é ��ÆE�Iƒ�…î��HÄè��[A\A]A^A_]ÃI‹wI‹W L‹|$@L‰øH)ð’ÁH´$���H9Ð’À1ÿÈA¼����HE÷H‰t$…¿��H‰T$ H…Ò„®��E1ä1ÉH‹D$€<�tHÿÁH9L$ uëé’��HAH)D$ H‹t$HHÿÀH‰„$Ø���H‰L$H…Ét/€>/u*H|$XH‹T$èæ��Hƒ|$X�„U��H‹|$`è \ÿÿéþ��H|$XH‹t$(H‰ÚèI��H‹D$XH‰D$H…ÀtH‹D$hH…Àt H‹T$€:/”ÁëH‹|$`èY\ÿÿéò��1ÉH‹T$H‹t$`H‰t$8H‰T$XH‰D$`ÆD$hˆŒ$’���fÇ„$����H¼$��Ht$Xè! ��¶„$��<
+u(HÇ„$À������Hƒ|$8�„j��H‹|$ÿâ�éZ��ú<wÒ¶ÀHÿÈHƒøwÆH|$XèáÿÿH‰ÃH…Àt´I‰ÔH…Ò„¶���ˆ]��¶x&�¾���L‰çèÃTþÿH…À„G��I‰ÆH‰ÇH‰ÞL‰âÿ �L‰´$��L‰¤$ ��L‰¤$(��C€|4ÿ/•Àë·D$h%�ð��=�€��…£��H‹\$H…ÛˆÒ��¶&�¾���H‰ßèNTþÿH…À„¼��I‰ÄH‰ÇH‹t$H‰Úÿ)�H‰\$éš��HÇ„$�����fïÀó„$ ��A¾���1ÀHƒ|$�tH‹L$€9/u1Ûë9„Àt?H¼$��º���L‰æèç‚ÿÿL‹´$��L‹¤$ ��H‹œ$(��AÆ /HÿÃH‰œ$(��ëL‰ãI)ÜL;d$s%H¼$��H‰ÞH‹T$蛂ÿÿL‹´$��H‹œ$(��I< H‹t$L‹d$L‰âÿ\�LãH‰œ$(��H|$XL‰öH‰ÚèI
��Hƒ|$X�t H‹|$`èZÿÿëA·D$h%�ð��=�€��u0H‹„$(��H‰„$Ð��óo„$��f„$À��Hƒ|$8�…ÙýÿÿëAHƒ¼$ ���t L‰÷ÿ°�Hƒ|$8�t H‹|$ÿ�H¼$À��H‹´$Ø���H‹T$ è#÷ÿÿL‹¤$À��M…ä„��H‹„$È��H‰D$H‹œ$Ð��H¼$��L‰æH‰Úè
+îÿÿHƒ¼$���„;��H‹œ$ ��L‹´$(��H¼$¨��1ö謑��H‹„$¨��H‹Œ$¸��H‰ÊHÁâH‰ L‰tHÿÁH‰Œ$¸��„q��H|$XH‰ÞL‰òè[ïÿÿL‰ãL‹d$XM…ä„Í��H‹„$˜���H‰D$L‹´$ ���H|$XèÛôÿÿH…Àt%H;T$ u H‰ÇH‹´$Ø���H‹T$ ÿÁ�…À„©��L‰ðM…ö„•��H‹|$ÿj�E1äéh��E1äH¼$p��HŒ$��H‹´$���H‹”$��è:��H‹„$���H‰„$��L‰¼$ ��H‹„$ø���H‰„$(��H‹„$ð���H‰„$0��L‰¬$8��H‹„$��H‰„$@��H‰¬$H��H‹„$��H‰„$P��H‹„$à���H‰„$X��H‹„$è���H‰„$`��(„$��(Œ$ ��„$h��Œ$x��H‹„$0��H‰„$ˆ��L‰d$X(„$À��(Œ$Ð��(”$à��D$`L$p”$€���H‹„$ð��H‰„$���H‹D$H‰„$˜���L‰´$ ���fo„$@��foŒ$P��ó„$¨���óŒ$¸���H‹„$`��H‰„$È���H¼$è��H´$��H”$��HL$XL„$p��L‹t$(L‹|$0L‹d$PL‹l$Hèü��H‹¬$ø��¶œ$è��€ûuBÆE�H¼$��èT��L‰ïL‰æÿ’�Iƒ�„ùÿÿL‰÷HÄè��[A\A]A^A_]ÿ%e�H´$é��H}ºÿ��ÿv�óo„$��óoŒ$ ��”$°��•0��ó ��ó…��ˆ]�L‰���L‰¥��Iƒ�u†é“øÿÿL‰ãE1äHƒ|$�„ýÿÿH‰ßÿå�éýÿÿE1äE1öëÞHD$`H‹H0H‰Œ$ð���HP )”$à��)Œ$Ð��)„$À��óo@HóoHXf„$@��fŒ$P��H‹@hH‰„$`��ë€H=+¬ýÿHŒ �¾+���è²gþÿë*èûRþÿë#¿���H‰Þè,SþÿëèåRþÿë
¿���L‰æèSþÿ I‰ÇHƒ¼$ ���t$H‹¼$��ÿ�ëI‰ÇH‰ßL‰öÿ�ëI‰ÇHƒ|$8�t4H‹|$ë'I‰ÇHƒ|$�t"L‰çëI‰ÇëI‰ÇM…ätM…öt H‹|$ÿÆ
�Hƒ¼$è����t6H‹¼$à���ÿ
�ë&L‰|$0L‰t$(I‰Çë4L‰l$HL‰d$PL‰|$0L‰t$(I‰ÇH¼$��èèQ��H‹|$HH‹t$Pÿp
�H‹D$0Hƒx�t H‹|$(ÿQ
�L‰ÿèYÚ� ÌÌÌÌÌÌÌAWAVATSHì˜��I‰ÖH‰ûHú��wkL|$L‰ÿL‰òÿ:
�BÆD4�IÿÆH‰çL‰þL‰òèKnþÿHƒ<$�tA¿���L5—�M…ÿuë>H‹|$E1ÿ1öÿØ
�I‰ÆM…ÿt&L‰sHÇ����é£���H‰÷L‰öè
‚�I‰ÇI‰ÖM…ÿuÚM…ötBL‰÷ÿ\
�I‰ÇH…ÀtNˆ€���¶W �¾���L‰ÿè¢LþÿI‰ÄH…Àu2¿���L‰þè=Qþÿ ÿÝ �‹�HÁà HƒÈH‰CHÇ����ë)A¼���L‰çL‰öL‰úÿQ �L‰÷ÿ �L‰#L‰{L‰{HĘ��[A\A^A_Ãè¡Pþÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHì˜���H‰|$¶n8@€ý„Û��I‰ö¶F9<„Ì��@8ŇÃ��H\$aA€~:�A¶NˆL$D¶éI‹H‰L$M‹~„„���Ld$Xë @�AÆF9°@8Ň��<…��L‰÷è`xÿÿI9ÇvÛL‰çL‰öè°yÿÿL‰ÿ¶D$`KS )D$ )L$0)T$@H‹K/H‰L$OH+|$X‚I��I‰~<
+…z��°I‰ÿëŽM‰üëfAÆF9°@8Ňÿ��<t|¶Àƒø…���L‰÷èØwÿÿI9ÄvÓH|$XL‰öè&yÿÿM‰ç¶D$`KS )D$ )L$0)T$@H‹K/H‰L$OL+|$X‚¹��M‰~<
+…ð���°M‰üë„ffff. „�����AÆF9�1ÀAƒý‚fÿÿÿAƒý„\ÿÿÿAƒý…ª���M…ät%H‹D$¶Iƒüt!€ù.u H‹D$€x/t&1Àé(ÿÿÿE1ä1Àé ÿÿÿ1ÀIƒü…ÿÿÿ€ù.… ÿÿÿIƒï‚K��M‰~H‹D$Æ�éþ���¶À…Àu,¶t$@€þ„Û���H’qýÿJc ¨HÁÿáI‹F HƒÀéƒ���AÆF9�Iƒï‚å���M‰~H‹D$Æ�é«���H‹L$ˆ(D$ (L$0(T$@AIQ!H‹D$OH‰A0ë~I‹F I‹N0HQH…ÉHDÑHÐHƒÀëI‹F I‹N0HQH…ÉHDÑHÐHƒÀH…Àt6AÆF9I‹F0H‹L$H‰A AFAN!IA@ˆ1H‹D$H‰A(L‰y0ë
AÆF9H‹D$Æ�
+HĘ���[A\A]A^A_]ÃL‰ÿM‰çH2��L‰þèr^þÿ H ��L‰ÿ1öè_^þÿ HÞÿ�ëëÌÌÌÌUAWAVAUATSHìˆ��I‰öI‰ÿH‹_L‹fL9ãuDA¶G8A:F8u9A€9u2A€~9u+A€’ÀA€~’Á0ÁuI‹?I‹6H‰Úÿx�…À„X��A¶G<t I‹O0H‰L$ AGAO!)L$)$M‹A¶O:A¶W8A¶w9H‹|$ H‰¼$��($(L$)Œ$���)„$ð���M‹A¶~@€ÿt M‹V0L‰T$ AFAN!)L$)$E¶V:E·^8L‹t$ L‰´$à���($(L$Œ$Ñ���„$Á���L‰L$pH‰\$xˆ„$€���(„$ð���(Œ$���„$���Œ$‘���H‹„$��H‰„$ ���ˆ”$¨���@ˆ´$©���ˆŒ$ª���L‰„$°���L‰¤$¸���@ˆ¼$À���fD‰œ$è���Dˆ”$ê���H¼$��Ht$pèÿúÿÿ€¼$��
+„Ô���H\$8L´$P��L¼$°���I‰äL¬$��Hl$pfff. „�����L‰÷L‰þèµúÿÿ€¼$P��
+„£���H‹„$H��H‰D$0„$��Œ$(��”$8��)T$ )L$)$H‹„$€��H‰C0„$P��Œ$`��”$p��S KL‰çH‰Þèzpÿÿ„Àt2L‰ïH‰îè+úÿÿ€¼$��
+…]ÿÿÿH‰çH´$°���è
úÿÿ€<$
+”Àë1ÀHĈ��[A\A]A^A_]ðëêÌÌÌÌÌÌÌÌÌÌÌÌAWAVSHì��I‰ÖH‰ûHú��‡S��L¼$��L‰ÿL‰òÿÅ�BÆ„4���IÿÆH¼$ø���L‰þL‰òèÎfþÿHƒ¼$ø����t H ý�H‰D$¸���H…À…Ö���é
+��H‹¼$���WÀ)„$à���)„$Ð���)„$À���)„$°���)„$ ���)„$���)„$€���HÇ„$ð�������H´$€���ÿ�ƒøÿtH‹„$ð���H‰D$x(„$à���D$h(„$Ð���D$X(„$À���D$H(„$€���(Œ$���(”$ ���(œ$°���\$8T$(L$D$1ÀH…Àt9H‹D$H‰C¸���ësÿõ�‹�HÁà HƒÈéòþÿÿH‰çL‰òèƒx�H‹$H…ÀuÇH‹D$xH‰CxD$hChD$XCXD$HCHD$L$T$(\$8[8S(KC1ÀH‰HÄ��[A^A_ö¡�„À…Ö���Hìø��H¸ib/debugH‰D$~H¸/usr/libH‰D$xÆ„$†����1ÀH=[û�ff. „�����€|x�t HÿÀHƒøuðëoHƒøuiWÀ)D$`)D$P)D$@)D$0)D$ )D$)$HÇD$p����H|$xH‰æÿ\�ƒøÿt·D$%�ð��=�@��”Á°(Èëÿ±�‹8HÁç HƒÏèJÿÿ°ˆÊ�HÄø��<”ÀÃÌÌÌÌÌUAWAVAUATSHìè���I‰ÔI‰õH‰|$(H…ÒH‰Œ$à���tQˆ/��¶¢�¾���L‰çèíBþÿH…À„��I‰ÇH‰ÇL‰îL‰âÿÊ�L‰|$L‰d$L‰d$A€}�/”ÀL‰ãëHÇD$���WÀD$A¿���1Û1ÀL‰l$0L‰d$8ÆD$@ˆD$jfÇD$h�H¼$¨���Ht$0èOöÿÿ¶„$¨���E1äH‹Œ$°���< LDátN¶õ�A½���¿���ÿ$�H…À„Á���I‰ÄÆ@pfÇ�dwA½���A¾���H…Û„ ��A€?/”Àé��H‹´$¸���Hƒþu ·ú..��t™H‰òf. „�����H‰×HÊL9âtHWÿ€|9ÿ.uêI‰õI)ý‚ ��IüH…ÒLDâ< …Xÿÿÿ1À„À…NÿÿÿM…ä„EÿÿÿM…ít4ˆ-��¶/�¾���L‰ïèzAþÿI‰ÆH…Àu¿���L‰îèFþÿé��A¾���L‰÷L‰æL‰êÿC�L‰t$0L‰l$8L‰l$@H|$0º���L‰îè:pÿÿL‹d$0L‹l$@CÇ,.dwpIƒÅL‹t$8H…Û…ôþÿÿ1ÀL‰|$0H‰\$8ÆD$@ˆD$jfÇD$h�H¼$¨���Ht$0è¸ôÿÿ1À€¼$¨��� H‹Œ$°���HDÁ…¸��H‹´$¸���Hƒþu·ú..��u º���1ÿëHH‰ò €����H‰×HÊH9Ât$HWÿ€|9ÿ.uêH‰ñH)ù‚Ú��H…ÒtHÇH‰Îë H‰Ç1Éë1ÿH‰òH‰ÁH…ÉHEùH…ÿ„>��L‰t$ H…ÉHDÖH×L)ÿH‰ÝH9ûrH‰|$H‰ýM…ít@MuH‰ØH)èL9ðƒ—���Iî‚~��L‰öH÷ÖHÁî?H…Ût L‰|$0HÇD$8���H‰\$@ëL‹t$ éÍ���HÇD$8����H¼$¨���HL$0L‰òèƒoÿÿHƒ¼$¨����H‹¼$°���t H¸������€H9ÇL‹t$ …��H9Ýt ë6H‰|$L‰t$I‰ÿL‰óL‹t$ H9Ýu H|$H‰îèjr�H‹l$L‹|$H‹\$AÆ/.HÿÅH‰l$H)ëL9ësH|$H‰îL‰êè6nÿÿH‹l$L‹|$I</L‰æL‰êÿÿ�LíH‰l$M…öt L‰çÿÆþ�H‹T$H¼$¨���L‰þèqÚÿÿHƒ¼$¨����„Ñ���L‹¬$°���L‹´$¸���H‹œ$à���LcH‹s(H;s u L‰çè~��H‹s(H‹KH‰ðHÁàL‰,L‰tHÿÆH‰s(„Ã���I‹ $H‹4H‹TH|$0è¸ÛÿÿHƒ|$0�t_H‹„$ ���H‹L$(H‰Ap„$���A`„$€���APD$pA@D$0L$@T$P\$`Y0Q IHƒ|$�uë H‹D$(HÇ�����Hƒ|$�t L‰ÿÿ´ý�HÄè���[A\A]A^A_]Ãè=Bþÿ ¿���L‰æènBþÿ H==›ýÿHžú�¾+���èÄVþÿëFH‹ë�è†Iþÿë8H}ë�èxIþÿë*H…ÿu L‹t$ èçAþÿëH‹´$¸���L‹t$ èBþÿëèÌAþÿ H‰ÃHƒ|$8�t4H‹|$0ÿý�ë'H‰ÃL‰ïL‰öÿ ý�ëH‰ÃM…ötL‰çÿðü�ëH‰ÃHƒ|$�t H‹|$ÿØü�H‰ßèàÉ� ÌÌÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHì¨��L‰„$à���H‰Œ$è���I‰ÔI‰÷H‰¼$à��H ýÿ¹
+���L‰çL‰¤$è��èÕ|��H‰T$@H…ÀH
šýÿH‰ÂHDÑH‰$H‹L$@HDÈH‰L$@HàŸýÿ¹���L‰çL‰þè–|��H‰T$ H…ÀH‰ÂH
Ü™ýÿHDÑH‰T$H‹L$ HDÈH‰L$ H¯Ÿýÿ¹
���L‰çL‰þèV|��H‰T$pH…ÀH‰ÂH
œ™ýÿHDÑH‰T$xH‹L$pHDÈH‰L$pH|Ÿýÿ¹���L‰çL‰þè|��H‰T$(H…ÀH‰ÂH
\™ýÿHDÑH‰T$hH‹L$(HDÈH‰L$(H¼žýÿ¹
���L‰çL‰þèÖ{��H‰T$`H…ÀH‰ÂH
™ýÿHDÑH‰T$0H‹L$`HDÈH‰L$`H‰žýÿ¹ ���L‰çL‰þè–{��H‰T$XH…ÀH‰ÂH
ܘýÿHDÑH‰”$¨���H‹L$XHDÈH‰L$XHQžýÿ¹���L‰çL‰þèS{��H‰T$PH…ÀH‰ÂH
™˜ýÿHDÑH‰”$��H‹L$PHDÈH‰L$PH+žýÿ¹ ���L‰çL‰þè{��H‰T$8H…ÀH‰ÂH
V˜ýÿHDÑH‰”$ ���H‹L$8HDÈH‰L$8Hóýÿ¹ ���L‰çL‰þèÍz��H‰T$H…ÀH‰ÂH
˜ýÿHDÑH‰”$¸���H‹L$HDÈH‰L$H»ýÿ¹���L‰çL‰þèŠz��H‰T$H…ÀH‰ÂH
ЗýÿHDÑH‰”$°���H‹L$HDÈH‰L$H¼ýÿ¹
+���L‰çL‰þèGz��I‰ÕH…ÀI‰ÆH
—ýÿLDñLDèH—ýÿ¹���L‰çL‰þèz��H‰ÃH‰ÕH›ýÿ¹ ���L‰çL‰þèûy��L‰¼$ø��H‹L$0H‰Œ$è��H‹L$`H‰Œ$ð��H‹Œ$¨���H‰Œ$ø��H‹L$XH‰Œ$���H‹Œ$��H‰Œ$��H‹L$PH‰Œ$��H‹Œ$ ���H‰Œ$��H‹L$8H‰Œ$ ��H‹Œ$¸���H‰Œ$(��H‹L$H‰Œ$0��H‹Œ$°���H‰Œ$8��H‹L$H‰Œ$@��L‰´$H��H…ÛHDëH
Š–ýÿHDÙL‰¬$P��H…ÀHDÐH‰œ$X��HDÁH‰¬$`��H‰„$h��H‰”$p��H‹$H‰„$x��H‹D$@H‰„$€��H‹D$H‰„$ˆ��H‹D$ H‰„$��H‹D$xH‰„$˜��H‹D$pH‰„$ ��H‹D$hH‰„$¨��H‹D$(H‰„$°��WÀ„$¸��Æ„$È���L‹¤$è���I‹$H‰„$��H…À„��H›ýÿ¹
+���L‰çL‹¼$ø��L‰þèEx��H‰T$@H…ÀH‰ÂH
‹•ýÿHDÑH‰$H‹L$@HDÈH‰L$@HP›ýÿ¹���L‰çL‰þèx��H‰T$ H…ÀH‰ÂH
L•ýÿHDÑH‰T$H‹L$ HDÈH‰L$ H ›ýÿ¹
���L‰çL‰þèÆw��H‰T$pH…ÀH‰ÂH
•ýÿHDÑH‰T$xH‹L$pHDÈH‰L$pHìšýÿ¹���L‰çL‰þè†w��H‰T$(H…ÀH‰ÂH
Ì”ýÿHDÑH‰T$hH‹L$(HDÈH‰L$(H,šýÿ¹
���L‰çL‰þèFw��H‰T$`H…ÀH‰ÂH
Œ”ýÿHDÑH‰T$0H‹L$`HDÈH‰L$`Hù™ýÿ¹ ���L‰çL‰þèw��H‰T$XH…ÀH‰ÂH
L”ýÿHDÑH‰”$¨���H‹L$XHDÈH‰L$XHÁ™ýÿ¹���L‰çL‰þèÃv��H‰T$PH…ÀH‰ÂH
”ýÿHDÑH‰”$ ���H‹L$PHDÈH‰L$PH›™ýÿ¹ ���L‰çL‰þè€v��H‰T$8H…ÀH‰ÂH
Æ“ýÿHDÑH‰”$¸���H‹L$8HDÈH‰L$8Hc™ýÿ¹ ���L‰çL‰þè=v��H‰T$H…ÀH‰ÂH
ƒ“ýÿHDÑH‰”$°���H‹L$HDÈH‰L$H+™ýÿ¹���L‰çL‰þèúu��H‰T$H…ÀH‰ÂH
@“ýÿHDÑH‰”$Ø���H‹L$HDÈH‰L$H,™ýÿ¹
+���L‰çL‰þè·u��I‰ÕH…ÀI‰ÆH
ÿ’ýÿLDñLDèH™ýÿ¹���L‰çL‰þèˆu��H‰ÅH‰ÓH ™ýÿ¹ ���L‰çL‰þèku��WÀ„$`��H‹L$0H‰Œ$��H‹L$`H‰Œ$˜��H‹Œ$¨���H‰Œ$ ��H‹L$XH‰Œ$¨��H‹Œ$ ���H‰Œ$°��H‹L$PH‰Œ$¸��H‹Œ$¸���H‰Œ$À��H‹L$8H‰Œ$È��H‹Œ$°���H‰Œ$Ð��H‹L$H‰Œ$Ø��H‹Œ$Ø���H‰Œ$à��H‹L$H‰Œ$è��L‰´$ð��L‰¬$ø��H…íHDÝH
ï‘ýÿHDéH‰¬$���H‰œ$��H…ÀHDÐHDÁH‰„$��H‰”$��H‹$H‰„$ ��H‹D$@H‰„$(��H‹D$H‰„$0��H‹D$ H‰„$8��H‹D$xH‰„$@��H‹D$pH‰„$H��H‹D$hH‰„$P��H‹D$(H‰„$X��Æ„$p���HÇ„$€�����HÇ„$ˆ�����¶R�¿ø���ÿ‡ó�H…À„ò2��H‰ÃH´$€��ºø���H‰Çÿuó�H‹„$¸��H…ÀtðHÿu
H¼$¸��è½p��H‰œ$¸��H‹„$è���HƒxH�t
+H‹x@ÿ ó�Ç„$°�������ë °‰„$°���H¼$��H´$è��ºè���ÿó�HÇ„$€�����HÇ„$ˆ�����¶”�¿ø���ÿÉò�H…À„ò1��H‰ÃH´$€��ºø���H‰Çÿ·ò�H‰œ$ø���H‰ØHƒÀH‰„$ð���HÇ„$������WÀ„$��H‹C0H‹k8H‰„$À��H‰¬$È��HÇ„$Ð������H…í„��A½���1öH„$€��H‰„$Ø���Hœ$À��E1ÿëAffffff. „�����I‰ôL‰àHÁàI‰l�M‰tIt$H‰´$��H‹¬$È��H…í„‚���I‰ôH¼$€��H‰ÞL‰úèøK�€¼$©��„Q��H+¬$È��L‹´$��I‰ïL¼$Ð��H‹¬$ ��L‰¼$Ð��L‰æL;¤$��…nÿÿÿH¼$���èñp��L‹¬$���L‹¤$��éOÿÿÿH‹„$���H‰$Hƒþs Hƒþ†þ��º���H‹<$èN�éë��H¸àÿÿÿÿÿÿH‰t$H<õ����HƒÀH!ǶÐ�¾���è 1þÿH…À„»0��I‰Æ¶³�¿���ÿèð�H…ÀL‰t$„²0��I‰Ç¸���L)àH‰„$ ���H‹$HH H‰Œ$¸���HHH‰Œ$Ø��HƒÀðH‰D$h¸���H‰„$¨���E1íHCß�H‰„$ð��1íH‹t$ëf½���L‹l$0I9õƒ
+��H‰òL)êL‰èHÁàH‹ $H<HƒúsbI‰ðL‰ÃL)ë‚È.��I9ð‡¿.��sxHƒú
+srI]
+H9óHCÞH‰\$0L)ë‚».��HƒúHƒÒ�H‰ÞèÙL�H‹t$H;¬$¨���tIé¡��� D��H‹L‹gI9̃°��Hƒú…º��MEº���éb�� „�����L‰D$0H;¬$¨���u]H‰ïHÁç¶[�¾���è©/þÿH…À„C.��I‰ÆHm����H‰„$¨���H‰êHÁâL‰÷L‰þÿrï�L‰ÿÿAï�M‰÷L‹t$H‹t$H‰èHÁàI‰ M‰lHÿÅHƒý‚¼þÿÿL‰|$xënM‰ÄL‹t$L‰öI)÷H‰ßL‰úÿ ï�H‹D$`LàH‹L$PH‰H‹D$8L‰(H‹|$XHwH‹D$(H÷ÐH‹T$pHÂHÁâÿûî�H‹l$@HƒýL‹|$xH‹t$†BþÿÿLMÿL‰ÉHÁáI‹I‹LHÁH9ñtVH‰êHÁâN‹D:àI9ÀvEHƒý†l��LUýL‰ÑHÁáI‹ I<�H9ùv8Hƒý†ü��IÈN9D:Àv$éßýÿÿf. „�����HƒýrLUýL‰ÑHÁáI‹ H9ÁrLUþL9Õ†å+��IBH9ņ†+��L‰ÑHÁáI‹\HÁàI‹M‹dIÔM‰æI)Þ‚{+��L‰L$@I9ô‡‰+��H‰T$`L‰T$(H‰l$pIH‰T$XI‹I H‰L$PLøHƒÀH‰D$8H‰\$ HÁãH $I‰×IÁçJ,;IÁäM‰õI)ÕH‰T$I9Õƒ¥���M‰ïIÁçL‹t$L‰÷H‰îL‰úÿrí�M÷H‹|$H…ÿŽ ��M…íŽ���Ld$hL‹l$ f D��H‰èL‰ùI‹WðH‹uðH9ò½����HíH9òA¿����Iƒ×ÿHÁåHÅIÁçIÏH9òL‰øHBÅ�A$H9Ýv IƒÄðM9÷w¬I‰üH‰ëé¹ýÿÿL‹l$L‰ïH‰ÞL‰úÿÔì�MïL‹D$M…À~wM9ÆL‹l$ ŽýÿÿL$$L‹t$L‰ö D��H‰òH‹M�1ö1ÀH;
+@“Æ’ÁH‰×HBýHƒÃHÁæHÖL9þsˆÈHÁàHÅL9årÀM‰Äé3ýÿÿ „�����I‰üH‰ëëM‰ÄL‹t$L‰öL‹l$ éýÿÿ �Hƒúu[MEº���éÍûÿÿH‹´$ ���N .H‹´$¸���LA¸���M‰ãff. „�����L‰ÛM‹I9ÛsgK HÿÃIÿÀIƒÂHƒûuáëNH‹´$ ���N .H‹´$¸���LA¸���M‰ãfffff. „�����L‰ÛM‹I9ÛrK HÿÃIÿÀIƒÂHƒûuáI‰ÐK4(L‰ÂI‰ðI9ÌH‹t$ƒûÿÿM9Ňc*��I9ð‡F*��Hƒú‚ûúÿÿM‰ÄH‰ÑHÑéH‰ÖHÁæHþI‰ÈIÁàL)ÆHƒùuE1Àé}���½���éšúÿÿI¸àÿÿÿÿÿÿMH I!ÉH„$Ø��N*IÁâLT$hE1ÀH»þÿÿÿÿÿÿf@ðA
+HðAM‰ÃI1ÛIËIÁã�B B IƒÀHƒÀ IƒÂàM9ÁuÂöÂt#L‰ÀH÷ÐHÁIÁàHÁáB B H‹t$M‰àé úÿÿ½���éèùÿÿL‰ÿH‹ 9ê�ÿÓL‰÷ÿÓHÇ„$€������WÀ„$ˆ���HÇ„$À������„$È���H‹„$ð���@0„$���HÇ„$������H¼$€��H´$���è¢m��H‹„$€��Hƒø… ��H‹œ$À���L‹´$Ð���IÿÆH‰ßf. „�����IƒþtL¿��IÿÎè H�L‰ÿëæHƒ¼$È����t H‰ßÿré�Hƒ¼$ˆ����tH‹¼$€���ÿYé�Hƒ¼$���tH‹¼$���ÿ@é�L‹´$ø���ðIÿu³H¼$ø���è³f��H‹„$à��Æ�H‹„$à���Hƒ8�tHƒxH�t
+H‹x@ÿùè�Hƒ¼$���H‹„$è���uHƒ8�tHƒxH�t
+H‹x@ÿÏè�H‹„$è��HƒxH�t
+H‹x@ÿ¶è�HĨ��[A\A]A^A_]ÃL´$˜��L¬$à��H¬$x��HŒ$€��H‰Œ$¸���L¤$���ë4L´$˜��f. „�����H¼$€��L‰æè l��H‹„$€��Hƒø„~þÿÿH‹œ$ˆ��H‹Œ$��I‹V0H‰”$���AANAV )”$ð��)Œ$à��)„$Ð��)„$€��AE�AM)„$@��)Œ$P��I‹U H‰”$`��Hƒø„Ø��H…À…[ÿÿÿH‰ÈHƒÈHƒø„JÿÿÿL‹¼$Ð���H‹´$ð���HÇ„$`������H‰œ$h��H‰Œ$p��(„$€��E�H‹„$`��H‰E0(„$@��(Œ$P��M EH¼$€��H”$`��èùu��ƒ¼$€��„¹þÿÿº¨��L´$Ð��L‰÷H´$€��ÿ5ç�H‹”$(��HBH‹´$ø��L‹„$���H‰´$`��L‰„$h��L‰´$p��H‰„$x��HÇ„$€������M…À„!��IxÿLN1À1ÉE¶Qÿƒù?u
+A€úƒñ��E¶ÒE‰ÓAƒãIÓãL ØE„ÒyƒÁIÿÁHƒÇÿrÊéÂ��L‰Œ$`��H‰¼$h��H…À…–���ðHÿ
+u
H‹¼$(��èÙ–��ƒ¼$0��/L´$˜��„ÓýÿÿHƒ¼$ˆ���tH‹¼$€��ÿæ�Hƒ¼$ ���tH‹¼$˜��ÿæ�Hƒ¼$¸���tH‹¼$°��ÿèå�Hƒ¼$Ð���„yýÿÿH‹¼$È��ÿËå�éfýÿÿHHÿH;J s
HkùpHzéƒ���H‹z(H…ÿ„��H‹J0··2��Lõ����HÇÂÿÿÿÿAºÿ���M…Àt*E1ÉH9„×à��A•ÁEGÊHÿÂIƒÀøA€ùtÛA¶ñ…öuëH‰òHƒé‚«��H‹¼×8��ëžH…ÿ„˜��HkÂpHÇ€ju HÇ„$€�����èe„þÿH‰D$ I‰ÖH…Ò„É��H‹„$ð���H‰D$(‹„$��H‹Œ$p��H‰L$`¶ÌH‰Œ$Ø���%�ÿ��‰„$Ø��·„$��f‰„$¨���¶„$��H‰D$8H‹„$`��H‰D$XIÁæE1Ò1ÀH‰D$p1ÀH‰D$1ÀH‰D$1ÀH‰D$x1ÀH‰D$Pë'ƒø&¸���H‹L$pDÈH‰L$pL‹T$@IƒÂM9Ö„+��H‹D$ L‰T$@B)„$��H‹„$p��‹PHH¼$€��H´$`��HŒ$��èÀÛ��H‹„$€��Hƒø.„c��H‹Œ$˜��„$ˆ��„$(��H‰„$ ��H‰Œ$8��·Áƒø¾���ƒø„]��ƒø…WÿÿÿH¼$€��H´$ ��èsï��H‹„$€��H…À„‰��ƒøL‹T$@„_��ƒø … ÿÿÿH‹D$(H‹HH+L$X‚Ì
��H‹„$ˆ��H¯D$8H‰ÎH)Æ‚²
��H‹|$8ÿσÿ‡¢
��L‹D$(M‹HLL$XLKýÿIc<¸LÇÿçH9Á„{
��A¶é¾��ƒø„B��ƒøU…™þÿÿH¼$€��H´$ ��èµî��H‹Œ$€��H‹„$ˆ��Hƒù„C��ƒù…‘��H‹L$(H‹‰È���H+L$`‚
��H¯„$Ø���H)Á‚þ ��H‹T$(H‹’À���HT$`¼$Ø�����…‰��Hƒù†Ò ��H‹éƒ��H¼$€��H´$ ��è î��H‹„$€��H…À„ñ���ƒø L‹T$@…ÔýÿÿH‹D$(H‹HH+L$X‚ ��H‹„$ˆ��H¯D$8H‰ÎH)Æ‚g ��H‹|$8ÿσÿ‡W ��L‹D$(M‹HLL$XLÝIýÿIc<¸LÇÿçH9Á„0 ��A¶é0��H¼$€��H´$ ��è|í��H‹„$€��Hƒø&…$ýÿÿ·Œ$ˆ��f‰L$0éýÿÿfƒ¼$¨���º����HBT$`H‹L$(€¹à����¹����HDÑHÂH‰”$ ���¸���ë ¸���H‰D$H‹„$ˆ��H‰D$héÐüÿÿ1ÀH‰D$PéÄüÿÿ¸���H‰D$xH‹„$ˆ��H‰D$éüÿÿ¸���H‰D$H‹„$ˆ��H‰$éüÿÿHƒù‚I ��‹L‹T$@HD$`H‰„$ ���¸���H‰D$PédüÿÿHƒþ‚ ��A·ë Hƒþ‚
+ ��I‹ëHƒþ‚ú
+��A‹H‰D$h¸���H‰D$é!üÿÿHƒþ‚Ø
+��A·ë Hƒþ‚Ç
+��I‹ëHƒþ‚·
+��A‹H‰$¸���H‰D$éßûÿÿ1ÀH‰D$p1ÀH‰D$1ÀH‰D$1ÀH‰D$xH‹´$��H…öt\H‹„$���I‰ö1ÒH‰ñëL‰ñI)ÖvBIÑîIÖM‰ñIÁá1ÿJ9 @•ÇA¸ÿ���ABø@€ÿtÑ@¶×úÿ���…Î��L‰òHÿÂI‰Îë¶H‹D$H…À„ó��Hƒ|$�„ç��H‹$H9T$hƒÙ��H‹´$���H;´$ˆ���uH¼$€���è^º��H‹´$���H‹„$€���H‰ñHÁáH‹T$hH‰H‹$H‰TL‰|HÇD����HÿÆH‰´$���@¶ér��Hƒ|$P�„ùþÿÿH‹”$ð���H²°���‹„$��‰ÁÁéLŠÀ���1ÿfƒùA“ÀLBÎI‹qL‹Œ$ ���L)΂8 ��DˆÇHÁçHÇ°���H‹<:LÏfƒùBH‹”$P��L‹„$`��„$€��H‰”$��L‰„$˜��H‰¼$ ��H‰´$¨��f‰„$°��f‰Œ$²��“„$´��ÇD$@����H¼$ ��H´$€��èi �H‹„$ ��L‹´$(��Hƒø…��H‹„$0��I9ÆsÄH‰D$@H‹´$���H;´$ˆ���uH¼$€���èî¸��H‹´$���H‹„$€���H‰ñHÁáL‰4H‹T$@H‰TL‰|HÇD����HÿÆH‰´$���°‰D$@éWÿÿÿ1öH…ÀH‹D$H‹L$hH‹$„��Hƒ|$x�„ö���L4L9ñƒç���H‹´$���H;´$ˆ���uH¼$€���èT¸��H‹´$���H‹„$€���H‰ñHÁáH‹T$hH‰L‰tL‰|HÇD����HÿÆH‰´$���@¶H‹D$H‹$ë~ƒøuhA€þK…n��AÁîD‰öH‹D$H‹$@€æëaI~ÿH9÷ƒ†��IÿÆJ HƒÁðIƒþ„z��IÿÎHQðH9H‰ÑtçI9ö†e��éò ��1öH‹D$ëH‹D$H‹$‹t$@ë1ö@€æ@€æHÇ„$`������@öÆH‰D$H‰$…��Hƒ¼$0��/„��H„$0��H‰„$ ��H„$Ð��H‰„$€��H„$ ��H‰„$ˆ��H„$ð���H‰„$��H¼$`��H´$€��è;�Hƒ8�„›���H‹HH‰L$ H…É„‰���H‹@H‰D$(H‹´$���HÁd$ E1öë<H‹„$€���H‰ñHÁá(D$@L‰|HÇD����HÿÆH‰´$���IƒÆ L9t$ t1H‹D$(BD0)D$@H;´$ˆ���uªH¼$€���èd¶��H‹´$���ë“L‹¼$Ð���º¨��H¼$€��H´$Ð��ÿoÛ�„$`��Œ$p��HŒ$˜��˜��‰¨��H‹„$€��H‰¸��H‰œ$(��H‹D$pf‰„$��·D$0f‰„$’��HÇ„$X������Æ„$€��LL;¼$È���uH¼$À���L‰þèr8�L‹¼$Ð���Iiÿ��H¼$À���º��Hœ$€��H‰Þÿ½Ú�IÿÇL‰¼$Ð���H‰ßL‰æèO^��H‹„$€��HƒøL´$˜��…'òÿÿé ðÿÿM…ö…¦��E1öI9öu1öH‹D$H‹$éýÿÿHÁæHÆIÁæIÆÇD$@����H‰t$ I9 … ��H‹Œ$ð���I‹VH‹A(H)Ђg��H‹I HÑH‰Œ$ ��H‰„$(��H¼$€��H´$ ��è4�€¼$©��„-��H‹´$ˆ��H…ö„§��H‹¼$€��D¶„$¨��¶Œ$¬��C��ÈD¶ÈH‰L$(…É„$��L‹T$(ë H ÐH È…<��L9΂[��ABÿƒø‡Ã��H
wAýÿHcHÈÿàH…ö„ª��HÿζHÿÇëBHƒþ‚•��HƒÆþ·HƒÇë+Hƒþ‚~��HƒÆøH‹HƒÇëHƒþ‚g��HƒÆü‹HƒÇAHÿƒù‡P��H$AýÿHc ŠHÑÿáHƒþ‚6��¶HƒÆþ¶WHƒÇé=ÿÿÿHƒþ†��HNþHƒù‚
+��·HƒÆü·WHƒÇéÿÿÿHƒþ‚ì��H‰ñHƒáøHƒù„Û��H‹H‹WHƒÆðHƒÇéâþÿÿHƒþ†½��HNüHƒù‚¯��‹HƒÆø‹WHƒÇé¸þÿÿH‰L$L‰L$8L‰D$PH‰|$XH‰t$`H‰T$H…ÒtkH‹´$���H;´$ˆ���uH¼$€���èæ²��H‹´$���H‹T$H‹|$H×H‹„$€���H‰ñHÁáH‰H‰|L‰|HÇD����HÿÆH‰´$���°‰D$@H‹t$`H…öH‹|$XL‹D$PL‹L$8…þÿÿéx��Hƒþ‚ã��¶HƒÆþ¶WHƒÇH‰ÈH Ð…¨���L9΂J��A@ÿƒø‡²��H
¦?ýÿHcHÈÿàHƒþ‚˜��HFþHƒø†Š��·HƒÆü·WHƒÇë¥Hƒþ‚o��H‰ðHƒàøHƒø„^��H‹H‹WHƒÆðHƒÇévÿÿÿHƒþ†@��HFüHƒø†2��‹HƒÆø‹WHƒÇéLÿÿÿH‰L$(L‰L$8L‰D$PH‰|$XH‰t$`H‰T$H…ÒtkH‹´$���H;´$ˆ���uH¼$€���èi±��H‹´$���H‹T$(H‹|$H×H‹„$€���H‰ñHÁáH‰H‰|L‰|HÇD����HÿÆH‰´$���°‰D$@H‹t$`H…öH‹|$XL‹D$PL‹L$8…þÿÿIƒÆH‹t$ I9ö…ÚûÿÿH‹D$H‹$‹t$@éZùÿÿL‹´$€���L‹¬$���IƒýƒÍ���Iƒý†,��º���L‰÷L‰îè6�é ��LÆ1ÿI‰ñL‰Œ$`��H‰¼$h��H‹„$(��ðHÿu
H‹¼$(��è†��ƒ¼$0��/„²ëÿÿHƒ¼$ˆ���tH‹¼$€��ÿYÕ�Hƒ¼$ ���tH‹¼$˜��ÿ@Õ�Hƒ¼$¸���tH‹¼$°��ÿ'Õ�Hƒ¼$Ð���„XëÿÿH‹¼$È��ÿ
+Õ�éEëÿÿL‰èHÁàH¿àÿÿÿÿÿÿH!ǶÂæ�¾���èþÿH…À„á��H‰Ã¶¥æ�¿���ÿÚÔ�H…ÀH‰\$„Ø��I‰ÄIF@H‰„$ ���IFàH‰D$h¸���H‰„$¨���1ÉHVÃ�H‰„$Ø���1íL‰4$L‰l$xëL‹4$H‹\$H‹L$0L9郖��L‰ðI‰ÎL‰êH)ÊH‰ÎHÁæH<0Hƒús\L‰îH‰óL)ó‚"��L9î‡��srHƒú
+slI^
+L9ëICÝH‰\$0L)ó‚a��HƒúHƒÒ�H‰ÞèS4�H;¬$¨���tHé–��� @�H‹H‹O H9Áƒà��Hƒú…ê��Ivº���éR�� „�����H‰t$0H;¬$¨���uSH‰ïHÁç¶kå�¾���è¹þÿH…À„ï��I‰ÇHm����H‰„$¨���H‰êHÁâL‰ÿL‰æÿ‚Ó�L‰çÿQÓ�M‰üH‰èHÁàI‰ M‰tHÿÅHƒý‚ÁþÿÿL‹4$H‹\$L‰d$ërH‹\$H‰ÞI)õL‰çL‰êÿ2Ó�H‹D$XHD$@H‹L$8H‰H‹D$`H‹L$H‰H‹|$PHwH‹D$(H÷ÐH‹T$pHÂHÁâÿÓ�H‹l$ HƒýL‹l$xL‹d$†¯��I‰éLEÿL‰ÁHÁáI‹ I‹L HÁL9étPL‰ÊHÁâJ‹t"àH9Æv?Iƒù†–��MQýL‰ÑHÁáI‹ H<H9ùv2Iƒù†~��HÎJ9t"Àv éy�� @�IƒùrMQýL‰ÑHÁáI‹ H9ÁrMQþM9цO��L‰D$ IBI9Á†%��L‰ÑHÁáI‹| HÁàI‹I‹lHÕH‰ëH)û‚W��L9í‡b��H‰T$XL‰T$(L‰L$pI H‰T$PI‹ I H‰L$8IDH‰D$H‰|$`I‰üIÁäMôI‰ÕIÁåO<,HÁåI‰ÞI)ÖH‰T$@I9Öƒµ���M‰õIÁåH‹\$H‰ßL‰þL‰êÿ‚Ñ�IÝH‹D$@H…ÀŽ)��M…öŽ ��Hl$hL‹4$ €����L‰øL‰éI‹UàI‹wàH9òA¿����MÿH9òA½����IƒÕÿIÁçIÇIÁåIÍH9òL‰èIBÇ�HME�M9çv HƒÅàI9Ýw¤M‰üé°ýÿÿfff. „�����L‹t$L‰÷L‰æL‰êÿÔÐ�MõH‹D$@H…ÀŽ€���H9ÃL‹4$ŽmýÿÿLõH‹\$H‰Þ �H‰òI‹1ö1ÀH;
+@“Æ’ÁH‰×IBÿOAL$A$IƒÄ HÁæHÖL9îƒ&ýÿÿˆÈHÁàIÇI9ïr±éýÿÿfff. „�����M‰üëH‹\$H‰ÞL‹4$éñüÿÿf. „�����½���éûÿÿf D��HƒúuCIvº���é£ûÿÿH´$ ���A¸���I‰Éff. „�����M‰ÊL‹M9Ñs?IÿÀHƒÆ L9Âuéë.H´$ ���A¸���I‰Éf D��M‰ÊL‹M9ÑrIÿÀHƒÆ L9ÂuéI‰ÐK40L‰ÂH9Áƒ-ûÿÿI9ö‡��L9î‡ô��Hƒú‚ûÿÿI‰ðH‰ÐHÑèI HÁáHL$hH‰þN)Œ$��)„$€��IN(„$€��(Œ$��IHƒÆ HƒÁàHÿÈu·L‰Æé¦úÿÿ½���énúÿÿ½���édúÿÿL‰Íé\úÿÿL‰çH‹¹Î�I‰ÞH‰ÃÿÐL‰÷ÿÓL‹´$€���L‹¬$���M…ít4L‰èHÁàLð1ÉL‰ò „�����H‹rH9ñHFÎH‰JHr H‰òH9ÆuåëE1íL‰4$L‹¤$ˆ���„$À���)„$Ð��H‹„$Ð���H‰„$à��Hƒ¼$���tH‹¼$���ÿÎ�L‹´$ø���Hƒ<$�„ÐäÿÿH‹„$à��H‰„$Ð���(„$Ð��)„$À���M‹¾à���M…ÿL‰l$xL‰d$ „Ç���HÇ„$ �����WÀ„$(��AG@„$@��HÇ„$P������H¼$€��H´$@��èYQ��H‹„$€��Hƒø…û���H¼$ ��èŠ/�H‹œ$À���L‹¤$Ð���IÿÄH‰ß @�IƒütL¿��IÿÌè»+�L‰ÿëæHƒ¼$È����t H‰ßÿ"Í�Hƒ|$ �„ÞãÿÿH‹<$ÿ Í�éÏãÿÿHÇ„$������WÀ„$��¿���1ÛE1ÿL‰´$€��H‹$H‰D$@M9ì† ��H‰ýM…í„ü��H‹t$ HÁæM‰ìIÁäº���H‹<$L‰áè
þÿH‰D$@H…ÀH‰ï…á��¿���L‰æèaþÿé× ��IƒÇA¼���1ÛL¬$€��H¬$@��ë5fffff. „�����Hƒø„G��L‰ïH‰îè P��H‹„$€��Hƒø„²þÿÿœ$ˆ��H”$˜��JR )„$`��)Œ$p��)”$€��H‹J0H‰Œ$��H…Àu•HÇ„$€������)\$@œ$ˆ��H‹„$��H‰B0(„$`��(Œ$p��(”$€��R JH¼$Ð��L‰þL‰êèJZ��ƒ¼$Ð��„6ÿÿÿº¨��L‰ïH´$Ð��ÿŽË�(D$@„$(��H;œ$(��u"H¼$ ��H‰Þèo.�H‹„$ ��H‹œ$0��ëL‰àHiû°��I‰ÄHǺ°��L‰îÿ7Ë�HÿÃH‰œ$0��é¹þÿÿM…ä„ŒýÿÿL‰çL‹¼$(��L‰¤$���L‰¼$��H‰œ$��L‹l$xL‹d$ éÞýÿÿH‹<$ÿºÊ�¸���H‰D$@H‰ïL‹¬$À���H‹„$È���L‹¤$Ð���L9àvYH‰ýM…ät?Hið��IiÌ��º���L‰ïH‰L$pèØ
+þÿI‰ÅH…ÀH‰ïu&¿���H‹t$pè.þÿé¤
+��L‰ïÿ@Ê�A½���H‰ïI9ßvEH…Ût5Ii÷°��Hië°��º���H‰éè‚
+þÿH‰ÇH…Àu ¿���H‰îèÝþÿéS
+��ÿòÉ�¿���M…ö„ÁàÿÿL‰´$˜��H‹D$@H‰„$ ��H‹D$xH‰„$¨��L‰¬$°��L‰¤$¸��H‰¼$À��H‰œ$È��L‹¼$à���Iƒ?�„1��Hålýÿ¹���L‰ÿL‹´$ø��L‰öèÑI��H "gýÿH…ÀHDÐHDÃH¼$€��H‰ÆèO.�¶¬$€��@€ý„¦���H‹„$��H‰„$���„$��)„$€���„$˜��)„$@��„$¨��)„$P��„$¸��)„$`��„$È��)„$p��H·lýÿ¹���L‹¼$à���L‰ÿL‰öè I��H…ÀHDÐHDÃH¼$€��H‰Æè£-�¶„$€��<u?H‹„$à��Æ�H‹„$à���HƒxH�t
+H‹x@ÿsÈ�1ÛH¼$˜��èD9�éfßÿÿ³éÁ��I‰ÜˆD$ H‹„$��H‰„$Ï���„$��)„$À���„$˜��)„$ ��„$¨��)„$0��„$¸��)„$@��„$È��)„$P��Hækýÿ¹���L‹¼$à���L‰ÿL‰öè2H��H‰T$8H…ÀH‹L$8HDÈH‰L$8IDÄH‰D$pH¹kýÿ¹���L‰ÿL‰öèüG��H‰T$@H…ÀH‹L$@HDÈH‰L$@IDÄH‰D$xH’kýÿ¹���L‰ÿL‰öèÆG��H‰T$H…ÀH‹L$HDÈH‰L$IDÄH‰D$hHŸkýÿ¹���L‰ÿL‰öèG��H‰T$H…ÀH‹L$HDÈH‰L$IDÄH‰D$0Hwkýÿ¹���L‰ÿL‰öèZG��H‰ÓH…ÀHDØIDÄH‰„$¨���Hkýÿ¹���L‰ÿL‰öè-G��H‰$I‰ÅH…ÀH‹$IDÅH‰$MDìHåjýÿ¹���L‰ÿL‰öèüF��H‰T$H…ÀH‹L$HDÈH‰L$IDÄH‰D$(HÂjýÿ¹���L‰ÿL‰öèÆF��H…ÀHDÐH‰”$ ���IDÄH‰D$`H7&ýÿ¹���L‰ÿL‰öè—F��I‰ÆL‰l$XH‰œ$°���@ˆ¬$¸���H…ÀHDÐH‰T$PMDôH‹„$���H‰„$ß��(„$€���)„$Ð��(„$@��(Œ$P��(”$`��(œ$p��„$ç��Œ$÷��”$��œ$��(„$À���)„$À��H‹„$Ï���H‰„$Ï��(„$ ��(Œ$0��(”$@��(œ$P��)œ$0��)”$ ��)Œ$��)„$���H‹„$ ��H‰„$¯��(„$��)„$ ��(„$Ð��(Œ$à��(”$ð��(œ$���)œ$��)”$€��)Œ$p��)„$`��IƒH�t
+I‹@ÿÞÄ�H‹|$8L‹D$xL‹T$hL‹\$L‹|$0L‹d$H‹¬$¨���¶œ$¸���L‹¬$°���H‹4$H‹T$L‹Œ$ ���H‹„$È��H‹Œ$à��H‰€��„$˜��Œ$¨��”$¸��‘p��‰`��P��H‹„$è���HP X0`@hPp`H‹@pH‰ø��ˆ��‰˜��‘¨��™¸��¡È��©Ø��±è��H‹„$¯��H‰AP(„$ ��AA(„$`��(Œ$p��(”$€��(œ$��Y1Q!IA(„$À��AYH‹„$Ï��H‰Ah(„$���(Œ$��(”$ ��(œ$0��Ap‰€���‘���™ ���ˆ¶D$ ˆAXH‹D$pH‰°���H‰¹¸���L‰À���H‹D$@H‰È���L‰‘Ð���L‰™Ø���L‰¹à���L‰¡è���H‰©ð���L‰©ø���H‹D$XH‰���H‰±��H‹D$(H‰��H‰‘��H‹D$`H‰ ��L‰‰(��L‰±0��H‹D$PH‰8��Hf`ýÿH‰@��HÇH������Hƒ¼$���H‹„$è���…ÏÙÿÿHƒ8�…´ÙÿÿéÀÙÿÿH§°�H‰„$€��H5`±�L‹t$ëKHj±�H‰ßL‰æL‹t$èÂ!þÿé˜��HN±�L‰çL‹t$èÙþÿé��HU°�H‰„$€��H5ö°�H‹¼$Ø���HÇG���H¯_ýÿH‰GWÀGèÇ
þÿé=��H°�H‰„$€��H5Ì°�ëHû¯�H‰„$€��H5œ°�H‹¼$¸���HÇG���HU_ýÿH‰GWÀGèm
þÿéã��H™°�H‰îèù þÿéÏ��H…°�H‰ïH‹t$xèþÿé¶��H=ŽaýÿHÝ°�¾,���è“þÿé™��Hß°�H‰„$ð��ëXH=Þ^ýÿH°�¾+���L‹t$è`þÿéf��H=>aýÿH°�¾,���èCþÿéI��H·¯�L‰Çèþÿé5��L‰D$0L‰ïH‹t$0H‹”$ð��L‹t$è; þÿé��¿���¾ø���è‡þÿéý���HC°�H‰„$Ø���ëMH=B^ýÿHã¯�¾+���èÉþÿéÏ���¿���¾ø���èEþÿé»���H)¯�H‰÷L‰îèþþÿé¤���H‰t$0L‰÷H‹t$0H‹”$Ø���è¯ þÿé…���H=Û]ýÿHL¯�¾+���èbþÿëkH=Á]ýÿHJ¯�¾+���èHþÿëQH=§]ýÿH¯�¾+���è.þÿë7H=]ýÿH¯�¾+���èþÿë H³�L‰÷èÓ þÿë Hê²�èE þÿ ë$ë"ë ë H‰ÅH¼$€��è �é��è‘,þÿ ëH‰ÅëH‰ÅHƒ¼$`���t
H¼$h��èÝ•��H¼$Ð��è` �éÈ��H‰ÅH¼$���è[!�L‰ïL‰æè€#�1Ûëè7,þÿ H‰ÅH¼$À���è… �³A·Hƒ|$x�uë#è,þÿ H‰Å³E1ÿH‹$H‰D$@H‹|$@ÿã¾�ðIÿu
H¼$€��è`<��„Ût
H¼$���èß �³E„ÿ…¥��A¶é ���ëWH‰Åé“���H‰ÅIƒH�tH‹„$à���H‹x@ÿ†¾�H¼$˜��èY/�éˆ��H‰ÅéÞ��H‰ÅH¼$€��è\"�ë>èe+þÿ H‰ÅH¼$0��è£ ��é»��ëYH‰ÅL‹t$éá��H‰ÅH‰œ$¸��éè���H‰ÅH¼$ ��è/ �E1öH¼$À���èo �³E„ö„‘���éà��èú*þÿ é¡���H‰ÅéX��H‰ÅéÄ��H‰ÅH¼$€��èã;��é‡���èÉ*þÿ é��H‰ÅH¼$€��èÂ;��³éŒ��è¦*þÿ H‰ÅIÿÌtM·��L‰ÿèü�M‰÷ëçHƒ¼$È����t H‰ßÿc½�Hƒ|$ �H‹<$…!��é"��èY*þÿ éè���H‰Åéõ���H‰ÅH‹„$è���HƒxH�tH‹„$è���H‹x@ÿ½�H¼$è��èù.�³Ç„$°�������éè���è*þÿ H‰Å³°‰„$°���éÎ���H‰Åf. „�����IÿÎtM§��L‰ÿè<�M‰çëçHƒ¼$È����t6H‰ßÿ£¼�ë+è¬)þÿ H‰ÅL‰çÿŽ¼�H‹|$ÿƒ¼�H¼$À���èæ �Hƒ¼$ˆ����t&H‹¼$€���ëèl)þÿ H‰ÅL‰ÿÿN¼�L‰÷ÿE¼�Hƒ¼$���tH‹¼$���ÿ,¼�H‹„$ø���ðHÿ³u
H¼$ø���èŸ9��„Ût H‹„$à���Hƒ8�tHƒxH�t
+H‹x@ÿì»�€¼$°����H‹„$è���tHƒ8�tHƒxH�t
+H‹x@ÿû�H‹„$è��HƒxH�t
+H‹x@ÿª»�H‰ï貈� è«(þÿ ÌÌÌÌÌÌÌÌÌAWAVAUATSH‰ûL‹7L‹M…ÿt2MfL‹-m»�ëff. „�����IƒÄIÿÏtIƒ<$�tðI‹|$øAÿÕëæHƒ{�t L‰÷ÿ6»�L‹sL‹{(M…ÿt.MfL‹-&»�fffff. „�����I‹|$øI‹4$AÿÕIƒÄIÿÏuëHƒ{ �tL‰÷[A\A]A^A_ÿ%âº�[A\A]A^A_ÃÌÌÌÌÌÌÌÌSHƒì0HÿÇ„›���H‹cÍ�H �H9ùHGùHƒÿ»���HCßH¹Á 8�1öH9Ë@’ÆHiÓH��HÁæH…Àt"H‹
Í�HiÀH��H‰ $HÇD$���H‰D$ë HÇD$����H|$H‰áèH*ÿÿHƒ|$�H‹|$ tH¸������€H9ÇtH…ÿuèÂþýÿ H‰=¹Ì�H‰ ºÌ�HƒÄ0[ÃH‹t$(èâþýÿ UAWAVAUATSHìè���I‰×I‰öH‰û¶–���€úL…‘��Iƒ~P�tM‹¦p��M…ät&I‹†x��H‰D$hëAƆ���KIdž������é©��I‹/M‹nXI‹†X��HƒÀAF(„$ˆ���L‰´$˜���H‰„$ ���HÇ„$¨�������HÇ„$à�������H|$H´$ˆ���è´��¶|$¶t$ @€ÿKu7@„ötWHƒ¼$¨����„m��H´$¨���fAƒ~Jƒç���H|$Hº0!��éâ���‹L$
+·D$HÁà H ÈH‹L$º/���Hƒú/ué`��º.���Hƒú/„Q��H‰T$@ˆ|$@ˆt$‰D$HÁè f‰D$H‰L$Hƒú.u1ÀëAHuI‹Žˆ��A¶VIH¼$ˆ���LD$蜘��Hƒ¼$ˆ����H‹„$���H‹Œ$˜���…û���ðHÿE�H‹T$hŽ´��H‰+L‰kL‰cH‰SH‰C H‰K(L‰s0L‰s8L‰{@é`��H|$Hºv���èö�H‹D$HHƒø/u"òD$P‹L$R·D$VHÁà H Ⱥ/���H‹L$XëXƒø.uº.���ëLH‰D$HT$PH‹BHL$H‰AH|$0Ht$èÃ��H‹T$0òD$8‹L$:·D$>HÁà H ÈH‹L$@)D$p¶|$p¶t$qHƒú/…¯þÿÿ@¶×@¶öHÁæH ÖHÁàH ðA¶–���€úLuI‰†���I‰Ž��‰Â€úKu I‹¶��H…öt@H‹HƒÀHƒÆ±1ÒI‰öë7I‹†���A¶Ž��A‹– ��‰T$+A‹– ��‰T$(º���ë I‹HƒÀ1É1ÒH‰H‰CˆK‹D$(‹L$+‰C‰KL‰sHÇC0����HÄè���[A\A]A^A_]ÃH=dTýÿHu¨�¾+���èëþÿ ÌÌÌÌÌUAWAVAUATSHìx��I‰üHƒ:�t0H‹B¶J‹rA‰t$ ‹RA‰T$I‰D$AˆL$AÇD$���éB��H‰õH‹BH‰„$°���¶Bˆ„$��H‹BH‰D$`H‹ Hƒ»Ø���t Hƒ»à���„H��HÃà��H‰ØéP��H‰l$XHÇ„$P�����fïÀó„$X��HÇ„$ð������ó„$ø���H‹t$`H‹ŽX��HƒÁH‹V(H‹F0H‰”$��H‰„$ ��H‰´$(��H‰Œ$0��HÇ„$8������H…ÀH‰œ$@��„€��‹^HH‹Ž ��H‰Œ$¨���H‹”$°���HŠÀ���H°���¶ÿH‰¼$H��‰ßç�ÿ��‰¼$¸���‰ÝÁíH‹¾��H‰¼$ ���¶ûH‰¼$��fƒý“„$˜���HCÑH‰”$Ø���H‹Ž€��H‰Œ$Ð���¹���H‰L$hHŒ$€��H‰Œ$p��1ÉH‰L$P1ÉH‰Œ$à���H‹´$��H‹Œ$(��1Ò€yI”ÂH‹y0L‹A8IðM<ÐHy(I)ÿIƒÇHxÿLF1Ò1Éffffff. „�����E¶Hÿƒù?u
+A€ùƒ¢ ��E¶ÉE‰ÊAƒâIÓâL ÒE„ÉyƒÁIÿÀHƒÇÿrÊé ��L‰„$��H‰¼$ ��H…Òt H‹Œ$0��HBÿH;AsHkøpH9éŸ���HÿŒ$8��éà��H‹y°H…ÿ„
+��H‹I D·‡2��N Å����HÇÆÿÿÿÿff. „�����M…Ét1E1ÒH9”÷à��A•ÂA»ÿ���EGÓHÿÆIƒÁøA€útÕE¶ÂE…ÀuëL‰ÆHƒé‚¯ ��H‹¼÷8��ë‘H…ÿ„œ ��HkÆpHÇ€juHÿ„$8��fƒh.uGè™RþÿI‰ÕH…Ò„È��I‰ÆL‰d$pIÁåE1ä1ÀH‰D$H1ÀH‰„$È���1ÀH‰„$è���1ÀH‰„$���ëcèRRþÿI‰ÐH‹Œ$(��‹QHH¼$€��H´$��H‰ÁèÜÚ��¶„$€��<K„·��é_"��¸���H‰D$HH‹„$€���H‰$IƒÄM9å„Ê��óCo&fD$ H‹„$(��‹PHH¼$€��H´$��HL$ è#ª��ƒ¼$€��.„ƒ��·„$˜��ƒø„U��ƒø„–���ƒøUu•H|$ H´$€��è¾��H‹D$ H‹L$(Hƒø„Ê��ƒøH‹´$¨���…ó��H‹”$°���H‹‚À���H‹’È���H)ò‚t!��HðH¯Œ$H��H)Ê‚_!��Hȼ$¸������…û��Hƒú†p"��H‹�é��H|$xH´$€��ès½��H‹D$xH…À„ª��ƒø„��ƒø …ÒþÿÿH‹„$°���H‹HH‹@H‹”$ ���H)Ђ "��HÑH‰L$H‹Œ$€���H‹´$��H¯ÎH‰ÂH)Ê‚#��ÿ΃þ‡ #��HL$H=£ýÿHc4·HþÿæH9È„B#��H‹D$¶�H‰D$é��H|$xH´$€��è½¼��H‹D$xH…À„þÿÿƒø …%þÿÿH‹„$°���H‹HH‹@H‹”$ ���H)Ђ~ ��HÑH‰ $H‹Œ$€���H‹´$��H¯ÎH‰ÂH)Ê‚"��ÿ΃þ‡ß!��H $H=ýÿHc4·HþÿæH9È„Ê!��H‹$¶�H‰$é��fƒýº����HB”$¨���H‹„$°���€¸à����¸����HDÐHÊH‰”$À���é���1ÀH‰„$���é\ýÿÿ¸���H‰„$è���H‹„$€���H‰„$h��é:ýÿÿ¸���H‰„$È���H‹„$€���H‰D$éýÿÿHƒú‚µ ��·H¶¶@ˆT${ˆD$~f‰L$|‹D${HðH‰„$À���¸���H‰„$���éØüÿÿHƒú‚Ü���H‹$·�H‰$f‰D$!°Ké��Hƒú‚!��H‹$H‹�H‰$éÿ���Hƒú‚Ç���H‹$·B¶
+¶RˆL$#ˆT$&f‰D$$‹D$#H‰$°KéÂ���Hƒú‚Ï���H‹D$·�H‰D$f‰D$!°Ké��Hƒú‚ã ��H‹D$H‹�H‰D$éî���Hƒú‚¶���H‹T$·B¶
+¶RˆL$#ˆT$&f‰D$$‹D$#H‰D$°Ké¯���fÇD$ ��ÇD$"����ÆD$&�‹D$ ‰D$‹D$#‰D$ë$ÇD$ ����ÆD$&�fÇD$$��‹D$#‰D$ÇD$����°<K…Û ��¸���H‰D$HéûÿÿfÇD$ ��ÇD$"����ÆD$&�‹D$ ‰D$‹D$#‰D$ë$ÇD$ ����ÆD$&�fÇD$$��‹D$#‰D$ÇD$����°<K…G ��¸���H‰„$È���é)ûÿÿHƒ¼$����„A��H‹„$Ø���L‹ H‹@H‹”$À���H)Ђ ��H‹Œ$°���óoAIÔó„$€��H‹Œ$Ð���H‰Œ$��H‹Œ$ ���H‰Œ$˜��L‰¤$ ��H‰„$¨��f‰œ$°��f‰¬$²��¶„$˜���ˆ„$´��E1öH|$ H´$€��èNÛ��H‹D$ L‹l$(L‹d$0HƒøuoM9åsÔH‹t$PH;´$ø���u H¼$ð���è‡��H‹”$ð���H‹´$���ëH‹T$hHvL‰,ÂL‰dÂH‹Œ$à���H‰T$hH‰LÂHÿÆH‰t$PH‰´$���A¶éjÿÿÿƒøuyE‰îAÁîA€ýK…3 ��L‹d$pé ��Hƒ¼$È����H‹D$HtXH…ÀtSH‹D$H9$L‹d$pƒì���H‹t$PH;´$ø���…O��H¼$ð���èQ†��H‹”$ð���H‹´$���é2��L‹d$pé°���E1öHƒ¼$è����L‹d$p„™���H…À„���H‹$H‹Œ$h��L4L9ðsxH‹D$PH;„$ø���u,H¼$ð���H‹t$PèÜ…��H‹„$ð���H‰D$hH‹„$���H‰D$PH‹L$PHIH‹$H‹t$hH‰ÆL‰tÆH‹”$à���H‰TÆHÿÁH‰L$PH‰Œ$���é³���E1öA€æAöÆtSH‹´$à���H;´$X��uH¼$P��è è��H‹´$`��H‹„$P��H öL‰<ÈHÇDÈ����HÿÆH‰´$à���H‰´$`��H‹„$ ��H…À…Föÿÿé8��H‹T$hHvH‹ $H‰ ÂH‹L$H‰LÂH‹Œ$à���H‰T$hH‰LÂHÿÆH‰t$PH‰´$���A¶éHÿÿÿ°ë
+HÆ°1ÿI‰ðL‰„$��H‰¼$ ��H‹l$XˆD$(ÆD$)�fÇD$.��ÇD$*����H‰t$0HÇD$ ����M‰åHƒ¼$ø����tH‹¼$ð���ÿUª�H‹œ$P��L‹´$`��M…ötBL{(L‹%5ª�ë �IƒÇHIÿÎt)Iƒà�tðI‹èH…ÿtçIƒð�tAÿÔIƒ?�t×I‹øAÿÔëÎHƒ¼$X���t H‰ßÿê©�M‰ìéô��óo„$ˆ��óD$(éG ��1öé+ÿÿÿH‹„$ð���H‰$L‹l$PIƒýs Iƒý†µ��º���H‹<$L‰îèµÐ��éŸ��J����HƒàøH<@¶Q»�¾���èŸéýÿH…À„^ ��I‰Æ¶4»�¿���ÿi©�H‰„$���H…ÀL‰´$˜���„J ��H‹$HH0H‰Œ$À���HƒÀèH‰D$¸���H‰„$È���E1ÿHØ—�H‰„$è���1íL‰d$pë½���L‹l$PL‹|$HM9ïƒØ��L‰êL)úK4H‹$H<ðHƒúsKL‰îH‰óL)û‚Ž ��L9 ��sYHƒú
+sSI_
+L9ëICÝH‰\$HL)û‚ž ��HƒúHƒÒ�H‰ÞèžÏ��ë-H‹H‹OH9ÁƒC��Hƒú…M��Iwº���é��H‰t$HH;¬$È���u{M‰æH‰ïHÁç¶ º�¾���èZèýÿH…À„H ��I‰ÄHm����H‰„$È���H‰êHÁâL‰çH‰¬$ ���H‹¬$���H‰îÿ¨�H‰ïH‹¬$ ���ÿÚ§�L‰áM‰ôL‹´$˜���ëH‹Œ$���H‰èHÁàH‰ H‰Œ$���L‰|HÿÅHƒýƒŽ���é«þÿÿM‰çL‹´$˜���L‰öH‹œ$¸���I)õL‰ÿL‰êÿ›§�H‹„$H��H„$¨���H‹L$hH‰H‹„$à���H‹Œ$Ø���H‰HsH‹„$��H÷ÐHÅHÁåH‰ßH‰êÿf§�H‹¬$ ���HƒýL‹d$p†þÿÿHMÿH‰Œ$ ���HÁáL‹„$���I‹I‹LHÁH;L$PtLH‰êHÁâJ‹tàH9Æv;Hƒý†®��LMýL‰ÉHÁáI‹ H<H9ùv.Hƒý†–��HÎJ9tÀvé¦ýÿÿHƒýrLMýL‰ÉHÁáI‹ H9ÁrLMþL9͆M��IAH9ņ(��L‰ÉHÁáI‹|HÁàI‹�I‹t�HÖH‰óH)û‚\��H;t$P‡b��H‰”$H��L‰Œ$��IH‰”$¸���I‹I �H‰L$hID�H‰„$Ø���H‰¼$à���HH‹ $L<ÁHRM$ÇHvH‰„$Ð���I‰ÞI)ÖI9ÖH‰”$¨���ƒÐ���Jõ����L,@H‹œ$˜���H‰ßL‰æL‰êÿÁ¥�IÝHƒ¼$¨����ŽïýÿÿM…öH‹œ$¸���Ž:��H‹D$H‹Œ$Ð���HÈL‹´$˜���ffff. „�����I‹MèI‹T$èH9Ѿ����HöH9Ñ¿����Hƒ×ÿH9ÑH vM$ÌH MlÍ�L‰éIBÌH‹QH‰Póoó�M9üv HƒÀèM9õw§M‰çL‰öéjýÿÿHÕ����L,@L‹´$˜���L‰÷L‰þL‰êÿñ¤�H‹„$¨���MõH…ÀŽ(ýÿÿH9ÃŽ ýÿÿH‹$H‹Œ$Ð���HÈL‰öH‹œ$¸���I‹$1ÿ1ÉH;@“Ç’ÂI‰ðMBÄM‹HM‰OóAo�óAIƒÇH<H4þL9îƒÎüÿÿˆÑH IM$ÌI9Är±éºüÿÿM‰çL‹´$˜���L‰öé§üÿÿHƒúu;Iwº���éQûÿÿL‹„$À���Mð¾���I‰ÉM‰ÊM‹M9Ñs<HÿÆIƒÀH9òuéë+L‹„$À���Mð¾���I‰ÉM‰ÊM‹M9ÑrHÿÆIƒÀH9òuéH‰ÖN>H‰òL‰ÆH9ÁƒãúÿÿI9÷‡]��L9î‡=��Hƒú‚ÇúÿÿI‰ñH‰ÐHÑèI H IH‹t$H ÎH‰þL‹FL‰„$��)„$€��L‹AL‰FL‹„$��L‰Afo„$€��óHƒÆHƒÁèHÿÈuµL‰ÎéWúÿÿ½���é úÿÿ½���éúÿÿH‹¼$���H‹ ø¢�ÿÓL‰÷ÿÓL‰åL‹¼$P��H‹„$X��L‹¤$`��L9àvCM…ätCHÁàH4ÀJå����H Àº���L‰ÿH‰ÙèãýÿI‰ÆH…Àu&¿���H‰Þèsçýÿéì��M‰þëL‰ÿÿ€¢�A¾���L‹¼$ð���H‹„$ø���L‹¬$���L9èv@M…ít@HÁàH4@Jí����H @º���L‰ÿH‰Ùè¤âýÿH…Àu%¿���H‰Þèçýÿé{��L‰øëL‰ÿÿ¢�¸���L‰t$ L‰d$(H‰D$0L‰l$8I‰ìH‹l$XH‹œ$@��Hƒ»Ø���„��H|$ ènß��Hƒ»à���…¸ëÿÿ¶‹è��H‹ƒð��€ùK…ˆ���L‹mH‹HH…ÉtsH‹PE1ÿ¾���E1ÀH‰Ïë „�����H‰ÏL)Á†€��HÑéLÁL IN;lÊAº����A€ÒÿN9,ÊE¶ÒDGÖA€útÉE¶ÂAøÿ���u@HÿÁI‰ÈH‰ùL)Áwºé5��E1ÿé-��‹“é��‹³ì��A‰t$A‰T$AˆL$I‰D$é¨êÿÿL‰d$pJ‹|ÊH‹pH9÷ƒv��H‹�H ÿL4ÈIƒÆHƒ|È�…«��L‰4$H‹ ÈH‹L$`H‹Q0H‹A8D¶qI1ÉA€þ”ÁH‰ÆH)ÖH4ÎHƒÆH‰ßH)÷H‰œ$p��‚ë���I‰ÑI)ù†ß���L‹}H Í���L‹\$`M‹S(I‹³X��LFL×H‰¼$��L‰Œ$ ��L‰œ$(��L‰„$0��HÇ„$8������LÒH‰ßH÷×HÏHÇI‰ÙI)ÉI)Á1À1ÉF¶
+ƒù?uA€úwnE¶ÒE‰ÓAƒãIÓãL ØE„Ò‰ò��ƒÁHÿÏIÿÁuËA´ëGóoD$ óoL$0ó‹ð��óƒà��HǃØ�����Hƒ»à���…—éÿÿéÚýÿÿA´81ÛE1ÿë
A´1ÛE1ÿH‰T$`L‹4$Iƒ>�uZH‰l$XE1öH‹$L‰pI‰ÆHÁãA¶ÇHÁàH ØA¶ÌH ÁI‰NH‹D$`I‰FI‰n H‹„$p��I‰F(I‰v0I‰V8IÇ���H‹l$XIƒ~�tIƒÆM‰÷L‹d$pëA¶FM‹~<KL‹d$p…Q��H‹]�½���ƒ{`/„Ã��Hƒ»°���uuHs`L´$€��L‰÷èƒQ��H¼$��H‰ÞL‰òH‹Œ$°���è˜U��Hƒ»°���tH¼$��èu��ë-óo„$��óoŒ$(��ó‹È��óƒ¸��Hǃ°�����Hƒ¸��H‹À��Hƒ»¸���HDÁu¶H‹HHƒúK…e��H‰ÈH…À„ ��H‹HH‹PH…ÒtwE1É¿���H‰ÖI‰Ðëfff. „�����I‰ðL)ÎvJHÑîLÎI‰òIÁâN;lA»����A€ÓÿN9lE¶ÓDG×A€útÉE¶ÊAùÿ���uHÿÆI‰ñL‰ÆL)Îw¶M…É…‡��1öH9ÖskI‰ðIÁàJ‹|H…ÿtZN‹E1ÒA¹ÿ���I‰ûëI‰ûL)×v7HÑïL×L41ÛO9,ð•ÃABÙ€ûtÜD¶ÓAúÿ���uHÿÇI‰úL‰ßL)×wÉIƒêL‰×s1ÿH9Öƒ
+��IÿÅI‰ñIÁáN9l ƒõ���J;| ƒ†���LÉH‹ H<L9,ùƒÖ���H‹TùH;Pƒ ��H‹�H4RH‹ðH‹tðé��·p¶xÁç ÷‹@HÁç(HÁàH øH ÐI‰D$I‰L$éOæÿÿA‹NA‹VA‰T$A‰L$AˆD$M‰|$é.æÿÿLFI9Ðt[M‰ÂIÁâIÊ1ÿI9ÐLC×A¸���I)ÐHƒÆIÉIƒÁ@L‰ÑL9is+Hƒy�…9ÿÿÿH9Ö¹����IBÉM0IÿÂHÿÆIƒÁ IƒúuÏM‰<$A‰l$A‰D$ I‰L$óAD$HÄx��[A\A]A^A_]ÃJ
+HÿÁH‰Œ$��H‰¼$ ��H…À„°��HHÿH;N s HkùpI8é»���H‹~(A´H…ÿ„×��H‹N0ºÿ���D·‡2��N Å����HÇÆÿÿÿÿM…Ét+E1ÒH9„÷à��A•ÂDGÒHÿÆIƒÁøA€útÛE¶ÂE…ÀuëKL‰ÆHƒé‚z��H‹¼÷8��ë¢1Ò‹Dù‹Lù1í…À@•Å1ÿ…É@•ÇHÁá H ùfHnÎfHnÂflÁéóþÿÿH…ÿ„3��HkÆpHÇL‰|$P€ju HÇ„$8�����H‰l$Xè0:þÿI‰Ç¶„$��‰„$��H…Ò„��I‰ÔH‹D$`H‹€ˆ��H‰„$¨���IÁä1ÛHl$ 1ÀH‰D$Hë'ƒø„Ø���ƒø1u Hƒ|$H�„#��HƒÃI9Ü„¶��óAo fD$ H‹„$(��‹PHH¼$€��H´$��H‰éèô‘��ƒ¼$€��.„’��·„$˜��ƒøF~ƒøGt˜ƒønt= ��u˜H‰ïH´$€��èØ¥��A¶ÖH|$xH‹´$°���H‹Œ$¨���I‰èèz��Hƒ|$x�…[ÿÿÿH‹„$ˆ���H‰„$À���H‹„$€���H‰D$Hé9ÿÿÿHƒ|$H�…-ÿÿÿH‰ïH´$€��èm¥��A¶ÖH|$xH‹´$°���H‹Œ$¨���I‰èèœy��Hƒ|$x�u{H‹„$€���H‰D$HH‹„$ˆ���ësH‰ïH´$€��è ¥��H‹t$ H‹T$(H|$x‹Œ$��L‹D$`L‹L$Pjÿ´$¸���èè��HƒÄHƒ|$x�H‹„$€���H‰D$HH‹„$ˆ���t éK
+��1ÀH‰D$HH‹„$ ���H‰„$ ���H‰„$À���éUþÿÿ1ÛE1ÿ1ÀH‰D$`éAùÿÿ1ÀH‰D$HHÇD$x���fïÀó„$€���HÇD$ ���óD$(HD$ LT$xL´$€��H´$��L‰÷1Ò‹Œ$��L‹D$`L‹L$Pj�PARÿ´$È���è—Ö��HƒÄ H‹l$XD¶¤$€��A€üKu@H‹D$ H‰„$Ø���L‹|$0Iƒÿƒ¬���Iƒÿ†8��º���H‹¼$Ø���L‰þèTæ��é ��D¶¼$��‹œ$‚��D·´$†��H‹„$ˆ��H‰D$`Hƒ|$(�t H‹|$ ÿÆ—�IÁæ Hƒ¼$€����t H‹|$xÿ¬—�L óé!øÿÿL‹¤$ˆ��H‹„$��E‰çAÁïL‰ãHÁëH‰D$`H‹l$Xéô÷ÿÿL‰øHÁàH¿àÿÿÿÿÿÿH!Ƕ4©�¾���è‚×ýÿH…À„u ��H‰ÃL‰´$h��¶©�¿���ÿD—�H…ÀH‰\$h„d ��H‰ÅH‹„$Ø���HHPH‰Œ$è���HƒÀàH‰„$���¸���H‰„$È���1ÉHµ…�H‰„$x��E1äL‰¼$@��L‰¬$Ð���ëL‹t$hH‹L$L9ùƒÃ��I‰ÎL‰øH)ÈHÁáH‹”$Ø���H<
+Hƒøs H‰ÂJ 2é��H‹w0H;wr L‹G w?L;s:º���HƒøruHŒ$è���ë HÿÂHƒÁ H9Ðt\I‰ðH‹1L9ÆréwRL‹AÐL9AðrÝëFº���HƒørHŒ$è���ëHÿÂHƒÁ M‰ÈH9ÐtI‰ñH‹1L9΂uÿÿÿL‹IðwÜM9Ás×éeÿÿÿH‰ÂH‰ÑLñ‚r
+��L9ù‡R
+��HƒúrhH‰ÐHÑèI‰ÈHÁáHŒ$���H‰þN)Œ$��)„$€��INfo„$€��foŒ$��óIóHƒÆ HƒÁàHÿÈu³L‰ÁH‰ËL)ó‚Y ��L9ù‡P ��s1Hƒú
+s+I^
+L9ûICßH‰\$L)ó‚€ ��HƒúHƒÒ�H‰Þè|ã��ëH‰L$L;¤$È���uWL‰çHÁç¶å¦�¾���è3ÕýÿH…À„O ��I‰ÇK$H‰„$È���L‰âHÁâL‰ÿH‰îÿ�•�H‰ïÿÏ”�L‰ýL‹¼$@��L‰àHÁàH‰\�L‰tIÿÄIƒü‚ÞýÿÿL‹t$hH‰¬$˜���é‘���I‰ÔL‰ýL‰öL‹¬$Ð���H)óH‰ïH‰Úÿœ”�H‹„$ ���LàH‹Œ$à���H‰H‹„$��H‹Œ$H��H‰H‹¼$��HwH‹D$PH÷ÐH‹”$¨���HÂHÁâÿb”�L‹d$`IƒüH‹¬$˜���L‹¼$@��†è��M‰áMD$ÿL‰ÁHÁáH‹D
�H‹L
HÁL9ùtML‰ÊHÁâH‹t*àH9Æv<Iƒù†·��MQýL‰ÑHÁáH‹L
�H<H9ùv/Iƒù†Ÿ��HÎH9t*Àvé›��IƒùrMQýL‰ÑHÁáH‹L
�H9ÁrMQþM9ц·��L‰D$`IBI9Á†½��L‰ÑHÁáH‹|
HÁàH‹T�L‹dIÔM‰æI)þ‚Ø��M9ü‡ã��H‰”$ ���L‰T$PL‰Œ$¨���H)H‰”$��H‹T
�HL�H‰Œ$à���HDH‰„$H��H‰¼$��H‰ýHÁåH¬$Ø���H‰ÓHÁãL<+IÁäM‰õI)ÕH‰”$¸���I9ÕƒÁ���L‰ëHÁãL‹t$hL‰÷L‰þH‰Úÿ¹’�LóH‹”$¸���H…ÒŽéýÿÿM…íŽàýÿÿL¤$���L‹¬$Ð��� @�I‹GðH9CðsIƒÇàë3–ÀH‹KàI;Oà’Á Á¶ÁH‰ÁHÁáI)Ï4¶ÈH‰ÈHÁàH)ÃH‰Ø„ÉuL‰øóo�óoHóAL$óA$I9ïv IƒÄàL9ów–I‰ÔL‰ýéÀ���L‹l$hL‰ïH‰îH‰Úÿÿ‘�LëL‹„$¸���M…ÀL‹¬$Ð���Žˆ���M9ÆŽ���L¤$Ø���L‹t$hL‰öfI‹OH‹VH9ÑrI‹H;@’Ç1ÀH9ÑwJH‰ñ@öÇt°L‰ùóoóoIóMóE�HƒÅ ‰Á€ñ¶ÉHÁáHÎH9Þs&¶ÀHÁàIÇM9çršëH‰ñë¿M‰ÄL‹t$hL‰öé üÿÿM‰Äé˜üÿÿA¼���éMúÿÿA¼���éBúÿÿA¼���é7úÿÿM‰Ìé/úÿÿH‰ïH‹ è�ÿÓL‰÷ÿÓL‹|$xH‹„$€���L‹¤$ˆ���L9àvFM…ä„‘���HÁàH4@L‰àHÁàH @º���L‰ÿH‰Ùè ÑýÿI‰ÆH…Àuu¿���H‰ÞèfÕýÿéß��M‰þë^¹���L‹d$pH‹l$Xé«��H‹Œ$��H‹”$ˆ��H‰T$0H‰L$)ˆD$(HÇD$ ����H‹l$XéÆåÿÿH‰L$é®��L‰ÿÿ$�A¾���L‹|$ H‹t$(H‹l$0H9îv?H…ítAHÁæH‰ëHÁãº���L‰ÿH‰ÙèZÐýÿH‰ÁH‰D$`H…Àu,¿���H‰Þè°Ôýÿé)��L‰|$`ëL‰ÿÿ»�¸���H‰D$`H‹$Hƒ8�t0M…ät L‰÷ÿ™�H…íH‹l$XL‹4$„hðÿÿH‹|$`ÿ|�éXðÿÿE‰çAÁïL‰ãHÁëH‹”$À���H‹t$HéæïÿÿH‰L$éœ��ÆD$~�fÇD$|��ÇD$x����H‰D$H‹L$x‹„$€���‹”$ƒ���‰D$‰T$H‰L$H‹D$ë>ÇD$x����ÆD$~�fÇD$|��‹L${‰L$ÇD$����¶L$Áá·T$ ÊHÁâ ‹L$H ÑL‹d$pH‹l$XHÁáHƒÉH‰L$(H‰D$0é4äÿÿL‹d$Hé÷ÿÿˆ\$°ë ÆD$�fÇD$��ÇD$����H‹$H‰D$°H‹L$H‰ $‹L$‹T$‰T$,‰L$)ˆD$(H‹$éË���ÆD$&�fÇD$$��ÇD$ ����H‹$H‰D$'H‹D$ ‹L$(‹T$+‰L$‰T$H‰D$ëŸAµE1ö1Àé·���ˆ\$°ëZÆD$&�fÇD$$��ÇD$ ����H‹D$H‰D$'H‹D$ ‹L$(‹T$+‰L$‰T$H‰D$ë ÆD$�fÇD$��ÇD$����H‹D$H‰D$°H‹L$H‰L$‹L$‹T$‰T$,‰L$)ˆD$(H‹D$H‰D$0HÇD$ ����L‹d$pH‹l$XéþâÿÿH�èÚýÿ L‰èHÁèDˆl$(Dˆt$)‰D$*HÁè f‰D$.L‰d$0ëµHm{�H‰„$€��H5&|�ëHU{�H‰„$€��H5ö{�H‹¼$p��HÇG���H¯*ýÿH‰GfïÀóGèÅØýÿé>��Hñ{�èTìýÿé-��Hà{�H‰÷H‹t$Pèkâýÿé��Hçz�H‰„$€��H5ˆ{�ëHÏz�H‰„$€��H5ˆ{�H‹¼$h��HÇG���H)*ýÿH‰GfïÀóGè?Øýÿé¸��Hk{�L‰æèËëýÿé¤��HW{�L‰çH‹´$@��èßáýÿéˆ��H=],ýÿH¬{�¾,���èbåýÿék��H=@,ýÿH{�¾,���èEåýÿéN��L‰ÿHŽ{�H‰„$è���é ���H=Š)ýÿH+{�¾+���èåýÿé��H]{�H‰„$x��ë9H=\)ýÿHýz�¾+���èãäýÿéì���HWz�H‰ÏL‰þè,áýÿéÕ���H‰L$L‰÷H‹t$H‹”$x��èÝêýÿé¶���H!z�H‰÷L‰îèöàýÿéŸ���L‰ÿH‰t$HH‹t$HH‹”$è���è§êýÿé€���H=Ó(ýÿHä~�¾+���èZäýÿ H=¹(ýÿH*z�¾+���è@äýÿëLH=Ÿ(ýÿH(z�¾+���è&äýÿë2H=…(ýÿHöy�¾+���è äýÿëH=k(ýÿHôy�¾+���èòãýÿ H‰ÃL‰ÿÿ”Š�M…ä…£��é§��H‰ÃL‰ÿÿzŠ�@µé���H‰ÃéB��H‰Ãéã���H‰Ãé$��H‰Ãé*��H‰Ãé"��H‰ÃéÎ���é²���éñ���H‰ÃL‰ÿÿ,Š�M…ä„D��M~(L‹-Š�ë
IƒÇHIÿÌ„!��Iƒà�tìI‹èH…ÿtãIƒð�tAÿÕIƒ?�tÓI‹øAÿÕëÊH‰ÃMw(L‹-Ò‰�ë IƒÆHIÿÌt)Iƒ~à�tðI‹~èH…ÿtçIƒ~ð�tAÿÕIƒ>�t×I‹~øAÿÕëÎL‰ÿÿ•‰�@µëjH‰ÃëcH‰ÃH‰ïÿ‰�H‹|$hÿt‰�1íHƒ|$(�t H‹|$ ÿ_‰�Hƒ¼$€����”À@ÅuoL‹t$xë_H‰ÃH‹¼$���ÿ6‰�H‹¼$˜���ÿ(‰�1íHƒ¼$ø����tH‹¼$ð���ÿ
‰�@„íu)L‹´$P��L‹¼$`��M…ÿu Hƒ¼$X���t L‰÷ÿ߈�H‰ßèçU� Mf(L‹-ʈ�ë „�����IƒÄHIÿÏtÄIƒ|$à�tïI‹|$èH…ÿtåIƒ|$ð�tAÿÕIƒ<$�tÓI‹|$øAÿÕëÉÌÌÌÌÌÌÌÌÌUAWAVAUATSHì8��I‰×I‰öH‰ûLN0Hƒ~0�„¶���I‹I‹NI‹VI‹vI‹~ H‰{ I‹~(H‰{(H‰SH‰sH‰H‰KAAIAQ )”$€���)L$p)D$`AAOAW A_0)„$���)Œ$ ���)”$°���)œ$À���AG@)„$Ð���I‹GPH‰„$à���HƒÃ0Ht$`ºˆ���H‰ßÿ·�é‘��L‰L$PA€P�I‹/M‹^M‹VA‹NE‹F I‹v tM‹&ƒù…B��A¹���é��H‰l$H‰t$L‰ $M‹o0I‹oHI‹W I‹w(I‹I‹GH‰D$M‹g8I‹L\$`ƒù„—��H…À…��ƒù…¥��M9å„��IƒÄàëf D��ID$àM9ìI‰Ä„ú��I9l$†ä��I;T$sÝI;4$v×H‰t$0H‰T$8M‰g8H‰øI‹|$H‹p H9÷ƒÅ��Hi÷��H‰D$HHpL‰ßH‰t$H‹T$è’ÌÿÿH‹L$H‰Œ$ ��H‹D$H‰„$0��H‹D$H‰„$(��H‹„$���H‰D$(H…ÀtPD$`L$p”$€���)”$��)Œ$���)„$ð���H‹„$˜���H‰D$ H‹„$ ���H‰D$@H‰L$XL‹L$ë H¼$ð���H´$ ��HT$`è_ÏÿÿL‹L$L‹”$ð���H‹Œ$ø���I‰ÈIÁè H‹´$���H‹”$��H‹¼$��L‹œ$��L‰ÐM‰I‰NH‰4$I‰vI‰ÒI‰VH‰|$I‰~ M‰^(H‹t$(I‰v0H‹T$ I‰V8H‹T$@I‰V@H‹T$XI‰VHL‰L$M‰NPH‹T$I‰VXH…öL‹L$PH‹T$8H‹t$0H‹|$HL\$`„þÿÿéÙüÿÿM…ä„Y��H‰t$H‰L$HÇD$`���WÀD$hI‹L$H…É„C��M‹l$I‹$H‰D$@I‹D$H‰D$(¸���1öL‰D$L‰T$8L‰ $L‰d$0I‰Ì1ÒH‰L$HëL‰áI‰ÌI)Ô†Î���IÑìIÔL‰çHÁçN/I9t=wÙrI9(wÒI‰éI9hwIÿÄL‰âëÄI‹T=H‰ÑH‰T$ H;T$(ƒˆ��H;t$huH|$`訪��H‹D$`H‹t$pH‹L$ H IHÁáHL$@H‰ ðHÿÆH‰t$pIÿÄL‰áHÁáIÍH‹L$HL)áL‹D$L‹T$8L‹ $L‹d$0…6ÿÿÿëGM‰g8AÆGPëM‰o8E1äA¹���é���L‹D$L‹T$8L‹ $L‹d$0ëƒùubA¹���E1äéOüÿÿ1öH‹L$`H‹T$hL4ñI‹wI‹H‹?HƒÇL‹L$L‹|$ëJA¹���L‹ $I‰Äë;L‹ $I‰ÄH‹l$éNþÿÿL‹ $H‹t$L‰Ð‰ÉM‰×M‰ÚL‰ÀHÁà H ÈA¹���E1äI‰ÃD‰ D‰CL‰[L‰SL‰{H‰s H‰{(L‰c0H‰K8H‰S@H‰KHL‰sPƃ°���HÄ8��[A\A]A^A_]ÃE1äA¹���L‹ $ë©Hpv�èƒÏýÿëH’v�H‹|$ H‹t$(èkÏýÿ ëëH‰ÃHƒ|$h�tH‹|$`ÿ¯‚�ëH‰ÃH‹D$PHƒ8�tI‹ðHÿuL‰÷è ���H‰ßè–O� èïýÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌAVSPH‰ûL‹7I‹†à���H…ÀtðHÿu I¾à���èØÿÿÿI‹¾è���H…ÿtðHÿOðu HƒÇðè¼2��H‹;HƒÿÿtðHÿOu
HƒÄ[A^ÿ%‚�HƒÄ[A^ÃH‰ÃIÆè���L‰÷è%¨��H‰ßèýN� èöîýÿ ÌÌÌÌAVSPH‰ûH‹‡à���H…ÀtðHÿu H»à���èKÿÿÿH‹»è���H…ÿtðHÿOðuHƒÇðHƒÄ[A^é(2��HƒÄ[A^ÃI‰ÆH‹»è���H…ÿtðHÿOðu HƒÇðè2��L‰÷èyN� èrîýÿ AWAVAUATSH‰óI‰þL‹~L‹oM…ítI‹A€|ÿ/•Àë1ÀL‹#M…ÿt A€<$/uE1íë)„Àt)M9nuº���L‰÷L‰îèFðþÿM‹nI‹BÆ(/IÿÅM‰nI‹FL)èL9øsL‰÷L‰îL‰úèðþÿM‹nI‹>LïL‰æL‰úÿë€�MýM‰nHƒ{�tL‰ç[A\A]A^A_ÿ%£€�[A\A]A^A_ÃI‰ÆHƒ{�t L‰çÿ†€�L‰÷èŽM� ÌÌÌÌÌÌÌÌÌÌÌÌAVSHƒì8HÿÆ„’���H‰ûH‹GH �H9ñHGñHƒþA¾���LCö1öL‰ñHÁé;@”ÆL‰òHÁâHÁæH…Àt H‹ HÁàH‰L$HÇD$���H‰D$ë HÇD$����H|$ HL$èïïþÿHƒ|$ �H‹|$(tH¸������€H9ÇtH…ÿuèiÄýÿ H‰;L‰sHƒÄ8[A^ÃH‹t$0èŽÄýÿ ÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHì���HÇ$����Hì���HÇ$����Hì8 ��H‰L$H‰$H‰t$ L‹H‰|$H‹oH…턳���H‹D$H‹X H…Û„”���H‹H(H‰L$L‹h0H‹@8H‰D$(I‰îIÁæM‰üëf „�����IƒÄ@IƒÆÀtlA‹$LêríH‰ßH‹t$H‹L$(è{LþÿH…ÀtÖH;T$uÏH‰ÇH‹4$H‹T$ÿ�…Àu¹Aƒ|$…¨��E1ÿAöD$ L5e ýÿME÷ë'H‰èHÁàHƒÀÀuú¸.debH‹$3¹bug_3J ÁtE1öL‰ðL‰úHÄ8+��[A\A]A^A_]Àz¿Ž��H…ítÖH‹D$L‹h M…í„#��Hƒ$H‹L$HƒÁùH‰L$H‹X(L‹`0L‹p8HÁåë fIƒÇ@HƒÅÀt“A‹LârîL‰ïH‰ÞL‰ñèKþÿH…ÀtÛHƒúrÕH¹.zdebug_H9uÆHÿÊH;T$u¼HƒÀH‰ÇH‹4$H‹T$ÿþ}�…Àu¢Aƒ„4ÿÿÿH‹|$H‹OI‹WI‹G H)Ñ@’ÆHH9Á’Á1Û@ñHDÚ…ÿÿÿE1äHƒèLCà‚óþÿÿH;ZLIB…æþÿÿIƒü‚ÜþÿÿIƒÄü‹sHƒÃ ÎH‹|$ èØ¡��I‰ÆI‰×H‰ßL‰æH‰ÂL‰ùè‘¢��„À„¦þÿÿé¤þÿÿHÁåHƒÅÀuúé’þÿÿH‹T$H‹BI‹\$M‹|$ H)Ø’ÁHL9ø’ÀE1öÈIEÞ…dþÿÿAöD$ uI‰ÞéTþÿÿIƒÿ‚Gþÿÿƒ;…>þÿÿIƒÇèH‹sHƒÃH‹|$ è;¡��I‰ÆI‰ÔLl$H1íºê*��L‰ï1öÿÖ|�H|$0L‰îH‰ÚL‰ùM‰ðM‰áè þÿL3|$0L‰àH3D$@L øLEõ€|$8�LEõM‰çéÐýÿÿL±y�º���H‹<$H‹L$H‰ÎèCîýÿ ÌH‹VH…ÒtWUAWAVAUATSHì¨���L‹.HƒúrED¶ND·VD¶^D‹FLrüIEE‹e�Aƒü���Aƒüÿ„��A¾���1ÉëHÇ���ÃL‰éHá�ÿÿÿA¾���L‰ðHÁèfHnÀf„$���D¶Œ$–���¶”$•���D¶„$”���D¶œ$“���¶œ$’���D¶”$���¶¬$‘���éÑ���D‰ã@µI)Þ‚ ���H H‰L‰vHƒû†‹���@ˆl$DˆL$ŽHkþLhD¶¶HHÁáF< L‰L$ÈAÉAƒÁþfAƒùƒ.��D‰|$ÈAƒüð‚F��Hƒý†@��LcöH‹HHƒÀ
+I‰ÅéY��Iƒþ‚¼���LrôI‹]IƒÅ @µL‰èI)Þƒ`ÿÿÿH‰ÁHá�ÿÿÿA¶E1Ò1í1ÛE1ÛE1À1ÒE1ÉA‰ÅHá�ÿÿÿA¶ÅH ÈH
4ýÿH‰HÇF����DˆwDˆO¶ËA¶óÁæ ÎA¶ÊD¶ÍAÁáA ÉfAnÁfÄÆf~G A¶È¶ÒÁâ Êf‰W
H‰GHÇ���HĨ���[A\A]A^A_]ÃÆD$–�fÇD$”��ÇD$����H‰D$—L‹l$H%�ÿÿÿM‰îIÁæIÁí8IƒÎH‰Áé þÿÿfAƒÿ…ï���H…í„ó���Hƒû…à��HƒÀéýþÿÿHƒý‚f��LcúLh·HD¶H¶@DˆL$“ˆD$–f‰L$”‹L$“M…äD¶L$Ž¶D$„›���H‰Œ$ ���IÿÌE¶}�IÿÅ1ɉÅL)òHVAÁãE ÚIÁâ M ÐHÇ����DˆOL‰ÂHÁê0ˆWL‰ÂHÁê f‰W
D‰G H‰OH‰GH‹L$¸H‰O L‰o(L‰g0H‰_8H‹Œ$ ���H‰O@DˆH@ˆoI‹D$Èf‰GJé¹þÿÿA¶L‹l$Èé?þÿÿL‰éHá�ÿÿÿA¶E1Ò1í1ÛE1ÛE1À1ÒE1ÉéþÿÿÆD$–�fÇD$”��ÇD$����L‰l$—H‹D$fHnÀ‹L$˜‹T$›‰L$¨‰T$«H‰D$ fD$ðD¶L$ö¶T$õD¶D$ôD¶\$ó¶\$òD¶T$ð¶l$ñL‹l$§ëUÇD$����ÆD$–�fÇD$”��‹D$“‰D$£ÇD$ ����ó~D$ f$D¶L$¶T$D¶D$D¶\$¶\$D¶$¶l$L‰éHá�ÿÿÿA¶éHýÿÿE‰ù¶HH‰L$¸HKüLhD¶xAƒüðr7Hƒù¶l$†é���Dˆ|$D‰L$ÈHKôH‰L$°H‹HH‰Œ$ ���HƒÀ I‰ÅëMHƒù¶l$‚ ��Dˆ|$D‰L$ÈHKøH‰L$°Lh·HD¶H¶@DˆL$“ˆD$–f‰L$”‹D$“H‰„$ ���1ÉL‹L$¸AÿÉAƒù‡¯��HÛßüÿNc ˆIÁAÿáH‹D$°Hƒø†æ��LHøIMI‹E�AƒüðH‰D$À‚k��Iƒù†��L‹d$°IƒÄðI‹EH‰D$¸IƒÅé„��ÆD$–�fÇD$”��ÇD$����L‰l$—H‹D$fHnÀ‹L$˜‹T$›‰L$¨‰T$«H‰D$ fD$pD¶L$v¶T$uD¶D$tD¶\$s¶\$rD¶T$p¶l$qéþÿÿÇD$����ÆD$–�fÇD$”��‹D$“‰D$£ÇD$ ����ó~D$ f„$€���D¶Œ$†���¶”$…���D¶„$„���D¶œ$ƒ���¶œ$‚���D¶”$€���¶¬$���éùýÿÿ¹���D¶L$ŽL‹d$°D¶|$éuüÿÿL‹d$°Iƒü†��IƒÄøM‹M�IƒÅ¹���ë L‹d$°Iƒü†L��IƒÄøM‹M�IƒÅ¹���L‰ÈD¶L$ŽD¶|$é üÿÿA¶?éÚúÿÿH‹D$°Hƒø†v��LHøIMI‹E�AƒüðH‰D$À‚
+��Iƒù†È��L‹d$°IƒÄðI‹EH‰D$¸IƒÅé#��ÆD$–�fÇD$”��ÇD$����L‰l$—H‹D$fHnÀ‹L$˜‹T$›‰L$¨‰T$«H‰D$ fD$0D¶L$6¶T$5D¶D$4D¶\$3¶\$2D¶T$0¶l$1éküÿÿÆD$–�fÇD$”��ÇD$����L‰l$—ó~D$Iå�ÿÿÿfD$ÐD¶L$Ö¶T$ÕD¶D$ÔD¶\$Ó¶\$ÒD¶T$жl$ÑA¶L‰é¶D$×A‰Åé»ùÿÿÆD$–�fÇD$”��ÇD$����L‰l$—ó~D$Iå�ÿÿÿfD$àD¶L$æ¶T$åD¶D$äD¶\$ã¶\$âD¶T$à¶l$áA¶L‰é¶D$çA‰ÅéUùÿÿÆD$–�fÇD$”��ÇD$����L‰l$—H‹D$fHnÀ‹L$˜‹T$›‰L$¨‰T$«H‰D$ fD$`D¶L$f¶T$eD¶D$dD¶\$c¶\$bD¶T$`¶l$aé5ûÿÿIƒù‚m��L‹d$°IƒÄôA·M E¶MA¶m IƒÅ DˆL$“@ˆl$–f‰L$”‹D$“H‰D$¸¹���ëCIƒù‚‡��L‹d$°IƒÄôA·M E¶MA¶m IƒÅ DˆL$“@ˆl$–f‰L$”‹D$“H‰D$¸¹���D¶L$Ž¶l$D¶|$H‹D$Àé…ùÿÿÆD$–�fÇD$”��ÇD$����H‰L$—H‹D$fHnÀ‹L$˜‹T$›‰L$¨‰T$«H‰D$ fD$D¶L$¶T$D¶D$D¶\$¶\$D¶T$¶l$é(úÿÿÆD$–�fÇD$”��ÇD$����H‰L$—H‹D$fHnÀ‹L$˜‹T$›‰L$¨‰T$«H‰D$ fD$@D¶L$F¶T$ED¶D$DD¶\$C¶\$BD¶T$@¶l$Aé¾ùÿÿÇD$����ÆD$–�fÇD$”��‹D$“‰D$£ÇD$ ����ó~D$ fD$ D¶L$&¶T$%D¶D$$D¶\$#¶\$"D¶T$ ¶l$!I‰Íé»ùÿÿÇD$����ÆD$–�fÇD$”��‹D$“‰D$£ÇD$ ����ó~D$ fD$PD¶L$V¶T$UD¶D$TD¶\$S¶\$RD¶T$P¶l$QI‰Íé\ùÿÿÌÌÌÌÌÌÌUAWAVAUATSHìh��H‰ÓI‰öH‰ýH‹J@H…Ét8I‹6I‹VL¼$0��L‰ÿèW��H|$@L‰þèic��¶D$@<K…¦��H‹|$Hë I‹¾Ø���H…ÿ„Ã��ðHÿGðŽª��HƒÇð‹CHL‰´$à��A€¾à����•Á‰ÂÁêfƒú“Â%�ÿ��1ö=���@”ÆHõ���E1À„ÑIDÀH õ ���IDÈH‹SH‹sHƒÂýE1ÀHƒúA’ÀC@)„$p��C0)„$`��C )„$P��K)Œ$@��)„$0��H‰¼$ˆ��HÇ„$������HÇ„$ ������HÇ„$°������H‰„$¸��HÇ„$À������H‰Œ$È��H‰Œ$Ð��HÇ„$��/���L‰„$€��H‰´$ˆ��„$X��HƒÇ„$@��H„$0��H‰„$P��H‰¼$X��HÇ„$`������HÇ„$˜������H|$@H´$@��èÓc��¶D$@<KuJL´$`��H\$@L¼$@�� D��€|$A�L‹¬$`��„€��M…í…€��H‰ßL‰þè‰c��¶D$@<KtжL$A·T$F‹t$BH‹|$HHÁæHÁâ0H òHÁáH ѶÀH ÈH‰EH‰}HÇE����H‹„$ˆ��ðHÿu
H‹¼$ˆ��èJ ��ƒ¼$��/„ˆ���Hƒ¼$è���tH‹¼$à��ÿ“n�Hƒ¼$����tH‹¼$ø��ÿzn�Hƒ¼$���tH‹¼$��ÿan�Hƒ¼$0���t2H‹¼$(��ÿHn�ë"H‹L$H‹T$A‹t$D‰u ‰U ˆEH‰MHÇE����HÄh��[A\A]A^A_]ÃI‹6I‹VL¼$0��L‰ÿ1ÉèùS��H¼$@��L‰þèY`��¶„$@��<K…+��H‹¼$H��HO1ÀðI±ŽØ���…—��ðHÿìüÿÿé��M…í„n��H‹œ$h��H‹¼$p��èß þÿI‰ÇI‰ÔH‰¬$°��L‰l$@H‰\$HH‰D$PH‰T$XL‰t$`L´$È���H‹„$€��H‰„$à���IƒÇIÿ̸.���H‰„$Ø��1ÀH‰„$°���L¬$À���Hl$@Hœ$€���¸.���H‰„$��H‰„$��ë=H‰ßL‰îèËx��H‹„$€���H‰„$��H„$ˆ����)„$�� „�����IƒÇIÿÌIƒüÿ„Ÿ��IGð�)„$€���H‹D$`H‹@‹PHL‰ïH‰îH‰ÙèFd��H‹„$À���Hƒø.„²��AH‹Œ$Ø���L‰|$PL‰d$X)„$ð��H‰„$À���AH‰Œ$Ø���·Áƒøq~Z=0!��¿���ƒÀŽƒø‡cÿÿÿH
hÕüÿHcHÈÿàH‰ßL‰îèèw��ƒ¼$€��� …:ÿÿÿH‹„$ˆ���H‰„$¸��é%ÿÿÿ D��ƒÀýƒø‡ÿÿÿH
µÔüÿHcHÈÿàH‰ßL‰îè™w��H‹„$€���HƒøuH‹Œ$ˆ���H‰Œ$��ƒøH‹„$°���¹���HDÁH‰„$°���éºþÿÿf. „�����=1!��„ÿ���=2!��t9=3!��…“þÿÿH‰ßL‰îè(w��ƒ¼$€��� …zþÿÿH‹„$ˆ���H‰„$À��éeþÿÿH‰ßL‰îèúv��ƒ¼$€���…LþÿÿH‹„$ˆ���H‰„$Ð��é7þÿÿH‰ßL‰îèÌv��H‹„$€���H‰„$��H„$ˆ����)„$ ��éþÿÿH‰ßL‰îè™v��H‹„$€���H‰„$Ø��H‹„$ˆ���H‰„$Ð��éÔýÿÿH‰ßL‰îèiv��ƒ¼$€���…»ýÿÿH‹„$ˆ���H‰„$È��é¦ýÿÿHƒ¼$à����…—ýÿÿH‰ßL‰îè,v��ƒ¼$€���-u#H‹„$ˆ���HÇ„$€�����H‰„$ˆ��¸���ë1ÀH‰„$à���éPýÿÿH‹D$`Hƒx(�uH‹L$@H+HÇ@(���H‰H0H‹„$��Hƒø.L‹´$à��H‹œ$��uWE1äH‹„$��éå���A)„$ð��H‹„$°��@HÇ����éÙúÿÿ‹Œ$A��‹”$D��‰T$D‰L$AH‹Œ$H��éJûÿÿH‰„$8��(„$��„$@��H‹Œ$¸��¶”$y��H¼$@��L„$8��L‰öèkI��Hƒ¼$@���u@L‹¤$H��ë9ÆEBHÇE����éHúÿÿI‰ÇðHÿuè§��ðIÿGðŽì ��IƒÇðL‰ÿé:øÿÿE1äH‹„$��L‹¼$P��L‰¤$��L‰¼$˜��Hƒû.u#HÇ„$ ������Hƒ¼$°����„¥���E1Ûéƒ���H‰œ$P��(„$ ��„$X��H‹Œ$¸��¶”$y��H¼$@��L„$P��L‰öè”H��Hƒ¼$@���H‹¼$P��u
+L‹œ$H��ëE1ÛH‹„$��L‰œ$ ��H‰¼$¨��Hƒ¼$°����tI‹n@I‹VHH)ƒ¨��³1Àéd��»/���H‰„$°���ƒ¼$��/tdHƒ¼$è���tH‹¼$à��ÿçg�Hƒ¼$����tH‹¼$ø��ÿÎg�Hƒ¼$���tH‹¼$��ÿµg�Hƒ¼$0���tH‹¼$(��ÿœg�H‰œ$��L‰¤$˜��L‰¼$ ��H‹„$`��H‰„$È��(„$@��(Œ$P��„$¨��Œ$¸��H‹„$¨��H‰„$Ð��H‹„$È��H‰„$Ø��L‰¬$à��H‹„$���H‰„$è��H‹„$0��H‰„$ð��H‹„$���H‰„$��(„$ð��„$ø��H‹D$0H‰„$��H‹D$H‰„$��H‹„$ø���H‰„$ ��H‹„$���H‰„$8��(„$ð��„$(��H‹„$8��H‰„$@��H‹„$��H‰„$H��H‹„$��H‰„$P��H‹„$ ��H‰„$X��H‹„$��H‰„$`��H‹„$��H‰„$h��H‹„$(��H‰„$p��¶„$à���ˆ„$x��¶D$ˆ„$y��f‰¬$z��¶D$tˆ„$|��¶D$wˆ„$}��¶D$?ˆ„$~��¶D$vˆ„$��¶D$uˆ„$€��H‹„$°���ˆ„$��·„$,��f‰„$†��‹„$(��‰„$‚��H‹„$Ø��Hƒø.H‹¼$°��uLH´$0��º¨��ÿ¥e�éT÷ÿÿHÅHƒúrTD¶„$x��HrüHE‹M�ƒùïvcƒùÿ„X��»���1Àë7Hƒø t{H…À…õ���L‹Œ$Ð��L‰ÉHÁé°1Ò1öéá���H‰èH%�ÿÿÿ»���A‰ÞAÁîI‰ÝIÁí@¶íH Åé1��A‰ÉA²L9΂��Iƒù†
��·(Uúfƒúüƒ´��³é��H‹´$À��I‹NI‹FH)ðr'¶”$x��D¶ÊHñL‹”$Ð��M¯ÑH‰ÆL)Öƒö���H‰L$G°A‰É¶L$FÁá·T$D ÊHÁâ ‹t$@‹L$HH Ö¶T$NÁâD·D$LA ÐIÁà L Áº���ë1Ò1À1öHÁæ¶ÀH ðHÁáA¶ñH ÎH…ÒtH‰GH‰wHÇ���é7õÿÿHƒø…rþÿÿH‰´$°��éeþÿÿHƒþ‚���HƒÂôL‹MHƒÅ A²H‰èH‰ÖL9΃éþÿÿ³E1öE1íH‰ÅA¶ÆIÁåHÁàL è¶ËH ÁH‹„$°��H‰HH‰hHÇ����é¼ôÿÿAÿÉAƒù‡��LÑL~ÍüÿOc ˆMÁAÿáL9Ð…=��ÆD$@�fÇD$E��ÇD$A����éÇþÿÿÆD$F�fÇD$D��ÇD$@����H‰D$GH‹l$@H%�ÿÿÿH‰ëHÁãHÁí8HƒËé þÿÿIqþHPfƒý†��H…ö„L��Iƒù…„���HƒÀéÿÿÿHƒþ‚‚���·A¶¶Iˆ”$C��ˆŒ$F��f‰„$D��D‹Œ$C��ëHƒþ‚ˆ���D· fD‰Œ$A��°KL‰L$Gé¬���Hƒþ‚¯���L‹ éQýÿÿˆT$@°D¶L$Géðýÿÿ€x�„ß���³Aé¿��Ç„$@������Æ„$F���fÇ„$D����‹„$C��‰D$CÇD$@����ë<D¶ éôüÿÿfÇ„$@����Ç„$B������Æ„$F���‹„$@��‰D$@‹„$C��‰D$C°H‰L$GI‰É<K„¯üÿÿéZýÿÿÆ„$F���fÇ„$D����Ç„$@������H‰Œ$G��L‹Œ$@��‹„$H��‹Œ$K��‰D$H‰L$KL‰L$@IÁé8°éýÿÿD¶@IqüHƒÀH‰ÂƒùðrHƒþv]HƒÆøHBH‰D$ H‹
+ë;Hƒþ‚“���HƒÆüHZH‰\$ H‰t$(·B¶
+¶RˆL$CˆT$Ff‰D$DH‰Ø‹L$CH)΃§���³éGýÿÿÆD$F�fÇD$D��ÇD$@����H‰T$GL‹t$@‹D$H‹L$K‰„$È���‰Œ$Ë���L‰´$À���M‰õIÁíH‹¬$Ç���³éøüÿÿÇD$@����ÆD$F�fÇD$D��‹D$C‰„$Ã���Ç„$À�������E1ö‹„$Á���D·¬$Å���IÁå I ųH‰ÕéªüÿÿH…É„–üÿÿL‰œ$��H‰´$��DˆT$L‰Œ$ ��Dˆ„$à���H‰¼$(��H‰Œ$��HÿÉH‰L$(¶ˆT$w„Òt|H‰„$8��HÿÀÆD$?fƒýr>H…É„/üÿÿH‹„$��HHþH‰L$(H‹„$8��¶@ˆD$?„À„Ð���H‹„$8��HƒÀH…É„ñûÿÿHPH‰T$ Hƒùu³E1öE1íH‰ÕéÝûÿÿ³éÖûÿÿ¶0H‰ÊHƒÂþH‰T$(„‡���¶PˆT$vHPH‰T$ ¶x@ˆ|$u@„ÿtq@„ö•D$tHƒùt§¶PH‰”$°���„ÒtZHQüHpH‰´$¨��H‹´$°���ÿÎ@¶þH‰þH‰¼$È��H)ús3³E1öE1íH‹¬$¨��éAûÿÿ³é_ÿÿÿHƒÀé&ûÿÿ³ éOÿÿÿ³ éHÿÿÿH‹´$¨��H‹¼$È��HþH‰t$H‰t$ H‰T$(HÇ„$€������WÀ„$ˆ���fƒý‡Ñ���H…Ò„„��Hȹ���1öH‰´$0��1öI‰ÝH‹\$E1öB€<3�tJ<3HÿÇIÿÆH9ÇuêéC��L‰ðH÷ÐHÂJ3HÿÀH‰D$ H‰T$(M…ö„D��H;´$ˆ���u H¼$€���è58��H‹Œ$€���H‹´$���HvHÇÁ ���H‰\ÁL‰tÁHÿÆH‰´$���H‹D$ H‹T$(H‰D$HÐI‰ÝH…Ò…Qÿÿÿé¼���H|$@Ht$ èÒm��H‹D$@H‰„$¸���H…À„À���H‹D$HH‰„$���H‹D$ H‹T$(H…Ò„Å���H‹L$PH‰Œ$0��H H‰L$HÿÊHÿÀ1Û1ɶpÿƒù?u
+@€þƒ¤���@¶ö‰÷ƒçHÓçH û@„ö‰£���ƒÁHÿÀHƒÂÿrÉH‹D$H‰D$ HÇD$(����ë^ H‰\$ë�E‰îAÁîIÁí¸���H‰„$¸���³1ÀH‰„$���é ��H‹\$HH‹D$PH‰D$A‰ÞAÁîI‰ÝIÁíA·éò
+��H‰D$³E1öE1íéÝ
+��H‰D$ H‰T$(³E1öE1íéÆ
+��H‰D$ H‰T$(H…Û„˜��Hƒ¼$0���„Ý ��¶D$Áඌ$à���È���‰„$ø���H‹„$0��H…����H‰D$¸���H‰D$x1ÀH‰„$��1ÀH‰D$h1ÀH‰„$ ���Hÿ„$ ���A½.���E1öH‹„$¸���B·L0H|$@Ht$ ‹”$ø���è/o��H‹D$@Hƒø.„Ë���H‹Œ$¸���fBƒ<1H‹L$0HDL$HH‰L$0H‹L$HDL$PH‰L$LDèIƒÆL9t$uIƒý.„ú
+��H‹D$hH;„$ˆ���u,H¼$€���H‹t$hèˆ5��H‹„$€���H‰D$xH‹„$���H‰D$hH‹t$hHvH‹T$xL‰,ÂH‹L$0H‰LÂH‹L$H‰LÂHÿÆH‰t$hH‰´$���H9œ$ ���…öþÿÿé4��H‹\$HH‹D$PH‰D$A‰ÞAÁîI‰ÝIÁíé ��HÇ„$À������WÀ„$È���1ÀH‰„$��H|$@Ht$ èÓj��H‹D$@H‰D$0H…À„“���H‹D$HH‰D$H‹D$ H‹T$(H…Ò„ÿ��H‹L$PH‰Œ$ø���H H‰L$HÿÊHÿÀ1ÉH‰L$h1ɶpÿƒù?u
+@€þƒÙ��@¶ö‰÷ƒçHÓçH |$h@„ö‰Ö��ƒÁHÿÀHƒÂÿrÇH‹D$H‰D$ HÇD$(����éŽ��H‹\$HH‹D$PH‰D$A‰ÞAÁîI‰ÝIÁíA·éî��¸���H‰„$¸���1ÀH‰„$���HÇ„$À������WÀ„$È���fƒýƒîþÿÿM…ä¸.���» ���HDØH‹D$ H‰D$H‹L$(H‰ÈH‰L$H…É„X��H‹D$H‹L$Hȹ���H‰Œ$¨���1ÉH‰Œ$ø���1ÉH‰L$xL‹l$0H‹L$H‹t$HVýH~üH‰L$0LAE1öH‹L$0B€<1�JL1H‰L$tIÿÆHÿÊHÿÏIÿÀH9D$u×éÞ��L‰ñH÷ÑHL$H‹D$H‰D$ H‰Œ$ ���H‰L$(M…ö„3��Hƒ¼$ ����„„��HÿL$E1íM‰ñ1ÉL‹œ$ ���ICÿH‹t$0NIƒÂL‰T$hF¶Tƒù?u
+A€úƒ��A¶òA‰òAƒâIÓâM Õ@„öy ƒÁIÿÁHÿÊHÿÏIÿÀI‰ÃL9L$u¦éð��H‹L$hH‰L$ H‰D$(H…À„;��H‹D$0J HÿÁH‰L$hIÁ1ÀH‰„$ ���¸���H‰D$¸���1ÉI4H‰t$H‹t$A¶41ƒù?u
+@€þƒ¾��D¶ÖD‰ÖƒæHÓæH ´$ ���E„Òy ƒÁHÿD$HÿÀHÿÏIÿÀHƒÂÿré™��H‹D$H‰D$ H‰T$(H…Ò„Y��HÿÂLL$1ÀH‰D$1ÉA¶@ÿƒù?u<ƒš��¶À‰ÆƒæHÓæH t$„ÀyƒÁIÿÀHƒÇÿrÎé–��L‰D$ H‰|$(H‹D$xH;„$È���u/H¼$À���H‹t$xè;/��H‹„$À���H‰„$¨���H‹„$Ð���H‰D$xH‹t$xH‰ðHÁàH‹”$¨���HÇ ���H‹L$0H‰LL‰tL‰lH‹¼$ ���H‰| H‹|$H‰|(WÀD0HÿÆH‰ðH‰t$xH‰´$Ð���H‹D$ H‹T$(H‰D$HÐI‰ÍH‰T$H…Ò…5ýÿÿéi��H‰D$³E1öE1íéu��H‰D$ H‰T$(³E1öE1íé^��H‰D$ H‰T$(Hƒ|$h�„Y��Hƒ¼$ø����„Á��¶D$Áඌ$à���È���‰„$ ���H‹„$ø���L,…����¸���H‰„$¸��1ÀH‰„$ ��1ÀH‰„$À��Hÿ„$À��WÀ)„$à��¸.���H‰D$xE1ö1ÀH‰„$è���1ÀH‰„$ð���1ÀH‰„$¨���ë'H‰œ$��H‹L$H‰Œ$��H‰D$xIƒÆM9õ„ª��H‹D$0B·L0H|$@Ht$ ‹”$ ���è¯h��H‹D$@H‹\$HH‹L$PH‰L$Hƒø.„
+��H‹L$0B· 1ÿɃùw£Há¾üÿHc ŠHÑÿáHƒÀþHƒøw‰H
¿üÿHcHÈÿà¶ÃH‰„$è���éiÿÿÿƒø…`ÿÿÿHƒ|$…Tÿÿÿ)„$à��éDÿÿÿHƒÀþHƒø‡6ÿÿÿH
¾üÿHcHÈÿà¶ÃH‰„$ð���éÿÿÿHƒÀþHƒø‡ÿÿÿH
Z¾üÿHcHÈÿà¶ÃH‰„$¨���éèþÿÿ‰ØH‰„$ð���éÙþÿÿ‰ØH‰„$¨���éÊþÿÿ‰ØH‰„$è���é»þÿÿ·ÃH‰„$ð���é«þÿÿH…Ûˆ¢þÿÿH‰œ$ð���é•þÿÿ·ÃH‰„$¨���é…þÿÿ·ÃH‰„$è���éuþÿÿH…ÛˆlþÿÿH‰œ$¨���é_þÿÿH…ÛˆVþÿÿH‰œ$è���éIþÿÿHƒ|$x.„U��H‹„$ ��H;„$È���u5H¼$À���H‹´$ ��è³+��H‹„$À���H‰„$¸��H‹„$Ð���H‰„$ ��H‹Œ$ ��H‰ÈHÁàH‹”$¸��H‹t$xH‰4H‹´$��H‰tH‹´$��H‰tH‹´$è���H‰tH‹´$ð���H‰t H‹´$¨���H‰t((„$à��D0HÿÁH‰ÈH‰Œ$ ��H‰Œ$Ð���H‹„$À��H;D$h…ýÿÿ».���H‹„$��H„$8��H‹„$���H‰„$���„$€���)„$ð��„$À���)„$ð��H‹„$Ð���H‰„$���WÀ)„$@��)„$P��HÇ„$`������‹„$ê��‰„$(��·„$î��f‰„$,��L‹´$à��L‹¬$¸���ƒ¼$��/…Lêÿÿé«êÿÿA‰ÞAÁîI‰ÝIÁíë*ë
+H‹D$0H‰D$E‰îAÁîIÁí¸���H‰D$0³1ÀH‰D$E1ÿHƒ¼$È����tH‹¼$À���ÿñQ�Hƒ|$�”ÀAÇu H‹|$0ÿØQ�E1ÿHƒ¼$ˆ����tH‹¼$€���ÿ¼Q�Hƒ¼$����”ÀAÇt
+H‹l$éßíÿÿH‹¼$¸���ÿ“Q�H‹l$éÇíÿÿH‹L$hH‰L$ H‰D$(éŽ���H‹D$H„$ ���H‰D$H‰D$ HÇD$(����¸���H‰D$0³E1öE1íé*ÿÿÿH‹D$H‰D$ H‰T$(ëFH‹D$hLØH‰D$hH‰D$ HÇD$(����¸���H‰D$0³E1öE1íH‹D$hH‰D$éÝþÿÿL‰D$ H‰|$(¸���H‰D$0³E1öE1íé¼þÿÿIÑL‰L$ HÇD$(����L‰L$é`ÿÿÿ¸���H‰D$01ÀH‰D$é¨ýÿÿH=PîüÿHB�¾+���èשýÿëH=6îüÿHÏA�¾+���轩ýÿ H‰Ã¸���H‰D$01ÀH‰D$1íëë�H‰Ã1íëë:H‰Ã@µHƒ¼$È����tH‹¼$À���ÿ)P�Hƒ|$�”À@Åu,H‹|$0ÿP�ë H‰ÃëH‰Ã¸���H‰„$¸���1ÀH‰„$���Hƒ¼$ˆ����tH‹¼$€���ÿÖO�Hƒ¼$����t H‹¼$¸���ÿ½O�ë ëH‰Ãë ë�H‰ÃH‹„$ˆ��ðHÿu
H‹¼$ˆ��è$���H¼$��èç1��H‰ßè � 舼ýÿ ÌÌÌÌÌÌAWAVAUATSHƒì`H‰ûL‹wL‹ M…ÿt5MfL‹-HO�ëf D��IƒÄpIÿÏtIƒ|$ð�tïIƒ<$�tèI‹|$øAÿÕëÞHƒ{�t L‰÷ÿO�H‹K(H…Ét5H‹S0H‹C8HÇD$ ����H‰L$(H‰T$0HÇD$@����H‰L$HH‰T$P¹���ë1É1ÀH‰L$H‰L$8H‰D$XH‰çHt$èp1��H‹$H…ÀtKI‰æL|$L‹%˜N�ëf D��L‰÷L‰þèE1��H‹$H…Àt HkL$pHƒ<�tßHÈHƒx�tÕH‹xAÿÔëÌHƒûÿt ðHÿKuH‰ßHƒÄ`[A\A]A^A_ÿ%9N�HƒÄ`[A\A]A^A_ÃÌÌÌÌÌÌÌÌÌÌÌAWAVS€?KuQH‰ûL‹wM…ötEI‹ðHÿuL‰÷è‰ËÿÿI‹†`��ðHÿu I‹¾`��èpþÿÿIƒÆhL‰÷è40��H‹{[A^A_ÿ%ÅM�[A^A_ÃI‰Çë I‰ÇI‹†`��ðHÿu I‹¾`��è.þÿÿIƒÆhL‰÷èò/��H‹{ÿˆM�L‰ÿè� IƒÆhL‰÷èÒ/��è}ºýÿ ÌÌÌÌÌÌÌÌÌÌÌHƒ@�t‹ƒÀýƒør
+H‹8ÿ%EM�ÃÌÌÌÌUAWAVAUATSHì˜���I‰ôI‰þH½ÿÿÿÿÿÿÿ ‹¾è���†À���L‹†Ð���¶Žñ���H‹V@H‹vHI‹\$PM‹l$`¸���M…íL‰l$HˆL$H‰T$8H‰t$0‰|$)D$`L‰D$(t>I9í‡'��N<����M…ÿt(¶‚^�¾���L‰ÿèÍŒýÿH…Àu¿���L‰þèk‘ýÿ E1ÿH‰D$H‰ÇH‰ÞL‰úÿšL�M‹l$hM‹|$x¸���M…ÿtOH¹VUUUUUUI9σ»��J ý����H IH…Ût+¶ ^�¾���H‰ßèVŒýÿH…Àu¿���H‰Þèôýÿé¡��1ÛH‰D$H‰ÇL‰îH‰Úÿ!L�I‹œ$€���M‹¬$���¸���M…íL‰|$@L‰l$ tAI9í‡C��J,����H…ít+¶]�¾���H‰ïèÛ‹ýÿH…Àu¿���H‰îèyýÿé&��1íH‰D$H‰ÇH‰ÞH‰êÿ¦K�I‹œ$˜���M‹¬$¨���½���M…ít8L‰èHÁè9…Õ��M‰ïIÁçt"¶ ]�¾���L‰ÿèj‹ýÿH…À„¶��H‰ÅëE1ÿH‰ïH‰ÞL‰úÿBK�I‹œ$°���M‹¼$¸���I‹„$Ø���H‰D$XI‹„$à���H‰D$PAƒ<$.u¹.���ë6H¼$€���L‰æè¢*��AL$I‹D$(AD$0H‹Œ$€���”$ˆ���)T$pH‹t$H‹|$D¶D$L‹L$8L‹T$0‹T$(T$`L‹\$(A‰–è���A–À���M‰žÐ���A‹”$ì���A‰–ì���A¶”$ð���Aˆ–ð���Eˆ†ñ���M‰N@M‰VHI‰vPH‹T$HI‰VXI‰V`I‰~hH‹T$@I‰VpI‰VxH‹T$I‰–€���H‹T$ I‰–ˆ���I‰–���I‰®˜���M‰® ���M‰®¨���I‰ž°���M‰¾¸���H‹T$XI‰–Ø���H‹T$PI‰–à���I‰(T$pAVANI‰F(AF0HĘ���[A\A]A^A_]Ãè2Žýÿ è+Žýÿëè$Žýÿëè Žýÿë
¿���L‰þèNŽýÿ I‰ÆHƒ|$ �tH‹|$ÿVI�ëI‰ÆHƒ|$@�tH‹|$ÿ>I�ëI‰ÆHƒ|$H�t H‹|$ÿ&I�L‰÷è.� ÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHìˆ��H‰Œ$`��H‰ÓH‰´$X��H‰¼$Ð���HÇ„$¸������WÀ„$À���HÇD$X���Ld$`D$`H¼$ð���º°���H‰ÞÿÌH�H‹ƒ°���H‹‹¸���ƒÜ���„$Ì��ƒÐ���„$À��óoƒÀ���ó„$°��¶“ì���‹³ô���‰´$ä��H‹³í���H‰´$Ý��H‰„$ ��H‰Œ$¨��ˆ”$Ü��fïÀó„$è��HÇ„$ø�����HÇ„$������ó„$��ó„$��ˆ”$!��Ç„$"������H‰„$(��H‰Œ$0��¸���H‰„$è���L¼$ˆ��1íL-V9�L579�H=êüÿ1ÀH‰„$à���A¸���1ÉH‰L$0HIIÀHƒÀèH‰D$(H‰Œ$°���L‰D$P€¼$#���tS¶„$Ü��HŒ$ð���fïÀóø���HÇ„$ø�����HÇ„$������Æ„$ ���ó��ˆ„$!��Æ„$#���HÇ„$������Æ„$"���fÇ„$$����L‹œ$0��M…Û„Ú
��H‹”$(��MCÿLJL‰Œ$(��L‰„$0��¶
+…É„Œ���¶„$á��8ÁƒÜ���qÿƒþ ‡ß��L½°üÿIc ²LÑÿáM…À„c
��IsþLB1À1Éff. „�����E¶Hÿƒù?u
+A€ùƒ‘
��E¶ÉE‰ÊAƒâIÓâL ÐE„ɉ–��ƒÁIÿÀHƒÆÿrÆéó ��M…À„
��IsþE1À1Éfffff. „�����A¶ƒù?u<ƒé ��¶ÀA‰ÂAƒâIÓâIYM ЄÀyIƒÁI‰ÙHƒÆÿrËé˜ ��f D��¶”$à��„Ò„Ë��(Á¶Áöò¶ÌH¾”$ß��HÑxjHŒ$���ë{L)Æ‚_��JH‰„$(��H‰´$0��M…À„B��A¶Aÿȃø‡E��IPÿIYH
¯üÿHcHÈÿàÆ„$#��°I‰ðé‹���H‹”$���H4
+H÷ÙH9ʹ����HCÎH‰Œ$���¶À¶Œ$Ý��¶´$Þ��ƒþuH¯ÈHŒ$è��1Òë0…ö„ý��H„$ð��H‰ÂHÁê t1ÒH÷öë1Ò÷öH¯ÁH„$è��H‰”$ð��¶„$#��€¼$ ���H‹L$0„Z ��„ÀtX¶„$Ü��HŒ$ð���fïÀóø���HÇ„$ø�����HÇ„$������ó!��ó��ˆ„$!��Ç„$"������ë HÇ„$������Æ„$"���fÇ„$$����L‰ÆI‰óH…ö…0ýÿÿé ��M…À„å
+��IsþHBE1À1Éfff. „�����D¶Hÿƒù?u
+A€ùƒ��E¶ÉE‰ÊAƒâIÓâM ÐE„ɉ¿��ƒÁHÿÀHƒÆÿrÆés
+��M…À„„
+��IsþHBE1À1Éff. „�����D¶Hÿƒù?u
+A€ùƒ ��E¶ÉE‰ÊAƒâIÓâM ÐE„ɉ|��ƒÁHÿÀHƒÆÿrÆé
+��Æ„$$��é ÿÿÿIÿË1ö1É1Àë%f „�����E‰ÊAƒâIÓâL ЃÁHÿÆE„ɉâ��I9ó„¦��IÿÈL 2IƒÁL‰Œ$(��L‰„$0��D¶L2ƒù?uµAƒùt¯E…Étªé��M…À„¨ ��IsþLB1À1ÉE¶Hÿƒù?u
+A€ùƒá ��E¶ÉE‰ÊAƒâIÓâL ÐE„ɉÉ��ƒÁIÿÀHƒÆÿrÆéC ��¶Œ$à��¾���„É„š��öжÀöñ¶À¶Œ$Ý��D¶Œ$Þ��Aƒù…í��H¯ÈHŒ$è��HÇ„$ð������éþÿÿ€´$!��é÷ýÿÿÆ„$"��éêýÿÿÆ„$%��éÝýÿÿIƒø†Õ��IƒÃýHBH‰„$(��L‰œ$0��·BH„$è��HÇ„$ð������L‰ÞéžýÿÿH‹œ$0��H‹„$8��þɶÉH9È‚m��HËH9È„a��¶…À„fýÿÿƒø… ��M…À„V��IsþHB¹?���D¶@ÿ…Éu
+A€øƒ��E„À‰m��ƒÁùHÿÀHƒÆÿrØé��fƒ¼$Ú��ƒýÿÿ°H…Ò„7��IpýIƒÀüE1öH‰Ù „�����€9�„Å��HÿÁIÿÆHÿÎIÿÈL9òuæé��H…Ò„²��1À1ÉI‰ÓI‰Øfffff. „�����E¶ƒù?u
+A€ùƒ§��E¶ÉE‰ÊAƒâIÓâL ÐE„ɉõ��IÿËIÿÀƒÁM…ÛuÅéW��¶Œ$Ø��‰Èÿȃø‡)��LتüÿIc€LÀÿàH…Ò„��¶éC��E…É„h��H„$ð��H‰ÂHÁê „c��1ÒI÷ñé^��HÇÂÿÿÿÿHÓâAöÁ@HDÕƒù@HMÕH ЈU��H„$���éÝûÿÿH‰„$(��H‰´$0��L‰„$��éÃûÿÿH‰„$(��H‰´$0��L‰„$��é¦ûÿÿL‰„$(��H‰´$0��H‰„$ø��é‰ûÿÿL‰„$(��H‰´$0��¶Œ$Ý��D¶„$Þ��Aƒø…î��H¯ÁH„$è��HÇ„$ð������éAûÿÿL‰ÉM‰Â1ÒM…Ò„‹��IrÿH‰ÏLYE1ö1É �E¶cÿƒù?u
+A€üƒA��L‰íE¶äE‰åAƒåIÓåM îE„äyƒÁIÿÃHƒÆÿI‰írÄé ��L‰œ$(��H‰´$0��HÿÂL‰ÙI‰òL‰óH9ÂLd$`H=4áüÿL5U0�I‰í½����…cÿÿÿM)ËM9؃úÿÿér��H‰„$��é~úÿÿHƒú‚,��A·Yf‰\$q°Kég��Hƒú‚6��H‹é]��Hƒú‚%��A·AA¶QE¶AˆT$sDˆD$vf‰D$t‹\$s°Ké#��L‰ñH÷ÑN3IÿÂHÊ„��E1ä1ÉM‰ÑA¶9ƒù?u
+@€ÿƒr��L‰íD¶ßE‰ÝAƒåIÓåIyM ìE„Û‰1��ƒÁIÿÈI‰ùHƒÆÿI‰írºéG��1ÒA÷ñH¯ÁH„$è��H‰”$ð��é•ùÿÿH‰ÂH÷ÚH‹Œ$���H9уÕ���HÇ„$�������émùÿÿE…À„œ��H„$ð��H‰ÂHÁê „��1ÒI÷ðéü���fÇD$p��ÇD$r����ÆD$v�‹D$p‰D$‹D$s‰D$ ë$ÇD$p����ÆD$v�fÇD$t��‹D$s‰D$ ÇD$����°<K…¦��öÙÀáHÇÀÿÿÿÿHÓèH9Ô„$ ��H‰œ$è��HÇ„$ð������éÁøÿÿH‰„$(��H‰´$0��é¬øÿÿHÁH‰Œ$���é™øÿÿH…ö„9��HÿÆE1í1ɶƒù?u €úƒþ��¶ÒA‰ÓAƒãIÓãLWM Ý„Òy/ƒÁL‰×IƒÀÿrËéñ��1ÒA÷ðH¯ÁH„$è��H‰”$ð��é3øÿÿM…À„¾��IP1ö1ÉH‰Œ$Ø���1ÉE¶
+ƒù?u
+A€ùƒ‰��E¶ÉE‰ËAƒãIÓãL œ$Ø���E„ÉyIÿƒÁHÿÆI9ðuÄé ��H‹´$˜��H;´$��uL‰ÿèà��H‹´$˜��L‰àHÁèH‹Œ$ˆ��H‰òHÁâHÇ ���H‰\L‰tDˆd‰DH‰ÇHÁï0@ˆ| HÁè f‰D L‰l H‹„$Ø���H‰D(fïÀóD0HÿÆH‰´$˜��H‹´$0��Ld$`H=·ÝüÿL5Ø,�I‰í1íé#÷ÿÿ„Àt&Hƒ¼$°����¸����H‰„$°���L‹D$P„®óÿÿéÖ���L‰íL‹¬$è��L‹¤$ø��D‹´$���‹œ$��H…ÉH‹D$(t:L9(u5L‰`D‰p‰X¸���H‰„$°���Ld$`H='ÝüÿL5H,�I‰í1íéCóÿÿH;L$`u#H|$XH‹t$0è°��H‹D$XH‰D$PH‹D$hH‰D$0H‹L$0HIL‹D$PM‰,ÀM‰dÀE‰tÀA‰\ÀHÿÁH‰L$hLd$`H=·ÜüÿL5Ø+�I‰í1íé°òÿÿI‰ýI‹L‹´$è��H‹D$`HÇD$X���fïÀóA$H9Èv6H…Ét6HÁàH4@HÍ����H @º���L‰ÇI‰ÏèbzýÿH‰ÅH…ÀuéZ��L‰ÅëL‰Çÿ×9�½���H‹´$à���H;´$À���H‹Œ$è���u H¼$¸���è›��H‹Œ$¸���H‹´$È���H‰ðHÁàH‰,H‹T$0H‰TH‰\H‰Œ$è���L‰tHÿÆH‰ðH‰´$à���H‰´$È���L‰ïL5Ü*�L-í*�L¼$ˆ��1íé ñÿÿLÚH‰”$(��HÇ„$0������I‰Ñ°1í1ÒL‰Ëé_
+��1Ò°éV
+��H‹„$¸���H‰„$¨���L‹¼$È���Iƒÿs+Iƒÿ†Ñ��º���H‹¼$¨���L‰þè���é·��°é
+��L‰øHÁàH¿àÿÿÿÿÿÿH!ǶJ�¾���èÏxýÿH…À„Ù
��H‰Å¶dJ�¿���ÿ™8�H…ÀH‰l$H„Î
��I‰ÄH‹„$¨���HHPH‰Œ$H��HƒÀàH‰„$h��¸���H‰„$P��1ÛH
+'�H‰„$@��E1íL‰¼$8��ë D��A½���H‹\$ L9ûƒç��L‰úH)ÚH‰ÞHÁæH‹„$¨���H<0Hƒús]L‰þI‰öI)Þ‚© ��L9þ‡ ��ssHƒú
+smLs
+M9þMC÷L‰t$ I)Þ‚œ ��HƒúHƒÒ�L‰öèÔ��L;¬$P��tIéŸ��� D��H‹GH‹O0H9Áƒ ��Hƒú…)��Hsº���é‘�� €����H‰t$ L;¬$P��u[L‰ïHÁç¶I�¾���èiwýÿH…À„) ��I‰ÇJm����H‰„$P��L‰êHÁâL‰ÿL‰æÿ27�L‰çÿ7�M‰üL‹¼$8��L‰èHÁàM‰4I‰\IÿÅIƒý‚¿þÿÿL‰¤$x��éƒ���M‰ÅH‹l$HH‰îI)÷L‰÷L‰úÿÚ6�H‹„$è���LèH‹Œ$Ø���H‰H‹„$€��H‰H‹¼$à���HwH‹D$PH÷ÐH‹”$°���HÂHÁâÿ¨6�L‹l$0IƒýL‹¤$x��L‹¼$8��†)þÿÿM‰éMEÿL‰ÁHÁáI‹ I‹L HÁL9ùtZL‰ÊHÁâJ‹t"àH9ÆvIIƒù†Ì��MQýL‰ÑHÁáI‹ H<H9ùv<Iƒù†µ��HÎJ9t"Àv(é±��fffff. „�����IƒùrMQýL‰ÑHÁáI‹ H9ÁrMQþM9цü ��L‰D$0IBI9Á†Õ ��L‰ÑHÁáM‹t HÁàI‹M‹lIÕL‰íL)õ‚�
+��M9ý‡
+��H‰”$è���L‰T$PL‰Œ$°���I H‰”$à���I‹ I H‰Œ$Ø���LàHƒÀH‰„$€��L‰t$(IÁæL´$¨���I‰×IÁçO$>IÁåH‰ëH)ÓH‰”$p��H9Óƒ¿���I‰ßIÁçH‹l$HH‰ïL‰æL‰úÿü4�IïH‹¼$p��H…ÿŽ@��H…ÛŽ7��L¬$h��H‹\$(f. „�����L‰àL‰ùI‹WðI‹t$ðH9òA¼����MäH9òA¿����Iƒ×ÿIÁäIÄIÁçIÏH9òL‰øIBÄóo�HAMóAE�M9ôv IƒÅàI9ïwŸI‰ýM‰æépýÿÿ @�H‹\$HH‰ßL‰öL‰úÿD4�IßL‹„$p��M…ÀŽ���L9ÅH‹\$(Ž.ýÿÿL¬$¨���H‹l$HH‰îf. „�����H‰òI‹L$1ö1ÀH;J@“Æ’ÁH‰×IBüóoOANóAIƒÆ HÁæHÖL9þsˆÈHÁàIÄM9ìr²M‰ÅéÉüÿÿf. „�����I‰ýM‰æëM‰ÅH‹l$HH‰îH‹\$(é¢üÿÿ �HƒúuCHsº���ébûÿÿH´$H��A¸���I‰Éff. „�����M‰ÊL‹M9Ñs?IÿÀHƒÆ L9Âuéë.H´$H��A¸���I‰Éf D��M‰ÊL‹M9ÑrIÿÀHƒÆ L9ÂuéI‰ÐI4L‰ÂH9ÁƒìúÿÿH9ó‡ô��L9þ‡×��Hƒú‚ÐúÿÿI‰ðH‰ÐHÑèH HÁáHŒ$h��H‰þfffff. „�����N)Œ$€���)D$pINfoD$p(Œ$€���IóHƒÆ HƒÁàHÿÈu»L‰ÆéYúÿÿA½���é úÿÿA½���éúÿÿM‰Íé úÿÿL‰çH‹ 2�ÿÓH‰ïÿÓHÇD$���fïÀóD$fƒ¼$Ú��sƒ¼$ð���.t~H”$ð���ëHƒ¼$˜���tiH‹”$ˆ��H|$pHŒ$ð���H‹´$X��L‹„$`��èÝ
��L‹|$pM…ÿ„q��D$x)D$0H|$1öè™ ��H‹l$L‹D$K@L‰|Å�foD$0ë'H|$1öèr ��H‹l$L‹D$K@HÇDÅ����fïÀóDÅIÿÀL‰D$A½���1Éë>ffffff. „�����H‰îH[L‰$ÆL‰tÆL‰|ÆHÿÃH‰\$IÿÅH‹L$0HƒÁ@H‰õI‰Øfƒ¼$Ú��s&M…ít@IEÿH;„$˜��ƒ»���H‹”$ˆ��HÊëBfL9¬$˜��†ž���L‰êHÁâH”$ˆ��ë!ƒ¼$ð���.H”$ð���t{ffffff. „�����L‰ÃH‰L$0H|$pH‹´$X��HŒ$ð���L‹„$`��è† ��L‹d$pL‹t$xL‹¼$€���M…䄈���H;\$…ÿÿÿH|$H‰Þè3
+��H‹t$H‹\$é÷þÿÿL‹|$H‹D$L9À†
+��M…À„d��HÁàH4@L‰ÃJÅ����L4@º���L‰ÿL‰ñèApýÿI‰ÇH…À…C��¿���L‰öè˜týÿé5��H‹„$Ð���L‰pL‰xL‹t$HÇ�����H…Û„€���M~ë „�����IƒÇHÿËtiIƒ?�tñI‹øÿg/�ëåH 2HÿÃë&H‰„$(��°é’���H‰„$(��H‰´$0��°ë~HÓ°1í1ÒëwóoD$xH‹„$Ð���ó@HÇ�����A¾���Hƒ|$�„†���L‰÷ÿù.�ë{L‰Ãém��1Òë4°1ÒéG��H‰ùLÑH‰Œ$(��HÇ„$0������°1í1ÒH‰Ëë°1í1ÒH Õ¶ÀH èH
_ÌüÿH‰Œ$(��HÇ„$0������H‹Œ$Ð���H‰AH‰YHÇ����Hƒ¼$H���tH‹¼$@��ÿc.�Hƒ¼$`���tH‹¼$X��ÿJ.�Hƒ¼$x���tH‹¼$p��ÿ1.�Hƒ¼$���tH‹¼$ˆ��ÿ.�Hƒ|$`�t H‹|$Xÿ.�H‹œ$¸���L‹´$È���M…öt+L{ëf. „�����IƒÇ IÿÎtIƒ?�tñI‹øÿÇ-�ëåHƒ¼$À����t H‰ßÿ±-�HĈ��[A\A]A^A_]Ã1Ò°1íéÝþÿÿL‰ÃL‰ÿÿˆ-�A¿���H‹¼$¸���H‹´$À���L‹¤$È���L9ævBM…ät2HÁæM‰æIÁæº���L‰ñè¸mýÿH‰ÇH…Àu ¿���L‰öèrýÿé°��ÿ(-�¿���H‹„$Ð���L‰8H‰XH‰xL‰`Hƒ¼$H���tH‹¼$@��ÿó,�Hƒ¼$`���tH‹¼$X��ÿÚ,�Hƒ¼$x���tH‹¼$p��ÿÁ,�Hƒ¼$���tH‹¼$ˆ��ÿ¨,�Hƒ|$`�„ëþÿÿH‹|$XéÛþÿÿIÒ1í1ÒL‰ÓéÌýÿÿIñL‰Ï1í1ÒH‰ûéºýÿÿ¶L$‹t$ ·T$
HÁâ H òëUH×I‰úëðëI°1Ò1ÉëAÆD$v�fÇD$t��ÇD$p����H‰\$wH‹L$p‹D$x‹T${‰D$‰T$H‰L$H‰ÊHÁê°H‹\$HÁâ¶éHÁåé>ýÿÿ¾9���ë¾���H=’ËüÿM‰îL‰òè'…ýÿéT��H={ËüÿL5| �ëãHó�H‰D$pH5¯�ëHÞ�H‰D$pH5‚�H|$pHÇG���H>ÉüÿH‰GfïÀóGèTwýÿéñ���H€�L‰÷L‰îèÝŠýÿéÚ���Hi�L‰ïH‹´$8��èñ€ýÿé¾���°éòÿÿH=hËüÿH·�¾,���èm„ýÿéš���H¹�H‰„$@��ë3H=¸ÈüÿHY�¾+���è?„ýÿëoH¶�H‰÷L‰þè‹€ýÿë[H‰t$ H‰ßH‹t$ H‹”$@��è?Šýÿë?L5æ�¾+���H=bÈüÿéÆþÿÿH=VÈüÿHß�¾+���è݃ýÿë
¿���L‰þè^oýÿ I‰ÅH‹|$Péž���I‰ÅHƒ|$0�„š���H‰ïé‡���éŠ���é…���I‰ÅH¼$¸���è> ��L‰ÿH‰Þè£ ��³ëkë<I‰ÅfoD$0fH~ÀH…Àt,L‰ÿÿ*�ë!ë I‰Åë2ëI‰ÅM…ötL‰çÿõ)�ëëI‰ÅH|$è¤��ë I‰ÅL‰çÿÖ)�H‹|$HÿË)�ëI‰Å1ÛH¼$ð���è‡��Hƒ|$`�t H‹|$Xÿ¤)�„Ûu
H¼$¸���è“��L‰ïè›ö�� ÌÌÌÌÌÌÌÌÌAWAVAUATSL‹7M…ötwH‰ûL‹M…ÿt6MfL‹-X)�ëf D��IƒÄIÿÏtIƒ<$�tðI‹|$øAÿÕëæL‰÷ÿ-)�L‹sM…öt,H‹[L{L‹%)�ë �IƒÇ IÿÎtIƒ?�tñI‹øAÿÔëè[A\A]A^A_ÃH‰ß[A\A]A^A_ÿ%Ü(�ÌÌÌÌÌÌÌÌÌÌÌÌH‹GPH…À„¡���SH‹O@E1ÉA¸ÿ���H‰ÂI‰Âëffff. „�����I‰ÒL)Êv:HÑêLÊH RE1ÛH94ÙA•ÃEBØA€ûtÙE¶ËAùÿ���uHÿÂI‰ÑL‰ÒL)ÊwÆIƒéL‰Êr/H9Âs*HRH‹ÑH9ðw HDÑH9ðrH‹GXH…Àt
+‹TÑHWhs1À[Ã1ÀÃH‹w`H‹OpH‰ÇèŸõýÿ[ÃÌÌÌÌÌÌÌÌÌÌÌÌÌAVSHƒì8HÿÆ„’���H‰ûH‹GH �H9ñHGñHƒþA¾���LCö1öL‰ñHÁé9@”ÆL‰òHÁâHÁæH…Àt H‹ HÁàH‰L$HÇD$���H‰D$ë HÇD$����H|$ HL$è—þÿHƒ|$ �H‹|$(tH¸������€H9ÇtH…ÿuèùkýÿ H‰;L‰sHƒÄ8[A^ÃH‹t$0è lýÿ ÌÌÌÌÌÌÌÌÌÌÌÌSH‰ûHƒX�t
+H‹{Pÿ'�Hƒ{p�t
+H‹{hÿ
+'�Hƒ»ˆ����t
H‹»€���ÿó&�Hƒ» ����tH‹»˜���[ÿ%Û&�[ÃÌÌÌÌÌÌÌÌÌHƒìHBÿH9ðƒ³���H9òƒ¥���H‰ÐHÁàHøHƒÀàë IƒÀà($A�I‰HM‰HHÿÂHƒÀ H9òtuI‰ÐIÁàJ‹LJ;LðsáIøA�)$M‹HA@àAHðAHA�Hƒút¥Aº���I‰ÀfI;Hðs˜MXàAAKAHA�IÿÂM‰ØL9ÒuÙI‰øéoÿÿÿHƒÄÃH=kÆüÿHÖ�¾.���èDýÿ ÌÌAVSHƒì8HÿÆ„¡���H‰ûH‹GH �H9ñHGñHƒþA¾���LCöH¹VUUUUUU1öI9Î@’ÆJ õ����HIHÁæH…Àt H‹ HÁàH@H‰L$HÇD$���H‰D$ë HÇD$����H|$ HL$è`•þÿHƒ|$ �H‹|$(tH¸������€H9ÇtH…ÿuèÚiýÿ H‰;L‰sHƒÄ8[A^ÃH‹t$0èÿiýÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌAVSHƒì8HÿÆ„’���H‰ûH‹GH �H9ñHGñHƒþA¾���LCö1öL‰ñHÁé:@”ÆL‰òHÁâHÁæH…Àt H‹ HÁàH‰L$HÇD$���H‰D$ë HÇD$����H|$ HL$è”þÿHƒ|$ �H‹|$(tH¸������€H9ÇtH…ÿuè iýÿ H‰;L‰sHƒÄ8[A^ÃH‹t$0è.iýÿ ÌÌÌÌÌÌÌÌÌÌÌÌAWAVAUATSI‰þH‹ L‹M…ÿt2LcL‹- $�ëff. „�����IƒÄIÿÏtIƒ<$�tðI‹|$øAÿÕëæIƒ~�tH‰ß[A\A]A^A_ÿ%Ý#�[A\A]A^A_ÃÌÌÌUAWAVAUATSHƒìXL‰ÃH‰ÍI‰ÔI‰÷H‰|$0H‹¶p��H…öL‰D$8t6I‹—x��H‰çèmýÿH‹$L‹t$L‹l$H…Àt*H‰D$L‰t$ L‰l$(M‰õëoHÇD$���WÀD$ E1íëYM…ít1ˆø��¶5�¾���L‰ïèecýÿH‰ÃH…Àu¿���L‰îè�hýÿ »���H‰ßL‰öL‰êÿ2#�H‰\$L‰l$ L‰l$(I‹D$H…Àt=fƒ½ê���s HÿÈH;Exrë(H9Exv"H4@HÁæHuhH|$@è��Hƒ|$@.…Ë���H‰ãH‰ßL‰æèv��I‹ˆ��A¶WIH|$@H‹t$8I‰Øè¨��Hƒ|$@�H‹t$HH‹T$Pt+H‹D$0H‰pH‰PHÇ�����L‹l$ M…ít`H‹|$ÿM"�ëSH‰çè³kýÿL‹4$L‹|$H‹T$M…öL‰öID÷H|$è1cýÿM…ötM…ÿt L‰÷ÿ"�H‹D$(H‹L$0H‰AD$HƒÄX[A\A]A^A_]ÃI‹ˆ��A¶WIH‰çLD$@H‹t$8èë��Hƒ<$�H‹t$H‹T$t H‹D$0H‰pH‰PHÇ�����M…í…Eÿÿÿë£H‰çèkýÿL‹4$L‹l$H‹T$M…öL‰öIDõH|$èbýÿM…ö„´þÿÿM…í„«þÿÿL‰÷ÿV!�éþÿÿèìeýÿ H‰ÃM…öt$M…íuë ëH‰ÃM…ötM…ÿtL‰÷ÿ#!�ëH‰ÃHƒ|$ �t H‹|$ÿ !�H‰ßèî�� ÌAWAVAUATSI‰þH‹ L‹M…ÿt2LcL‹-Ý �ëff. „�����IƒÄ IÿÏtIƒ<$�tðI‹|$øAÿÕëæIƒ~�tH‰ß[A\A]A^A_ÿ% �[A\A]A^A_ÃÌÌÌAWAVATSPH…öt?I‰öH‰ûLL‹%r �ë IƒÇIÿÎtIƒ?�tñI‹øAÿÔëèH‰ßHƒÄ[A\A^A_ÿ%D �HƒÄ[A\A^A_ÃÌÌÌÌÌÌÌÌH‹H
ªŠüÿHcHÊÿâH‹NH‰OH‰Ã¶NˆOH‰ÃFGH‰Ã·Nf‰OH‰Ã‹N‰OH‰ÃÌÌÌÌI‹�HƒÀæHƒø‡¦���L
‹üÿIcLÈÿàI‹PH‹F`H‹NhH9Ñ‚ê��HÐH)Ñ„Þ��1Òfff. „�����€<�„<��HÿÂH9Ñuîé¹��H‹ŽÐ���H…ÉtDI‹PH‹ApH‹IxH9Ñ‚˜��HÐH)Ñ„Œ��1Òf. „�����€<�„ì���HÿÂH9Ñuîéi��ÆGEéh��H‹FpL‹NxI)É‚A��HȶÊI¯HI)É‚-��HÈ€úuQIƒù†���H‹ëhI‹PH‹FPH‹NXH9Ñ‚��HÐH)Ñ„��1Ò€<�tpHÿÂH9Ñuòéí���A@Gë`Iƒù‚–���·H¶¶@ˆT$ÛˆD$Þf‰L$Ü‹T$ÛH‹F`H‹NhH9Ñ‚«���HÐH)Ñ„Ÿ���1Ò€<�t
HÿÂH9ÑuòéŠ���H‰GH‰W1ÀH‰ÃÆD$Þ�fÇD$Ü��ÇD$Ø����H‰D$ßH‹D$Ø‹L$à‹T$ã‰L$ø‰T$ûH‰D$ðH‹D$÷ë$ÇD$Ø����ÆD$Þ�fÇD$Ü��‹L$Û‰L$óÇD$ð����‹L$ð‹T$ó‰T$ë‰L$è‹L$è‹T$ë‰W ‰O ÆGH‰G¸���H‰ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌSƒ?/tTH‰ûHƒX�t
+H‹{Pÿ† �Hƒ{p�t
+H‹{hÿu �Hƒ»ˆ����t
H‹»€���ÿ^ �Hƒ» ����tH‹»˜���[ÿ%F �[ÃÌÌÌÌUAWAVAUATSPI‰öH‰ûH‹F@H…À„¹���HÿÈI‰F@I‹I‹~H…À„��H…ÿ…ü���IFI‹~I‹VH…ÒtoH‰ÖH‰ÑHƒætHƒáøH‹¿8��HÿÎuôHƒúrLfffff. „�����H‹—8��H‹’8��H‹’8��H‹’8��H‹’8��H‹’8��H‹’8��H‹º8��HƒÁøuÂWÀ�IÇ���I‰~E1äE1ÿëtI‹~I‹FI‹VIƒ>�IÇ����„ë��H…ÿ„Q��H‹‡Ð��H…À„Æ��L‹=, �fff. „�����I‰ÆAÿ×I‹†Ð��L‰÷H…Àuëéœ��H…À„Ú��M‹~M‹f·‡2��I9ÄsI‰ýë>H‹-Ý�ffff. „�����L‹¯Ð��M…í„}��IÿÇD·§0��ÿÕL‰ïfE;¥2��sÖM…ÿt@K‹„å@��L‰úHÿÊt,IOþH‰ÖHƒætH‰òH‹€8��HÿÊuôH÷ÖLþH‰òHƒùs1ÉëOIL$L‰èëE1É D��H‹€8��H‹€8��H‹€8��H‹€8��H‹€8��H‹€8��H‹€8��H‹€8��HƒÂøuÂI‰FIÇF����I‰NL‰+L‰{L‰cé˜���H…Ò„ž���H‰ÖH‰ÑHƒætHƒáøf „�����H‹€8��HÿÎuôH‰ÇHƒú‚tþÿÿH‰Ç @�H‹‡8��H‹€8��H‹€8��H‹€8��H‹€8��H‹€8��H‹€8��H‹¸8��HƒÁøuÂé*þÿÿI‰þL‰÷ÿa�HÇ����HƒÄ[A\A]A^A_]ÃH‰Çé�þÿÿÿ=�H=î·üÿH? �¾+���èusýÿ H=Ô·üÿH= �¾+���è[sýÿ ÌÌÌÌÌUAWAVAUATSHì¨��I‰öI‰ýH9ÊsAÆEM‰uIÇE�����éÉ ��I‰×IÎHÇ„$������HÇ„$¸�������WÀ„$˜���HÇ„$¨�������I)Ï„ ��LL$8E1ä1ÉL‰øL‰ò¶2»���ƒù?u
+@€þƒ��@¶þA‰øAƒàIÓàHpÿHjM Ä@„ÿyƒÁH‰ðH‰êH…öu½é±��M…ä„q��H…ö„E��LxþHj¶J‰Ïƒç„ÉyVM…ÿ„'��LxýHj¶J‰ÎƒæÁæ·ÿ ÷„Éy0M…ÿ„��¶M�fƒù‡p��HƒÂHƒÀü·ÉÁá·ÿ ÏH‰ÕI‰Çf…ÿ„B��M…ÿ„È��¶E�<ƒ4��ˆD$‰|$,HÿÅH‰l$IÿÏHÇD$P����ÇD$X����HÇD$`����ÇD$h����HÇD$p����ÇD$x����HÇ„$€�������Ç„$ˆ�������WÀ)D$0D$<1ÀH‰„$è���1Û1ÀH‰„$à���L‰l$ ë*H‹t$HM‰ñH‹D$8H‰ñHÁáL‰,H‰lHÿÆH‰t$HL‹l$ M…ÿ„��IWÿH‹D$HH¶0‰ðƒà@„öyiH…Ò„Î��IWþH‹t$HN¶v‰÷ƒçÁç·À ø@„öy=H…Ò„¢��¶ fƒù‡”��H‹T$HƒÂIƒÇý·ÉÁá·À ÈH‰ÑL‰úf „�����f…À„€��H…Ò„\��LzÿLY¶9‰þƒæ@„ÿyiM…ÿ„ž��LzþLY¶yA‰øAƒàAÁà·öD Æ@„ÿy>M…ÿ„s��A¶;fƒÿ‡��HƒÁHƒÂý·ÿÁç·ö þI‰ËI‰×fffff. „�����D·ÖfAƒú!tE…Ò„9��L‰\$E1íës1ÉL‰ÚL‰þE1íë D��A‰øAƒàIÓàHÿÂM ŃÁ@„ÿy Hƒî‚��¶:ƒù?uÖƒÿtÑ…ÿtÍéh��IÇÀÿÿÿÿIÓà@öÇ@¿����LDǃù@LMÇM ÅH‰T$I‰÷IÁâH¹����ÿÿÿÿH!Í·ÀH ÅL ÕL‰èH!ÈH‰„$è���L‰ëHã��ÿÿL‰èH%�ÿÿÿH‰„$à���Hƒ|$0�t H‹t$HH;t$@…ÖýÿÿM‰ÎL‰Ïèi•ÿÿé¾ýÿÿH‹|$8Hƒÿ…Ë���¶–'�¿P���ÿË�H…À„N��HL$@A@@@IQ Y0X0P H�H‰„$À���HÇ„$È������HÇ„$Ð������¾���H¼$À���èÝ”ÿÿH‹„$À���H‹Œ$Ð���H‰ÊHÁâL‰,H‰lHÿÁH‰Œ$Ð���LL$8I‰I„$À���AHÇD$0���L‹l$ éýÿÿƒ…��HÁçL‰l<@H‰l<HHÿD$8L‹l$ éëüÿÿH…Ò„Ü��LzÿLq¶1‰ðƒà@„öyWM…ÿ„-��LzþLq¶q‰÷ƒçÁç·À ø@„öy0M…ÿ„��A¶6fƒþ‡ˆ��HƒÁHƒÂý·öÁæ·À ðI‰ÎI‰×f…À…w��H‹D$0H‹\$8H‹l$@HL$@AIQ(Y8)„$ð��)Œ$���)”$��)œ$ ��H‹IHH‰Œ$0��Hƒø„A��H‹Œ$0��H‰Œ$à��(„$ð��(Œ$���(”$��(œ$ ��)œ$Ð��)”$À��)Œ$°��)„$ ��Hƒø„ö��H‹Œ$à��H‰Œ$��(„$ ��(Œ$°��(”$À��(œ$Ð��)œ$€��)”$p��)Œ$`��)„$P��‹Œ$Û���‰L$¶Œ$ß���ˆL$ H‰„$8��H‰œ$@��H‰¬$H��H‹„$��HŒ$P��H‰A@(„$P��(Œ$`��(”$p��(œ$€��Y0Q IL‰¤$˜��‹D$,f‰„$ ��¶D$ˆ„$¢��¶D$ ˆAW‹D$‰ASH¼$���H´$8��èß›ýÿ„ÀLL$8…��M…ÿ…þøÿÿëMþ»���E1ÿL‰õ1É1Àé��Mû¸���1ÒL‰Ý1ÛE1äL‹l$ I¿����ÿÿÿÿL!úã��ÿÿH ÓAä�ÿ��I ÄHƒ|$0�tHƒ|$@�t H‹|$8ÿ �L ãH‰ÙHá�ÿÿÿH‰ØH%��ÿÿI!ßé£���¸���1Ò1ÛE1ä딸���1Ò1ÛE1äH‰Í눻���E1ÿé[ÿÿÿ¸���1Ò1ÛE1äH‹l$éeÿÿÿ„$���Œ$ ���”$°���AU AMAE�é��¸���1ÒL‰Ýé—��¸ ���L‰ÒL‰ÓM‰Ôéÿÿÿ»���ë»
+���E1ÿ1À1É%��ÿÿá�ÿ��H Á¶ÃL øH ÈI‰EI‰mIÇE�����H‹œ$���L‹´$ ���M…öt0L{L‹%�ë
@�IƒÇpIÿÎtIƒð�tðIƒ?�têI‹øAÿÔëáHƒ¼$˜����t H‰ßÿÝ�H‹Œ$¨���H…Ét=H‹”$°���H‹„$¸���HÇD$8����H‰L$@H‰T$HHÇD$X����H‰L$`H‰T$h¹���ë1É1ÀH‰L$0H‰L$PH‰D$pH¼$ð���Ht$0è.óÿÿH‹„$ð���H…Àt\Hœ$ð���Lt$0L‹=M�ë#ff. „�����H‰ßL‰öèõòÿÿH‹„$ð���H…Àt#HkŒ$���pHƒ<�tØHÈHƒx�tÎH‹xAÿ×ëÅHĨ��[A\A]A^A_]ø���1Ò1ÛE1äé‰ýÿÿ¸
���I¿����ÿÿÿÿH‹”$è���L‹¤$à���éoýÿÿI¿����ÿÿÿÿé”ýÿÿH‰ÙHá�ÿÿÿH‰ØH%��ÿÿI¿����ÿÿÿÿé…ýÿÿAÆEéEþÿÿ¸���1Ò1ÛE1äL‰õéýÿÿHò��¾���èþ[ýÿë¿���¾P���è-Týÿ ë>H‰ÃHƒ¼$È����t3H‹¼$À���ÿ-�ë#H‰ÃHƒ|$0�tHƒ|$@�tH‹|$8ÿ
�ëH‰ÃL‹´$���L‹¼$ ���M…ÿu*Hƒ¼$˜����t L‰÷ÿß�H‹Œ$¨���H…ÉuD1É1Àéˆ���MfL‹-¾�ëfff. „�����IƒÄpIÿÏt´Iƒ|$ð�tïIƒ<$�tèI‹|$øAÿÕëÞH‹”$°���H‹„$¸���HÇ„$ø�������H‰Œ$���H‰”$��HÇ„$������H‰Œ$ ��H‰”$(��¹���H‰Œ$ð���H‰Œ$��H‰„$0��H¼$8��H´$ð���èÔðÿÿH‹„$8��H…ÀtPL´$8��L¼$ð���L‹%ð
�HkŒ$H��pHƒ<�tHÈHƒx�tH‹xAÿÔL‰÷L‰þè„ðÿÿH‹„$8��H…ÀuÇH‰ßè¿Ú�� è¸zýÿ è±zýÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHì˜���H‰ûH‹H…ÀteH‰D$L‹vL‹~H‹nL‹n L‹f(¶, �¿@���ÿa
�H…ÀtNHÇ����HÇ@���H‹L$H‰HL‰pL‰x H‰h(L‰h0L‰`8H‰CÆKëFHĘ���[A\A]A^A_]ÃL‰t$0H‰l$L‰l$(L‰d$¿���¾@���è³Qýÿ H‰D$ M…ÿu&Hƒ|$0�t H‹|$ÿ´ �Hƒ|$�uK1À1ÉH‰L$ë{H‹D$HXL‹5‘ �ëffffff. „�����HƒÃpIÿÏt°Hƒ{ð�tðHƒ;�têH‹{øAÿÖëáHÇD$X����H‹L$H‰L$`H‹D$(H‰D$hHÇD$x����H‰Œ$€���H‰„$ˆ���¸���H‰D$PH‰D$pH‹D$H‰„$���H|$8Ht$PèÀîÿÿH‹D$8H…ÀtDLt$8L|$PL‹%å �HkL$HpHƒ<�tHÈHƒx�tH‹xAÿÔL‰÷L‰þè|îÿÿH‹D$8H…ÀuÍH‹|$ è¸Ø�� è±xýÿ èªxýÿ ÌÌÌÌÌÌÌÌUAWAVAUATSHƒìhI‰öH‹^ H…Ût&Iƒ~H�„®���I‹F(I‹NPH)ȃl��¸���éì��I‹FH…À„h��I‹6I‹VM‹VH‹J8E1À€zIA”ÀH+J0N$ÁIôL+b(IƒÄLHÿÈHÿÆE1É1É €����D¶^ÿƒù?u
+A€ûƒ(��E¶ÛD‰ÛƒãHÓãI ÙE„Û‰?��ƒÁHÿÆHƒÀÿrǹ���éþ���H‰<$Mn I‹n(I‹~0èø©ýÿH‰\$H‰l$H‰D$H‰T$ L‰l$(H…ÒtwI‰ÇI‰ÔIƒÇIÿÌLl$HHl$H\$0fffff. „�����AGð)D$0H‹D$(H‹@‹PHL‰ïH‰îH‰Ùèì��ƒ|$H.„¿���L‰|$L‰d$ IƒÇIƒÄÿr½H‹\$L‹l$(Iƒ}(�uH‰ØI+E�IÇE(���I‰E0H‹D$H‹<$ëHËI‰ I‰FH…À…˜þÿÿIÇF ����IÇFX����fÇK�ëg¹���Hp§üÿI‰IÇF����IÇFX����IÇF ����H‰L‰Gë7I‰6I‰FM…Ét:IIÿI;JsGLkÙpMéÒ���H‹D$PH‹\$XH‹<$H‰H‰_HƒÄh[A\A]A^A_]ÃIÇFXÿÿÿÿIÇF ����fÇKëÚM‹Z¹���M…Û„¹���H‰<$M‹R E1À»ÿ���A·»2��L,ý����IÇÇÿÿÿÿfffff. „�����M…ít(1íO9Œûà��@•ÅGëIÿÇIƒÅø@€ýtÝ@¶í…ítëI‰ÿIƒêrYO‹œû8��ë›M…ÛtGIkÏpIËH‹<$1ÉA€{j”ÁI‰NXI‰v I‰F(M‰^0I‰V8M‰f@IÇFH����fÇKéÿÿÿE1Àé¥þÿÿE1ÀH‹<$é™þÿÿÌÌÌÌÌÌÌÌUAWAVAUATSHìˆ���I‰ÎH‰ûA‰ÐAÁè‰ÑÁéE·V
+L‹>L‹fL nsüÿD‰ÕL‰øL‰çD·ýEgÿAƒü+‡º���Oc<£MßAÿçH…ÿ„> ��A‰éLgÿLxL‰>L‰fD¶(D‰íƒåE„íy´M…ä„Ž��LgþLxL‰>L‰fH‰t$(H‰ÞL‰óD¶pE‰õAƒåAÁå·íD íE„öI‰ÞH‰óH‹t$(‰gÿÿÿM…ä„A��HƒÇýLxL‰>H‰~¶@fƒø‡‚��·ÀÁà·í ÅI‰üé.ÿÿÿAÇÿàÿÿAƒÿ ‡ ��H
1süÿJc¹HÊÿâH…ÿ„k ��L8HÿÏHÿÀ1Ò1Éffff. „�����D¶Hÿƒù?u
+A€ùƒC ��E¶ÉE‰ÊAƒâIÓâL ÒE„ɉ��ƒÁHÿÀHƒÇÿrÆé ��H…ÿ„ ��L8HÿÏHÿÀ1Ò1Éf. „�����D¶Hÿƒù?u
+A€ùƒã��E¶ÉE‰ÊAƒâIÓâL ÒE„ɉÏ��ƒÁHÿÀHƒÇÿrÆé¤��A€ø…‰��Hƒÿ†÷��HƒÇøHHH‰H‰~H‹é��Hƒÿ†
+��HƒÇþHHH‰H‰~·‰Ñá�ÿ��¿
���é« ��Hƒÿ† ��HƒÇüHHH‰H‰~·H¶¶@ˆT$ ˆD$f‰L$ ‹T$ ‰Ñá�ÿ��‰Öæ��ÿÿ¿
���é^ ��Hƒÿ†S
+��HƒÇøHHH‰H‰~H‹éO��A€ø…w
+��Hƒÿ†.��HƒÇøHHH‰H‰~H‹é‹
+��Hƒÿ†¨
+��HƒÇøHHH‰H‰~H‹‰Ñá�ÿ��‰Öæ��ÿÿI¸����ÿÿÿÿI!п���éÒ��H…ÿ„q��L8HÿÏHÿÀ1Ò1ÉD¶Hÿƒù?u
+A€ùƒV��E¶ÉE‰ÊAƒâIÓâL ÒE„ɉõ
��ƒÁHÿÀHƒÇÿrÆé��Hƒÿ‡å���ÆD$�fÇD$ ��ÇD$����H‰D$H‹L$fHnÁH‰ÂHÁê‰K HÁé f‰K
fD$p·L$vé/��Hƒÿ†³��HƒÇýHHH‰H‰~·¶pÁæ Ö‰Ñá�ÿ��æ��ÿ�¿ ���éí��Hƒÿ†Z��HƒÇüHHH‰H‰~·H¶¶@ˆT$ ˆD$f‰L$ ‹T$ ‰Ñá�ÿ��‰Öæ��ÿÿ¿ ���éž��A€ø…y ��Hƒÿ†��HƒÇøHHH‰H‰~H‹é ��Hƒÿ‚L ��HƒÇüHHH‰H‰~·H¶¶@ˆT$ ˆD$f‰L$ ‹T$ ‰Ñá�ÿ��‰Öæ��ÿÿI¸����ÿÿÿÿI!п���é��¶ÒH|$èõ#��¶D$<K…+
+��H‹T$‰Ñá�ÿ��‰Öæ��ÿÿI¸����ÿÿÿÿI!Ð1ÿé×��Hƒÿ‚ ��HƒÇþHPH‰H‰~D·ë8Hƒÿ‚ ��HƒÇüHPH‰H‰~·HD¶�¶@DˆD$ ˆD$f‰L$ D‹L$ ¹���L)σ/��H‰ÐH‰Kéý ��Hƒÿ†Ø��HƒÇþHHH‰H‰~¶¶HÁá¿���é4��â�ÿ��ú���…
��A·VƒÂþƒúw‡
��LÏpüÿIcLÂÿâH|$º���è_$��¶D$<K… ��H‹L$I¸����ÿÿÿÿI!È¿
+���éÿ ��â�ÿ��ú���…?
��A·VƒÂþƒúw‡.
��L„nüÿIcLÂÿâHƒÿ†´
+��HƒÇøHHH‰H‰~H‹¿
+���é
��H…ÿ„:��E1ÉB€<�„@
+��IÿÁL9Ïuíé ��H…ÿ„6��H8HÿÏHÿÀE1É1ÉD¶@ÿƒù?u
+A€øƒš ��E¶ÀE‰ÂAƒâIÓâM ÑE„À‰
+��ƒÁHÿÀHƒÇÿrÆéK��H…ÿ„¾��HÿÏHPH‰H‰~D¶L)σ’��H‰Ðé›��H…ÿ„‚��HÿÏHHH‰H‰~¶¿���1Éé¢��H…ÿ„\��HÿÏHHH‰H‰~€8�•Â¿ ���1Ééy��HÿÏ1É1Òë)ffff. „�����E‰ÁAƒáIÓáL ʃÁHÿÏE„À‰}��I‰ÀHƒÿÿ„ê��I@H‰H‰~E¶�ƒù?uÃAƒøt½E…Àt¸°éÑ��A€ø…›��Hƒÿ†��HƒÇøHHH‰H‰~H‹é¯��H…ÿ„��L8HÿÏHÿÀ1Ò1ÉD¶Hÿƒù?u
+A€ùƒr��E¶ÉE‰ÊAƒâIÓâL ÒE„ɉƒ ��ƒÁHÿÀHƒÇÿrÆé3��fƒù…v��¶ÒH|$èÉ"��ér��H…ÿ„1��HÿÏHHH‰H‰~¶¿
���1ÉéQ��H…ÿ„õ��L8HÿÏHÿÀ1Ò1ÉD¶Hÿƒù?u
+A€ùƒÚ��E¶ÉE‰ÊAƒâIÓâL ÒE„ɉ ��ƒÁHÿÀHƒÇÿrÆé›��H…ÿ„æ��H8HÿÏHÿÀE1É1ÉD¶@ÿƒù?u
+A€øƒJ��E¶ÀE‰ÂAƒâIÓâM ÑE„À‰ð��ƒÁHÿÀHƒÇÿrÆH‰HÇF����¹���éã��¿ ���1ɲé†��Hƒÿ†õ��HƒÇüHHH‰H‰~·H¶¶@ˆT$ ˆD$f‰L$ ‹T$ ‰Ñá�ÿ��‰Öæ��ÿÿ¿���é9��Hƒÿƒ|��HÇC���é¼��A€ø…£��HƒÿvHƒÇøHHH‰H‰~H‹é·��ÆD$�fÇD$ ��ÇD$����H‰D$H‹D$‹L$‹T$‰L$ ‰T$#H‰D$H‹D$ éÅ��fAƒú!…Ñ��I‹éý��H…ÿtQL8HÿÏHÿÀ1Ò1ÉD¶Hÿƒù?uA€ùs:E¶ÉE‰ÊAƒâIÓâL ÒE„ɉÅ��ƒÁHÿÀHƒÇÿrÊL‰HÇF����ëI‰À°ë H‰H‰~°ˆCÆC �fÇC��ÇC
+����L‰CéÆ��H…ÿ„à���HÿÏHHH‰H‰~¶¿ ���1Éé���Hƒÿ†.��HƒÇþHHH‰H‰~·‰Ñá�ÿ��¿ ���éÒ���HƒÿvEHƒÇüHHH‰H‰~·H¶¶@ˆT$ ˆD$f‰L$ ‹T$ ‰Ñá�ÿ��‰Öæ��ÿÿ¿ ���é‰���ÇD$����ÆD$�fÇD$ ��‹L$ ‰K ÇC ����ÆCéø��H…ÿtHÿÏHHH‰H‰~¶¿ ���1Éë=fÇC�fÇC��ÇC
+����éÁ��HƒÿvWHƒÇþHHH‰H‰~·‰Ñá�ÿ��¿ ���1öE1ÀA·F¶Ò Ñ·É ñHº����ÿÿÿÿL!ÂH ÑH‰;H‰KL‰Kf‰Céo��fÇD$��ÆD$�ÇD$
+����‹L$ ‰K ‹L$é¸��Hƒÿv3HƒÇýHHH‰H‰~·¶pÁæ Ö‰Ñá�ÿ��æ��ÿ�¿ ���émÿÿÿÆCÆC�fÇC
��ÇC ����éí��±E1ÉéÐ��ÆC éÞ��J
+H‰H‰~‰Ñá�ÿ��‰Öæ��ÿÿI¸����ÿÿÿÿI!п���éÿÿÿH‰Â¹���éN��ÆD$�fÇD$ ��ÇD$����H‰D$H‹L$fHnÁH‰ÂHÁê‰K HÁé f‰K
fD$P·L$VéÁ��Hƒÿ‚•��HƒÇüHHH‰H‰~·H¶¶@ˆT$ ˆD$f‰L$ ‹T$ ‰Ñá�ÿ��‰Öæ��ÿÿI¸����ÿÿÿÿI!п
+���écþÿÿÆD$�fÇD$ ��ÇD$����H‰D$H‹L$fHnÁH‰ÂHÁê‰K HÁé f‰K
fD$`·L$fé ��Hƒÿ‚ô��HƒÇüHHH‰H‰~·H¶¶@ˆT$ ˆD$f‰L$ ‹T$ ‰Ñá�ÿ��‰Öæ��ÿÿI¸����ÿÿÿÿI!п���éÂýÿÿfÇD$��ÇD$
+����·L$ ‹T$HÁâHÁá(HÑHƒÁH‰Ké)��¹���H‰Ké��ÆCÇC ����é��Hƒÿ‚J��HƒÇüHHH‰H‰~·H¶¶@ˆT$ ˆD$f‰L$ ‹T$ ‰Ñá�ÿ��‰Öæ��ÿÿI¸����ÿÿÿÿI!п���éýÿÿA¶ÐH|$èr��¶D$<Ku,H‹T$‰Ñá�ÿ��‰Öæ��ÿÿI¸����ÿÿÿÿI!п���éÕüÿÿ‹L$ ‹T$ ‰S ‰K H‹L$ˆCH‰KéQ��HƒÇðHHH‰H‰~‰Áá�ÿ��‰Ææ��ÿÿI¸����ÿÿÿÿI!À¿���A¹���‰ÂéxüÿÿHƒÿrRHƒÇüHHH‰H‰~·H¶¶@ˆT$ ˆD$f‰L$ ‹T$ ‰Ñá�ÿ��‰Öæ��ÿÿI¸����ÿÿÿÿI!п ���é üÿÿÇD$����ÆD$�fÇD$ ��‹L$ ‰L$ÇD$����‹L$‹T$‰S ‰K ÆCé|��ÆCFéw��±E1ÉL‰øéS��HÇÀÿÿÿÿHÓà1öAöÀ@HDƃù@HMÆH ‰Ñá�ÿ��‰Öæ��ÿÿI¸����ÿÿÿÿI!п���éŠûÿÿH‰H‰~¹���éÃ��H‰H‰~‰Ñá�ÿ��‰Öæ��ÿÿI¸����ÿÿÿÿI!п ���éKûÿÿH‰H‰~‰Ñá�ÿ��‰Öæ��ÿÿI¸����ÿÿÿÿI!п ���é ûÿÿL‰ÉH÷ÑHÏJ HÿÁH‰H‰~‰Áá�ÿ��‰Ææ��ÿÿI¸����ÿÿÿÿI!À¿ ���‰ÂéÝúÿÿÆD$�fÇD$ ��ÇD$����H‰D$H‹L$fHnÁH‰ÂHÁê‰K HÁé f‰K
fD$@·L$Féš��H‰H‰~‰Ñá�ÿ��‰Öæ��ÿÿI¸����ÿÿÿÿI!п���éjúÿÿH‰H‰~L)Ï‚œ���J H‰H‰~‰Áá�ÿ��‰Ææ��ÿÿI¸����ÿÿÿÿI!À¿���‰Âé&úÿÿH‰H‰~‰Ñá�ÿ��‰Öæ��ÿÿI¸����ÿÿÿÿI!п���éøùÿÿH‰H‰~‰Ñá�ÿ��‰Öæ��ÿÿI¸����ÿÿÿÿI!п
���éÊùÿÿH‰H‰~L)Ïsr¹���H‰ÂH‰KH‰SëGH‰H‰~‰Ñá�ÿ��‰Öæ��ÿÿI¸����ÿÿÿÿI!п���é~ùÿÿ±ˆKÆC �fD‰K
+ÇC ����H‰CHÇ.���HĈ���[A\A]A^A_]ÃJ H‰H‰~‰Áá�ÿ��‰Ææ��ÿÿI¸����ÿÿÿÿI!À¿���‰Âéùÿÿáþÿ��fƒù„óÿÿHƒÿvHHƒÇüHHH‰H‰~·H¶¶@ˆT$ ˆD$f‰L$ ‹L$ ¿���E1À‰Ê‰Îæ��ÿÿá�ÿ��éºøÿÿÇD$����¶L$
+ˆK fÇC ��ÆCÆC �ÆC�fÇC
��é$ÿÿÿáþÿ��fƒù„âòÿÿHƒÿv9HƒÇøHHH‰H‰~H‹¿���I¸����ÿÿÿÿI!ЉÖæ��ÿÿ‰Ñá�ÿ��é>øÿÿÆD$�fÇD$ ��ÇD$����H‰D$H‹L$fHnÁH‰ÂHÁê‰K HÁé f‰K
fD$0·L$6f‰KÆCH‰ÁHÁé8ˆKHÁè(f‰C‰SéwþÿÿÌÌÌÌAVSPI‰öH‰û·F=0!��ƒ���ƒÀþ=Š���‡��H
JdüÿHcHÈÿàI‹Hƒø„¦��ƒø„��éÚ��I‹Hƒø„‹��ƒø„‚��ƒø
+…»��I‹FH‰CHÇ���éu��L‰÷ès��Hƒø„��é��=1!��„��=2!��„¿���=3!��…o��Aƒ>
+…e��I‹FH‰CHÇ ���é ��I‹HÿÈHƒø‡A��H
²eüÿHcHÈÿàI‹Fé��Aƒ>
+… ��I‹FH‰CHÇ���éØ��L‰÷èÖ��Hƒø„j��I‹Hƒø„©��ƒø„ ��éÝ��L‰÷è©��Hƒø…Ë��H‰SHÇ,���é‰��Aƒ>
+…±��I‹FH‰CHÇ���ék��L‰÷è ��¨„��ˆSHÇ+���éL��Aƒ>
+…t��I‹FH‰CHÇ���é.��L‰÷èŒ��fƒø…N��f‰SHÇ&���é ��L‰÷èª��¨„.��ˆSHÇ$���éí��L‰÷è‹��¨„��ˆSHÇ*���éÎ��L‰÷èl��¨„ð��ˆSHÇ#���é¯��L‰÷è��Hƒø…Ï��H‰SHÇ'���é��L‰÷è+��¨„¯��ˆSHÇ)���én��L‰÷èl��Hƒø…5��H‰SHÇ���éL��L‰÷èê��¨„n��ˆSHÇ ���é-��L‰÷èË��¨„O��ˆSHÇ(���é��Aƒ>
+…6��I‹FH‰CHÇ���éð���L‰÷èŽ��¨„��ˆSHÇ%���éÑ���L‰÷èo��¨„ó���ˆSHÇ!���é²���L‰÷èP��¨„Ô���ˆSHÇ"���é“���Aƒ>
+…»���I‹FH‰CHÇ ���ëxAƒ>
+… ���I‹FH‰CHÇ���ë]Aƒ>
+……���I‹FH‰CHÇ���ëBL‰÷è@��HƒøufH‰SHÇ-���ë'I‹Hƒøtƒø
+…_üÿÿé‡üÿÿAFCHÇ���HƒÄ[A^ÃA¶FëA·FëA‹Fë I‹FH…Àx
H‰CHÇ���ëÎH‰ßL‰öHƒÄ[A^éÂÏÿÿÌÌUAWAVAUATSHƒì8H‰ûH‹H‹nH…í„ö��I‰öHÿÍL`L‰&H‰nD¶(M…í„ø��N<����¶z�¾���L‰ÿèÅ/ýÿH…À„–��H‰D$L‰l$HÇD$ ����1öÇD$ ����1Ò‰L$L‰l$(H…í„Ø��HÿÂH‰T$0E1ÿ1ÉH‰êL‰ç „�����LRÿLOD¶ ƒù?u
+A€ûƒ‰��E¶ÛE‰ÝAƒåIÓåM ïE„ÛyƒÁL‰ÒL‰ÏM…ÒuÁék��M‰M‰VIÿÿÿ��A½ÿÿ��MBïIƒý”ÁM…Ò„—��ˆL$HjþLgM‰&I‰nD¶GD‰ÁƒáE„Ày3H…í„‹��HjýLgM‰&I‰nD¶GE‰ÁAƒáAÁá·ÉD ÉE„Àx]‰L$H;t$uH|$è
��H‹D$H‹t$ 1ɶT$ˆÑL$ fD‰,°‹L$f‰L°HÿÆH‰t$ M‰øL‹l$(H‹T$0L9ê…Âþÿÿéê���H…í„û���HƒÂüLgM‰&I‰V¶fƒÿ‡ç���·ÿÁç·É ù‰L$H‰ÕH;t$„kÿÿÿézÿÿÿfÇC�fÇC��ÇC
+����H‰CHÇ����ëmHÇD$���L‰l$HÇD$ ����ÆCDë6M‰M‰V°ëIìM‰&IÇF����°M‰àˆCÆC �fÇC��ÇC
+����L‰CHÇ����Hƒ|$�t H‹|$ÿLí��HƒÄ8[A\A]A^A_]ð1Éë)ƒ|$ uŽH‹D$ H‰CD$ëÑ°1ÉM‰áë°‹L$ˆCÆC �f‰K
+ÇC ����L‰Kë¿���L‰þèÉ1ýÿ H‰ÃHƒ|$�t H‹|$ÿÑì��H‰ßèÙ¹�� ÌÌÌÌÌÌÌÁê·ÁHýƒù%wLH?_üÿHc ˆHÁÿáH‹L‹FIƒø†´��IƒÀþHAH‰L‰F·I)Ђ…��H H‰L‰Fé§��= ��t<=! ��…“���€ú…á��H‹H‹NHƒù†ƒ��HƒÁøHPH‰H‰NH‹�éõ��L‹L‹NM…É„Ú��KIÿÉIÿÀ1À1É D��E¶Pÿƒù?u
+A€úƒæ��E¶ÒE‰ÓAƒãIÓãL ØE„Ò‰e ��ƒÁIÿÀIƒÁÿrÆé{��ÆG HÇ.���ÃH‹H‹NHƒù†ò��HƒÁüHBH‰H‰ND·BD¶
+¶RDˆL$ˈT$ÎfD‰D$Ì‹T$Ëé��H‹H‹FHƒø†Õ��HƒÀþHQH‰H‰F¶¶IÁáA¹���é1��H‹H‹NHƒù†·��HƒÁüHPH‰H‰N·H¶¶@ˆT$ˈD$Îf‰L$Ì‹D$ˉÁá�ÿ��‰Ææ��ÿÿA¹���E1ÀéD ��H‹H‹NHƒù†Š��HƒÁøHPH‰H‰NH‹�‰Áá�ÿ��‰Ææ��ÿÿI¸����ÿÿÿÿI!ÀA¹���éù��H‹H‹NH…É„•��1Ò @�€<�„J��HÿÂH9Ñuîéx��H‹L‹NM…É„��NIÿÉHÿÀ1Ò1Éff. „�����D¶Pÿƒù?u
+A€úƒ<��E¶ÒE‰ÓAƒãIÓãL ÚE„Ò‰Ž��ƒÁHÿÀIƒÁÿrÆL‰HÇF����°é
��H‹H‹NH…É„��HÿÉHBH‰H‰N¶H)Ñ‚Ù��LL‰H‰N‰Áá�ÿ��‰Ææ��ÿÿI¸����ÿÿÿÿI!ÀA¹���éú��H‹H‹NH…É„4��HÿÉHPH‰H‰N¶�A¹���é��H‹H‹NH…É„��HÿÉHPH‰H‰N€8�•ÀA¹ ���éå��L‹H‹VHÿÊ1É1Àë(fff. „�����E‰ÊAƒâIÓâL ЃÁHÿÊE„ɉQ��M‰ÁHƒúÿ„"��MAL‰H‰VE¶ ƒù?uÃAƒùt½E…Ét¸°éþ��€ú…ç��H‹H‹NHƒù†���HƒÁøHPH‰H‰NH‹�éû��L‹L‹NM…Ét[KIÿÉIÿÀ1À1Éf D��E¶Pÿƒù?u
+A€úƒf��E¶ÒE‰ÓAƒãIÓãL ØE„Ò‰‹��ƒÁIÿÀIƒÁÿrÆH‰HÇF����ëL‰Â°é2��€ú…©��H‹H‹NHƒùvbHƒÁøHPH‰H‰NH‹�éÁ��H‹H‹NHƒùƒØ��HÇG���é��€ú…þ��H‹H‹NHƒùvHƒÁøHPH‰H‰NH‹�é��ÆD$Î�fÇD$Ì��ÇD$È����H‰D$ÏH‹D$È‹L$ЋT$Ó‰L$à‰T$ãH‰D$ØH‹D$ßé!��H‹H‹NH…ÉtHÿÉHPH‰H‰N¶�A¹ ���1ÉëIfÇG�fÇG��ÇG
+����éô��H‹H‹NHƒù†ï��HƒÁþHPH‰H‰N·�‰Áá�ÿ��A¹ ���1öE1Àéc��H‹H‹FHƒø†Õ��HƒÀýHQH‰H‰F·¶qÁæ ƉÁá�ÿ��æ��ÿ�ëLH‹H‹NHƒù†º��HƒÁüHPH‰H‰N·H¶¶@ˆT$ˈD$Îf‰L$Ì‹D$ˉÁá�ÿ��‰Ææ��ÿÿA¹ ���E1ÀéÍ��H‹H‹NHƒù‚Ü��HƒÁüHPH‰H‰N·H¶¶@ˆT$ˈD$Îf‰L$Ì‹D$ˉÁá�ÿ��‰Ææ��ÿÿI¸����ÿÿÿÿI!ÀA¹���éi��L‰L‰N°ˆGÆG �fÇG��ÇG
+����H‰WHÇ.���ÃfÇD$È��ÆD$Î�ÇD$Ê����‹D$ˉG ‹D$ȉG ÆGé��ÇD$È����ÆD$Î�fÇD$Ì��‹D$ˉG ÇG ����ÆGë¡ÆGÇG ����ÇG ����én��ÇD$È����¶L$ʈO fÇG ��ÆGÆG �ÆG�fÇG
��éÿ��ÆD$Î�fÇD$Ì��ÇD$È����H‰D$ÏH‹L$ÈfHnÁH‰ÂHÁê‰O HÁé f‰O
fD$è·L$îf‰OÆGH‰ÁHÁé8ˆOHÁè(f‰G‰WHÇ.���ÃH‹H‹NHƒù‚S��HƒÁüHPH‰H‰N·H¶¶@ˆT$ˈD$Îf‰L$Ì‹D$ˉÁá�ÿ��‰Ææ��ÿÿI¸����ÿÿÿÿI!ÀA¹���éà��H‹H‹NHƒù‚ï���HƒÁüHPH‰H‰N·H¶¶@ˆT$ˈD$Îf‰L$Ì‹D$ˉÁá�ÿ��‰Ææ��ÿÿI¸����ÿÿÿÿI!ÀA¹
+���é|��HƒÁðHPH‰H‰N‰Áá�ÿ��‰Ææ��ÿÿI¸����ÿÿÿÿI!ÀA¹���º���é@��H‹H‹NHƒùrSHƒÁüHPH‰H‰N·H¶¶@ˆT$ˈD$Îf‰L$Ì‹D$ˉÁá�ÿ��‰Ææ��ÿÿI¸����ÿÿÿÿI!ÀA¹ ���éà��ÇD$È����ÆD$Î�fÇD$Ì��‹L$ˉL$ÛÇD$Ø����‹L$Ø‹T$Û‰W ‰O ÆGH‰GHÇ.���ÃfÇD$È��ÆD$Î�ÇD$Ê����‹L$ˉO ‹L$ÈëÌÆGÆG�fÇG
��ÇG ����H‰OHÇ.���ÃÇD$È����ÆD$Î�fÇD$Ì��‹L$ˉO ÇG ����늰ˆGÆG �fÇG��ÇG
+����L‰OHÇ.���ÃHÇÂÿÿÿÿHÓâ1öAöÁ@HDÖƒù@HMÖH ЉÁá�ÿ��‰Ææ��ÿÿI¸����ÿÿÿÿI!ÀA¹���éÐ���L‰L‰N‰Áá�ÿ��‰Ææ��ÿÿI¸����ÿÿÿÿI!ÀA¹ ���é¡���I‰À°ëPfÇG�é6üÿÿI‰ÐI÷ÐLÁLIÿÀL‰H‰N‰Áá�ÿ��‰Ææ��ÿÿI¸����ÿÿÿÿI!ÀA¹ ���ëSH‰L‰N°ˆGÆG �fÇG��ÇG
+����L‰GHÇ.���ÃL‰L‰N‰Áá�ÿ��‰Ææ��ÿÿI¸����ÿÿÿÿI!ÀA¹���L‰¶À Á·Á ðL ÀH‰GH‰WÃH‰L‰NI)Ñ‚ƒùÿÿH H‰L‰Né¥÷ÿÿÌÌÌÌAVSHƒì8HÿÆ„’���H‰ûH‹GH �H9ñHGñHƒþA¾���LCö1öL‰ñHÁé=@”ÆJµ����HöH…Àt H‹ HÁàH‰L$HÇD$���H‰D$ë HÇD$����H|$ HL$èßPþÿHƒ|$ �H‹|$(tH¸������€H9ÇtH…ÿuèY%ýÿ H‰;L‰sHƒÄ8[A^ÃH‹t$0è~%ýÿ ÌÌÌÌÌÌÌÌÌÌÌÌH‹HƒÀþHƒøw:H
¨SüÿHcHÈÿàH‹W±ë$¶W±ë ·W±ë‹W±ë
H‹W±H…Òy1ÉHú���’À ÈÃÌÌÌÌÌÌÌÌÌÌH‹HƒÀþHƒøwFH
`SüÿHcHÈÿàH‹W¸���öW¸���÷W¸���ËW¸���ÃH‹W¸���H…ÒxÃ1ÀÃÌÌÌÌÌÌÌÌÌÌH‹HƒÀþHƒøw:H
SüÿHcHÈÿàH‹W°ë$¶W°ë ·W°ë‹W°ë
H‹W°H…Òy1ÀHú���’Á Á¶ÁÃÌÌÌÌÌÌ̶ÂÿȃøwcH
ÓRüÿHcHÈÿàH‹H‹NH…É„1��HÿÉHPH‰H‰N¶�H‰GÆKÃH‹H‹NHƒù‚‚���HƒÁþHPH‰H‰N·�f‰D$ñë`ƈWÃH‹H‹NHƒùr}HƒÁüHPH‰H‰N·H¶¶@ˆT$óˆD$öf‰L$ô‹D$óë H‹H‹NHƒùrkHƒÁøHPH‰H‰NH‹�H‰G°KˆÃfÇD$ð��ÆD$ö�ÇD$ò����‹L$ó‰O‹L$ð‰OH‰GëXÇD$ð����ÆD$ö�fÇD$ô��‹L$ó‰OÇG����H‰Gë0ÆD$ö�fÇD$ô��ÇD$ð����H‰D$÷H‹D$ð‹L$ø‹T$û‰O ‰W H‰G°ˆÃfÇ�fÇG��ÇG����H‰GÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌ€úu!H‹H‹NHƒùvUHƒÁøHPH‰H‰NH‹�ë8H‹H‹NHƒùrvHƒÁüHPH‰H‰N·H¶¶@ˆT$ëˆD$îf‰L$ì‹D$ëH‰G°KˆÃÆD$î�fÇD$ì��ÇD$è����H‰D$ïH‹D$è‹L$ð‹T$ó‰L$ø‰T$ûH‰G‹D$ø‹L$û‰G ‰O ë&ÇD$è����ÆD$î�fÇD$ì��‹L$ë‰OÇG����H‰G°ˆÃÌÌÌÌÌÌÌÌÌÌÌ̶ÂÿȃøweH
“PüÿHcHÈÿàH‹H‹NH…É„A��HÿÉHPH‰H‰N¶�éí���H‹H‹NHƒù‚†���HƒÁþHPH‰H‰N·�f‰D$á±Ké´���ˆT$ð±é ��H‹H‹NHƒùrvHƒÁüHPH‰H‰N·H¶¶@ˆT$ãˆD$æf‰L$ä‹D$ã±KëmH‹H‹NHƒùrsHƒÁøHPH‰H‰NH‹�ëVfÇD$à��ÇD$â����ÆD$æ�‹L$à‰L$ð‹L$ã‰L$óë$ÇD$à����ÆD$æ�fÇD$ä��‹L$ã‰L$óÇD$ð����±H‰D$÷€ùKuYH‰G±KˆÃÆD$æ�fÇD$ä��ÇD$à����H‰D$çH‹D$à‹L$è‹T$ë‰L$ø‰T$ûH‰D$ðëÆD$ð�fÇD$õ��ÇD$ñ����H‰D$÷±H‹D$ðH‹T$÷H‰WH‰GˆÃÌÌÌÌÌAWAVATSPI‰öI‰ÿH‹_H…öt+ˆ‘���¾���L‰÷ÿ]Ü��I‰ÄH…Àu¿���L‰öè ýÿ A¼���H‰ÞI;_uL‰ÿH‰Þè$µÿÿI‹wI‹H vL‰$ÈL‰tÈL‰tÈHÿÆI‰wH9ós I‹H[H‹ÑH‹TÑHƒÄ[A\A^A_ÃHÔ×��H‰ßèd'ýÿ è] ýÿ H‰ÃM…öt L‰çÿªÚ��H‰ß貧�� UAWAVAUATSHì���HÇ$����Hì���HÇ$����Hì ��H‰ËI‰×I‰öI‰üÇ„$0)������HÇ„$()������Hl$L‹-ŠÚ��º)��H‰ï1öAÿÕºÎ��H¼$4)��1öAÿÕH‰çH‰îL‰âL‰ñM‰øI‰Ùèœyýÿ€|$�”ÀL94$”Á ÁH9\$”À ÈHÄ+��[A\A]A^A_]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌH‹?H…ÿtðHÿOðu HƒÇðéHŠÿÿÃÌÌÌÌÌÌÌAVSHƒì8HÿÆ„“���H‰ûH‹GH �H9ñHGñHƒþA¾���LCö1öL‰ñHÁé<@”ÆJõ����HÁæH…Àt H‹ HÁàH‰L$HÇD$���H‰D$ë HÇD$����H|$ HL$è.IþÿHƒ|$ �H‹|$(tH¸������€H9ÇtH…ÿuè¨ ýÿ H‰;L‰sHƒÄ8[A^ÃH‹t$0èÍ ýÿ ÌÌÌÌÌÌÌÌÌÌÌHƒìHBÿH9ðƒ±���H9òƒ£���HRHÇHƒÀèë „�����I‰($A@HÿÂHƒÀH9òtuLRJ‹ ÇJ;LÇèsåN ÇNÇIƒÀèAA)$M‹PM‰QA�AHƒút®A¹���I‰À D��I;HèsšMPèM‹ZM‰XAA�IÿÁM‰ÐL9ÊuÛI‰øésÿÿÿHƒÄÃH=}xüÿHèÇ��¾.���èV1ýÿ ÌÌÌÌUAWAVAUATSM…À„.��H‰ÈIÁàIÈH‹ L‹VA‰ÓAÁë‰Ñá��ÿÿù���D‰ÝDêE1íL%kKüÿ‰L$ÔH‰ÙD·p
+A¹���E~ÿAƒÿ+w<Oc<¼MçAÿçI‰ßA¹���é��I‰ßé ��I‰ßA¹���éý���I‰ßA¹���éï���E¾ààÿÿAƒÿs$I‰ßE‰Ùé×���I‰ßE1ÉéÌ���I‰ßA¹���é¾���M…ítM)ê‚G��LéH‰L‰VI‰ÏANýƒù ‡²���H cKüÿHc ‹HÙÿáM…Ò„Q��‰l$àMJÿI_E1í1Éfff. „�����D¶sÿƒù?u
+A€þƒ��A¶îA‰îAƒæIÓæM õ@„퉷���ƒÁHÿÃIƒÁÿrÆéç��I‰ßA‰ÑëI‰ßA‰éëI‰ßA¹��� „�����E¶ÉMÍL‰ûHƒÀL9À…©þÿÿéq��AÆÿàÿÿAƒþƒÛ�� �Iƒê‚f��I_H‰ L‰VA€?�I‰ßxâH‰ÙE1íë´M…Ò„®��MrÿIOH‰L‰vE¶/D‰ëƒãE„íx#M‰òé“���H‰ L‰NM‰ÊH‰ÙL‰l$ð‹l$àéjÿÿÿM…ö„µ��MrþIOH‰L‰t$àL‰vE¶wE‰õAƒåAÁå·ÛD ëE„öxL‹T$àë9Hƒ|$à�„s��IƒÂýIOH‰L‰VE¶wfAƒþ‡q��E·öAÁæ·ÛD óM‰ÕA‰ÞI‰ÏM‰êD‰t$ÔA·ÎYÿƒû+‡¾��L5JüÿIc žLñÿáM…Ò„»��MjÿIOH‰L‰nA¶ A‰ÞAƒæ„Ûy®D‰t$ÔM…í„à��MjþIOH‰L‰nE¶wD‰t$àAƒæAÁæ‹\$Ô·ÛD óA‰Þ€|$à�‰gÿÿÿM…í„ž��IƒÂýIOH‰L‰VA¶_fƒû‡¥��·ÛÁãE·öA ÞM‰Õé+ÿÿÿIƒú†��IƒÂþI_H‰ L‰VE·/H‰ÙéòýÿÿIƒú†��IƒÂüI_H‰ L‰VA·OE¶A‰îA¶oDˆL$Û@ˆl$ÞD‰õf‰L$ÜD‹l$ÛH‰Ùé©ýÿÿM…ÒL‹L$ø„‰��1Éffffff. „�����A€<�t0HÿÁI9Êuñéd��M…Ò„��IÿÊI_H‰ L‰VE¶/H‰ÙéSýÿÿI HÿÃH÷ÑIÊH‰ L‰VH‰ÙL‰|$øE1íé/ýÿÿL‰ùE1íA¹���éýÿÿL‰ùE1íé ýÿÿD‰ÿàÿÿAƒù‚(ýÿÿÁààÿÿƒùƒñ���L‰ùE1íE‰ÙéÛüÿÿL‰ùE1íA¹���éÊüÿÿL‰ùE1íA¹���é¹üÿÿL‰ùE1íE1Éé«üÿÿL‰ùE1íA¹���éšüÿÿL‰ùE1íA‰ÑéŒüÿÿL‰ùE1íA‰éé~üÿÿL‰ùE1íéeüÿÿM…ít M)êsÆH‰_ëMfÇ�ë5LëH‰ L‰VÆKë7H‰ L‰N°L‹|$ðëM×L‰>HÇF����°ˆÆG�fÇG��ÇG����L‰[A\A]A^A_]ÃIá�ÿÿÿIƒÉL‰ëáÆ ëà°1ÒëRfÇD$è��ÆD$î�ÇD$ê����‹D$ë‰G‹D$è‰Gë"ÇD$Ø����ÆD$Þ�fÇD$Ü��‹D$Û‰GÇG����Æë‹°1ÒI‰ÏˆÆG�f‰WÇG����énÿÿÿ°‹T$Ôëâ°fº�ëÚÌÌÌÌÌUAWAVAUATSHƒìhI‰üL‹v(M…ö„ý ��I‰õL~ H|$H‰t$0L‰|$(E‹]0A€}4�„���M‹E M~ÿMHM‰M M‰}(A¶�Hƒø‡’ ��D‰ÞÁîH
GüÿHcHÈÿàM…ÿ„Ù
+��IFþIp1Ò1ÉL‹|$(ff. „�����D¶Nÿƒù?u
+A€ùƒz
+��E¶ÉE‰ÊAƒâIÓâL ÒE„ɉ¡��ƒÁHÿÆHƒÀÿrÆél
+��M‰ÞA¶ëL‰þ‰êI‰ýè|ñÿÿ¶D$<K…º
+��H‹\$L‰ïL‰þ‰êè]ñÿÿ¶D$<K…›
+��H‹D$H‰ÁH ÙH|$L‹l$0„Í
+��L‰ñöÙÀáHÇÆÿÿÿÿHÓîA¶U01É(ÑÀáIÇÁÿÿÿÿIÓéfAƒ}2L‰ÊHƒÚ�H9óu
+L‹|$(éæ��L‹D$PI‹MH9ÑuL‰D$PL‹|$(éR ��HËL!ËHÈL!ÈL‹t$HL‰D$PL‹|$(é$ ��M…ÿ„˜ ��L‰\$@L‰d$8I^ÿMVýMX1íE1É1Éfffff. „�����A¶T(°ƒù?u €úƒú��D¶êE‰ìAƒäIÓäIWÿM áE„퉵��ƒÁHÿÅIÿÊIÿÃI‰×H9ëu¸éÓ��M…ÿ„ ��L‰\$@L‰d$8InÿMVýMX1ÛE1É1Éffff. „�����A¶T°ƒù?u €úƒz��D¶âE‰åAƒåIÓåIWÿM éE„䉨��ƒÁHÿÃIÿÊIÿÃI‰×H9Ýu¸éS��M…ÿ„—��L‰\$@L‰d$8InÿMNýMPE1Û1Û1Éffff. „�����C¶T°ƒù?u €úƒú��D¶âE‰åAƒåIÓåIWÿL ëE„䉖��ƒÁIÿÃIÿÉIÿÂI‰×L9Ýu¸éÓ��A¶ÓL‹|$(L‰þè"ïÿÿ¶D$<K…B ��H‹D$H|$I‰Eé€��A¶ëL‹|$(L‰þ‰êI‰ýèìîÿÿ¶D$<K…+ ��H‹\$L‰ïL‰þ‰êèÍîÿÿ¶D$<K… ��L‹l$0A¶E01É(ÁÀáHÇÂÿÿÿÿHÓêfAƒ}2H‹D$HƒÚ�L‹t$HH|$é÷��A¶ÓL‹|$(L‰þèvîÿÿ¶D$<K…–��I‹u I‹E(H…À„˜��H‹\$HPÿL^E1À1ÉH|$E¶Kÿƒù?u
+A€ùƒò��E¶ÉE‰ÊAƒâIÓâM ÐE„ɉÎ��ƒÁIÿÃHƒÂÿrÆé2��I‰u I‰E(I‹uI‹E�I‹MH)ñ‚»��HðA¶óH¯ÖH‰ÎH)Ö‚¤��E¶ÃAÿÈAƒø‡v��HÐL
:CüÿOcMÈAÿàH9Ñ„b��¶�éŒþÿÿI (HƒÃH‹L$0H‰Y H‰Q(H…ÒL‹d$8„o��I (HÿÃE1ö1ÉL‹l$0 �A¶Sÿƒù?u €úƒ��¶ÒA‰ÐAƒàIÓàM Æ„Ò‰2��ƒÁIÿÃIƒÂÿrÉé��I<HƒÇL‹l$0I‰} I‰U(H…ÒL‹d$8„‹��I<HÿÇE1À1É D��A¶Sÿƒù?u €úƒ��¶Ò‰ÓƒãHÓãI Ø„Ò‰M��ƒÁIÿÃIƒÂÿrËé1��K<HƒÇL‹l$0I‰} I‰U(H…ÒL‹d$8„ ��K<HÿÇE1À1É €����A¶Rÿƒù?u €úƒK��¶ÒA‰ÓAƒãIÓãM Ø„Ò‰d��ƒÁIÿÂIƒÁÿrÉé¿��M‰] I‰U(A¶E01É(ÁÀáHÇÆÿÿÿÿHÓîfAƒ}2H‰òHƒÚ�IH!ðL‹t$HL‰D$`és��M‰] H‹|$@‰ùöÙÀáHÇÂÿÿÿÿHÓêM‰U(fƒþHƒÚ�I‹MI‹E�I‹uH)΂V��HÈD¶ÇM¯ÈH‰ñL)É‚?��D¶×AÿÊAƒú‡J��J H=Ý@üÿNc —IûAÿãL9΄Ò��¶é¶��M‰] M‰U(L‹\$@D‰ÙöÙÀáIÇÂÿÿÿÿIÓêfƒþL‰ÒHƒÚ�I‹MI‹]�I‹EH)È‚Ð��HËA¶ËL¯ÉH‰ÁL)É‚¹��A¶óÿ΃þ‡Ê��LËH=3@üÿHc4·HþÿæL9È„I��¶é‹��M‰U M‰M(H‹L$@öÙÀáIÇÁÿÿÿÿIÓéfƒþL‰ÊHƒÚ�L‰ÀH|$éÑùÿÿHƒþrG·�f‰D$ ±Ké„���HƒþrX·H¶¶@ˆT$ ˆD$f‰L$ ‹D$ ±Kë^Hƒþ‚Œ��H‹�éeûÿÿfÇD$��ÇD$
+����ÆD$�‹L$‰L$‹L$ ‰L$ë$ÇD$����ÆD$�fÇD$ ��‹L$ ‰L$ÇD$����±€ùK„ûÿÿéï��Hƒù‚µ���·f‰\$ ë*Hƒù‚Ç���·KD¶ D¶[DˆL$ Dˆ\$f‰L$ ‹\$ ±KéÆ���Hƒù‚2��H‹L‹|$(H|$é½���Hƒù‚K��·f‰\$ ë'Hƒù‚]��·C¶ ¶sˆL$ @ˆt$f‰D$ ‹\$ ±Ké_��Hƒù‚Ô��H‹L‹|$(H|$éV��fÇD$��ÇD$
+����ÆD$�‹L$‰L$‹L$ ‰L$ë$ÇD$����ÆD$�fÇD$ ��‹L$ ‰L$ÇD$����±L‹|$(H|$€ùK…��M¯ÆH‰ñL)Á‚ž��Aƒú‡Ÿ��LÀL <>üÿOc “MÙAÿáL9Æ„—��¶�é)��Hƒù‚Á���·�f‰D$ ±Kéþ���Hƒù‚Î���·H¶0¶@@ˆt$ ˆD$f‰L$ ‹D$ ±KéÐ���Hƒù‚Y��H‹�éÐ���fÇD$��ÇD$
+����ÆD$�‹D$‰D$‹D$ ‰D$ë$ÇD$����ÆD$�fÇD$ ��‹D$ ‰D$ÇD$����±L‹|$(H|$€ùK…˜��JL!ÐL‹t$HL‰D$Xë^fÇD$��ÇD$
+����ÆD$�‹L$‰L$‹L$ ‰L$ë$ÇD$����ÆD$�fÇD$ ��‹L$ ‰L$ÇD$����±H‰D$ €ùK…º�� @�L‰t$HH9Ó…��M‹u(M…ö…9õÿÿé��1É1ÒL‹d$8L‹l$0ëSMðL‹l$0M‰E IÇE(����M‰ÁL‹d$8ë/1É°1Òë-M‰] I‰U(°1É1ÒL‹L$`ëMðM‰E IÇE(����M‰Á°1É1ÒHÁá¶ÒHÁâH ʶÀH ÐH
düÿI‰M IÇE(����I‰D$M‰L$IÇ$���é‚���HÆI‰u IÇE(����°1É1ÒI‰ñ먶L$Áá·t$
ÎHÁæ ‹T$ H òL‹L$L‹l$0H‰ÑHÁééxÿÿÿLÿI‰} IÇE(����°1É1ÒI‰ùé[ÿÿÿH‰cüÿI‰E IÇE(����IÇ$����HƒÄh[A\A]A^A_]Ã1É1ÒL‹L$Hé#ÿÿÿ1É1ÒL‹L$Xéÿÿÿ1É1ÒL‹L$PéÿÿÿLûI‰] IÇE(����°1É1ÒI‰ÙL‹l$0éåþÿÿH9Ãv]HcüÿI‰E IÇE(����±0éÆ���¶T$ ‹t$
+·L$HÁá H ñL‹L$é§þÿÿ¶T$ ‹t$
+·L$HÁá H ñL‹L$L‹l$0éƒþÿÿIÇ$���I‰\$I‰D$é,ÿÿÿ°0é6þÿÿ±H‰Ã뱶D$ Áà·t$ ÆHÁæ ‹T$H òH‰Øë=±ë9Dˆ\$±ëÆD$�fÇD$ ��ÇD$����±¶T$ Áâ·t$ ÖHÁæ ‹T$H òHÁâ¶ÉH ÑI‰L$I‰D$IÇ$���éŸþÿÿÆD$�fÇD$ ��ÇD$����H‰D$H‹D$‹L$‹T$‰L$ ‰T$#H‰D$±H‹D$ ë‰ÆD$�fÇD$ ��ÇD$����±é,ÿÿÿÆD$�fÇD$ ��ÇD$����H‰\$H‹D$‹L$‹T$‰L$ ‰T$#H‰D$±H‹\$ éíþÿÿH‹D$@ˆD$ëDˆ\$±éÖþÿÿH‹D$@ˆD$±H‹D$ éÿÿÿÆD$�fÇD$ ��ÇD$����H‰D$ ë3ÆD$�fÇD$ ��ÇD$����H‰D$H‹D$‹L$‹T$‰L$ ‰T$#H‰D$±H‹D$ é©þÿÿAVSHƒì8HÿÆ„¡���H‰ûH‹GH �H9ñHGñHƒþA¾���LCöH¹Èq Çq Ç1öI9Î@’ÆJ õ����HÉHÁæH…Àt H‹ HÁàHÀH‰L$HÇD$���H‰D$ë HÇD$����H|$ HL$è°2þÿHƒ|$ �H‹|$(tH¸������€H9ÇtH…ÿuè*ýÿ H‰;L‰sHƒÄ8[A^ÃH‹t$0èOýÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌAWAVAUATSL‹7M…ötyH‰ûL‹M…ÿtSMf(L‹-8Â��ëf D��IƒÄHIÿÏt.Iƒ|$à�tïI‹|$èH…ÿtåIƒ|$ð�tAÿÕIƒ<$�tÓI‹|$øAÿÕëÉL‰÷ÿðÁ��Hƒ{�tH‹{[A\A]A^A_ÿ%ÖÁ��[A\A]A^A_ÃÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHì¨��L‰Œ$X��‰Œ$4��I‰õI‰þH‹Œ$à��A‹pHHÀ���HÁ°���H‰´$ø���Á$È���fƒþ“D$7HCÈH‰Œ$��I‹E H‰”$˜��H‰„$(��H9ÐŽÅ��M‰ÇH‹´$ø��A·@Jf‰„$¶���A¶@IˆD$I‹€ˆ��H‰„$P��I‹€ ��H‰„$Ø���H‹œ$ø���¶ÇH‰„$p��‰Ø%�ÿ��‰„$0��I‹EH‹H8IM�I‹��H‰”$��1Ò€xI¶Û”ÂH,ÑH‹H0HH(H)ÍHƒÅI‹€€��H‰„$x��HFH‰„$ˆ��L‰t$8L‰„$H��ëw „�����è»_ýÿI‰ÐI‹M‹QHH|$pL‰îH‰ÁèQèÿÿ¶D$p<K…(��I‹EI‹} H‹H0H‹P81ö€xI@”ÆIU�HH(H,òH)ÍHƒÅH‰¼$(��H;¼$˜��ŽŠ
��H|$pL‰îèt��¶D$p<K…
��H‹|$xH…ÿt™·Ghƒø „ ���ƒø.…Wÿÿÿè_ýÿI‰ÐI‹M‹QHH|$pL‰îH‰Áè¨çÿÿ¶D$p<K…*
��L‹¤$(�� �M9e ŽBÿÿÿH|$pL‰îèù��¶D$p<K…û ��H‹|$xH…ÿtÒè^ýÿI‰ÐI‹M‹QHH|$pL‰îH‰ÁèCçÿÿ¶D$p<KtªéÄ �� D��è{^ýÿH‰„$ ��¶„$4��‰„$Ì���H…Ò„¾��I‰ÔIÁäE1ÿ1ÀH‰D$X1ÀH‰„$ð���1ÀH‰„$��1ÀH‰„$ ��1ÀH‰„$è���1ÀH‰„$à���1ÀH‰„$���1ÀH‰„$À���L5å4üÿëL5Ü4üÿ @�IƒÇM9ü„“��H‹„$ ��B8)D$@I‹E‹PHH|$pL‰îHL$@è¶ÿÿH‹D$pHƒø.„ ��·Œ$ˆ���QýƒúV‡…���Ic –LñÿáHƒ|$X�u”H|$@Ht$pèõÉÿÿH‹t$@H‹T$HH|$‹Œ$Ì���L‹„$H��L‹Œ$X��jÿ´$è��èQ
��HƒÄHƒ|$�H‹D$ H‰D$XH‹L$(…
+��H‰Œ$��é%ÿÿÿ D��ƒùnt ù ��…ÿÿÿLt$@L‰÷Ht$pèmÉÿÿ¶T$H|$H‹´$à��H‹Œ$P��M‰ðè›ÿÿHƒ|$�…ÄþÿÿH‹D$(H‰„$��H‹D$ H‰D$Xé¨þÿÿHƒ|$X�…§þÿÿLt$@L‰÷Ht$pèÉÿÿ¶T$H|$H‹´$à��H‹Œ$P��M‰ðè3ÿÿHƒ|$�…3��H‹D$ H‰D$XH‹D$(L5)3üÿé.��H|$@Ht$pèÈÿÿH‹D$@H…À„5��ƒø …&þÿÿH‹Œ$à��H‹AH‹IH‹”$��H)Ñ‚É ��HÐH‹T$HH¯ÓH‰ÎH)Ö‚± ��H‰ß{ÿƒÿ‡~ ��HÐLX4üÿIc<¸LÇÿçH9Ñ„r ��¶�é„��H|$@Ht$pèÈÿÿH‹D$@H…À„+��ƒø„A��ƒø …‹ýÿÿH‹Œ$à��H‹AH‹IH‹”$��H)Ñ‚. ��HÐH‹T$HH¯ÓH‰ÎH)Ö‚ ��H‰ß{ÿƒÿ‡ã��HÐL3üÿIc<¸LÇÿçH9Ñ„×��¶�éX��H|$@Ht$pè€ÇÿÿH‹L$@H‹D$HHƒù„!��ƒùH‹´$¨���…r��fƒ¼$È���¾����HB´$Ø���H‹Œ$à��€¹à����¹����HDñéÜ��HƒÀþHƒø‡��H
Ö2üÿHcHÈÿàH‹D$xéù��H|$@Ht$pèðÆÿÿƒ|$@,…uüÿÿfƒ¼$¶���“ÀH‹L$HH…É•ÂÂH‹„$@��HEÁH‰„$@��¸���H‹Œ$ð���HEÈH‰Œ$ð���é*üÿÿHƒÀþHƒø‡Ò��H
a2üÿHcHÈÿàH‹D$xH‰„$��éúûÿÿ¸���H‰„$è���H‹D$HH‰„$¸���éÛûÿÿH‹Œ$à��H‹±À���H‹‰È���H‹”$Ø���H)Ñ‚0��HÖH¯„$p��H)Á‚��HƼ$0�����…‚���Hƒù†q��H‹6é–���1ÀéŸ���¸���H‰„$à���H‹D$HH‰„$Ð���éSûÿÿ¸���H‰„$���H‹D$HH‰„$`��é4ûÿÿ1ÀH‰D$XL5þ/üÿH‹„$h��H‰„$h��H‰„$��é ûÿÿHƒù‚5��·F¶¶VˆL$ˆT$ f‰D$ ‹t$H‹„$Ø���HƸ���H‰„$À���H‰´$¨���H‰´$€��é¶úÿÿ¶D$xë·D$xë‹D$xë H‹D$xH…Ày1ÀH‰„$ ��é‰úÿÿ¶D$xH‰„$��éwúÿÿ·D$xH‰„$��éeúÿÿ‹D$xH‰„$��éTúÿÿH‹D$xH…Ày1ÀH‰„$��é;úÿÿHƒþ‚¦���·�f‰D$±Kéã���Hƒþ‚³���·H¶¶@ˆT$ˆD$ f‰L$ ‹D$±Ké¶���Hƒþ‚Û��H‹�é���Hƒþ‚½���·�f‰D$±Kéú���Hƒþ‚Ê���·H¶¶@ˆT$ˆD$ f‰L$ ‹D$±KéÍ���Hƒþ‚ƒ��H‹�éÄ���fÇD$��ÇD$����ÆD$ �‹L$‰L$‹L$‰L$ ë$ÇD$����ÆD$ �fÇD$ ��‹L$‰L$ ÇD$����±€ùK…��¹���H‰Œ$è���H‰„$¸���é ùÿÿfÇD$��ÇD$����ÆD$ �‹L$‰L$‹L$‰L$ ë$ÇD$����ÆD$ �fÇD$ ��‹L$‰L$ ÇD$����±€ùK…—��¹���H‰Œ$à���H‰„$Ð���éøÿÿ1ÀH‰„$À���1ÀH‰„$���1ÀH‰„$à���1ÀH‰„$è���1ÀH‰„$ ��1ÀH‰„$��1ÀH‰„$ð���1ÀH‰D$XL‹¼$è��M‹wL‰ðM;wuL‰ÿL‰öèà��I‹GI‹H@HÁâH‹´$ð���H‰4H‹´$@��H‰tH‰lH‹t$XH‰tH‹´$��H‰t H‹´$��‰t(H‹´$ ��‰t,HÿÀI‰GHƒ¼$À����„B��H‹„$��L‹8H‹@H‹”$€��H)ЂI��H‹Œ$à��AI×D$pH‹Œ$x��H‰Œ$€���H‹Œ$��H‰Œ$ˆ���L‰¼$���H‰„$˜���H‹„$ø���f‰„$ ���‹„$È���f‰„$¢���¶D$7ˆ„$¤���ë9ffff. „�����H‹H‰ñHÁáH‰,L‰|H‹”$ø��H‰TL‰tHÿÆH‰wH|$@Ht$pèµãÿÿH‹D$@H‹l$HL‹|$PHƒøu*L9ýs×H‹¼$ð��H‹wH;wu™èTÿÿH‹¼$ð��H‹w놃ø…��@€ýK„
��éB��HD$x�)D$`éB��Hƒ¼$à����H‹„$è���tcH…Àt^H‹„$Ð���H9„$¸���ƒÈ���H‹¼$ð��H‹wH;wuè×ÿÿH‹¼$ð��H‹wH‹”$¸���L‹„$Ð���H‹H‰ñHÁáH‰L‰DëgHƒ¼$����tuH…ÀtpH‹„$`��H‹Œ$¸���L<L9ùsWH‹¼$ð��H‹wH;wuèfÿÿH‹¼$ð��H‹wH‹H‰ñHÁáH‹”$¸���H‰L‰|H‹”$ø��H‰TL‰tHÿÆH‰wH|$`L‰îH‹”$(��‹Œ$Ì���L‹„$H��L‹Œ$X��ÿ´$ˆ��ÿ´$ø��ÿ´$ø��ÿ´$ø��è.òÿÿHƒÄ L‹t$8H‹´$¨���¶l$`@€ýK…ù��H‰´$¨���é}óÿÿH‹D$XH‰D$`H‰L$hëÆÆD$ �fÇD$ ��ÇD$����H‰t$ H‹t$HL$ ‹‹IHT$‰‰JH‰´$8��H‰t$H‹t$ëFÇD$����ÆD$ �fÇD$ ��‹D$‰D$ ÇD$����¶D$Áà·L$ ÁHÁá ‹D$H ÈH‰„$8��L‹t$8H‹„$8��HÁàHƒÈH‰D$`H‰t$hé#ÿÿÿH‹„$ø���ˆD$±ëÆD$�fÇD$
��ÇD$ ����H‰D$±H‹D$‹T$‹t$ H|$a‰w‰ˆL$`H‰D$héÆþÿÿÆD$ �fÇD$ ��ÇD$����H‰D$ H‹D$HT$ ‹
+‹RHt$‰‰VH‰D$ë AÆKëC‹L$q‹T$t‰T$C‰L$@H‹L$x‹T$@‹t$CA‰vA‰Vë‹L$q‹T$tA‰VA‰NH‹L$xAˆI‰NHĨ��[A\A]A^A_]ÃH‹L$qH‹T$xI‰VI‰NAˆë×@µ1À1Éë ‰éÁéH‰èHÁèL‹t$8ˆL$a‰D$bHÁè f‰D$fL‰|$hHL$aH‹H‹II‰NI‰FAˆ.ëŽÌÌÌÌÌÌÌÌÌÌÌÌAVSPHBÿH9ðƒâ���H9òƒÑ���H‰ÐHÁàHøHƒÀàë(f D��I‰ùM‰M‰YI‰IM‰QHÿÂHƒÀ H9ò„™���H‰ÓHÁãL IƒÁàL‹ H‹L H;L ðrwÏM;sÊHûL‹[L‹SAAIKHƒútš»���I‰Áë.ffff. „�����AANAIAHÿÃM‰ñH9Ú„_ÿÿÿMqàI;IðrÕ‡RÿÿÿM;rÊéHÿÿÿHƒÄ[A^ÃH= QüÿH‡ ��¾.���èõ ýÿ ÌÌÌUAWAVSPL‹\$8M…Û„��I‰ÒH‹D$0Hƒþ
„��Hƒþ„'��Hƒþ…õ���H‹€Ð���H…À„å���I‹Q0H…Ò„c��I‹I(E1À¾ÿ���H‰Óë €����H‰ÓL)ÂvCHÑêLÂLiò°��1íN9”1¨��@•ÅBî@€ýtÔD¶ÅAøÿ���…��HÿÂI‰ÐH‰ÚL)Âw½M…À„÷��Iiа��Hƒ¼
+Pþÿÿ�…á��HÊHÂPþÿÿL+R‚Í��H‹J0H‹r8E1À€zIA”ÀH)ÎNÆIƒÀL‰ÖL)Æ‚£��H9΃š��HƒÀL‰ $¾���ëWÀé“��L‰ $¶ñL‰ÂL‰ÑM‰ÈI‰Áè��év��¶ñ@„ö„–���ƒþ…N��I‹Q0H…Ò„A��I‹I(1ÛA¸ÿ���I‰Öë
D��I‰ÖH)ÚvCHÑêHÚLiú°��1íN9”9¨��@•ÅABè@€ýtÓ@¶Ýûÿ���…î���HÿÂH‰ÓL‰òH)Úw½H…Û„×���HiÓ°��HÊHÂPþÿÿéƒ���I‹Q H…Ò„´���I‹I1ÛA¸ÿ���I‰Öë „�����I‰ÖH)Úv?HÑêHÚLiú��1íN9”9¨��@•ÅABè@€ýtÓ@¶Ýûÿ���ubHÿÂH‰ÓL‰òH)ÚwÁH…ÛtOHiÓ��HÊHÂèýÿÿHƒ:�u8L+Rr2H‹J0L‹B81Û€zI”ÃI)ÈI ØHƒÃM‰ÐI)ØrI9Ès L‰ $éŠþÿÿHÇG7���L‰WHÇ���HƒÄ[A^A_]ÃÌÌÌÌÌÌÌUAWAVAUATSHìÈ���H‰ÈI‰ÔH‰ûH‹R0I‹L$8A¶l$IE1Ò@€ýA”ÂH‰ÏH)×N ×IƒÃH‰ÇL)ß‚—���H9׃Ž���N Õ���M‹´$X��IT$(M~L‰¤$˜���L‰¼$ ���HÇ„$¨�������H‰ÇH÷×LßHÏL)ØH)ÈE1í1Éffff. „�����D¶ƒù?uA€úw3E¶ÒE‰ÓAƒãIÓãM ÝE„ÒyPƒÁHÿÏHÿÀuÏ°ëHÇC8���L‰cë°ˆCÆC �fÇC��ÇC
+����H‰SHÇ���HÄÈ���[A\A]A^A_]ÃHÐHÿÀH‰„$ˆ���H‰¼$���M…ítIEÿI;F sHkøpI?é¥���ÆC7ë°I‹~(°H…ÿ„4��L‰L$I‹N01ÒA¿ÿ���D·—2��N Õ����IÇÁÿÿÿÿfff. „�����M…Ût+E1öN9¬Ïà��A•ÆEG÷IÿÁIƒÃøA€þtÛE¶ÖE…ÒuëM‰ÑHƒé‚ÿÿÿJ‹¼Ï8��ë–H…ÿ„°��IkÁpHÇL‹L$M‰Î‰t$L‰D$P€ju HÇ„$¨������èñJýÿH‰D$`H…Ò„»��I‰×L‰t$I‹„$ˆ��H‰D$(IÁç¸.���H‰D$ E1íL´$°���1ÀH‰D$ë@fff. „�����L‰÷Ht$hè·ÿÿH‹„$°���H‰D$ H‹„$¸���H‰D$XIƒÅM9ï„��H‹D$`B()„$°���H‹„$˜���‹PHH|$hH´$ˆ���L‰ñ蚢ÿÿƒ|$h.„Æ���·„$€���ƒøF~RƒøG„yÿÿÿƒønt= ��u”L‰÷Ht$h耶ÿÿ@¶ÕH|$0H‹t$H‹L$(M‰ð赊ÿÿHƒ|$0�…`ÿÿÿé·��� @�ƒøtƒø1„"ÿÿÿéDÿÿÿL‰÷Ht$hè0¶ÿÿ@¶ÕH|$0H‹t$H‹L$(M‰ðèeŠÿÿHƒ|$0�…ÿÿÿH‹D$8H‰D$H‹D$@H‰D$Hé÷þÿÿ1ÒéNýÿÿD$pCéXýÿÿH‹D$H…ÀtH‰CH‹D$HH‰CHÇ����é<ýÿÿH‹t$ Hƒþ.H‹D$u WÀé!ýÿÿD$8CHÇ����é ýÿÿL‹”$���IÿʶL$H‰ßH‹T$XM‰àL‹L$PARPèðøÿÿHƒÄéÛüÿÿÌÌÌÌÌÌÌSL‹L‹NM…ÉtTKIÿÉIÿÀ1À1É D��E¶Pÿƒù?uA€ús8E¶ÒE‰ÓAƒãIÓãL ØE„ÒyDƒÁIÿÀIƒÁÿrÎH‰HÇF����°ëL‰Â°ë L‰L‰N°ˆÆG�fÇG��ÇG����H‰W[ÃL‰L‰NH…Àt%H‹VHHÿH;Js(HkÉpH
+€yjuHÿF H‰Oë HÿN HÇG����ÆK[ÃH‹JH…É„‚���H‹R A¸ÿ���D·‘2��N Õ����IÇÁÿÿÿÿf D��M…Ût(1ÛJ9„Éà��•ÃAGØIÿÁIƒÃø€ûtÞD¶ÓE…ÒuëM‰ÑHƒêr%J‹ŒÉ8��ë£H…ÉtIkÁpHÁ€yj„[ÿÿÿéZÿÿÿ‹D$ù‹L$ü‰O‰GÆHÇG����[ÃÌÌÌÌÌÌÌÌÌÌAVSHƒì8HÿÆ„ ���H‰ûH‹GH �H9ñHGñHƒþA¾���LCöH¹«ªªªªªª1öI9Î@’ÆL‰ñHÁáHIHÁæH…Àt H‹ HÁàH@H‰L$HÇD$���H‰D$ë HÇD$����H|$ HL$èqþÿHƒ|$ �H‹|$(tH¸������€H9ÇtH…ÿuèëëüÿ H‰;L‰sHƒÄ8[A^ÃH‹t$0èìüÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHìˆ���‰ÕH‰óH‰<$L‹&L‹nH‹~èFFýÿL‰d$L‰l$H‰D$H‰T$ H‰\$(H…Ò„¥���I‰ÆI‰×IƒÆIÿÏLd$@Ll$H\$`IƒÿÿtafIFð�)D$`H‹D$(H‹@‹PHL‰çL‰îH‰Ùè:žÿÿH‹D$@Hƒø.tsHL$HH‹L$XL‰t$L‰|$ )D$0f9étpIƒÆIÿÏIƒÿÿu¡H‹D$(Hƒx(�u,H‹L$H+HÇ@(���H‰H0ëHƒ{(�uL+#HÇC(���L‰c0H‹$HÇ�.���ë2HD$H�)D$0H‹$@HÇ�/���ë(D$0H‹$BH‰H‰JHĈ���[A\A]A^A_]ÃÌÌÌÌÌÌÌÌUAWAVSH‹L‹^Iƒûr%MSüHAH‰L‰VD‹ Aƒùïv9AƒùÿtIº���ë H‰ÈHÁèº���H‰ˆO‰G H‰ÁHÁé0ˆOHÁè f‰G
é¤���E‰È±M)Âs3HÇ���éŠ���Iƒú‚���IƒÃôHA H‰L‰^L‹A±M‰ÚM)ÂrÍN �L‰ L‰VIƒøvA·0A‰òAƒâþfAƒú…‚���MXþLPAƒùðr}Iƒû†É���MXöH‹XHƒÀ
+I‰Âé���ÆÇG����ÇG����H‰GÆG)[A^A_]ÃÆD$æ�fÇD$ä��ÇD$à����H‰D$çH‹L$àHÁèH‰ÊHÁâHÁé8HƒÊéûþÿÿÆH‰wë¶Iƒû‚†���MXúLP·X¶h¶@@ˆl$ãˆD$æf‰\$ä‹\$ãM…Ût
Iƒû…���IÿÂfÇ�fÇG��ÇG����ëoÆD$æ�fÇD$ä��ÇD$à����L‰T$çH‹D$à‹L$è‹T$ë‰L$ø‰T$ûH‰D$ðL‹T$÷ë$ÇD$à����ÆD$æ�fÇD$ä��‹D$ã‰D$óÇD$ð����‹D$ð‹L$ó‰O‰GÆL‰WéèþÿÿE¶2Aƒùð“ÀE„öxjE¶JC,6D�Ír\tZIƒÃþIƒÂÀà�ȶÀ@öõ¶Ä@(ÅE1ÿ„À@¶ÅADǶÀI)Ãr¤IÂL‰L‰_H‰WL‰GH‰_ Dˆw(ˆO)f‰w*DˆO,érþÿÿÆ0éfþÿÿÌÌÌÌÌÌÌÌÌÌÌÌÌÌPHBÿH9ðƒ–���H9òƒ‹���H‰ÐHÁàHøHƒÀðë f „�����I‰ M‰AHÿÂHƒÀH9òt_I‰ÐIÁàJ‹ J;LðsâNN IƒÁðN‹DAAHƒút¼Aº���I‰Á �I;IðsªMYðAAIÿÂM‰ÙL9ÒuãI‰ùëŽXÃH=ËBüÿH6’��¾.���è¤ûüÿ ÌÌAVSHƒì8HÿÆ„›���H‰ûH‹GH �H9ñHGñHƒþA¾���LCöH¹ÏnáWc"=�1öI9Î@’ÆIiÖ��HÁæH…Àt H‹ HiÀ��H‰L$HÇD$���H‰D$ë HÇD$����H|$ HL$èÆþÿHƒ|$ �H‹|$(tH¸������€H9ÇtH…ÿuè@æüÿ H‰;L‰sHƒÄ8[A^ÃH‹t$0èeæüÿ ÌÌÌAVSPH‰ûH‹‡X��ðHÿu H‹»X��èðQÿÿH{`è·ƒÿÿHƒ»°���t H»¸��èÁwÿÿHƒ»Ø���t H»à��èËÞÿÿ€»���LuHƒÄ[A^ÃHÃ���H‰ßHƒÄ[A^éäRÿÿI‰ÆH{`èXƒÿÿHƒ»°���uHƒ»Ø���u!€»���Lu-ë:H»¸��èMwÿÿHƒ»Ø���tßH»à��èWÞÿÿ€»���LtHÃ���H‰ßèRÿÿL‰÷è§m�� è
ýÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌÌAWAVATSHì��H‰ûHƒ?�uUL‹6H‹FL‹fH‹0L|$ L‰ÿèSÿÿI‹ $H‰çL‰öL‰úè,WÿÿHƒ;�t
+H‰çè®vÿÿë$L$KCHÇ���HƒÃH‰ØHÄ��[A\A^A_ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌAVSPH‰ûH‹‡X��ðHÿu H‹»X��è`PÿÿHƒÃ`H‰ßHƒÄ[A^é ‚ÿÿI‰ÆHƒÃ`H‰ßè‚ÿÿL‰÷è¶l�� ÌÌÌÌHƒìHBÿH9ðƒ×���H9òƒÉ���H‰ÐHÁàHøHƒÀàë+f D��I‰($A@H‹L$I‰HHÿÂHƒÀ H9ò„Ž���I‰ÐIÁàJ‹ J;LàsÞN IøIƒÀàM‹QL‰T$AA)$A�AHAAIHƒút”A¹���I‰Àff. „�����I;HàƒvÿÿÿMPàAAJAHA�IÿÁM‰ÐL9ÊuÕI‰øéMÿÿÿHƒÄÃH=?üÿH‚Ž��¾.���èð÷üÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSPI‰þH‹ L‹oIÿÅH‰ß D��IƒýtL§��IÿÍèÛüÿÿL‰çëæIƒ~�tH‰ßHƒÄ[A\A]A^A_]ÿ%8ž��HƒÄ[A\A]A^A_]ÃI‰Çf D��IÿÍtI¬$��L‰çè‹üÿÿI‰ìëæIƒ~�t H‰ßÿö��L‰ÿèþj�� è÷
+ýÿ ÌÌÌÌÌUAWAVAUATSPH‰ûL‹oM…ítJL‹3MeÿIÆ°��½���ë @�I¾°þÿÿè€ÿÿIÆ°��HÿÅIƒÄÿsI‹F¨ðHÿuÚI‹~¨èNÿÿëÏHƒ{�tH‹;HƒÄ[A\A]A^A_]ÿ%a��HƒÄ[A\A]A^A_]ÃI‰ÇI¾°þÿÿè£ÿÿL9íu3Hƒ{�t H‹;ÿ.��L‰ÿè6j�� @�I~`èwÿÿIÆ°��IÿÌtÍI‹†X��ðHÿuÞI‹¾X��è‚MÿÿëÐIƒÆ`L‰÷èDÿÿèï ýÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌAVSHƒì8HÿÆ„›���H‰ûH‹GH �H9ñHGñHƒþA¾���LCöH¹¢½„öÚK�1öI9Î@’ÆIiÖ°��HÁæH…Àt H‹ HiÀ°��H‰L$HÇD$���H‰D$ë HÇD$����H|$ HL$èF þÿHƒ|$ �H‹|$(tH¸������€H9ÇtH…ÿuèÀàüÿ H‰;L‰sHƒÄ8[A^ÃH‹t$0èåàüÿ ÌÌÌAVSPH‰ûH‹‡X��ðHÿu H‹»X��èpLÿÿHƒÃ`H‰ßHƒÄ[A^é-~ÿÿI‰ÆHƒÃ`H‰ßè ~ÿÿL‰÷èÆh�� ÌÌÌÌUAWAVAUATSPI‰öH‰ûA½���f „�����K.HƒøtL§��IÿÍè÷ùÿÿL‰çëâM…ötH‰ßHƒÄ[A\A]A^A_]ÿ%V›��HƒÄ[A\A]A^A_]ÃI‰ÇI÷ÝIÿÅM9îtI¬$��L‰çè¨ùÿÿI‰ìëãM…öt H‰ßÿ›��L‰ÿè h�� èýÿ ÌÌÌÌH…ÒtvUAWAVAUATSHƒú† ��D¶D·ND¶VDˆD$»DˆT$¾fD‰L$¼‹L$»f¸�ƒùt!AÁâE ÑAÁáE·ÀE Èf¸�fAƒø……���I‰ÑIƒáüIƒùuMHƒÆé©���HÇ����H‰wHÇG����H‰wHÇG ����H‰w(HÇG0����H‰w8WÀG@ÇGP����fÇGT�ÃD·FD¶VD¶^DˆT$»Dˆ\$¾fD‰D$¼IƒùuHƒÆë:A·ÀÆGH‰GëXD‹D$»D·V D¶^¶^ Dˆ\$»ˆ\$¾fD‰T$¼Iƒù u>HƒÆ ÇD$¸����¶D$ºˆG fÇG ��ÆGÆG �ÆG�fÇG
��H‰wÆ[A\A]A^A_]ÃD‹L$»D·V
D¶^ ¶^Dˆ\$»ˆ\$¾fD‰T$¼D‹T$»M…ÒtrE9ÊvmE‰ÓAÑëAãUUUUD‰ÓD)ÛA‰ÛAã3333Áëã3333DÛA‰ÛAÁëAÛAãEiÛAÁëAƒûs"HƒÂðHƒÆN Õ����L)ÚsHÇG���éPÿÿÿÆGHéKÿÿÿJ M‰ÖIÁæL)òsHÇG���H‰_é*ÿÿÿAƒøv ÆGGéÿÿÿJ,3E…À„ ���ƒù…ê���Hƒú‚'��·MD¶}�D¶eDˆ|$»Dˆd$¾f‰L$¼‹L$»ÿɃù‡ò���I¼�
+
LmLzüÁáIÓìL‰d$ÈAƒø…¶��¹���E1ä1ÒH‰T$Ð1ÒH‰T$Ø1ÒH‰T$à1ÒH‰T$è1ÒH‰T$ð1ÒH‰T$øL‰úéh��E1ä1ÉH‰L$Ð1ÉH‰L$Ø1ÉH‰L$à1ÉH‰L$è1ÉH‰L$ð1ÉH‰L$øE1ÿ1ÉM‰ÍL¯éL)ꃌ���HÇG���H‰oéþÿÿHƒúvA·MD¶}�D¶eDˆ|$»Dˆd$¾f‰L$¼‹L$»ÿɃùsA¿ý���A£Ï‚x��ÆGJéÔýÿÿI‰íÇD$¸����¶D$ºˆG fÇG ��ÆGÆG �ÆG�fÇG
��L‰oé ýÿÿH‰éLéL9êsHÇG���H‰Oé„ýÿÿIÁä8¶T$ÐHÁâ0L âM‰üD¶|$ØIÁç(I ׶T$àHÁâ L úL‹|$èAÁçI ׶T$ðÁâL úL‹|$øAÁçE·ÿI ×A¶ÔL úH‰H‰wL‰_H‰_L‰w H‰o(L‰o0H‰O8L‰o@D‰GHD‰OLD‰WPf‰GTéõüÿÿIƒÿ‚ÿÿÿ·MD¶}D¶eDˆ|$»Dˆd$¾f‰L$¼‹L$»ÿɃù‡ßþÿÿLmLzøÁáI¼�
+
IÓìL‰d$øAƒø…@��¹���E1ä1ÒH‰T$Ð1ÒH‰T$Ø1ÒH‰T$à1ÒH‰T$è1ÒH‰T$ðéïýÿÿLzüL‰|$ÀLmI¿�
ÁáIÓïL‰|$ÈAƒøuD¹���E1ä1ÒH‰T$Ð1ÒH‰T$Ø1ÒH‰T$à1ÒH‰T$è1ÒH‰T$ð1ÒH‰T$øH‹T$ÀL‰íL‹|$Èé½ýÿÿHƒ|$À‚ þÿÿ·MD¶}D¶eDˆ|$»Dˆd$¾f‰L$¼‹L$»ÿɃù‡äýÿÿA¿ý���A£ÏƒÔýÿÿLzøL‰|$ÀLmÁáI¿�
IÓïL‰|$øAƒø…¶���¹���E1ä1ÒH‰T$Ð1ÒH‰T$Ø1ÒH‰T$à1ÒH‰T$è1ÒH‰T$ðéJÿÿÿIƒÿ‚zýÿÿ·M D¶}D¶e Dˆ|$»Dˆd$¾f‰L$¼‹L$»ÿɃù‡BýÿÿLm LzôÁáI¼�
+
IÓìL‰d$ðAƒø…Æ���¹ ���E1ä1ÒH‰T$Ð1ÒH‰T$Ø1ÒH‰T$à1ÒH‰T$èéYüÿÿHƒ|$À‚òüÿÿ·M D¶}D¶e Dˆ|$»Dˆd$¾f‰L$¼‹L$»ÿɃù‡ºüÿÿA¿ý���A£ÏƒªüÿÿLzôL‰|$ÀLm ÁáI¿�
IÓïL‰|$ðAƒø…¨���¹ ���E1ä1ÒH‰T$Ð1ÒH‰T$Ø1ÒH‰T$à1ÒH‰T$èé'þÿÿIƒÿ‚Wüÿÿ·M
D¶} D¶eDˆ|$»Dˆd$¾f‰L$¼‹L$»ÿɃù‡ üÿÿLmLzðÁáI¼�
+
IÓìL‰d$èAƒø…¸���¹���E1ä1ÒH‰T$Ð1ÒH‰T$Ø1ÒH‰T$àé=ûÿÿHƒ|$À‚Öûÿÿ·M
D¶} D¶eDˆ|$»Dˆd$¾f‰L$¼‹L$»ÿɃù‡žûÿÿA¿ý���A£ÏƒŽûÿÿLzðL‰|$ÀLmÁáI¿�
IÓïL‰|$èAƒø…��¹���E1ä1ÒH‰T$Ð1ÒH‰T$Ø1ÒH‰T$àéýÿÿIƒÿ‚Bûÿÿ·MD¶}D¶mDˆ|$»Dˆl$¾f‰L$¼‹L$»ÿɃù‡
+ûÿÿLmLzìÁáI¼�
+
IÓìL‰d$àAƒøu¹���E1ä1ÒH‰T$Ð1ÒH‰T$Øé3úÿÿIƒÿ‚Îúÿÿ·MD¶}D¶mDˆ|$»Dˆl$¾f‰L$¼‹L$»ÿɃù‡–úÿÿLmLzèÁáI¼�
+
IÓìL‰d$ØAƒø…£���¹���E1ä1ÒH‰T$ÐéÂùÿÿHƒ|$À‚[úÿÿ·MD¶}D¶mDˆ|$»Dˆl$¾f‰L$¼‹L$»ÿɃù‡#úÿÿA¿ý���A£ÏƒúÿÿLzìL‰|$ÀLmÁáI¿�
IÓïL‰|$àAƒø……���¹���E1ä1ÒH‰T$Ð1ÒH‰T$ØéžûÿÿIƒÿ‚Îùÿÿ·MD¶}D¶mDˆ|$»Dˆl$¾f‰L$¼‹L$»ÿɃù‡–ùÿÿLm LzäÁáI¼�
+
IÓìL‰d$ÐAƒø…‘���¹ ���E1äéÉøÿÿHƒ|$À‚bùÿÿ·MD¶}D¶mDˆ|$»Dˆl$¾f‰L$¼‹L$»ÿɃù‡*ùÿÿA¿ý���A£ÏƒùÿÿLzèL‰|$ÀLmÁáI¿�
IÓïL‰|$ØAƒøuq¹���E1ä1ÒH‰T$Ðé°úÿÿIƒÿ‚àøÿÿ·M D¶} D¶m Dˆ|$»Dˆl$¾f‰L$¼‹L$»ÿɃù‡¨øÿÿHƒÅ HƒÂàÁáI¼�
+
IÓì¹ ���L‹|$Èé"øÿÿHƒ|$À‚øÿÿ·MD¶}D¶mDˆ|$»Dˆl$¾f‰L$¼‹L$»ÿɃù‡IøÿÿA¿ý���A£Ïƒ9øÿÿLzäL‰|$ÀLm ÁáI¿�
IÓïL‰|$ÐAƒøu
¹ ���E1äéÖùÿÿHƒ|$À‚øÿÿ·M D¶} D¶m Dˆ|$»Dˆl$¾f‰L$¼‹L$»ÿɃù‡Ì÷ÿÿA¿ý���A£Ïƒ¼÷ÿÿHƒÂàHƒÅ ÁáI¼�
éÿÿÿÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSPH‰ûH‹ðHÿuH‰ßè‘ ÿÿHƒ{�t
+H‹{ÿðŽ��L‹{L‹k ½���L‰ÿL‰èHèHƒøtL§��HÿÍèEíÿÿL‰çëàM…ít L‰ÿÿ²Ž��HƒÃ(H‰ßHƒÄ[A\A]A^A_]é��H‰$Hƒ{�t
+H‹{ÿƒŽ��H‹{H‹s èÆòÿÿë?H‰$H÷Ýffff. „�����HÿÅI9ítM´$��L‰çèÈìÿÿM‰ôëãM…ít L‰ÿÿ5Ž��HƒÃ(H‰ßè™���H‹<$è0[�� è)ûüÿ è"ûüÿ AVSPH‰ûH‹‡Ð���H…ÀtðHÿu H»Ð���è{ ÿÿH‹»Ø���H…ÿtðHÿOðuHƒÇðHƒÄ[A^éX>ÿÿHƒÄ[A^ÃI‰ÆHÃØ���H‰ßèÞ³ÿÿL‰÷è¶Z�� è¯úüÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌAWAVAUATSL‹gM…ätdH‰ûL‹7IÆ°��ë'ffffff. „�����I¾°þÿÿè´oÿÿIÆ°��IÿÌtI‹F¨ðHÿuÞI‹~¨èÅ=ÿÿëÓHƒ{�tH‹;[A\A]A^A_ÿ%��[A\A]A^A_ÃI‰ÇI¾°þÿÿèaoÿÿIÿÌtM®°��L‰÷èìðÿÿM‰îëçHƒ{�t H‹;ÿ׌��L‰ÿèßY�� èØùüÿ ÌÌÌÌÌÌAVSHƒì8HÿÆ„ƒ���H‰ûH‹GH �H9ñHGñHƒþ A¾���LCöL‰öH÷ÖHÁî?H…ÀtH‹ H‰L$HÇD$���H‰D$ë HÇD$����H|$ HL$L‰òèNüýÿHƒ|$ �H‹|$(tH¸������€H9ÇtH…ÿuèÈÐüÿ H‰;L‰sHƒÄ8[A^ÃH‹t$0èíÐüÿ ÌÌÌÌÌÌÌÌÌÌÌPH‰ðH‰<$H51ìûÿL*~��H‰áº���H‰ÇèºûüÿYÃÌÌÌÌÌÌÌÌAWAVSHì ���H‰ûH‰çè ÒüÿH‹<$H…ÿt0HYƒ��H‰CHÇ���Hƒ|$�„ä���HÄ ���[A^A_ÿ%€‹��L‹t$L‹|$WÀ)„$€���)D$p)D$`)D$P)D$@)D$0)D$ HÇ„$�������Ht$ L‰÷ÿCŒ��ƒøÿtRH‹„$���H‰Cx(„$€���Ch(D$pCX(D$`CH(D$ (L$0(T$@(\$P[8S(KC1Àëÿ^Š��‹�HÁà HƒÈH‰C¸���H‰AÆ�M…ÿt L‰÷ÿ®Š��HÄ ���[A^A_ÃÌAWAVATSHƒì(H‰òH‰þH|$èÕÐüÿH‹\$H…Ût0L=$‚��A¾���Hƒ|$�t H‰ßÿ]Š��L‰ðL‰úHƒÄ([A\A^A_ÃH‹\$L‹d$E1öH‰ß1öÿ;‹��I‰ÇÆ�M…äuÂëÉÌÌÌÌÌÌAVSHƒì8HÿÆ„¡���H‰ûH‹GH �H9ñHGñHƒþA¾���LCöH¹VUUUUUU1öI9Î@’ÆJ õ����HIHÁæH…Àt H‹ HÁàH@H‰L$HÇD$���H‰D$ë HÇD$����H|$ HL$èùýÿHƒ|$ �H‹|$(tH¸������€H9ÇtH…ÿuè
+Îüÿ H‰;L‰sHƒÄ8[A^ÃH‹t$0è/Îüÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHìˆ��‰L$ Hƒþs.I‰÷I‰üIƒÿvº���L‰çL‰þè‰��HĈ��[A\A]A^A_]ÃH‰t$8H‰|$0@µ±@„í”À„É”ÃÃL‹d$0L‹l$8H‰T$@fff. „�����ƒ|$ �„ý ��@„턤��L‰éHÁéL< HIIƒý1v7HqÿH<II‹TüèI‹<üH9×s1A¹���I‰øI‰òH‰ÎH‰×ë&ffff. „�����E1öé��� „�����I‰ÐE1ÉI‰ÊHÿÁHIM‹ Ô1ÒI9ûICÊIBû’ÂL9ÇLÊL9ÇHBÎIÿK4M‹DôèI‹4ôL9ÆsHÿÂI‰ñI‰úL‰ÿëff. „�����M‰ÁM‰úI‰ðIƒÏK4M‹ ô1öM9ÃMCúMBÃ@’ÆM9ÈHÖM9ÈLBÿHxÿH@M‹DÔèI‹ÔL9ÂsHÿÆI‰ÑI‰úH‰Çëf „�����M‰ÁI‰ÂI‰ÐHÿÀH@M‹ ÔE1öM9ÃICÂMBÃA’ÆM9ÈIöM9ÈHBÇH‹T$@K4H<IM‹ ôI‹4üI9ñsIÿÆL‰ÏI‰Èë „�����H‰÷M‰øI‰ÏL‰ÎH @I‹ ÌH9ñIƒÖ�H9ñLBÀHBñH9þƒ���¸���Iƒþ ‚x���L‰èHÑèJ m����LéI ÌHƒÁèL‰çf D��H‹wH‰´$€���)D$pH‹qH‰wH‹´$€���H‰q(D$pHƒÇHƒÁèHÿÈu½I÷×Mï°ë �M‰ÇL‰ðH…À”À„À”ÀØ<…v��H…Ò„Œ��M9 ��KH‹
+I; Ä‚‚��IÄI‹L$H‰Œ$€���A$)D$pH‹H�A$I‰L$H‹Œ$€���H‰H(D$p�M\$IuÿI‹ $ID$AD$)„$���1ÿH9÷s LOà �I;rHÿÇIƒÀH9þuïH‰÷LvO à @�HÿÎH9÷shMAèI;IèM‰ÁrëL O‹TËL‰”$€���CË)D$pM‹PA�CËO‰TËL‹Œ$€���M‰H(D$pA�HÿÇH9÷‚rÿÿÿëff. „�����HÿÇI‰ $(„$����M‰ïI)ÿ‚¨��HM$ÄM‰ýIƒÿƒMüÿÿééûÿÿL‰çL‰îè
��H‹T$@ÿL$ éCüÿÿL‰çL‰îèÔ ��H‹T$@„À„rþÿÿéÉûÿÿfL‹l$8ëf „�����L‰d$0M9ïL‹D$0ƒ��KI‹HH‰Œ$€���A�)D$pI‹LÀAÀA�I‰HH‹Œ$€���I‰LÀ(D$pAÀI@IuÿM‹ IHH‰L$`A@)„$ð���H‰Á1ÿ D��L9!sHÿÇHƒÁH9þuïH‰÷H9÷H‰ñHBÏJm����LêIÐHƒÂèM‰éfff. „�����IÿÉL9ÏsLBèL9"L‰Âsìë
f. „�����I‰ÉL9χ|��L‰l$8I9ñ‡]��H‰|$HH LÈL‰L$hK IH,È¿€���E1ÉE1ÿE1ÒE1íA»€���L‰D$Pëpfffff. „�����HIH‹L$ H‰LÅ(D$DÅ�IÿÅIÿÇL‰ßL‹\$XM9Õ¸����IDÃH‰ùH÷ÙM9Ϻ����HEÊH@MÀHIHlÅ�Hþ��‚î��H‰îL)ÆHþ��sB·ÎiÉ«ª��ÁéM9Õ’ÂM9Ï’ÃÓHQ€„ÛI‰ÎLEòM9ÕHBúMCÞ„Ûu A‰ËAÑëL)ÙH‰ÏM9Õ„ä���M9Ï„û���L‰ÑL)éL‰ÊL)úH9ÑHBÑH…Ò„EÿÿÿL‰\$XI‰ûA¶E�H@I‹LÀH‰L$ AÀ)D$A¶ H‰ÙH÷ÑHIE¶u�O4vH‹|ÅK‰|ðDÅ�CðHƒú„ÅþÿÿHÿÊfA¶EIÿÅH@¶ËH÷ÑH II‹|ÀH‰|ÍAÀDÍ�A¶_IÿÇH‰ÙH÷ÑH<IL‹týM‰tÀDý�AÀHÿÊu«éfþÿÿf D��M…Ût9IƒûL¬$���sHM‰êL‰Ã1Òé���H…ÿt)HƒÿƒÃ���LL$p1ÛI‰îé ��L¬$���M‰êéÎþÿÿL|$pM‰ùéÊþÿÿM‰ÞIƒæüM‰êL‰Ã1Òf D��‰ÑAˆL9#IƒÚÿDiEˆ*L9cIƒÚÿDiL9c0Eˆ*IƒÚÿHƒÂƒÁAˆ
+L9cHIƒÚÿHƒÃ`I9Öu»L¬$���D‰Ùƒá„Sþÿÿ €����AˆL9#IƒÚÿHƒÃþÂHÿÉuëL¬$���é*þÿÿH‰úHƒâüLL$p1ÉI‰ï1Ûff. „�����Aˆ E1öM9gèA’ÆAM9gÐCˆ1MñAAˆ1ÀM9g¸’ÀHƒÃƒÁAˆ M9g IÁMw H‰ÙM‰÷H9Úu´‰ùL|$pƒá„¹ýÿÿHÁáH I1Òf. „�����AˆM9dèIƒÑ�þÃHƒÂèI‰ÏI×uæL|$péýÿÿfff. „�����M9ÕsD‰ÐD)è¨L‹\$@H‹t$8u5L‰Òë|fM9ÏL‹\$@H‹t$8ƒ&��D‰ÈD)ø¨L‹T$P…%��L‰Êél��IRÿA¶BÿH @HEèI‹|ÈH‰|$ AÈ)D$H‹}øEèAÈI‰|ÈH‹L$ H‰Mø(D$EèH‰ÅL‹L$HL‰éH÷ÑLÑL‹T$P„½��ffff. „�����¶BÿH@I‹LÀH‰L$ AÀ)D$H‹MøEèAÀI‰LÀH‹D$ H‰Eø(D$Eè¶BþHƒÂþH @HEÐI‹|ÈH‰|$ AÈ)D$H‹}àEÐAÈI‰|ÈH‹L$ H‰Mà(D$EÐH‰ÅI9Õ‚lÿÿÿé��L‰ÀL‹L$HL‹T$Pé��IQÿA¶AÿH÷ÐH@I‹HH‰L$ A�)D$H‹LÅDÅ�A�I‰HH‹L$ H‰LÅ(D$DÅ�IƒÀL‰ÀL‰ùH÷ÑLÉL‹L$H„¢���f¶BÿH÷ÐH@I‹HH‰L$ A�)D$H‹LÅDÅ�A�I‰HH‹L$ H‰LÅ(D$DÅ�¶BþHƒÂþH÷ÐH@I‹H(H‰L$ A@)D$H‹LÅDÅ�A@I‰H(H‹L$ H‰LÅ(D$DÅ�IƒÀ0I9ׂgÿÿÿL‰À @�L)ÐH¹«ªªªªªªªH÷áI‰×IÁïMÏL‹t$0M‰&(„$ð���H‹D$`�I‰ôM)ü†÷���L;L$h“D$XKM,ÆI‹NH‰Œ$€���A)D$pI‹LÆAÆAI‰NH‹Œ$€���I‰LÆ(D$pAÆM9çL‰áIBÏHÁîH9ñ@“ÅI ÆHƒÃIÿÌM9çs L‰÷L‰þL‰Ú‹L$ è»óÿÿL‰êM‰çI‰ÜëH‰ßL‰æL‰ê‹L$ èžóÿÿH‹T$@M‰ôL‰|$8L‰d$0Iƒÿ¶L$XƒÕóÿÿé™óÿÿL‰çL‰îè���éŸóÿÿH‘l��L‰ÿL‰îè6Éüÿ Hõl��ëêH m��L‰ÿè Éüÿ H{l��L‰îè‹Èüÿ Hâl��L‰Ïè
+ÒüÿëHÑl��L‰ÎèÉÛüÿ ë�H‹L$0L‰!(„$ð���H‹L$`H‰Çè5I�� ÌÌÌHƒìH‰òHÑêë
@�H…Ò„À���H‰ÐHÿÊLEÿÿÿÿI9ðsäL EþÿÿÿH‰Ñf „�����IƒÁI9ñsK@O IH‹ÇJ;ÏIƒÐ�L‰ÀH9ñƒ‘��H9ðƒ™��H IL@L‹ ÏN; ÇsŒH ÏNÇL‹IL‰L$)$M‹HA�L‰IH‹L$I‰H($A�L �LE���H‰ÁI9ð‚lÿÿÿé7ÿÿÿH‰ð @�HÿÈH9ðƒ0��H @H‹WH‰T$)$H‹TÏÏH‰WH‹T$H‰TÏ($ÏHƒø‚©���º���E1ÉE1Àf „�����IƒÁI9ÁsH RO IH‹ ÏJ; ÏHƒÒ�H‰ÑI9ÀsuH9Ás|O @NÏLIJ×N‹ ÏN; ׃XÿÿÿM‹HL‰L$A�)$L‹JA�M‰HL‹D$L‰B($L HM���I‰ÈH9‚pÿÿÿé ÿÿÿHƒÄÃHwj��L‰Çë
+Hƒj��H‰ÏH‰ÆèÈÆüÿ HWj��H‰Ïè·Æüÿ H^j��H‰Çè¦Æüÿ H j��ëíÌÌÌÌÌÌÌÌÌÌÌHƒìHFÿH½È÷ÑIÇÀÿÿÿÿIÓèH‰òHÑêI‰ÑIƒáþIIÿH‰ðHÁà
H1ðI‰ÃIÁëI1ÃM‰ÚIÁâM1ÚL‰ÐL!ÀE1ÛH9ðLCÞH9ñƒd��L)ØH9ðƒ?��H IH@L‹\ÏL‰\$Ï)$L‹\ÇÇÏL‰\ÏH‹L$H‰LÇ($ÇL‰ÐHÁà
L1ÐI‰ÂIÁêI1ÂL‰ÑHÁáL1ÑH‰ÈL!ÀE1ÒH9ðLCÖI9ñƒÛ���L)ÐH9ðƒ¾���O IH@N‹TÏL‰T$BÏ)$L‹TÇÇBÏN‰TÏL‹L$L‰LÇ($ÇH‰ÈHÁà
H1ÈH‰ÁHÁéH1ÁH‰ÈHÁàH1ÈL!À1ÉH9ðHCÎHƒÊH9òsaH)ÈH9ðsCH RH@H‹TÏH‰T$Ï)$H‹TÇÇÏH‰TÏH‹L$H‰LÇ($ÇHƒÄÃH¶g��H‰ÇèÖÄüÿ L‰ÉëH‰ÑHg��H‰Ïè½Äüÿ ÌÌÌÌÌÌÌÌÌÌÌAWAVAUATSHƒì H‰óI‰þHƒþ2sLI‹F¹���I;‚��IƒÆ0º���H)Úf „�����H4
+Hƒþ„î��HÿÁI‹6IƒÆH9ÆH‰ðsàéÚ��I‹FI;sA¿���°HƒûuJéÄ��IN0º���H)ÚA¿���ffff. „�����J4:Hƒþ„Š��H‹1HƒÁIÿÇH9ÆH‰ðsàI9ß’ÀIWÿH9Úƒ¡��„À„…��L,RO$K‹DîH‰D$Cî)$K‹DæK‰DîCæCîH‹D$K‰Dæ($CæIƒÿrL‰÷L‰þèb��L‰÷L‰þè7��I9߃��KîKæH‹�±H;r-K æHƒÁHSÿL9ú„Ï��H‹1HƒÁIÿÇH9ÆH‰ðsåI9ß’ÁIWÿH9Úƒæ��„É„Ê��L,RO$K‹DîH‰D$Cî)$K‹DæK‰DîCæCîH‹D$K‰Dæ($CæIƒÿrL‰÷L‰þè§��L‰÷L‰þè|��I9߃Z��KîKæH‹�±H;r2K æHƒÁHSÿ D��L9ú„��H‹1HƒÁIÿÇH9ÆH‰ðsåI9ß’ÁIWÿH9Úƒ&��„É„
+��L,RO$K‹DîH‰D$Cî)$K‹DæK‰DîCæCîH‹D$K‰Dæ($CæIƒÿrL‰÷L‰þèç��L‰÷L‰þè¼��I9߃š��KîKæH‹�±H;r2K æHƒÁHSÿ D��L9ú„O��H‹1HƒÁIÿÇH9ÆH‰ðsåI9ß’ÁIWÿH9Úƒf��„É„J��L,RO$K‹DîH‰D$Cî)$K‹DæK‰DîCæCîH‹D$K‰Dæ($CæIƒÿrL‰÷L‰þè'��L‰÷L‰þèü��I9߃Ú���KîKæH‹�±H;r2K æHƒÁHSÿ D��L9ú„���H‹1HƒÁIÿÇH9ÆH‰ðsåI9ß’ÁIWÿH9Úƒ¦���„É„Š���HRK I‹tÆH‰t$AÆ)$I‹tÎI‰tÆAÎAÆH‹D$I‰DÎ($AÎIƒÿr5L‰÷L‰þèg���L‰÷L‰þè<��1Àë
°ë H‰ÙH9Ù”ÀHƒÄ [A\A]A^A_Ã1ÀëîIWÿH9ÚsHic��L‰ÿH‰Þè>Àüÿ HUc��H‰×H‰ÞH‰Âè'Àüÿ ÌÌÌÌÌHƒìHBÿH9ðƒ±���H9òƒ£���HRHÇHƒÀèë „�����I‰($A@HÿÂHƒÀH9òtuLRJ‹ ÇJ;LÇèsåN ÇNÇIƒÀèAA)$M‹PM‰QA�AHƒút®A¹���I‰À D��I;HèsšMPèM‹ZM‰XAA�IÿÁM‰ÐL9ÊuÛI‰øésÿÿÿHƒÄÃH= üÿHˆb��¾.���èöËüÿ ÌÌÌÌH‹H9GslHOG)D$èH‹QH‰WHƒþr?H9G0s9HƒÇ0HƒÆþ „�����H‹OH‰OøGèHÿÎtH‰ùHWH9GH‰×rÜëH‰ùH‰(D$èAÃÌÌÌÌÌÌÌÌÌÌAWAVATSHƒì(I‰ÎI‰ÿH|$èU¸üÿH‹\$H…Ût.H¤i��I‰GAÇ���Hƒ|$�t4H‰ßHƒÄ([A\A^A_ÿ%Íq��H‹\$L‹d$L‰ÿH‰ÞL‰òè5���Æ�M…äuÌHƒÄ([A\A^A_ÃI‰ÆÆ�M…ät H‰ßÿq��L‰÷è•>�� ÌÌÌUAWAVAUATSPI‰öH‰û€z�¶J¶Bt½
+��„Ét'„ÀuH½��ë½ ��„Ét4„Àu4½��¶r ¶B ëI„Àu!€z �u,€z
+�u&€z �u 1À½���1öë(„Àt¶r ¶B @„öt„ÀuH¸������H‰Cé´���€z
+�t1É@„ö@•Æ„Àu @ˆñÁá
+É���ë1É@„ö@•Æ„À„š���¹�
+��‹ƒàü Å ÍD·zE1äL‰÷‰îD‰ú1Àÿ(p��ƒøÿuJH‰ $L‹-p��H‹ p��f „�����AÿÕ‹�H‰ÇHÁç HƒÏƒøu èV·ýÿL‰÷‰îD‰ú1ÀÿÓƒøÿtÕH‹ $‰CëH‹ $H‰{A¼���D‰#HƒÄ[A\A]A^A_]Ã@ˆñÁá
+é`ÿÿÿÌAVSHƒì8HÿÆ„•���H‰ûH‹GH �H9ñHGñHƒþA¾���LCöH¹^tÑE]t1öI9Î@’ÆIkÖXHÁæH…Àt H‹ HkÀXH‰L$HÇD$���H‰D$ë HÇD$����H|$ HL$èŒßýÿHƒ|$ �H‹|$(tH¸������€H9ÇtH…ÿuè´üÿ H‰;L‰sHƒÄ8[A^ÃH‹t$0è+´üÿ ÌÌÌÌÌÌÌÌÌAWAVAUATSI‰þH‹ L‹M…ÿt2LcL‹- o��ëff. „�����IƒÄXIÿÏtIƒ<$�tðI‹|$øAÿÕëæIƒ~�tH‰ß[A\A]A^A_ÿ%Ýn��[A\A]A^A_ÃÌÌÌAVSHƒì8HÿÆ„•���H‰ûH‹GH �H9ñHGñHƒþA¾���LCöH¹J’$I’$I1öI9Î@’ÆIkÖ8HÁæH…Àt H‹ HkÀ8H‰L$HÇD$���H‰D$ë HÇD$����H|$ HL$èLÞýÿHƒ|$ �H‹|$(tH¸������€H9ÇtH…ÿuèƲüÿ H‰;L‰sHƒÄ8[A^ÃH‹t$0èë²üÿ ÌÌÌÌÌÌÌÌÌSH‰ûHƒ�t H‹;ÿìm��Hƒ{ �t H‹{[ÿ%Úm��[ÃÌÌÌÌÌÌÌÌH‰òH‰øH…ö„`��USH41ÉH=qüÿI‰Âë,E¶ÉAö9„9��fffff. „�����L)ÁLÑI9ò„��M‰ÐE¶
+E„ÉxMPéŒ���fff. „�����E‰ËAƒã A¶hƒå?A€ùßv@A¶XÁåƒã? ëA€ùðr=E¶HAƒãAÁãÁãAƒá?A ÙE ÙAù���„©���MPë+MPAÁãA ëE‰ÙëMPAÁã D ÛA‰Ùffff. „�����EY÷Aƒû‚BÿÿÿAƒù „8ÿÿÿAù€���rZE‰ËAÁëAƒû E…Û„üþÿÿAƒûu>Aù€��„ÿÿÿë/Aƒû tAƒû0u#Aù�0��„ëþÿÿëE¶ÉAö9…ÚþÿÿëH‰Ñ[]ë1ÉHÈH)ÊÃÌÌÌÌÌÌÌÌH‹H;VtfHBH‰¶„Ày~‰Áƒá LBL‰D¶JAƒá?<ßvRLBL‰D¶BAÁáAƒà?E È<ðrAHBH‰¶BƒáÁáAÁàƒà?D À È=���u&HU üÿH‰HÇG���ÃÁáD ɉÈë Áá A ÈD‰À‰GHÇ����ÃH‹7H;wtHFH‰¶„Òx ¸���Ã1ÀÉуá HFH‰D¶NAƒá?¸���€úßv:LFL‰D¶FAÁáAƒà?E È€úðr'HVH‰¶VƒáÁáAÁàƒâ?D  ÊÃÁáD ɉÊÃÁá A ÈD‰ÂÃÌÌÌÌAWAVSHƒìPI‰×I‰öH‰ûH‰t$ H‰T$(HÇD$0����H‰T$8HÇD$@���H¸:���:���H‰D$HH|$Ht$ èo;ýÿHƒ|$�t H‹D$H‹L$II)ÏH‰CH‰SL‰{ëE1öL‰3HƒÄP[A^A_ÃÌÌÌÌÌÌÌÌAWAVATSPH‰ÓI‰÷I‰þH…Òt-xW¶I|��¾���H‰ß蔪üÿI‰ÄH…Àu¿���H‰Þè/¯üÿ A¼���L‰çL‰þH‰Úÿ`j��M‰&I‰^I‰^HƒÄ[A\A^A_Ãè¼®üÿ ÌÌÌÌÌÌÌÌÌÌAWAVSHì€���H‰ûƒ>u
+L‹vL‹~ëL‹v(M…ö„ž���L‹~0H‰çL‰öL‰úè3ÌüÿHƒ<$�¸���uDH‹t$H‹T$H‰çèµýÿH‹$Hƒøt(H‹L$8H‰L$pD$L$T$()T$`)L$P)D$@H‹L$pH‰K8(D$@(L$P(T$`S(KCH‰L‰s@L‰{HHÄ€���[A^A_ÃHÇ���ëêÌÌÌÌÌÌÌÌÌÌÌÌÌÌHƒì(HÇD$����H‰|$H‹>H‹FHt$ÿP 4¶ÀÀHƒÄ(ÃèÔüÿ ÌÌÌÌÌÌÌÌÌÌÌUAWAVATSHƒì0H‰û‹=ÿÿÿ?u ¹ÿÿÿ �ó‹=ÿÿÿ?u Q…ɉÑuìL‹=h��L‹%6h��ëfff. „�����Hð± „ ���‰Ááÿÿÿ?=ÿÿÿ?wùþÿÿ?rÜùþÿÿ?„Š���‰ÅÍ���@©���@uð±+uÈA‰î „�����‹9èu H‰ß¾���L‰ò1ÉE1ÀAÿ×…ÀyAÿÔƒ8tÛ‹=ÿÿÿ?u¹ÿÿÿffff. „�����ó‹Q=ÿÿÿ?…kÿÿÿ…ɉÑuèé`ÿÿÿHƒÄ0[A\A^A_]ÃH_d��H‰$HÇD$���HƒüÿH‰D$WÀD$H5Gd��H‰çè³üÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌS÷Æÿÿÿ?…���H‰ûþ���€u 1ɸ���€ð± uðÿCHƒÃº���ëS‰Æþ���Àt
+þ���@t/ëS¹���@¸���Àð± uCH{ðÿCº���¾���1ÉE1Àÿ#g��1ɸ���@ð± uºÿÿÿH‰ß¾���1ÉE1À[ÿ%ýf��[ÃH=§üÿHc��¾$���è;Àüÿ ÌÌÌÌÌÌÌÌÌUAWAVAUATSHìè���E‰ÇI‰ÔH‰ûH‹/L‹wH‰´$à���H…öu€} �uIÿÆL‰s1Àéë��D‰Œ$Ä���H‰Œ$Ø���H‹E�M…ö„ï���H
"a��H‰ $HÇD$���H
üÿH‰L$WÀD$H‹x H‹p(I‰åL‰êèÖüÿ„À…‰��€} …��H‹E�H
ñZ��H‰Œ$���H:ÁüÿH‰”$˜���HããûÿH‰”$ ���H¼±üÿH‰”$¨���HÇ$���HÇD$���HÇD$���HÇD$ ����HÇD$( ���ÆD$0H‰L$XHÇD$`���L‰l$xHÇ„$€������HŒ$���H‰L$héO��HMH‰Œ$���H
Ÿ²üÿH‰Œ$˜���HÇ$���HÇD$����HÇD$���HÇD$ ����HÇD$( ���ÆD$0H
§_��H‰L$XHÇD$`���H‰áH‰L$xHÇ„$€������L¬$���L‰l$hHÇD$p���H‹x H‹p(HT$XèÅÔüÿ„À…8��€} …Ã���H‹E�HŒ$à���H‰Œ$���H
X��H‰Œ$˜���H
yâûÿH‰Œ$ ���H
j°üÿH‰Œ$¨���HÇ$���HÇD$���HÇD$���HÇD$ ����HÇD$( ���ÆD$0H
ò^��H‰L$XHÇD$`���H‰áH‰L$xHÇ„$€������L‰l$hHÇD$p���H‹x H‹p(HT$XèøÓüÿ„À…k��Aƒ<$„��¶E Hƒø„ô��H…À…ê���AD$@)D$@A$AL$AT$ A\$0)\$0)T$ )L$)$H‹E�H‰áH‰Œ$È���H
CÃýÿH‰Œ$Ð���HÇD$X���HÇD$h���HÇD$x����H¹ ������H‰Œ$€���Æ„$ˆ���H
7X��H‰Œ$���HÇ„$˜������HL$XH‰Œ$°���HÇ„$¸������HŒ$È���H‰Œ$ ���HÇ„$¨������H‹x H‹p(H”$���ë7H‹E�H
Á]��H‰ $HÇD$���H
�üÿH‰L$WÀD$H‹x H‹p(H‰âè¨Òüÿ„Àu H‹E�H‹x H‹@(H5÷üÿº���ÿP„Àt°HÄè���[A\A]A^A_]ÃAƒÿL‹¤$Ø���‹Œ$Ä���…ÜûÿÿI‹$ƒø„Ïûÿÿ‰Œ$È���€} …Ã���H‹E�H
'W��H‰Œ$���Hp½üÿH‰”$˜���HàûÿH‰”$ ���HòüÿH‰”$¨���HÇ$���HÇD$���HÇD$���HÇD$ ����HÇD$( ���ÆD$0H‰L$XHÇD$`���H‰áH‰L$xHÇ„$€������HŒ$���H‰L$hHÇD$p���H‹x H‹p(HT$XèÑüÿ„À…òþÿÿH‹E�H
d\��H‰ $HÇD$���L=@ÿûÿL‰|$WÀD$H‹x H‹p(H‰âè;Ñüÿ„À…®þÿÿH‹}H‹EH‹u�H‰4$HT$A$D$I‹L$H‰L$ÿP „À…zþÿÿH‹E�HŒ$È���H‰L$XH
wÉüÿH‰L$`L-ã[��L‰,$HÇD$���HÇD$ ����Ld$XL‰d$HÇD$���H‹x H‹p(H‰âè¢Ðüÿ„À…þÿÿƒ¼$ ��ug‹„$(��‰„$���H‹E�HŒ$���H‰L$XH
úÈüÿH‰L$`L‰,$HÇD$���HÇD$ ����L‰d$HÇD$���H‹x H‹p(H‰âè1Ðüÿ„À…¤ýÿÿH‹E�H
6[��H‰ $HÇD$���L‰|$WÀD$H‹x H‹p(H‰âèôÏüÿ‰Á°„É„lùÿÿé`ýÿÿAD$@)D$@A$AL$AT$ A\$0)\$0)T$ )L$)$H‹E�H‰áH‰Œ$���H
X¿ýÿH‰Œ$˜���H
T��H‰L$XHÇD$`���HÇD$x����HŒ$���H‰L$hHÇD$p���H‹x H‹p(HT$XéüÿÿÌÌÌÌÌÌÌÌÌÌUSHì˜���H‰óH‹óo‹n4‰é@öÅt ‰éƒÉfH~ÂH…ÒuHÇ���HÇC���ƒÉ‰K4º���¹0���H‰ÆH‰×HÁî‰Â€â€ú
+A¸W���DBÁA�ÐDˆD<HWÿHƒøH‰ðsÒf$HƒÇþHÿ€���w>A¹���I)ÑL<IƒÀHÝúûÿ¹���H‰ß¾���èæ¬üÿ($‰k4HĘ���[]ÃHÃ=��¾€���豪üÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌH‹H…ÉHEÏ‹GH‰÷H‰Ö‰Âé¶ÀýÿÌÌÌÌÌÌUAWAVAUATSPH…ö„±���I‰öI‰ÿI¼ÿÿÿÿÿÿÿL‹-Õ^��H T��H‹-¯]��ë D��H…É„|���L‰òM9ærL‰â¿���L‰þAÿÕHƒøÿtH…Àt7L‰ñH)ÁrgIÇI‰ÎëÆf D��ÿÕ‹�H‰ÇHÁç HƒÏƒøu
+èǤýÿL‰ñë¢H‰û‰ØƒàHƒørƒøuH‰ØHÁè ƒø u
+H‰ß蛤ýÿ1ÛH‰ØHƒÄ[A\A]A^A_]ÃH€S��H‰ÇL‰öè•©üÿ ÌÌÌP@„ÿuH‹³o��HÑàH…Àu,1À‡{o��ƒøu H=oo��º���¾���1ÉE1ÀXÿ%)]��XÃèŠÎýÿ„ÀuËÆKo��ëÂÌÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSPHƒ�…ç��I‰ÖI‰÷H‰ûHÇGÿÿÿÿHFHƒàøH)ðH‰×H‰ÑH9ÂrD‰ñ)ÁƒáL‰÷H)Ï‚è��H‰ÁLcK7L)úH)úK7HÿÈ €����H…ÒtI‰ÕHÿÊ€8
+H@ÿuìIýé‡���HºÿþþþþþþþH¾
+
+
+
+
+
+
+
+I¸€€€€€€€€f D��H‰øH9Ïv4HxðM‹LðM‹TøM‰ËI1óIÓI÷ÑM!ÙM‰ÓI1óIÓI÷ÒM!ÚM ÊM…ÂtÄL9ð‡0��ff. „�����H…ÀtUI‰ÅHÿÈC€|/ÿ
+uíM)î‚ï���H‹k H…ít(H‹CH)èL9èvQH‹{HïL‰þL‰êÿô[��LíH‰k ëHL‰ÿL‰îèXýÿÿëCL‹k M…ítLI‹$A€|ÿ
+uCL‰çèYýÿH…ÀunL‹k ë0L‰çL‰þL‰êèÐ���H…ÀuUL‰çè3ýÿH…ÀuHMïH‹CL‹k ëE1íH‹CL)èL9ðv H‹{LïL‰þL‰òÿg[��MõL‰k 1ÀëL‰çL‰þL‰òèv���HÿCHƒÄ[A\A]A^A_]ÃH=DP��è'»üÿ H=ÇúûÿHÏO��¾#���è=´üÿë#HT:��H‰ÇL‰ö艰üÿëHX:��L‰öèè¦üÿ HÿCH‰ÇèÊ'�� ÌÌÌÌÌÌÌÌAWAVATSPI‰ÖI‰÷H‰ûH‹GH‰ÁH+OH9ÑsH‰ßèG¬ýÿH…Àu=H‹CL9ðv!L‹cH‹;LçL‰þL‰òÿ‹Z��MôL‰c1ÀëÆCL‰ÿL‰öèéûÿÿÆC�HƒÄ[A\A^A_ÃÌÌÌÌÌÌÌÌÌAVSPH‰ûH‹H‹8èýÿÿI‰ÆH…ÀtH‹{H…ÿtè¡ýÿL‰sM…ö•ÀHƒÄ[A^ÃL‰sH‰Çèú&�� ÌÌÌÌÌÌÌÌAVSPH‰ûÇD$����þ€���s@ˆt$º���é���‰ðþ���s Áè ÀˆD$@€æ?@€Î€@ˆt$º���ëiþ���s*Áè àˆD$‰ðÁè$? €ˆD$@€æ?@€Î€@ˆt$º���ë7Áè$ ðˆD$‰ðÁè $? €ˆD$‰ðÁè$? €ˆD$@€æ?@€Î€@ˆt$º���H‹H‹8Ht$è
+üÿÿI‰ÆH…ÀtH‹{H…ÿtè ýÿL‰sM…ö•ÀHƒÄ[A^ÃL‰sH‰Çèö%�� ÌÌÌÌH‰òH5¶K��é1´üÿÌHƒìHè'(ýÿ‰D$HD$H‰D$HÁüÿH‰D$HÖR��H‰D$HÇD$ ���HÇD$8����HD$H‰D$(HÇD$0���H|$Ht$èížýÿH‰Çèu£ýÿèðŸýÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌÌAWAVSHì€��H‹]j��Hƒø‡È��H
0ÐûÿHcHÈÿàH¸ACKTRACEH‰D$H¸RUST_BACH‰$ÆD$�1Àffffff. „�����€<�t&HÿÀHƒøuñé���A·é°���A·é¨���E1ÿé ���Hƒøu‹j��=þÿÿ?ƒ��Hð±
j��…
+��¶ýi��H‰çÿ¬X��H…ÀtsI‰ÇH‰ÇÿCX��I‰ÆH…Àtcˆ ��¶>i��¾���L‰÷艗üÿH‰ÃH…ÀuF¿���L‰öè$œüÿéó���H=èN��è3žýÿ¸���A·H‰Di��D‰øHÄ€��[A^A_Ã1Ûë»���H‰ßL‰þL‰òÿ$W��¾ÿÿÿÿðÁ5Oi��ÿΉð%ÿÿÿ¿=���€t^H…Ût§IƒþtIƒþu €;0A”ÇE�ÿë;fullA•ÇAö×A€çëE1ÿM…öt H‰ßÿžV��AG¶ÀégÿÿÿH=ëh��è–íÿÿéåþÿÿH=Úh��èÕîÿÿH…Ûu–é8ÿÿÿH=#øûÿHL��¾(���裯üÿ èìšüÿ H‰Ã¾ÿÿÿÿðÁ5šh��ÿΉð%ÿÿÿ¿=���€u H=ƒh��è~îÿÿH‰ßè&#�� è Ãüÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌPèŠýÿ ÌÌÌÌÌÌÌÌUAWAVAUATSHì¸���H‰ó¶/@ˆl$ ¶¥g��A¿���¿���ÿÔU��H…À„��I‰ÆH‰D$HÇD$���¾���H‰Çÿ¼V��H…ÀtIL‰÷ÿNV��I‰ÄI9džÿ���M…ä„â���º���L‰÷L‰þL‰áèΕüÿH…À…Ô���¿���L‰æè(šüÿ ÿÈT��‹�I‰ÄIÁä IƒÌƒø"……���@ˆl$ H‰\$HA¿���Ll$H‹ 6V��H‹-T�� €����L‰çèø›ýÿL‰|$ º���L‰ïL‰þè#ÄýÿL‹t$L‹|$L‰÷L‰þÿÓH…À… ��ÿÕ‹�I‰ÄIÁä IƒÌƒø"t´M…ÿH‹\$H¶l$ t L‰÷ÿœT��L‰çè”›ýÿE1öëL‰÷ÿ†T��¸���M‰çI‰Æ@ˆl$hL‰t$PL‰|$XL‰d$`H(L��H‰D$HÇD$���L-òûÿL‰l$ WÀD$(H‹{ H‹s(Ld$L‰âèùÃüÿ„À…â���H‰œ$���HÇ„$¨�������@ˆ¬$°���HD$PH‰„$˜���HÉK��H‰„$ ���HÇD$p����ÆD$
�HÇD$x����ÆD$@„í•D$HD$ H‰D$HD$pH‰D$HD$H‰D$ HD$xH‰D$(HD$H‰D$0H„$���H‰D$8HD$
H‰D$@L‰¤$€���HmK��H‰„$ˆ���H=.êÿÿH´$€���ÿ€T��€|$
�t1L‹t$PL‹|$XM…ötM…ÿt L‰÷ÿ,S��°Hĸ���[A\A]A^A_]À|$ �u8H2K��H‰D$HÇD$���L‰l$ WÀD$(H‹{ H‹s(HT$èÂüÿ„ÀuH‹|$PH…ÿtHƒ|$X�tÿÁR��1Àë“H‹\$H¶l$ é ýÿÿ¿���¾���è—üÿ H‰Ãë'H‰ÃH‹|$PH…ÿt#Hƒ|$X�uëH‰ÃHƒ|$�tL‹t$L‰÷ÿhR��H‰ßèp �� ÌÌÌÌÌÌÌÌÌÌÌÌÌÌé ���ÌÌÌÌÌÌÌÌÌÌÌAWAVAUATSHì���I‰öH‰ûH‹€8�uH‹KHƒ9dv1ÀéÆ���ÆD$�L‹kL‹c(L‹{0HL$H‰L$(H‰D$0L‰l$8CD$@L‰d$PL‰|$XL‰t$`Ht$(L‰÷ègÃýÿ€|$�ugA€}��t`L‰d$HÇD$ ����I‹vIƒ>�u H‰÷ÿhR��H‰ÆHÇD$(���HÇD$x���Ç$����H|$HT$(HL$xE1Àè…êÿÿAˆH‹D$Hÿ@H‹CHÿ�A€?�”ÀHÄ���[A\A]A^A_ÃH‹L$HÿAH‰Çè9 �� ÌÌÌÌÌÌÌAWAVAUATSHì€���I‰öH‰ûH‹Æ�H‹G€8�„��H‹C€8�„q��L‹{I‹H…À„®���L‹c A€<$�…“���H‹K(H‹ 1ÒHƒø“ÂHºüûÿH5eîûÿHCðH‰4$H‰T$L‰|$H´üÿH‰D$H‰àH‰D$ H «üÿH‰D$(H¬H��H‰D$0HÇD$8���HÇD$P����HD$H‰D$@HÇD$H���H‹y H‹q(HT$0èÀüÿAÆ$�IÇ����H‹C(H‰$HÇD$����H‹C8L‹xHƒ8�u L‰ÿÿÔP��I‰ÇH|$0L‰öèäåÿÿE‹Aƒøt(Aƒøt"I‹FH…ÀtI‹NHÇD$����H‰D$H‰L$ ë HÇD$���1ÀAƒøDCÀE‹NE‹V ABFH‰çHT$0HL$L‰þARPè«èÿÿHƒÄH‹K0ˆH‹$Hÿ@HÄ€���[A\A]A^A_ÃH|$0L‰öèKåÿÿH‹D$0Hƒøtƒø„PþÿÿL‹|$PL‹d$Xë*H‹t$pH‹T$xH|$臱üÿHƒ|$�…$þÿÿL‹|$L‹d$ L‹kA€}��t%H=°úûÿ¾ ���L‰úL‰áè_���„Àt
+AÆE��éhÿÿÿH=§úûÿ¾���L‰úL‰áè:���„Àt
+AÆE�éCÿÿÿA€}��…ºýÿÿH‹CHÿ�é®ýÿÿH‹ $HÿAH‰Çè¥�� ÌÌÌUAWAVAUATSHìH��I‰ÕI‰÷H‰ýH9΃à���I‰È¶E�IOÿH‰L$h1ÉL‰úHƒêHBÑHuÿM‰îf „�����I<H9úƒÆ���M$IÿÌM9üƒ
+��B¶<>IÿÎHÿÉHÿÎ@8ÇtÐIOH‰Œ$˜���L9ÁL‰D$†û���L‰ïH‰îL‰úÿ N��…À„å��IÿÅH‹L$HÿÉH‹ N��ffff. „�����L9ù@“Ç‚¥��I‰üL‰ïH‰îL‰úI‰ÎÿÓL‰çL‰ñIÿÅHÿÉ…ÀuÒé��……���H‰ïL‰îL‰úÿ°M��…À@”Çé_��H¼$ ���L‰îL‰ÂH‰éM‰øè”ËüÿHƒ¼$ ����„ ��H´$¨���Hƒ¼$Ø���ÿH‹”$è���H‹Œ$ð���L‹„$ø���L‹Œ$���„ß��Ç$����éÚ��1ÿéí��¶ÀfnÀf`ÀòpÀ�fpÐ�@¶ÇfnÀf`ÀòpÀ�fpØ�HÿÅL‰¬$ ���L‰„$¨���H‰¬$°���H‹D$hH‰„$¸���IG?L9ÀfT$Pf\$@ƒ…��IO1í1ÿH‰L$fI/óAoD-�óEoD-óAot- óAod-0ftÂóAo óEoLóAo| óAol0ftËfÛÈf×Ñ…ÒuofDtÂfDtËfEÛÈfA×Ñf…Ò…ë���ftòftûfÛþf××f…Ò…D��ftâftëfÛìf×Õf…Ò…��H)HƒÅ@L9ÀƒË��‰ø$„Gÿÿÿé¼��‰ø$¶ÈH‰ûH¼$ ���H‰îfd$ fl$0f´$€���f|$pfD„$0��fDŒ$ ��è ��fDoŒ$ ��fDo„$0��fo|$pfo´$€���fol$0fod$ H‹L$fo\$@foT$PL‹D$Ø$‰ÇéøþÿÿHu‰ø$¶ÈH‰ûH¼$ ���fd$ fl$0f´$€���f|$pèƒ��fo|$pfo´$€���fol$0fod$ H‹L$fo\$@foT$PL‹D$Ø$‰Çé£þÿÿHu ‰ø$¶ÈH‰ûH¼$ ���fd$ fl$0è ��fol$0fod$ H‹L$fo\$@foT$PL‹D$Ø$‰ÇéhþÿÿHu0‰ø$¶ÈH‰ûH¼$ ���èØ��H‹L$fo\$@foT$PL‹D$Ø$‰ÇéEþÿÿ€¼$º����„$��1ÀH‰„$��éï���1ÿ1íH‹Œ$˜���Hé‰ø$L9Áƒ‡���„À…���Iw L‰ëHëH‰t$ €����óoI/óAo ftÂftËfÛÈf×Ñ…ÒuH .‰ø$L9Ás:HƒÅHƒÃ„ÀtÅë,H¼$ ���H‰î1Éè��H‹t$ fo\$@foT$PL‹D$‰Çë¹L+D$hK (HƒÁðóCoDðóAo ftÂftËfÛÈf×Ñ…Ò…æ���@€çë!Ç$���H¼$��èÛ��Hƒ¼$���@•Ç‰øHÄH��[A\A]A^A_]Ã@·ëçH‹”$¨���H‹¼$è���H‹Œ$ð���¶„$¸���H‰ÎH…ÒtH‰ÎH)Öv €<À} é1��…+��H…ötW¶4@„ö‰§���A‰ðAƒà D¶TAƒâ?@€þàrfD¶LAÁâAƒá?E Ñ@€þðro¶tAƒàAÁàAÁáƒæ?D ÎD Æë]„Àu]é6þÿÿIƒÀð„À•Ã¶ÈH¼$ ���L‰ÆèÃ���‰Ç@ß@€çéÿÿÿAÁàE ÐD‰Æë HZ6��L‰çL‰þ觔üÿ AÁà E ÁD‰Î„Àt¸���H‰„$��éÊþÿÿþ���„Àýÿÿ¸���þ€���r ¸���þ���rþ���¸���HƒØ�HÂtH‰ÈH)Ðv
€<¿ ëH‰Èëu H…Àt˜€<�ë’L’:��H‰Î芹üÿ ÌÌÌÌÌÌÌÌ…Ét1ÀÃSHÿÆL‹L‹OH‹H‰øHƒè‚©���H…ÀHIÀA‹<ó¼ÊHA9<�”ÀtfA¹þÿfAÓÁfD!Êuà[Ãfffff. „�����f¿þÿfÓÇf!ú„°���ó¼ÊH‰ÏH÷LÇLM‰Ëfff. „�����‹ A;uÉHƒÇIƒÃL9×rìA‹:A;<u³°[Ãffffff. „�����f¸þÿfÓÀf!ÂtT°H…ÿ„yÿÿÿó¼ÊLG¶ E:u×Hƒÿ„]ÿÿÿG¶\E:YuÁHƒÿ„GÿÿÿG¶TE:Qu«Hƒÿu¥é0ÿÿÿ1À[ÃÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHƒì(L‹V KHÿÈH9ȃô��D¶|$`IYÿL‹vL‹.L‹^M‰ÌL‰\$ M)ÜL‰d$L‹f0O L‰\$H‰<$E„ÿt3M‰Ó¶I£ÆrFMËL‰^ JNI9Êrâé“��ffff. „�����¶I£ÆsL‰åM‰Óë~fffff. „�����1íëlO
+L‰^ HÇF0����JH9ȃE��LT$f. „�����B¶DÿI£Ær#MËL‰V HÇF0����K
+HÿÈMÊH9ÈrÖé��1íE1äfff. „�����M9åL‰d$L‰çIGýE„ÿM‰ìIEýL9Ïs3N,H‰øff. „�����MI9ʃ��E¶<�E:|�upHÿÀI9ÁußM‰åL‰àD¶|$`L‹d$fffff. „�����H9Ń…���HÿÈL9ȃ°���NI9ʃ·���A¶<�B:<tÓL\$ L‰^ H‹D$M‰ÚE„ÿH‹<$t+ë0M‰åM)âIÿÂL‰V D¶|$`E„ÿt H‹<$L‹d$ë
1ÀH‹<$H‰F0I‰ÄJH9È‚BþÿÿH‰N 1Àë%MÙL‰N E„ÿuHÇF0����H‹<$L‰_L‰O¸���H‰HƒÄ([A\A]A^A_]ÃHD2��H‰ÇL‰Îèyüÿ HH2��L‰×ëLßH9ùHGùHJ2��H‰ÎèRüÿ H‰øH‹?H…ÿt
Hƒx�tÿ%˜C��ÃÌÌÌÌÌÌÌUAWAVSHƒì(H‰ðI‰þHt$H‹JH‰L$ D$H‰D$H‹ H…ÛH‰ùHDË‹WH‰Çè¥ýÿ‰ÅH…ÛtIƒ~�t H‰ßÿ6C��‰èHƒÄ([A^A_]ÃI‰ÇH…ÛtIƒ~�t H‰ßÿC��L‰ÿè�� ÌÌÌÌÌÌÌSHƒì`H‰t$HD$H‰D$ HüÿH‰D$(Hq;��H‰D$0HÇD$8���HÇD$P����HD$ H‰D$@HÇD$H���HD$H‰D$HÇD$����H55��H|$HT$0èæüÿH‹|$„ÀtH…ÿH‹8��HEÇH‰ÇëH…ÿtè`‰ýÿHƒÄ`[ÃH‰ÃH‹|$H…ÿtèH‰ýÿH‰ßèP�� èI¯üÿ ÌÌÌÌÌÌÌHƒìHHÝ:��H‰D$HÇD$ ���H‰àH‰D$(WÀD$0H‰D$HÇD$����H5r4��H|$HT$èCüÿH‹|$„ÀtH…ÿHè7��HEÇH‰ÇèĈýÿë
+H…ÿt踈ýÿèC‰ýÿ èLüÿ H‹|$H…ÿt蛈ýÿè6üÿ 蟮üÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌHƒìHH=:��H‰D$HÇD$ ���H‰àH‰D$(WÀD$0H‰D$HÇD$����H5Â3��H|$HT$è“œüÿH‹|$„ÀtH…ÿH87��HEÇH‰Çèˆýÿë
+H…ÿtèˆýÿ蓈ýÿ 蜬üÿ H‹|$H…ÿtèë‡ýÿ膬üÿ èïüÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌAVSHƒìhH‰óI‰þH‹H‹OH‹WH‰D$HÌ›üÿH‰D$H‰L$H
ë���H‰L$ H‰T$(H‰D$0H]9��H‰D$8HÇD$@���HÇD$X����HD$H‰D$HHÇD$P���Ht$8H‰ßèΆýÿH…ÀtH‰ÇèA‡ýÿI‹F¶�HƒøtqƒøtH‰ßƒøuP¾���ëK1À†¨Q��„ÀtQH%9��H‰D$HÇD$���H°ÝûÿH‰D$WÀD$ Ht$H‰ßè^†ýÿH…Àuë1öè°���H…ÀtH‰ÇèÆýÿHƒÄh[A^ÃÌÌÌÌÌÌÌÌÌÌÌHƒìhH‹HHH‰D$HƒÀHµšüÿH‰T$H‰L$H
ä§üÿH‰L$ H‰D$(H‰L$0HV ��H‰D$8HÇD$@���HÇD$X����HD$H‰D$HHÇD$P���H‹~ H‹v(HT$8è’šüÿHƒÄhÃÌÌÌÌÌÌÌÌÌÌÌÌÌUAVSHƒìPA‰öH‰û¹���1Àð±
+Q��…È���H‹FQ��HÑàH…À…Æ���1í¶
Q��Dˆt$HD$H‰D$HÛèÿÿH‰D$H‡3��H‰D$ HÇD$(���HÇD$@����HD$H‰D$0HÇD$8���Ht$ H‰ßè…ýÿH‰Ã@„íuH¸ÿÿÿÿÿÿÿH‹
¿P��H…ÁuV1À‡ŠP��ƒøu H=~P��º���¾���1ÉE1Àÿ9>��H‰ØHƒÄP[A^]ÃH=VP��è¹®ýÿé'ÿÿÿè¯ýÿ‰Å@€õé,ÿÿÿèo¯ýÿ„Àu¡Æ0P��ë˜H‰Ã@¶ýè†àÿÿH‰ßèþ
+�� è÷ªüÿ ÌÌÌÌÌHƒìH‹GH…ÀuH=„ÛûÿHí6��¾+���è —üÿ H‹OH‰$H‰|$H‰L$H‰çè��� ÌÌÌÌÌÌÌÌÌÌÌÌÌPè
+��� ÌÌÌÌÌÌÌÌSHƒì H‹H‹PH‹HHƒútH…ÒuOH…ÉuJHÛûÿ1ÉëH…Éu:H‹H‹H‹IH‰$H‰L$H‹GH‹OH‹PD¶@ D¶H!H5 6��H‰çèh��� H‰$HÇD$����H‹GH‹OH‹PD¶@ D¶H!H5”6��H‰çè4��� H‰ÃH‹|$H…ÿtHƒ|$�tÿÇ<��H‰ßèÏ �� ÌÌÌÌÌÌÌÌÌÌÌÌÌUAWAVAUATSHìˆ���D‰ÍD‰ÃI‰ÌI‰ÕðHÿÛN��~:I‰öI‰ÿèþ…ýÿH…À…ä���H=7æûÿH
-��L°1��HT$0¾F���è‘£üÿ H�ÚûÿH‰D$H 6��H‰D$L‰l$L‰d$ ˆ\$(@ˆl$)HD$H‰D$pHó¥üÿH‰D$xH÷5��H‰D$0HÇD$8���HÇD$P����HD$pH‰D$@HÇD$H���HD$0H‰D$`HÇD$h����H5C.��H|$`HT$0è—üÿH‹|$h„À„D��H…ÿHµ1��HEÇH‰Çé3��€x�…Å���Hÿ�Æ@H1ÙûÿH‰D$H=5��H‰D$L‰l$L‰d$ ˆ\$(@ˆl$)‹M��=þÿÿ?s
Hð±
mM��t H=dM��è?Òÿÿ¶`M��Hƒ=`M���I‹F …Ä���L‰ÿÿÐI‰ÄI‰ÕH‰D$H‰T$€|$)�…��èq„ýÿH…À…m��H=ªäûÿH
Š+��L#0��HT$0¾F���è¢üÿ HË4��H‰D$0HÇD$8���H^ØûÿH‰D$@WÀD$HHD$0H‰D$HÇD$����H5ÿ,��H|$HT$0èЕüÿH‹|$„À…¼þÿÿH…ÿtèYýÿèäýÿ L‰ÿÿÐH‰D$H‰T$H‹=|L��H‹}L��Ht$ÿP(¾ÿÿÿÿðÁ5PL��ÿΉð%ÿÿÿ¿=���€u H=9L��èdÒÿÿèƒýÿH…À„ýÿÿÆ@�„Û„&��L‰ÿL‰öèáÿÿ ÆD$H‹D$ H‰„$€���L‰çAÿUH¹Á{ ͜ȢÁH1ÈH¹dï±�¼ýH1ÊH Â…«���L‰àHƒÀI‹ $H‹�H‰L$pH‰D$xèT˜ýÿI‰Ä¸ ���H
´æûÿM…ätI‹T$H…Òt I‹D$ HÿÈH‰ÑH‰L$`H‰D$hHD$`H‰D$0H„$€���H‰D$8HD$pH‰D$@HD$H‰D$HH|$0Ht$0èGøÿÿM…ä„áþÿÿðIÿ $…ÖþÿÿL‰çè[…ýÿéÉþÿÿL‰çAÿUH¹rSoNá;wsH1ÈH¹¤'åhÒk&zH1ÊH ÂusL‰àHƒÀé*ÿÿÿHÝ2��H‰D$0HÇD$8���H`ÖûÿH‰D$@WÀD$HH|$0Ht$0è ýÿH…À„*þÿÿH‰Çé þÿÿHƒ8v
+ÆD$é“þÿÿèàÿÿˆD$é…þÿÿ¸ ���H
„åûÿé¹þÿÿH‰ÃM…ät/ðIÿ $u(L‰çè•„ýÿë H‰ÃH‹|$H…ÿtUè!ýÿëNè*¥üÿ H‰Ã¾ÿÿÿÿðÁ58J��ÿΉð%ÿÿÿ¿=���€u'H=!J��èLÐÿÿëèõ¤üÿ H‰ÃH‹|$hH…ÿtèÑ~ýÿH‰ßèÙ�� èÒ¤üÿ H‰øH‹H…ÿt
Hƒx�tÿ%§7��ÃÌÌÌÌÌÌAVSHƒì8I‰þH‹_H…Ûu?I‹HÇD$���fïÀóD$H5 *��H|$èÆ’üÿIFH‹L$H‰HD$�H‹AF)D$ IÇF���WÀAF¶I��¿���ÿ:7��H…ÀtH‰(D$ @HJ0��HƒÄ8[A^ÿ���¾���èÓ{üÿ I‰ÆHƒ|$�t#H‹\$ëI‰ÆfoD$ fH~ÀH…Àt H‰ßÿÃ6��L‰÷èË�� ÌÌÌÌÌÌÌÌÌSHƒì H_Hƒ�u6H‹HÇD$���WÀD$H55)��H|$èÛ‘üÿH‹D$H‰CD$H£/��H‰ØHƒÄ [ÃH‰ÃHƒ|$�t H‹|$ÿD6��H‰ßèL�� ÌÌÌÌÌÌÌÌÌÌH¸rSoNá;wsHº¤'åhÒk&zÃÌÌÌÌÌÌÌÌÌÌÌAWAVATSPH‰ÓI‰÷I‰þH‹GL‹gL)àH9Ðr'I‹>LçL‰þH‰Úÿ6��IÜM‰f1ÀHƒÄ[A\A^A_ÃL‰÷L‰æH‰Úèú¤ýÿM‹fëÅÌÌÌÌUAWAVSP‰õH‰ûþ€���s)H‹sH;su H‰ßèʨÿÿH‹sH‹@ˆ,0HÿÆH‰séÆ���ÇD$����‰èý���s Áè ÀˆD$@€å?@€Í€@ˆl$A¾���ëký���s+Áè àˆD$‰èÁè$? €ˆD$@€å?@€Í€@ˆl$A¾���ë8Áè$ ðˆD$‰èÁè $? €ˆD$‰èÁè$? €ˆD$@€å?@€Í€@ˆl$A¾���H‹CL‹{L)øL9ðr(H‹;LÿHt$L‰òÿÜ4��M÷L‰{1ÀHƒÄ[A^A_]ÃH‰ßL‰þL‰òèÒ£ýÿL‹{ëÄÌÌÌÌÌÌÌÌÌÌÌÌH‰òH5&'��éÑüÿÌH¸fM± Ò†ÅHºÏDÏê
,é2ÃÌÌÌÌÌÌÌÌÌÌÌAVSPH‹ L‹w¶F��¿���ÿK4��H…ÀtH‰L‰pH€-��HƒÄ[A^ÿ���¾���èéxüÿ ÌÌÌÌÌÌÌH‰øHV-��ÃÌÌÌÌÌH¸Á{ ͜ȢÁHºdï±�¼ýÃÌÌÌÌÌÌÌÌÌÌÌPèÊðÿÿèÅÝÿÿ ÌÌÌPH‰øH‰÷H‰Æèáÿÿÿ ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌUH‰åSPH ³�� �H‹HHHƒùrÿÐHƒÃøëëHƒÄ[]ÃHƒìèËÿÿÿHƒÄÃ��Hƒìè;aüÿHƒÄÃ������ÿ5Š4��ÿ%Œ4�� @�ÿ%Š4��h����éàÿÿÿÿ%‚4��h���éÐÿÿÿÿ%z4��h���éÀÿÿÿÿ%r4��h���é°ÿÿÿÿ%j4��h���é ÿÿÿÿ%b4��h���éÿÿÿÿÿÿÿÿÿÿÿ��������ÿÿÿÿÿÿÿÿ��������������������������������
������������������������������ �������!������������� ���������7�����������<���������������������������������������������������������������������������������������������������������������������������������������������� �������ˆ�������������� ��������������������� ������������������������������������������������������������ ��������������������������������������������� ��������������� ��������������������������������������������������������������������i���������������������5 ��������������������. ��"����������� ���������� ����������� �������‘��� ��������������������������"������������������������������"������������������������������
���������������,������������������������������+������������������������������*��������������� �������F������������� �������F��(����������� �������9������������� �������g������������� �������h������������������������������������������������������������������������� ���������������&������������������������������������������������������������ ���������������������������������������������������� ��,�����������%����������6�����������%�������
+���+�����������(�������P���(�����������(�������\���������������������4��� ������������������b���#�����������[�������œ�� �����������[������� �� �����������[������� �������������[�������œ��#�����������[�������Ü��$�����������*�������e�������������*�������~��4��������������������������O�������Æ��2�����������0�������7��� �����������0�������“��0�����������0��������� �����������0�������±�������������0�������¸��+�����������0�������Ñ�� �����������0�������ÿ��
�����������0�������ô�������������0�������¹��
�����������0�������>�������������0�������A�������������0�������N��"�����������0�������N��
�����������0�������O��&�����������0�������O��
�����������0�������P��&�����������0�������P��
�����������0�������Q��&�����������0�������Q��
�����������0�������Y��#�����������0�������Y�������������0�������[��"�����������0�������[��
�����������0�������\��&�����������0�������\��
�����������0�������_��"�����������0�������_��
�����������0�������`��&�����������0�������`��
�����������0�������a��&�����������0�������a��
�����������0�������H�������������0�������v�� �����������0�������v�� �����������0�������w��"�����������0�������w�� �����������0�������x��"�����������0�������x�� �����������0�������Š��4�����������0�������‹�������������0�������‹��O�����������0�������‡��4�����������0�������ˆ�������������0�������ˆ��>�����������9������� ��� �����������9�������*��������������0�������i��5�����������0�������o��3�����������0�������p��6�����������0�������p�������������0�������u��%�����������0�������Ì��M�����������0�������I��(�����������0�������a��/�����������0�������[��!�����������0�������{��#�����������0�������}�������������0�������ƒ��)�����������P�������¦��������������J�������b���#������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������.�������=��� �����������.�������:��� �����������.�������6��� �����������.�������f��� �����������.�������o���'�����������.�������p��� �����������.�������r���!�����������.�������r���H�����������.�������s��������������.�������~��� �����������.�������´���&�����������.�������µ���!�����������.�������Š���I�����������.�������‹��� �����������.�������‹���/�����������.����������5�����������.�������‚���,�����������.�������„���%�����������.�������‡���%�����������*�������2��������������*�������/��������������*�������+��������������*�������K��������������*�������Z���(�����������*�������Š���
�����������*������� ��1�����������*�������1�������������*�������4��G�����������9������������������������������"������������������������������*�������\�������������*�������Q�������������*�������¿�� �����������*������� �� �����������*�������#��"�����������*�������$��%�����������*�������‡�������������*�������Ô��-�����������*�������Ê��-�����������+�������b��������������+�������i��������������+�������S�� ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������N�������î��'��������������������������O�������Þ��I�����������O�������·�������������O�������·��!�����������O�������«��!��������������������������M�������Ù���B�����������N�������;�������������N�������H�� �����������N�������I�� �����������N�������J��%�����������N�������Ž��@�����������N�������´��N�����������N�������Â��V�����������N�������Ñ�������������N�������-�������������N�������>��)�����������N�������ç��� �����������N�������›��������������N�������Z�� �����������N�������^�������������N������� �� �����������N��������������������N���������$�����������N�������6�� �����������N�������V��(�����������N�������^���������������������������������������������������������������������������������������������������������_�������Y��0�����������_�������Ç���'�����������L���������$�����������(�������ó�� �����������(�������Å�������������(�������Ø�� �����������K�������‘�������������(�������Z��)�����������)���������'�����������)�������ø���$�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������O�������;��$�����������O�������¸��7�����������&�������¡��+�����������&�������¤��7�����������&�������d�������������&�������y�������������&�������å��2�����������+�������X��)�����������+�������³���3�����������;�������������������������������������r���
�����������3���������������8��������������� �������É��#�����������7��������������� �������œ��
�����������"����������������������!����������������������(�������Ì��� ���������������������������-���������)��������������������������� �������������������������������������~��������������������ë������������� �������ö���������������������������������������������������ý�� ������������������ƒ�� �����������S�������Î���B������������������Ó��5����������� �����������������������������]��$������������������(����������������������õ���������������������Ô��!������������������ý��&������������������û��,������������������
+��'��������������������'������������������€��)��������������������+������������������–��/������������������Ž��/������������������œ��+������������������Ä��/������������������½��/������������������²��+����������� �������Ð�������������� �������‘��������������*������������������������������������� ��������������������������������������8��������������������������������������X�������������������������������������������������������������������������������������������u���������������������������������������������2���������������:���������������������������������������������������������������������������N��������������� �������„�� ������������������������������������������������������������������������������������������������������������� �������������������������������������������������������������������������������������1���������������2���������������-���������������5������������������������������4�������v��0���������������������������������������������������������������������������������������� ������������������������������������������������������������3�������������������������������������������������������������������������������������������������������������������������� �������Œ���
����������� ������������������������������$���������������/���������������*�������ž���
�����������)���������������*�������š���
�����������"�������)��
�����������"�������-��
�����������"�������!�� �����������"�������5�� �����������W���������������$���������������.�������{��������������.��������� �����������*���������������N���������������,�������
+��������������C���������������<�������!��������������<�������/��������������6�������‘��9�����������6�������š��)�����������:�������Æ��� �����������:�������œ��)����������ò��������������������������/������ ��������������ûÿÿo��������������������������������X�������������ð-������ ��������������ùÿÿo����±�������������H=���������������������������hà��������������������������ð������ ��������������������� ������
+�������9������õþÿo����ð �������������
+�������������x¼������������������� �������¼«�����
�������Ì«�����ðÿÿo����ð������þÿÿo����p ������ÿÿÿo���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ÈÜ���������������������ö«�����¬�����¬�����&¬�����6¬�����F¬������������������������������������������������������������������������������������FreeBSD clang version 14.0.5 (https://github.com/llvm/llvm-project.git llvmorg-14.0.5-0-gc12386ae247c)�Linker: LLD 14.0.5 (FreeBSD llvmorg-14.0.5-0-gc12386ae247c-1400004)�rustc version 1.75.0 (82e1608df 2023-12-21)���.interp�.note.tag�.dynsym�.gnu.version�.gnu.version_r�.gnu.hash�.hash�.dynstr�.rela.dyn�.rela.plt�.rodata�.gcc_except_table�.eh_frame_hdr�.eh_frame�.text�.init�.fini�.plt�.ctors�.dtors�.jcr�.init_array�.data.rel.ro�.dynamic�.got�.got.plt�.data�.bss�.comment�.shstrtab���������������������������������������������������������������������������������¨������¨������������������������������������ �������������À������À������0��������������������������������� ����������ð������ð������������������������������������ÿÿÿo�������ð������ð������€����������������������������(���þÿÿo�������p ������p ������€����������������������������7���öÿÿo�������ð ������ð ������$�����������������������������A�������������
+������
+���������������������������������G������������� ������ ������9�����������������������������O�������������X������X������ð-���������������������������Y������B�������H=������H=���������������������������������c������2�������à=������à=������ôS�����������������������������k�������������Ô‘������Ô‘������”�����������������������������}�������������h¡������h¡������D �����������������������������‹�������������°¬������°¬������¼M�����������������������������•�������������p
+�����pú������L¡����������������������������›�������������¼«�����¼›�����������������������������������¡�������������Ì«�����Ì›�����������������������������������§�������������à«�����à›�����p������������������������������¬�������������P¼�����Pœ�����������������������������������³�������������`¼�����`œ�����������������������������������º�������������p¼�����pœ�����������������������������������¿�������������x¼�����xœ�����������������������������������Ë�������������€¼�����€œ�����H �����������������������������Ø�������������ÈÜ�����ȼ�����À���������������������������á�������������ˆÞ�����ˆ¾�����à�����������������������������æ�������������hà�����hÀ�����H������������������������������ï�������������°ð�����°À�����P������������������������������õ��������������ñ������Á�����é������������������������������ú������0����������������Á�����Ø��������������������������������������������������ØÁ�����
�����������������������������
\ No newline at end of file
diff --git a/tests/fixtures/nohup/is_a_tty.sh b/tests/fixtures/nohup/is_a_tty.sh
new file mode 100644
index 0000000000000000000000000000000000000000..1eb0fb5229ed9e6124a450879d83cb3970a2528b
--- /dev/null
+++ b/tests/fixtures/nohup/is_a_tty.sh
@@ -0,0 +1,21 @@
+#!/bin/bash
+
+if [ -t 0 ] ; then
+ echo "stdin is a tty"
+else
+ echo "stdin is not a tty"
+fi
+
+if [ -t 1 ] ; then
+ echo "stdout is a tty"
+else
+ echo "stdout is not a tty"
+fi
+
+if [ -t 2 ] ; then
+ echo "stderr is a tty"
+else
+ echo "stderr is not a tty"
+fi
+
+true
diff --git a/tests/fixtures/split/separator_nul.txt b/tests/fixtures/split/separator_nul.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c4c49609dbd79d27ec1457c489741e63995dc080
--- /dev/null
+++ b/tests/fixtures/split/separator_nul.txt
@@ -0,0 +1 @@
+1�2�3�4�5�
\ No newline at end of file
diff --git a/tests/fixtures/split/separator_semicolon.txt b/tests/fixtures/split/separator_semicolon.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a8396d8eef503db8d4b20a4eb49d1d46d6d7c41d
--- /dev/null
+++ b/tests/fixtures/split/separator_semicolon.txt
@@ -0,0 +1 @@
+1;2;3;4;5;
\ No newline at end of file
diff --git a/tests/fixtures/uniq/locale-fr-schar.txt b/tests/fixtures/uniq/locale-fr-schar.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4e285f37aefcef8fecaf06f593c9975683e56cb6
--- /dev/null
+++ b/tests/fixtures/uniq/locale-fr-schar.txt
@@ -0,0 +1,2 @@
+ y z
+ y z
diff --git a/tests/fixtures/uniq/skip-2-fields.expected b/tests/fixtures/uniq/skip-2-fields.expected
index b971c2b2b394ab40872597289e5db5196c529c70..c7f9bde9d28e5db6a3cb3d4de402a6d327d215af 100644
--- a/tests/fixtures/uniq/skip-2-fields.expected
+++ b/tests/fixtures/uniq/skip-2-fields.expected
@@ -1,2 +1,5 @@
aaa ⟪⟫ a
aa a
+a a a a a a a a a a a a a a a a a a a b a a a
+a a a a a a a a a a a a a a a a a a a a b a a
+a a a a a a a a a a a a a a a a a a a a a b a
diff --git a/tests/fixtures/uniq/skip-21-fields.expected b/tests/fixtures/uniq/skip-21-fields.expected
new file mode 100644
index 0000000000000000000000000000000000000000..1f5295afa5fe0a62229e7294f2150503dd7549c8
--- /dev/null
+++ b/tests/fixtures/uniq/skip-21-fields.expected
@@ -0,0 +1,3 @@
+ aaa ⟪⟫ a
+a a a a a a a a a a a a a a a a a a a b a a a
+a a a a a a a a a a a a a a a a a a a a a b a
diff --git a/tests/fixtures/uniq/skip-fields.txt b/tests/fixtures/uniq/skip-fields.txt
index 4ec2744c61df6f3a21fc59159f3ad4febaef60d9..0ca708a74ca5c89cc3225f9b0836812b0cd20caa 100644
--- a/tests/fixtures/uniq/skip-fields.txt
+++ b/tests/fixtures/uniq/skip-fields.txt
@@ -6,3 +6,6 @@ ZZZ aa a
aa a
a
+a a a a a a a a a a a a a a a a a a a b a a a
+a a a a a a a a a a a a a a a a a a a a b a a
+a a a a a a a a a a a a a a a a a a a a a b a
diff --git a/tests/fixtures/util/is_a_tty.sh b/tests/fixtures/util/is_a_tty.sh
new file mode 100644
index 0000000000000000000000000000000000000000..0a6d64494f08eb95876b461f999417978baebb26
--- /dev/null
+++ b/tests/fixtures/util/is_a_tty.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+
+if [ -t 0 ] ; then
+ echo "stdin is a tty"
+ echo "terminal size: $(stty size)"
+else
+ echo "stdin is not a tty"
+fi
+
+if [ -t 1 ] ; then
+ echo "stdout is a tty"
+else
+ echo "stdout is not a tty"
+fi
+
+if [ -t 2 ] ; then
+ echo "stderr is a tty"
+else
+ echo "stderr is not a tty"
+fi
+
+>&2 echo "This is an error message."
+
+true
diff --git a/tests/fixtures/wc/alice in wonderland.txt b/tests/fixtures/wc/alice in wonderland.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a95562a1ce6c507b56ec2ca7ba4a0e01f18c0f2d
--- /dev/null
+++ b/tests/fixtures/wc/alice in wonderland.txt
@@ -0,0 +1,5 @@
+Alice was beginning to get very tired of sitting by
+her sister on the bank, and of having nothing to do: once or twice
+she had peeped into the book her sister was reading, but it had no
+pictures or conversations in it, "and what is the use of a book,"
+thought Alice "without pictures or conversation?"
diff --git a/tests/fixtures/wc/dir with spaces/.keep b/tests/fixtures/wc/dir with spaces/.keep
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tests/fixtures/wc/files0 with nonexistent.txt b/tests/fixtures/wc/files0 with nonexistent.txt
new file mode 100644
index 0000000000000000000000000000000000000000..00c00b705b1675852a0f3f72509aed19b4eb851c
--- /dev/null
+++ b/tests/fixtures/wc/files0 with nonexistent.txt
@@ -0,0 +1 @@
+this_file_does_not_exist.txt��this file does not exist.txt�this files doesn't exist either.txt
\ No newline at end of file
diff --git a/tests/test_util_name.rs b/tests/test_util_name.rs
index bf0ea2fa32195a122d46ac4bcc7be5aef6433576..689c38214c5e9dc519cf5c34d1f7f36999702c83 100644
--- a/tests/test_util_name.rs
+++ b/tests/test_util_name.rs
@@ -1,3 +1,7 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
#![allow(unused_imports)]
mod common;
@@ -88,3 +92,145 @@ fn util_name_single() {
scenario.fixtures.plus("uu-sort").display()
)));
}
+
+#[test]
+#[cfg(any(unix, windows))]
+fn util_invalid_name_help() {
+ use std::{
+ io::Write,
+ process::{Command, Stdio},
+ };
+
+ let scenario = TestScenario::new("invalid_name");
+ symlink_file(scenario.bin_path, scenario.fixtures.plus("invalid_name")).unwrap();
+ let child = Command::new(scenario.fixtures.plus("invalid_name"))
+ .arg("--help")
+ .stdin(Stdio::piped())
+ .stdout(Stdio::piped())
+ .stderr(Stdio::piped())
+ .spawn()
+ .unwrap();
+ let output = child.wait_with_output().unwrap();
+ assert_eq!(output.status.code(), Some(0));
+ assert_eq!(output.stderr, b"");
+ let output_str = String::from_utf8(output.stdout).unwrap();
+ assert!(output_str.contains("(multi-call binary)"), "{output_str:?}");
+ assert!(
+ output_str.contains("Usage: invalid_name [function "),
+ "{output_str:?}"
+ );
+}
+
+#[test]
+// The exact set of permitted filenames depends on many factors. Non-UTF-8 strings
+// work on very few platforms, but linux works, especially because it also increases
+// the likelihood that a filesystem is being used that supports non-UTF-8 filenames.
+#[cfg(target_os = "linux")]
+fn util_non_utf8_name_help() {
+ // Make sure we don't crash even if the util name is invalid UTF-8.
+ use std::{
+ ffi::OsStr,
+ io::Write,
+ os::unix::ffi::OsStrExt,
+ path::Path,
+ process::{Command, Stdio},
+ };
+
+ let scenario = TestScenario::new("invalid_name");
+ let non_utf8_path = scenario.fixtures.plus(OsStr::from_bytes(b"\xff"));
+ symlink_file(scenario.bin_path, &non_utf8_path).unwrap();
+ let child = Command::new(&non_utf8_path)
+ .arg("--help")
+ .stdin(Stdio::piped())
+ .stdout(Stdio::piped())
+ .stderr(Stdio::piped())
+ .spawn()
+ .unwrap();
+ let output = child.wait_with_output().unwrap();
+ assert_eq!(output.status.code(), Some(0));
+ assert_eq!(output.stderr, b"");
+ let output_str = String::from_utf8(output.stdout).unwrap();
+ assert!(output_str.contains("(multi-call binary)"), "{output_str:?}");
+ assert!(
+ output_str.contains("Usage: <unknown binary name> [function "),
+ "{output_str:?}"
+ );
+}
+
+#[test]
+#[cfg(any(unix, windows))]
+fn util_invalid_name_invalid_command() {
+ use std::{
+ io::Write,
+ process::{Command, Stdio},
+ };
+
+ let scenario = TestScenario::new("invalid_name");
+ symlink_file(scenario.bin_path, scenario.fixtures.plus("invalid_name")).unwrap();
+ let child = Command::new(scenario.fixtures.plus("invalid_name"))
+ .arg("definitely_invalid")
+ .stdin(Stdio::piped())
+ .stdout(Stdio::piped())
+ .stderr(Stdio::piped())
+ .spawn()
+ .unwrap();
+ let output = child.wait_with_output().unwrap();
+ assert_eq!(output.status.code(), Some(1));
+ assert_eq!(output.stderr, b"");
+ assert_eq!(
+ output.stdout,
+ b"definitely_invalid: function/utility not found\n"
+ );
+}
+
+#[test]
+#[cfg(feature = "true")]
+fn util_completion() {
+ use std::{
+ io::Write,
+ process::{Command, Stdio},
+ };
+
+ let scenario = TestScenario::new("completion");
+ let child = Command::new(scenario.bin_path)
+ .arg("completion")
+ .arg("true")
+ .arg("powershell")
+ .stdin(Stdio::piped())
+ .stdout(Stdio::piped())
+ .stderr(Stdio::piped())
+ .spawn()
+ .unwrap();
+ let output = child.wait_with_output().unwrap();
+ assert_eq!(output.status.code(), Some(0));
+ assert_eq!(output.stderr, b"");
+ let output_str = String::from_utf8(output.stdout).unwrap();
+ assert!(
+ output_str.contains("using namespace System.Management.Automation"),
+ "{output_str:?}"
+ );
+}
+
+#[test]
+#[cfg(feature = "true")]
+fn util_manpage() {
+ use std::{
+ io::Write,
+ process::{Command, Stdio},
+ };
+
+ let scenario = TestScenario::new("completion");
+ let child = Command::new(scenario.bin_path)
+ .arg("manpage")
+ .arg("true")
+ .stdin(Stdio::piped())
+ .stdout(Stdio::piped())
+ .stderr(Stdio::piped())
+ .spawn()
+ .unwrap();
+ let output = child.wait_with_output().unwrap();
+ assert_eq!(output.status.code(), Some(0));
+ assert_eq!(output.stderr, b"");
+ let output_str = String::from_utf8(output.stdout).unwrap();
+ assert!(output_str.contains("\n.TH true 1 "), "{output_str:?}");
+}
diff --git a/tests/tests.rs b/tests/tests.rs
index 17581799dd7a916924424b2927de94284b81a538..1fb5735eb719765fef1cec0d6fb66e04cad5dd64 100644
--- a/tests/tests.rs
+++ b/tests/tests.rs
@@ -1,9 +1,10 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
#[macro_use]
mod common;
-#[cfg(unix)]
-extern crate rust_users;
-
#[cfg(feature = "arch")]
#[path = "by-util/test_arch.rs"]
mod test_arch;
@@ -268,10 +269,6 @@ mod test_readlink;
#[path = "by-util/test_realpath.rs"]
mod test_realpath;
-#[cfg(feature = "relpath")]
-#[path = "by-util/test_relpath.rs"]
-mod test_relpath;
-
#[cfg(feature = "rm")]
#[path = "by-util/test_rm.rs"]
mod test_rm;
diff --git a/util/analyze-gnu-results.sh b/util/analyze-gnu-results.sh
old mode 100644
new mode 100755
index 2bc08a9a4cb460796eb2e7b0b16a427e0d4d1f86..76ade340f6b6a844d9d4333c6d477d1f5fe77a9c
--- a/util/analyze-gnu-results.sh
+++ b/util/analyze-gnu-results.sh
@@ -1,4 +1,4 @@
-#!/bin/sh
+#!/usr/bin/env bash
# spell-checker:ignore xpass XPASS testsuite
set -e
@@ -67,9 +67,13 @@ function get_error {
echo $((NON_ROOT + AS_ROOT))
}
-export TOTAL=$(get_total)
-export PASS=$(get_pass)
-export SKIP=$(get_skip)
-export FAIL=$(get_fail)
-export XPASS=$(get_xpass)
-export ERROR=$(get_error)
+# we don't need the return codes indeed, ignore them
+# shellcheck disable=SC2155
+{
+ export TOTAL=$(get_total)
+ export PASS=$(get_pass)
+ export SKIP=$(get_skip)
+ export FAIL=$(get_fail)
+ export XPASS=$(get_xpass)
+ export ERROR=$(get_error)
+}
diff --git a/util/android-commands.sh b/util/android-commands.sh
index 42e27ad886836f820b7ed1c5622a7ef6beabedec..ac84917444be7c9d1d462d777c6b1712c4dab888 100755
--- a/util/android-commands.sh
+++ b/util/android-commands.sh
@@ -1,37 +1,93 @@
-#!/bin/bash
-# spell-checker:ignore termux keyevent sdcard binutils unmatch adb's dumpsys logcat pkill
-
-# There are three shells: the host's, adb, and termux. Only adb lets us run
-# commands directly on the emulated device, only termux provides a GNU
-# environment on the emulated device (to e.g. run cargo). So we use adb to
-# launch termux, then to send keystrokes to it while it's running.
-# This means that the commands sent to termux are first parsed as arguments in
+#!/usr/bin/env bash
+# spell-checker:ignore termux keyevent sdcard binutils unmatch adb's dumpsys logcat pkill nextest logfile
+# spell-checker:ignore screencap reinit PIPESTATUS keygen sourceslist
+
+# There are four shells: the host's, adb, termux and termux via ssh.
+# But only termux and termux via ssh provides a GNU environment on the
+# emulated device (to e.g. run cargo).
+# Initially, only adb lets us run commands directly on the emulated device.
+# Thus we first establish a ssh connection which then can be used to access
+# the termux shell directly, getting output and return code as usual.
+# So we use adb to launch termux, then to send keystrokes to it while it's running.
+# This way we install sshd and a public key from the host. After that we can
+# use ssh to directly run commands in termux environment.
+
+# Before ssh, we need to consider some inconvenient, limiting specialties:
+# The commands sent to termux via adb keystrokes are first parsed as arguments in
# this shell, then as arguments in the adb shell, before finally being used as
# text inputs to the app. Hence, the "'wrapping'" on those commands.
-# There's no way to get any feedback from termux, so every time we run a
-# command on it, we make sure it ends by creating a unique *.probe file at the
-# end of the command. The contents of the file are used as a return code: 0 on
-# success, some other number for errors (an empty file is basically the same as
-# 0). Note that the return codes are text, not raw bytes.
+# Using this approach there's no way to get any direct feedback from termux,
+# so every time we run a command on it, we make sure it creates a unique *.probe file
+# which is polled every 30 seconds together with the current output of the
+# command in a *.log file. The contents of the probe file are used as a return code:
+# 0 on success, some other number for errors (an empty file is basically the same as 0).
+# Note that the return codes are text, not raw bytes.
+
+# Additionally, we can use adb screenshot functionality to investigate issues
+# when there is no feedback arriving from the android device.
+
+this_repo="$(dirname "$(dirname -- "$(readlink -- "${0}")")")"
+cache_dir_name="__rust_cache__"
+dev_probe_dir=/sdcard
+dev_home_dir=/data/data/com.termux/files/home
+
+# This is a list of termux package mirrors approved to be used.
+# The default mirror list contains entries that do not function properly anymore.
+# To avoid failures due to broken mirrors, we use our own list.
+# Choose only reliable mirrors here:
+repo_url_list=(
+ "deb https://packages-cf.termux.org/apt/termux-main/ stable main"
+ "deb https://packages-cf.termux.dev/apt/termux-main/ stable main"
+# "deb https://grimler.se/termux/termux-main stable main" # slow
+ "deb https://ftp.fau.de/termux/termux-main stable main"
+)
+number_repo_urls=${#repo_url_list[@]}
+repo_url_round_robin=$RANDOM
+move_to_next_repo_url() {
+ repo_url_round_robin=$(((repo_url_round_robin + 1) % number_repo_urls))
+ echo "next round robin repo_url: $repo_url_round_robin"
+}
+move_to_next_repo_url # first call needed for modulo
+
+get_current_repo_url() {
+ echo "${repo_url_list[$repo_url_round_robin]}"
+}
-this_repo="$(dirname $(dirname -- "$(readlink -- "${0}")"))"
+# dump some information about the runners system for debugging purposes:
+echo "====== runner information ======"
+echo "hostname: $(hostname)"
+echo "uname -a: $(uname -a)"
+echo "pwd: $(pwd)"
+echo "\$*: $*"
+echo "\$0: $0"
+# shellcheck disable=SC2140
+echo "\$(readlink -- "\$\{0\}"): $(readlink -- "${0}")"
+echo "\$this_repo: $this_repo"
+echo "readlink -f \$this_repo: $(readlink -f "$this_repo")"
+this_repo=$(readlink -f "$this_repo")
+echo "====== runner info end ========="
-help () {
+help() {
echo \
-"Usage: $0 COMMAND [ARG]
+ "Usage: $0 COMMAND [ARG]
where COMMAND is one of:
+ init download termux and initialize the emulator image
snapshot APK install APK and dependencies on an emulator to prep a snapshot
(you can, but probably don't want to, run this for physical
devices -- just set up termux and the dependencies yourself)
- sync [REPO] push the repo at REPO to the device, deleting and restoring all
- symlinks (locally) in the process; by default, REPO is:
+ sync_host [REPO]
+ push the repo at REPO to the device, deleting and restoring all symlinks (locally)
+ in the process; The cached rust directories are restored, too; by default, REPO is:
$this_repo
+ sync_image [REPO]
+ copy the repo/target and the HOME/.cargo directories from the device back to the
+ host; by default, REPO is: $this_repo
build run \`cargo build --features feat_os_unix_android\` on the
- device, then pull the output as build.log
+ device
tests run \`cargo test --features feat_os_unix_android\` on the
- device, then pull the output as tests.log
+ device
If you have multiple devices, use the ANDROID_SERIAL environment variable to
specify which to connect to."
@@ -41,109 +97,578 @@ hit_enter() {
adb shell input keyevent 66
}
+exit_termux() {
+ adb shell input text \"exit\" && hit_enter && hit_enter
+}
+
+timestamp() {
+ date +"%H%M%S%Z"
+}
+
+add_timestamp_to_lines() {
+ while IFS= read -r line; do printf '[%s] %s\n' "$(date '+%Y-%m-%d %H:%M:%S')" "$line"; done
+}
+
+# takes a screenshot with given name from the android device. Filename is prefixed with timestamp.
+# screenshots are collected at the end of the github workflow and provided as download link.
+take_screen_shot() {
+ filename_prefix="$1"
+ filename="$this_repo/output/$(timestamp)_${filename_prefix}_screen.png"
+ echo "take screenshot: $filename"
+ mkdir -p "$this_repo/output"
+ adb exec-out screencap -p > "$filename"
+}
+
launch_termux() {
echo "launching termux"
- if ! adb shell 'am start -n com.termux/.HomeActivity' ; then
+ take_screen_shot "launch_termux_enter"
+
+ adb shell input tap 120 380 # close potential dialog "System UI isn't responding" with "wait".
+ # should not cause side effects when dialog is not there as there are
+ # no relevant GUI elements at this position otherwise.
+
+ if ! adb shell 'am start -n com.termux/.HomeActivity'; then
echo "failed to launch termux"
exit 1
fi
+
+ take_screen_shot "launch_termux_after_start_activity"
+
# the emulator can sometimes be a little slow to launch the app
- while ! adb shell 'ls /sdcard/launch.probe' 2>/dev/null; do
- echo "waiting for launch.probe"
- sleep 5
- adb shell input text 'touch\ /sdcard/launch.probe' && hit_enter
+ loop_count=0
+ while ! adb shell "dumpsys window windows" | \
+ grep -E "imeInputTarget in display# 0 Window{[^}]+com.termux\/com\.termux\.HomeActivity}"
+ do
+ sleep 1
+ loop_count=$((loop_count + 1))
+ if [[ loop_count -ge 20 ]]; then
+ break
+ fi
+ done
+
+ take_screen_shot "launch_termux_after_wait_activity"
+
+ touch_cmd() {
+ adb shell input text "\"touch $dev_probe_dir/launch.probe\"" && hit_enter
+ sleep 1
+ }
+
+ local timeout_start=120
+ local timeout=$timeout_start
+ touch_cmd
+ while ! adb shell "ls $dev_probe_dir/launch.probe" 2>/dev/null
+ do
+ echo "waiting for launch.probe - ($timeout / $timeout_start seconds)"
+ take_screen_shot "launch_termux_touch_probe"
+ sleep 4
+ touch_cmd
+
+ timeout=$((timeout - 4))
+ if [[ timeout -le 0 ]]; then
+ take_screen_shot "error_launch_termux"
+ echo "timeout waiting for termux to start up"
+ return 1
+ fi
+
done
echo "found launch.probe"
- adb shell 'rm /sdcard/launch.probe' && echo "removed launch.probe"
+ take_screen_shot "launch_termux_found_probe"
+ adb shell "rm $dev_probe_dir/launch.probe" && echo "removed launch.probe"
}
+# Usage: run_termux_command
+#
+# Runs the command specified in $1 in a termux shell, polling for the probe specified in $2 (and the
+# current output). If polling the probe succeeded the command is considered to have finished. This
+# method prints the current stdout and stderr of the command every SLEEP_INTERVAL seconds and
+# finishes a command run with a summary. It returns with the exit code of the probe if specified as
+# file content of the probe.
+#
+# Positional arguments
+# $1 The command to execute in the termux shell
+# $2 The path to the probe. The file name must end with `.probe`
+#
+# It's possible to overwrite settings by specifying the setting the variable before calling this
+# method (Default in parentheses):
+# keep_log 0|1 Keeps the logs after running the command if set to 1. The log file name is
+# derived from the probe file name (the last component of the path) and
+# `.probe` replaced with `.log. (0)
+# debug 0|1 Adds additional debugging output to the log file if set to 1. (1)
+# timeout SECONDS The timeout in full SECONDS for the command to complete before giving up. (3600)
+# retries RETRIES The number of retries for trying to fix possible issues when we're not receiving
+# any progress from the emulator. (3)
+# sleep_interval
+# SECONDS The time interval in full SECONDS between polls for the probe and the current
+# output. (5)
run_termux_command() {
- command="$1" # text of the escaped command, including creating the probe!
- probe="$2" # unique file that indicates the command is complete
- launch_termux
- adb shell input text "$command" && hit_enter
- while ! adb shell "ls $probe" 2>/dev/null; do echo "waiting for $probe"; sleep 30; done
- return_code=$(adb shell "cat $probe")
- adb shell "rm $probe"
- echo "return code: $return_code"
+ # shellcheck disable=SC2155
+ local command="$(echo "$1" | sed -E "s/^['](.*)[']$/\1/")" # text of the escaped command, including creating the probe!
+ local probe="$2" # unique file that indicates the command is complete
+ local keep_log=${keep_log:-0}
+ local debug=${debug:-1}
+
+ log_name="$(basename -s .probe "${probe}").log" # probe name must have suffix .probe
+ log_file="$dev_probe_dir/${log_name}"
+ log_read="${log_name}.read"
+ echo 0 >"${log_read}"
+ if [[ $debug -eq 1 ]]; then
+ shell_command="'set -x; { ${command}; } &> ${log_file}; set +x'"
+ else
+ shell_command="'{ ${command}; } &> ${log_file}'"
+ fi
+
+ launch_termux || return
+
+ take_screen_shot "run_termux_command_before_input_of_shell_command"
+
+ # remove artificial quoting
+ shell_command="${shell_command%\'}"
+ shell_command="${shell_command#\'}"
+
+ echo "Running command: ${command}"
+ echo "Running shell-command: ${shell_command}"
+ start=$(date +%s)
+ adb_input_text_long "$shell_command" && sleep 1 && hit_enter
+ # just for safety wait a little bit before polling for the probe and the log file
+ sleep 1
+
+ take_screen_shot "run_termux_command_after_input_of_shell_command"
+
+ local timeout=${timeout:-3600}
+ local retries=${retries:-10}
+ local sleep_interval=${sleep_interval:-10}
+ try_fix=3
+ echo "run_termux_command with timeout=$timeout / retries=$retries / sleep_interval=$sleep_interval"
+ while ! adb shell "ls $probe" 2>/dev/null; do
+ echo -n "Waiting for $probe: "
+
+ if [[ -e "$log_name" ]]; then
+ rm "$log_name"
+ fi
+
+ adb pull "$log_file" . || try_fix=$((try_fix - 1))
+ if [[ -e "$log_name" ]]; then
+ tail -n +"$(<"$log_read")" "$log_name"
+ echo
+ wc -l <"${log_name}" | tr -d "[:space:]" >"$log_read"
+ fi
+
+ if [[ retries -le 0 ]]; then
+ echo "Maximum retries reached running command. Aborting ..."
+ take_screen_shot "run_termux_command_maximum_tries_reached"
+ return 1
+ elif [[ try_fix -le 0 ]]; then
+ retries=$((retries - 1))
+ try_fix=3
+ # Since there is no output, there is no way to know what is happening inside. See if
+ # hitting the enter key solves the issue, sometimes the github runner is just a little
+ # bit slow.
+ echo "No output received. Trying to fix the issue ... (${retries} retries left)"
+ take_screen_shot "run_termux_command_before_trying_to_fix"
+ hit_enter
+ sleep 1
+ take_screen_shot "run_termux_command_after_trying_to_fix"
+ fi
+
+ sleep "$sleep_interval"
+ timeout=$((timeout - sleep_interval))
+
+ if [[ $timeout -le 0 ]]; then
+ echo "Timeout reached running command. Aborting ..."
+ take_screen_shot "run_termux_command_timeout_reached"
+ return 1
+ fi
+ done
+ end=$(date +%s)
+
+ return_code=$(adb shell "cat $probe") || return_code=0
+ adb shell "rm ${probe}"
+
+ adb shell "cat $log_file" > "$log_name"
+ echo "==================================== SUMMARY ==================================="
+ echo "Command: ${command}"
+ echo "Finished in $((end - start)) seconds."
+ echo "Output was:"
+ cat "$log_name"
+ echo "Return code: $return_code"
+ echo "================================================================================"
+
+ adb shell "rm ${log_file}"
+ [[ $keep_log -ne 1 ]] && rm -f "$log_name"
+ rm -f "$log_read" "$probe"
+
+ take_screen_shot "run_termux_command_finished_normally"
+
+ # shellcheck disable=SC2086
return $return_code
}
-snapshot () {
- apk="$1"
- echo "running snapshot"
- adb install -g "$apk"
- probe='/sdcard/pkg.probe'
- command="'yes | pkg install rust binutils openssl -y; touch $probe'"
+init() {
+ arch="$1"
+ # shellcheck disable=SC2034
+ api_level="$2"
+ termux="$3"
+
+ snapshot_name="${AVD_CACHE_KEY}"
+
+ # shellcheck disable=SC2015
+ wget -nv "https://github.com/termux/termux-app/releases/download/${termux}/termux-app_${termux}+github-debug_${arch}.apk" &&
+ snapshot "termux-app_${termux}+github-debug_${arch}.apk" &&
+ hash_rustc &&
+ exit_termux &&
+ adb -s emulator-5554 emu avd snapshot save "$snapshot_name" &&
+ echo "Emulator image created. Name: $snapshot_name" || {
+ pkill -9 qemu-system-x86_64
+ return 1
+ }
+ pkill -9 qemu-system-x86_64 || true
+}
+
+reinit_ssh_connection() {
+ setup_ssh_forwarding
+ test_ssh_connection && return
+
+ start_sshd_via_adb_shell && (
+ test_ssh_connection && return
+ generate_and_install_public_key && test_ssh_connection && return
+ ) || (
+ install_packages_via_adb_shell openssh openssl
+ generate_and_install_public_key
+ start_sshd_via_adb_shell
+ test_ssh_connection && return
+ ) || (
+ echo "failed to setup ssh connection"
+ return 1
+ )
+}
+
+start_sshd_via_adb_shell() {
+ echo "start sshd via adb shell"
+ probe="$dev_probe_dir/sshd.probe"
+ command="'sshd; echo \$? > $probe'"
run_termux_command "$command" "$probe"
- echo "snapshot complete"
- adb shell input text "exit" && hit_enter && hit_enter
}
-sync () {
- repo="$1"
- echo "running sync $1"
- # android doesn't allow symlinks on shared dirs, and adb can't selectively push files
- symlinks=$(find "$repo" -type l)
- # dash doesn't support process substitution :(
- echo $symlinks | sort >symlinks
- git -C "$repo" diff --name-status | cut -f 2 >modified
- modified_links=$(join symlinks modified)
- if [ ! -z "$modified_links" ]; then
- echo "You have modified symlinks. Either stash or commit them, then try again: $modified_links"
- exit 1
- fi
- if ! git ls-files --error-unmatch $symlinks >/dev/null; then
- echo "You have untracked symlinks. Either remove or commit them, then try again."
- exit 1
+setup_ssh_forwarding() {
+ echo "setup ssh forwarding"
+ adb forward tcp:9022 tcp:8022
+}
+
+copy_file_or_dir_to_device_via_ssh() {
+ scp -r "$1" "scp://termux@127.0.0.1:9022/$2"
+}
+
+copy_file_or_dir_from_device_via_ssh() {
+ scp -r "scp://termux@127.0.0.1:9022/$1" "$2"
+}
+
+# runs the in args provided command on android side via ssh. forwards return code.
+# adds a timestamp to every line to be able to see where delays are
+run_command_via_ssh() {
+ ssh -p 9022 termux:@127.0.0.1 -o StrictHostKeyChecking=accept-new "$@" 2>&1 | add_timestamp_to_lines
+ return "${PIPESTATUS[0]}"
+}
+
+test_ssh_connection() {
+ run_command_via_ssh echo ssh connection is working
+}
+
+# takes a local (on runner side) script file and runs it via ssh on the virtual android device. forwards return code.
+# adds a timestamp to every line to be able to see where delays are
+run_script_file_via_ssh() {
+ ssh -p 9022 termux:@127.0.0.1 -o StrictHostKeyChecking=accept-new "bash -s" < "$1" 2>&1 | add_timestamp_to_lines
+ return "${PIPESTATUS[0]}"
+}
+
+# Experiments showed that the adb shell input text functionality has a limitation for the input length.
+# If input length is too big, the input is not fully provided to the android device.
+# To avoid this, we divide large inputs into smaller chunks and put them one-by-one.
+adb_input_text_long() {
+ string=$1
+ length=${#string}
+ step=20
+ p=0
+ for ((i = 0; i < length-step; i = i + step)); do
+ chunk="${string:i:$step}"
+ adb shell input text "'$chunk'"
+ p=$((i+step))
+ done
+
+ remaining="${string:p}"
+ adb shell input text "'$remaining'"
+}
+
+generate_rsa_key_local() {
+ yes "" | ssh-keygen -t rsa -b 4096 -C "Github Action" -N ""
+}
+
+install_rsa_pub() {
+
+ run_command_via_ssh "echo hello" && return # if this works, we are already fine. Skipping
+
+ # remove old host identity:
+ ssh-keygen -f ~/.ssh/known_hosts -R "[127.0.0.1]:9022"
+
+ rsa_pub_key=$(cat ~/.ssh/id_rsa.pub)
+ echo "====================================="
+ echo "$rsa_pub_key"
+ echo "====================================="
+
+ adb shell input text \"echo \"
+
+ adb_input_text_long "$rsa_pub_key"
+
+ adb shell input text "\" >> ~/.ssh/authorized_keys\"" && hit_enter
+ sleep 1
+}
+
+install_packages_via_adb_shell() {
+ install_package_list="$*"
+
+ install_packages_via_adb_shell_using_apt "$install_package_list"
+ if [[ $? -ne 0 ]]; then
+ echo "apt failed. Now try install with pkg as fallback."
+ probe="$dev_probe_dir/pkg.probe"
+ command="'mkdir -vp ~/.cargo/bin; yes | pkg install $install_package_list -y; echo \$? > $probe'"
+ run_termux_command "$command" "$probe" || return 1
fi
- rm $symlinks
- # adb's shell user only has access to shared dirs...
- adb push "$repo" /sdcard/coreutils
- git -C "$repo" checkout $symlinks
- # ...but shared dirs can't build, so move it home as termux
- probe='/sdcard/mv.probe'
- command="'cp -r /sdcard/coreutils ~/; touch $probe'"
- run_termux_command "$command" "$probe"
+
+ return 0
}
-build () {
- probe='/sdcard/build.probe'
- command="'cd ~/coreutils && cargo build --features feat_os_unix_android 2>/sdcard/build.log; echo \$? >$probe'"
- echo "running build"
+# We use apt to install the packages as pkg doesn't respect any pre-defined mirror list.
+# Its important to have a defined mirror list to avoid issues with broken mirrors.
+install_packages_via_adb_shell_using_apt() {
+ install_package_list="$*"
+
+ repo_url=$(get_current_repo_url)
+ move_to_next_repo_url
+ echo "set apt repository url: $repo_url"
+ probe="$dev_probe_dir/sourceslist.probe"
+ command="'echo $repo_url | dd of=\$PREFIX/etc/apt/sources.list; echo \$? > $probe'"
run_termux_command "$command" "$probe"
- return_code=$?
- adb pull /sdcard/build.log .
- cat build.log
- return $return_code
-}
-tests () {
- probe='/sdcard/tests.probe'
- export RUST_BACKTRACE=1
- command="'cd ~/coreutils && timeout --preserve-status --verbose -k 1m 60m cargo test --features feat_os_unix_android --no-fail-fast >/sdcard/tests.log 2>&1; echo \$? >$probe'"
+ probe="$dev_probe_dir/adb_install.probe"
+ command="'mkdir -vp ~/.cargo/bin; apt update; yes | apt install $install_package_list -y; echo \$? > $probe'"
run_termux_command "$command" "$probe"
+}
+
+install_packages_via_ssh_using_apt() {
+ install_package_list="$*"
+
+ repo_url=$(get_current_repo_url)
+ move_to_next_repo_url
+ echo "set apt repository url: $repo_url"
+ run_command_via_ssh "echo $repo_url | dd of=\$PREFIX/etc/apt/sources.list"
+
+ run_command_via_ssh "apt update; yes | apt install $install_package_list -y"
+}
+
+apt_upgrade_all_packages() {
+ repo_url=$(get_current_repo_url)
+ move_to_next_repo_url
+ echo "set apt repository url: $repo_url"
+ run_command_via_ssh "echo $repo_url | dd of=\$PREFIX/etc/apt/sources.list"
+
+ run_command_via_ssh "apt update; yes | apt upgrade -y"
+}
+
+generate_and_install_public_key() {
+ echo "generate local public private key pair"
+ generate_rsa_key_local
+ echo "install public key via 'adb shell input'"
+ install_rsa_pub
+ echo "installed ssh public key on device"
+}
+
+run_with_retry() {
+ tries=$1
+ shift 1
+
+ for i in $(seq 1 $tries); do
+ echo "Try #$i of $tries: run $*"
+ "$@" && echo "Done in try#$i" && return 0
+ done
+
+ exit_code=$?
+
+ echo "Still failing after $tries. Code: $exit_code"
+
+ return $exit_code
+}
+
+snapshot() {
+ apk="$1"
+ echo "Running snapshot"
+ adb install -g "$apk"
+
+ echo "Prepare and install system packages"
+
+ reinit_ssh_connection || return 1
+
+ apt_upgrade_all_packages
+
+ install_packages_via_ssh_using_apt "rust binutils openssl tar mount-utils"
+
+ echo "Read /proc/cpuinfo"
+ run_command_via_ssh "cat /proc/cpuinfo"
+
+ echo "Installing cargo-nextest"
+ # We need to install nextest via cargo currently, since there is no pre-built binary for android x86
+ # explicitly set CARGO_TARGET_DIR as otherwise a random generated tmp directory is used,
+ # which prevents incremental build for the retries.
+ command="export CARGO_TERM_COLOR=always && export CARGO_TARGET_DIR=\"cargo_install_target_dir\" && cargo install cargo-nextest"
+
+ run_with_retry 3 run_command_via_ssh "$command"
return_code=$?
- adb pull /sdcard/tests.log .
- cat tests.log
+
+ echo "Info about cargo and rust - via SSH Script"
+ run_script_file_via_ssh "$this_repo/util/android-scripts/collect-info.sh"
+
+ echo "Snapshot complete"
+ # shellcheck disable=SC2086
return $return_code
}
+sync_host() {
+ repo="$1"
+ cache_home="${HOME}/${cache_dir_name}"
+ cache_dest="$dev_home_dir/${cache_dir_name}"
+
+ reinit_ssh_connection
+
+ echo "Running sync host -> image: ${repo}"
+
+ # run_command_via_ssh "mkdir $dev_home_dir/coreutils"
+
+ copy_file_or_dir_to_device_via_ssh "$repo" "$dev_home_dir"
+ [[ -e "$cache_home" ]] && copy_file_or_dir_to_device_via_ssh "$cache_home" "$cache_dest"
+
+ echo "Finished sync host -> image: ${repo}"
+}
+
+sync_image() {
+ repo="$1"
+ cache_home="${HOME}/${cache_dir_name}"
+ cache_dest="$dev_probe_dir/${cache_dir_name}"
+
+ reinit_ssh_connection
+
+ echo "Running sync image -> host: ${repo}"
+
+ command="rm -rf $dev_probe_dir/coreutils ${cache_dest}; \
+mkdir -p ${cache_dest}; \
+cd ${cache_dest}; \
+tar czf cargo.tgz -C ~/ .cargo; \
+tar czf target.tgz -C ~/coreutils target; \
+ls -la ${cache_dest}"
+ run_command_via_ssh "$command" || return
+
+ rm -rf "$cache_home"
+ copy_file_or_dir_from_device_via_ssh "$cache_dest" "$cache_home" || return
+
+ echo "Finished sync image -> host: ${repo}"
+}
+
+build() {
+ echo "Running build"
+
+ reinit_ssh_connection
+
+ run_script_file_via_ssh "$this_repo/util/android-scripts/collect-info.sh"
+
+ command="export CARGO_TERM_COLOR=always;
+ export CARGO_INCREMENTAL=0; \
+ cd ~/coreutils && cargo build --features feat_os_unix_android"
+ run_with_retry 3 run_command_via_ssh "$command" || return
+
+ echo "Finished build"
+}
+
+tests() {
+ echo "Running tests"
+
+ reinit_ssh_connection
+
+ run_script_file_via_ssh "$this_repo/util/android-scripts/collect-info.sh"
+
+ run_script_file_via_ssh "$this_repo/util/android-scripts/run-tests.sh" || return
+
+ echo "Finished tests"
+}
+
+hash_rustc() {
+ tmp_hash="__rustc_hash__.tmp"
+ hash="__rustc_hash__"
+
+ reinit_ssh_connection
+
+ echo "Hashing rustc version: ${HOME}/${hash}"
+
+ run_command_via_ssh "rustc -Vv" > rustc.log || return
+ rm -f "$tmp_hash"
+ mv "rustc.log" "$tmp_hash" || return
+ # sha256sum is not available. shasum is the macos native program.
+ shasum -a 256 "$tmp_hash" | cut -f 1 -d ' ' | tr -d '[:space:]' >"${HOME}/${hash}" || return
+
+ rm -f "$tmp_hash"
+
+ echo "Finished hashing rustc version: ${HOME}/${hash}"
+}
+
#adb logcat &
exit_code=0
if [ $# -eq 1 ]; then
case "$1" in
- sync) sync "$this_repo"; exit_code=$?;;
- build) build; exit_code=$?;;
- tests) tests; exit_code=$?;;
- *) help;;
+ sync_host)
+ sync_host "$this_repo"
+ exit_code=$?
+ ;;
+ sync_image)
+ sync_image "$this_repo"
+ exit_code=$?
+ ;;
+ build)
+ build
+ exit_code=$?
+ ;;
+ tests)
+ tests
+ exit_code=$?
+ ;;
+ *) help ;;
esac
elif [ $# -eq 2 ]; then
case "$1" in
- snapshot) snapshot "$2"; exit_code=$?;;
- sync) sync "$2"; exit_code=$?;;
- *) help; exit 1;;
+ snapshot)
+ snapshot "$2"
+ exit_code=$?
+ ;;
+ sync_host)
+ sync_host "$2"
+ exit_code=$?
+ ;;
+ sync_image)
+ sync_image "$2"
+ exit_code=$?
+ ;;
+ *)
+ help
+ exit 1
+ ;;
+ esac
+elif [ $# -eq 4 ]; then
+ case "$1" in
+ init)
+ shift
+ init "$@"
+ exit_code=$?
+ ;;
+ *)
+ help
+ exit 1
+ ;;
esac
else
help
diff --git a/util/android-scripts/collect-info.sh b/util/android-scripts/collect-info.sh
new file mode 100644
index 0000000000000000000000000000000000000000..412423bd13581e26e9ceff7b326eb8280d2a24d6
--- /dev/null
+++ b/util/android-scripts/collect-info.sh
@@ -0,0 +1,20 @@
+#!/bin/bash
+
+# spell-checker:ignore nextest watchplus PIPESTATUS
+
+echo "system resources - RAM:"
+free -hm
+echo "system resources - CPU:"
+lscpu
+echo "system resources - file systems:"
+mount
+
+echo "$HOME"
+PATH=$HOME/.cargo/bin:$PATH
+export PATH
+echo "$PATH"
+pwd
+command -v rustc && rustc -Vv
+ls -la ~/.cargo/bin
+cargo --list
+cargo nextest --version
diff --git a/util/android-scripts/run-tests.sh b/util/android-scripts/run-tests.sh
new file mode 100644
index 0000000000000000000000000000000000000000..17eed8808e0e7600914d0b45594cb1da45d7e72c
--- /dev/null
+++ b/util/android-scripts/run-tests.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+# spell-checker:ignore nextest watchplus PIPESTATUS
+
+echo "PATH: $PATH"
+
+export PATH=$HOME/.cargo/bin:$PATH
+export RUST_BACKTRACE=full
+export CARGO_TERM_COLOR=always
+export CARGO_INCREMENTAL=0
+
+echo "PATH: $PATH"
+
+run_with_retry() {
+ tries=$1
+ shift 1
+
+ for i in $(seq 1 $tries); do
+ echo "Try #$i of $tries: run $*"
+ "$@" && echo "Done in try#$i" && return 0
+ done
+
+ exit_code=$?
+
+ echo "Still failing after $tries. Code: $exit_code"
+
+ return $exit_code
+}
+
+run_tests_in_subprocess() (
+
+ # limit virtual memory to 3GB to avoid that OS kills sshd
+ ulimit -v $((1024 * 1024 * 3))
+
+ watchplus() {
+ # call: watchplus <interval> <command>
+ while true; do
+ "${@:2}"
+ sleep "$1"
+ done
+ }
+
+ kill_all_background_jobs() {
+ jobs -p | xargs -I{} kill -- {}
+ }
+
+ # observe (log) every 2 seconds the system resource usage to judge if we are at a limit
+ watchplus 2 df -h &
+ watchplus 2 free -hm &
+
+ nextest_params=(--profile ci --hide-progress-bar --features feat_os_unix_android)
+
+ # run tests
+ cd ~/coreutils && \
+ run_with_retry 3 timeout --preserve-status --verbose -k 1m 10m \
+ cargo nextest run --no-run "${nextest_params[@]}" &&
+ timeout --preserve-status --verbose -k 1m 60m \
+ cargo nextest run "${nextest_params[@]}"
+
+ result=$?
+
+ kill_all_background_jobs
+
+ return $result
+)
+
+# run sub-shell to be able to use ulimit without affecting the sshd
+run_tests_in_subprocess
diff --git a/util/build-code_coverage.sh b/util/build-code_coverage.sh
index 4082bc13dcf8f5ffd6d214795826b5889891d557..bbe4abaab3f03e1ee00c36c68156c48961cf550b 100755
--- a/util/build-code_coverage.sh
+++ b/util/build-code_coverage.sh
@@ -1,15 +1,25 @@
-#!/bin/sh
+#!/usr/bin/env bash
# spell-checker:ignore (abbrevs/acronyms) HTML gcno llvm
# spell-checker:ignore (jargon) toolchain
# spell-checker:ignore (rust) Ccodegen Cinline Coverflow Cpanic RUSTC RUSTDOCFLAGS RUSTFLAGS RUSTUP Zpanic
-# spell-checker:ignore (shell) OSID esac
-# spell-checker:ignore (utils) genhtml grcov lcov readlink sccache shellcheck uutils
+# spell-checker:ignore (shell) OSID OSTYPE esac
+# spell-checker:ignore (utils) genhtml grcov lcov greadlink readlink sccache shellcheck uutils
FEATURES_OPTION="--features feat_os_unix"
+# Use GNU coreutils for readlink on *BSD
+case "$OSTYPE" in
+ *bsd*)
+ READLINK="greadlink"
+ ;;
+ *)
+ READLINK="readlink"
+ ;;
+esac
+
ME="${0}"
-ME_dir="$(dirname -- "$(readlink -fm -- "${ME}")")"
+ME_dir="$(dirname -- "$("${READLINK}" -fm -- "${ME}")")"
REPO_main_dir="$(dirname -- "${ME_dir}")"
cd "${REPO_main_dir}" &&
diff --git a/util/build-gnu.sh b/util/build-gnu.sh
index dad97086636f29723e3b0f7bf233e6de556d5b00..07f788ac185203eafffc08d1cad0a0540d9cd9b9 100755
--- a/util/build-gnu.sh
+++ b/util/build-gnu.sh
@@ -1,53 +1,108 @@
-#!/bin/bash
+#!/usr/bin/env bash
# `build-gnu.bash` ~ builds GNU coreutils (from supplied sources)
#
-# UU_MAKE_PROFILE == 'debug' | 'release' ## build profile for *uutils* build; may be supplied by caller, defaults to 'debug'
-# spell-checker:ignore (paths) abmon deref discrim eacces getlimits getopt ginstall inacc infloop inotify reflink ; (misc) INT_OFLOW OFLOW baddecode submodules ; (vars/env) SRCDIR vdir rcexp xpart
+# spell-checker:ignore (paths) abmon deref discrim eacces getlimits getopt ginstall inacc infloop inotify reflink ; (misc) INT_OFLOW OFLOW baddecode submodules xstrtol ; (vars/env) SRCDIR vdir rcexp xpart dired OSTYPE ; (utils) gnproc greadlink gsed
set -e
+# Use GNU version for make, nproc, readlink and sed on *BSD
+case "$OSTYPE" in
+ *bsd*)
+ MAKE="gmake"
+ NPROC="gnproc"
+ READLINK="greadlink"
+ SED="gsed"
+ ;;
+ *)
+ MAKE="make"
+ NPROC="nproc"
+ READLINK="readlink"
+ SED="sed"
+ ;;
+esac
+
ME="${0}"
-ME_dir="$(dirname -- "$(readlink -fm -- "${ME}")")"
+ME_dir="$(dirname -- "$("${READLINK}" -fm -- "${ME}")")"
REPO_main_dir="$(dirname -- "${ME_dir}")"
-echo "ME='${ME}'"
-echo "ME_dir='${ME_dir}'"
-echo "REPO_main_dir='${REPO_main_dir}'"
+# Default profile is 'debug'
+UU_MAKE_PROFILE='debug'
+
+for arg in "$@"
+do
+ if [ "$arg" == "--release-build" ]; then
+ UU_MAKE_PROFILE='release'
+ break
+ fi
+done
+
+echo "UU_MAKE_PROFILE='${UU_MAKE_PROFILE}'"
### * config (from environment with fallback defaults); note: GNU is expected to be a sibling repo directory
path_UUTILS=${path_UUTILS:-${REPO_main_dir}}
-path_GNU="$(readlink -fm -- "${path_GNU:-${path_UUTILS}/../gnu}")"
+path_GNU="$("${READLINK}" -fm -- "${path_GNU:-${path_UUTILS}/../gnu}")"
-echo "path_UUTILS='${path_UUTILS}'"
-echo "path_GNU='${path_GNU}'"
+###
+
+# On MacOS there is no system /usr/bin/timeout
+# and trying to add it to /usr/bin (with symlink of copy binary) will fail unless system integrity protection is disabled (not ideal)
+# ref: https://support.apple.com/en-us/102149
+# On MacOS the Homebrew coreutils could be installed and then "sudo ln -s /opt/homebrew/bin/timeout /usr/local/bin/timeout"
+# Set to /usr/local/bin/timeout instead if /usr/bin/timeout is not found
+SYSTEM_TIMEOUT="timeout"
+if [ -x /usr/bin/timeout ]; then
+ SYSTEM_TIMEOUT="/usr/bin/timeout"
+elif [ -x /usr/local/bin/timeout ]; then
+ SYSTEM_TIMEOUT="/usr/local/bin/timeout"
+fi
###
+release_tag_GNU="v9.5"
+
if test ! -d "${path_GNU}"; then
- echo "Could not find GNU (expected at '${path_GNU}')"
+ echo "Could not find GNU coreutils (expected at '${path_GNU}')"
+ echo "Run the following to download into the expected path:"
echo "git clone --recurse-submodules https://github.com/coreutils/coreutils.git \"${path_GNU}\""
+ echo "After downloading GNU coreutils to \"${path_GNU}\" run the following commands to checkout latest release tag"
+ echo "cd \"${path_GNU}\""
+ echo "git fetch --all --tags"
+ echo "git checkout tags/${release_tag_GNU}"
exit 1
fi
###
-UU_MAKE_PROFILE=${UU_MAKE_PROFILE:-release}
-echo "UU_MAKE_PROFILE='${UU_MAKE_PROFILE}'"
+echo "ME='${ME}'"
+echo "ME_dir='${ME_dir}'"
+echo "REPO_main_dir='${REPO_main_dir}'"
+
+echo "path_UUTILS='${path_UUTILS}'"
+echo "path_GNU='${path_GNU}'"
+
+###
UU_BUILD_DIR="${path_UUTILS}/target/${UU_MAKE_PROFILE}"
echo "UU_BUILD_DIR='${UU_BUILD_DIR}'"
cd "${path_UUTILS}" && echo "[ pwd:'${PWD}' ]"
-SELINUX_ENABLED=1 make PROFILE="${UU_MAKE_PROFILE}"
+
+if [ "$(uname)" == "Linux" ]; then
+ # only set on linux
+ export SELINUX_ENABLED=1
+fi
+
+"${MAKE}" PROFILE="${UU_MAKE_PROFILE}"
+
cp "${UU_BUILD_DIR}/install" "${UU_BUILD_DIR}/ginstall" # The GNU tests rename this script before running, to avoid confusion with the make target
# Create *sum binaries
for sum in b2sum b3sum md5sum sha1sum sha224sum sha256sum sha384sum sha512sum; do
sum_path="${UU_BUILD_DIR}/${sum}"
- test -f "${sum_path}" || cp "${UU_BUILD_DIR}/hashsum" "${sum_path}"
+ test -f "${sum_path}" || (cd ${UU_BUILD_DIR} && ln -s "hashsum" "${sum}")
done
-test -f "${UU_BUILD_DIR}/[" || cp "${UU_BUILD_DIR}/test" "${UU_BUILD_DIR}/["
+test -f "${UU_BUILD_DIR}/[" || (cd ${UU_BUILD_DIR} && ln -s "test" "[")
##
@@ -67,14 +122,16 @@ if test -f gnu-built; then
echo "'rm -f $(pwd)/gnu-built' to force the build"
echo "Note: the customization of the tests will still happen"
else
- ./bootstrap
- ./configure --quiet --disable-gcc-warnings
+ ./bootstrap --skip-po
+ ./configure --quiet --disable-gcc-warnings --disable-nls --disable-dependency-tracking --disable-bold-man-page-references
#Add timeout to to protect against hangs
- sed -i 's|^"\$@|/usr/bin/timeout 600 "\$@|' build-aux/test-driver
+ sed -i 's|^"\$@|'"${SYSTEM_TIMEOUT}"' 600 "\$@|' build-aux/test-driver
# Change the PATH in the Makefile to test the uutils coreutils instead of the GNU coreutils
sed -i "s/^[[:blank:]]*PATH=.*/ PATH='${UU_BUILD_DIR//\//\\/}\$(PATH_SEPARATOR)'\"\$\$PATH\" \\\/" Makefile
sed -i 's| tr | /usr/bin/tr |' tests/init.sh
- make -j "$(nproc)"
+ # Use a better diff
+ sed -i 's|diff -c|diff -u|g' tests/Coreutils.pm
+ "${MAKE}" -j "$("${NPROC}")"
touch gnu-built
fi
@@ -94,7 +151,7 @@ t_max=36
# done
# )
# for i in ${seq}; do
-# make "tests/factor/t${i}.sh"
+# "${MAKE}" "tests/factor/t${i}.sh"
# done
# cat
# sed -i -e 's|^seq |/usr/bin/seq |' -e 's|sha1sum |/usr/bin/sha1sum |' tests/factor/t*.sh
@@ -118,44 +175,58 @@ grep -rl 'path_prepend_' tests/* | xargs sed -i 's| path_prepend_ ./src||'
# Remove tests checking for --version & --help
# Not really interesting for us and logs are too big
sed -i -e '/tests\/misc\/invalid-opt.pl/ D' \
- -e '/tests\/misc\/help-version.sh/ D' \
- -e '/tests\/misc\/help-version-getopt.sh/ D' \
+ -e '/tests\/help\/help-version.sh/ D' \
+ -e '/tests\/help\/help-version-getopt.sh/ D' \
Makefile
# logs are clotted because of this test
-sed -i -e '/tests\/misc\/seq-precision.sh/ D' \
+sed -i -e '/tests\/seq\/seq-precision.sh/ D' \
Makefile
# printf doesn't limit the values used in its arg, so this produced ~2GB of output
-sed -i '/INT_OFLOW/ D' tests/misc/printf.sh
+sed -i '/INT_OFLOW/ D' tests/printf/printf.sh
# Use the system coreutils where the test fails due to error in a util that is not the one being tested
-sed -i 's|stat|/usr/bin/stat|' tests/touch/60-seconds.sh tests/misc/sort-compress-proc.sh
+sed -i 's|stat|/usr/bin/stat|' tests/touch/60-seconds.sh tests/sort/sort-compress-proc.sh
sed -i 's|ls -|/usr/bin/ls -|' tests/cp/same-file.sh tests/misc/mknod.sh tests/mv/part-symlink.sh
-sed -i 's|chmod |/usr/bin/chmod |' tests/du/inacc-dir.sh tests/tail-2/tail-n0f.sh tests/cp/fail-perm.sh tests/mv/i-2.sh tests/misc/shuf.sh
-sed -i 's|sort |/usr/bin/sort |' tests/ls/hyperlink.sh tests/misc/test-N.sh
-sed -i 's|split |/usr/bin/split |' tests/misc/factor-parallel.sh
-sed -i 's|id -|/usr/bin/id -|' tests/misc/runcon-no-reorder.sh
+sed -i 's|chmod |/usr/bin/chmod |' tests/du/inacc-dir.sh tests/tail/tail-n0f.sh tests/cp/fail-perm.sh tests/mv/i-2.sh tests/shuf/shuf.sh
+sed -i 's|sort |/usr/bin/sort |' tests/ls/hyperlink.sh tests/test/test-N.sh
+sed -i 's|split |/usr/bin/split |' tests/factor/factor-parallel.sh
+sed -i 's|id -|/usr/bin/id -|' tests/runcon/runcon-no-reorder.sh
+sed -i "s|grep '^#define HAVE_CAP 1' \$CONFIG_HEADER > /dev/null|true|" tests/ls/capability.sh
# tests/ls/abmon-align.sh - https://github.com/uutils/coreutils/issues/3505
-sed -i 's|touch |/usr/bin/touch |' tests/cp/reflink-perm.sh tests/ls/block-size.sh tests/mv/update.sh tests/misc/ls-time.sh tests/misc/stat-nanoseconds.sh tests/misc/time-style.sh tests/misc/test-N.sh tests/ls/abmon-align.sh
+sed -i 's|touch |/usr/bin/touch |' tests/cp/reflink-perm.sh tests/ls/block-size.sh tests/mv/update.sh tests/ls/ls-time.sh tests/stat/stat-nanoseconds.sh tests/misc/time-style.sh tests/test/test-N.sh tests/ls/abmon-align.sh
sed -i 's|ln -|/usr/bin/ln -|' tests/cp/link-deref.sh
+
+# our messages are better
+sed -i "s|cannot stat 'symlink': Permission denied|not writing through dangling symlink 'symlink'|" tests/cp/fail-perm.sh
+sed -i "s|cp: target directory 'symlink': Permission denied|cp: 'symlink' is not a directory|" tests/cp/fail-perm.sh
+
+# Our message is a bit better
+sed -i "s|cannot create regular file 'no-such/': Not a directory|'no-such/' is not a directory|" tests/mv/trailing-slash.sh
+
sed -i 's|cp |/usr/bin/cp |' tests/mv/hard-2.sh
-sed -i 's|paste |/usr/bin/paste |' tests/misc/od-endian.sh
-sed -i 's|timeout |/usr/bin/timeout |' tests/tail-2/follow-stdin.sh
+sed -i 's|paste |/usr/bin/paste |' tests/od/od-endian.sh
+sed -i 's|timeout |'"${SYSTEM_TIMEOUT}"' |' tests/tail/follow-stdin.sh
# Add specific timeout to tests that currently hang to limit time spent waiting
-sed -i 's|\(^\s*\)seq \$|\1/usr/bin/timeout 0.1 seq \$|' tests/misc/seq-precision.sh tests/misc/seq-long-double.sh
+sed -i 's|\(^\s*\)seq \$|\1'"${SYSTEM_TIMEOUT}"' 0.1 seq \$|' tests/seq/seq-precision.sh tests/seq/seq-long-double.sh
-# Remove dup of /usr/bin/ when executed several times
-grep -rlE '/usr/bin/\s?/usr/bin' init.cfg tests/* | xargs --no-run-if-empty sed -Ei 's|/usr/bin/\s?/usr/bin/|/usr/bin/|g'
+# Remove dup of /usr/bin/ and /usr/local/bin/ when executed several times
+grep -rlE '/usr/bin/\s?/usr/bin' init.cfg tests/* | xargs -r sed -Ei 's|/usr/bin/\s?/usr/bin/|/usr/bin/|g'
+grep -rlE '/usr/local/bin/\s?/usr/local/bin' init.cfg tests/* | xargs -r sed -Ei 's|/usr/local/bin/\s?/usr/local/bin/|/usr/local/bin/|g'
#### Adjust tests to make them work with Rust/coreutils
# in some cases, what we are doing in rust/coreutils is good (or better)
# we should not regress our project just to match what GNU is going.
# So, do some changes on the fly
+eval cat "$path_UUTILS/util/gnu-patches/*.patch" | patch -N -r - -d "$path_GNU" -p 1 -i - || true
+
sed -i -e "s|rm: cannot remove 'e/slink'|rm: cannot remove 'e'|g" tests/rm/fail-eacces.sh
+sed -i -e "s|rm: cannot remove 'a/b'|rm: cannot remove 'a'|g" tests/rm/fail-2eperm.sh
+
sed -i -e "s|rm: cannot remove 'a/b/file'|rm: cannot remove 'a'|g" tests/rm/cycle.sh
sed -i -e "s|rm: cannot remove directory 'b/a/p'|rm: cannot remove 'b'|g" tests/rm/rm1.sh
@@ -164,23 +235,38 @@ sed -i -e "s|rm: cannot remove 'a/1'|rm: cannot remove 'a'|g" tests/rm/rm2.sh
sed -i -e "s|removed directory 'a/'|removed directory 'a'|g" tests/rm/v-slash.sh
+# 'rel' doesn't exist. Our implementation is giving a better message.
+sed -i -e "s|rm: cannot remove 'rel': Permission denied|rm: cannot remove 'rel': No such file or directory|g" tests/rm/inaccessible.sh
+
# overlay-headers.sh test intends to check for inotify events,
# however there's a bug because `---dis` is an alias for: `---disable-inotify`
-sed -i -e "s|---dis ||g" tests/tail-2/overlay-headers.sh
+sed -i -e "s|---dis ||g" tests/tail/overlay-headers.sh
+
+# Do not FAIL, just do a regular ERROR
+sed -i -e "s|framework_failure_ 'no inotify_add_watch';|fail=1;|" tests/tail/inotify-rotate-resources.sh
test -f "${UU_BUILD_DIR}/getlimits" || cp src/getlimits "${UU_BUILD_DIR}"
+# pr produces very long log and this command isn't super interesting
+# SKIP for now
+sed -i -e "s|my \$prog = 'pr';$|my \$prog = 'pr';CuSkip::skip \"\$prog: SKIP for producing too long logs\";|" tests/pr/pr-tests.pl
+
+# We don't have the same error message and no need to be that specific
+sed -i -e "s|invalid suffix in --pages argument|invalid --pages argument|" \
+ -e "s|--pages argument '\$too_big' too large|invalid --pages argument '\$too_big'|" \
+ -e "s|invalid page range|invalid --pages argument|" tests/misc/xstrtol.pl
+
# When decoding an invalid base32/64 string, gnu writes everything it was able to decode until
# it hit the decode error, while we don't write anything if the input is invalid.
-sed -i "s/\(baddecode.*OUT=>\"\).*\"/\1\"/g" tests/misc/base64.pl
-sed -i "s/\(\(b2[ml]_[69]\|b32h_[56]\|z85_8\|z85_35\).*OUT=>\)[^}]*\(.*\)/\1\"\"\3/g" tests/misc/basenc.pl
+sed -i "s/\(baddecode.*OUT=>\"\).*\"/\1\"/g" tests/basenc/base64.pl
+sed -i "s/\(\(b2[ml]_[69]\|b32h_[56]\|z85_8\|z85_35\).*OUT=>\)[^}]*\(.*\)/\1\"\"\3/g" tests/basenc/basenc.pl
# add "error: " to the expected error message
-sed -i "s/\$prog: invalid input/\$prog: error: invalid input/g" tests/misc/basenc.pl
+sed -i "s/\$prog: invalid input/\$prog: error: invalid input/g" tests/basenc/basenc.pl
# basenc: swap out error message for unexpected arg
-sed -i "s/ {ERR=>\"\$prog: foobar\\\\n\" \. \$try_help }/ {ERR=>\"error: Found argument '--foobar' which wasn't expected, or isn't valid in this context\n\n If you tried to supply '--foobar' as a value rather than a flag, use '-- --foobar'\n\nUsage: basenc [OPTION]... [FILE]\n\nFor more information try '--help'\n\"}]/" tests/misc/basenc.pl
-sed -i "s/ {ERR_SUBST=>\"s\/(unrecognized|unknown) option \[-' \]\*foobar\[' \]\*\/foobar\/\"}],//" tests/misc/basenc.pl
+sed -i "s/ {ERR=>\"\$prog: foobar\\\\n\" \. \$try_help }/ {ERR=>\"error: Found argument '--foobar' which wasn't expected, or isn't valid in this context\n\n If you tried to supply '--foobar' as a value rather than a flag, use '-- --foobar'\n\nUsage: basenc [OPTION]... [FILE]\n\nFor more information try '--help'\n\"}]/" tests/basenc/basenc.pl
+sed -i "s/ {ERR_SUBST=>\"s\/(unrecognized|unknown) option \[-' \]\*foobar\[' \]\*\/foobar\/\"}],//" tests/basenc/basenc.pl
# Remove the check whether a util was built. Otherwise tests against utils like "arch" are not run.
sed -i "s|require_built_ |# require_built_ |g" init.cfg
@@ -193,21 +279,17 @@ sed -i "s|\$PACKAGE_VERSION|[0-9]*|g" tests/rm/fail-2eperm.sh tests/mv/sticky-to
# with the option -/ is used, clap is returning a better error than GNU's. Adjust the GNU test
sed -i -e "s~ grep \" '\*/'\*\" err || framework_failure_~ grep \" '*-/'*\" err || framework_failure_~" tests/misc/usage_vs_getopt.sh
sed -i -e "s~ sed -n \"1s/'\\\/'/'OPT'/p\" < err >> pat || framework_failure_~ sed -n \"1s/'-\\\/'/'OPT'/p\" < err >> pat || framework_failure_~" tests/misc/usage_vs_getopt.sh
-# Ignore some binaries (not built)
-# And change the default error code to 2
-# see issue #3331 (clap limitation).
-# Upstream returns 1 for most of the program. We do for cp, truncate & pr
-# So, keep it as it
-sed -i -e "s/rcexp=1$/rcexp=2\n case \"\$prg\" in chcon|runcon) return;; esac/" -e "s/rcexp=125 ;;/rcexp=2 ;;\ncp|truncate|pr) rcexp=1;;/" tests/misc/usage_vs_getopt.sh
+# Ignore runcon, it needs some extra attention
+# For all other tools, we want drop-in compatibility, and that includes the exit code.
+sed -i -e "s/rcexp=1$/rcexp=1\n case \"\$prg\" in runcon|stdbuf) return;; esac/" tests/misc/usage_vs_getopt.sh
# GNU has option=[SUFFIX], clap is <SUFFIX>
-sed -i -e "s/cat opts/sed -i -e \"s| <.\*>$||g\" opts/" tests/misc/usage_vs_getopt.sh
+sed -i -e "s/cat opts/sed -i -e \"s| <.\*$||g\" opts/" tests/misc/usage_vs_getopt.sh
# for some reasons, some stuff are duplicated, strip that
sed -i -e "s/provoked error./provoked error\ncat pat |sort -u > pat/" tests/misc/usage_vs_getopt.sh
# Update the GNU error message to match ours
sed -i -e "s/link-to-dir: hard link not allowed for directory/failed to create hard link 'link-to-dir' =>/" -e "s|link-to-dir/: hard link not allowed for directory|failed to create hard link 'link-to-dir/' =>|" tests/ln/hard-to-sym.sh
-
# GNU sleep accepts some crazy string, not sure we should match this behavior
sed -i -e "s/timeout 10 sleep 0x.002p1/#timeout 10 sleep 0x.002p1/" tests/misc/sleep.sh
@@ -216,11 +298,48 @@ sed -i -e "s/ginstall: creating directory/install: creating directory/g" tests/i
# GNU doesn't support padding < -LONG_MAX
# disable this test case
-sed -i -Ez "s/\n([^\n#]*pad-3\.2[^\n]*)\n([^\n]*)\n([^\n]*)/\n# uutils\/numfmt supports padding = LONG_MIN\n#\1\n#\2\n#\3/" tests/misc/numfmt.pl
+# Use GNU sed because option -z is not available on BSD sed
+"${SED}" -i -Ez "s/\n([^\n#]*pad-3\.2[^\n]*)\n([^\n]*)\n([^\n]*)/\n# uutils\/numfmt supports padding = LONG_MIN\n#\1\n#\2\n#\3/" tests/misc/numfmt.pl
# Update the GNU error message to match the one generated by clap
sed -i -e "s/\$prog: multiple field specifications/error: The argument '--field <FIELDS>' was provided more than once, but cannot be used multiple times\n\nUsage: numfmt [OPTION]... [NUMBER]...\n\n\nFor more information try '--help'/g" tests/misc/numfmt.pl
+sed -i -e "s/Try 'mv --help' for more information/For more information, try '--help'/g" -e "s/mv: missing file operand/error: the following required arguments were not provided:\n <files>...\n\nUsage: mv [OPTION]... [-T] SOURCE DEST\n mv [OPTION]... SOURCE... DIRECTORY\n mv [OPTION]... -t DIRECTORY SOURCE...\n/g" -e "s/mv: missing destination file operand after 'no-file'/error: The argument '<files>...' requires at least 2 values, but only 1 was provided\n\nUsage: mv [OPTION]... [-T] SOURCE DEST\n mv [OPTION]... SOURCE... DIRECTORY\n mv [OPTION]... -t DIRECTORY SOURCE...\n/g" tests/mv/diag.sh
+
+# our error message is better
+sed -i -e "s|mv: cannot overwrite 'a/t': Directory not empty|mv: cannot move 'b/t' to 'a/t': Directory not empty|" tests/mv/dir2dir.sh
# GNU doesn't support width > INT_MAX
# disable these test cases
-sed -i -E "s|^([^#]*2_31.*)$|#\1|g" tests/misc/printf-cov.pl
+sed -i -E "s|^([^#]*2_31.*)$|#\1|g" tests/printf/printf-cov.pl
+
+sed -i -e "s/du: invalid -t argument/du: invalid --threshold argument/" -e "s/du: option requires an argument/error: a value is required for '--threshold <SIZE>' but none was supplied/" -e "/Try 'du --help' for more information./d" tests/du/threshold.sh
+
+# Remove the extra output check
+sed -i -e "s|Try '\$prog --help' for more information.\\\n||" tests/du/files0-from.pl
+sed -i -e "s|when reading file names from stdin, no file name of\"|-: No such file or directory\n\"|" -e "s| '-' allowed\\\n||" tests/du/files0-from.pl
+sed -i -e "s|-: No such file or directory|cannot access '-': No such file or directory|g" tests/du/files0-from.pl
+
+awk 'BEGIN {count=0} /compare exp out2/ && count < 6 {sub(/compare exp out2/, "grep -q \"cannot be used with\" out2"); count++} 1' tests/df/df-output.sh > tests/df/df-output.sh.tmp && mv tests/df/df-output.sh.tmp tests/df/df-output.sh
+
+# with ls --dired, in case of error, we have a slightly different error position
+sed -i -e "s|44 45|48 49|" tests/ls/stat-failed.sh
+
+# small difference in the error message
+# Use GNU sed for /c command
+"${SED}" -i -e "/ls: invalid argument 'XX' for 'time style'/,/Try 'ls --help' for more information\./c\
+ls: invalid --time-style argument 'XX'\nPossible values are: [\"full-iso\", \"long-iso\", \"iso\", \"locale\", \"+FORMAT (e.g., +%H:%M) for a 'date'-style format\"]\n\nFor more information try --help" tests/ls/time-style-diag.sh
+
+# disable two kind of tests:
+# "hostid BEFORE --help" doesn't fail for GNU. we fail. we are probably doing better
+# "hostid BEFORE --help AFTER " same for this
+sed -i -e "s/env \$prog \$BEFORE \$opt > out2/env \$prog \$BEFORE \$opt > out2 #/" -e "s/env \$prog \$BEFORE \$opt AFTER > out3/env \$prog \$BEFORE \$opt AFTER > out3 #/" -e "s/compare exp out2/compare exp out2 #/" -e "s/compare exp out3/compare exp out3 #/" tests/help/help-version-getopt.sh
+
+# Add debug info + we have less syscall then GNU's. Adjust our check.
+# Use GNU sed for /c command
+"${SED}" -i -e '/test \$n_stat1 = \$n_stat2 \\/c\
+echo "n_stat1 = \$n_stat1"\n\
+echo "n_stat2 = \$n_stat2"\n\
+test \$n_stat1 -ge \$n_stat2 \\' tests/ls/stat-free-color.sh
+
+# no need to replicate this output with hashsum
+sed -i -e "s|Try 'md5sum --help' for more information.\\\n||" tests/cksum/md5sum.pl
diff --git a/util/compare_gnu_result.py b/util/compare_gnu_result.py
index 704951863b587b25166a4d36c6d594076c0a85ec..0ea55210d11070e785eee5620e02a33ae9c5546c 100755
--- a/util/compare_gnu_result.py
+++ b/util/compare_gnu_result.py
@@ -1,4 +1,4 @@
-#! /usr/bin/python
+#!/usr/bin/env python3
"""
Compare the current results to the last results gathered from the main branch to highlight
diff --git a/util/deps.nu b/util/deps.nu
new file mode 100644
index 0000000000000000000000000000000000000000..368048fff4546b0a439dbcb1b5d08a6556ca4b87
--- /dev/null
+++ b/util/deps.nu
@@ -0,0 +1,130 @@
+# This is a script to analyze the dependencies of this project.
+# It is a replacement of / complement to
+#
+# - cargo tree (used by this script)
+# - cargo deps
+# - cargo deny
+#
+# The idea is that by calling all_dep_info, you get a table of all dependencies
+# in Cargo.lock, with a few additional columns based on some other tools.
+# Currently, these tools are
+#
+# - cargo tree
+# - the crates.io API
+#
+# The most useful columns in the table are:
+#
+# - `name`: the name of the crate.
+# - `version`: the version of the crate.
+# - `num_versions`: the number of versions in Cargo.lock.
+# - `normal_dep`: whether the crate is a normal dependency.
+# - `build_dep`: whether the crate is a build dependency.
+# - `dev_dep`: whether the crate is a dev dependency.
+# - `organization`: the GitHub/GitLab organization or user of the repository of the crate.
+# - `repository_name`: the name of the repository the crate is in. The format is "{owner}/{repo}".
+# - `dependencies`: direct dependencies of the crate (in the format of Cargo.lock).
+#
+# To use this script, start Nushell (tested only on version 0.82.0), import the library and
+# call `all_dep_info`:
+#
+# ```
+# > nu
+# > use util/deps.nu
+# > let dep = (deps all_dep_info)
+# ```
+#
+# Then you can perform analysis. For example, to group the dependencies by organization:
+#
+# ```
+# > $dep | group-by organization
+# ```
+#
+# Or to find all crates with multiple versions (like cargo deny):
+# ```
+# > $dep | where num_versions > 1
+# ```
+#
+# Ideas to expand this:
+#
+# - Figure out the whole dependency graph
+# - Figure out which platforms and which features enable which crates
+# - Figure out which utils require which crates
+# - Count the number of crates on different platforms
+# - Add license information
+# - Add functions to perform common analyses
+# - Add info from cargo bloat
+# - Add MSRV info
+# - Add up-to-date info (the necessary info is there, it just needs to be derived)
+# - Check the number of owners/contributors
+# - Make a webpage to more easily explore the data
+
+# Read the names output by cargo tree
+export def read_tree_names [edge_kind: string, features: list<string>]: any -> table<> {
+ cargo tree --edges $edge_kind --features ($features | str join ",")
+ | parse -r "(?P<name>[a-zA-Z0-9_-]+) v(?P<version>[0-9.]+)"
+}
+
+# Read the crates.io info for a list of crates names
+def read_crates_io [names: list<string>] -> any -> table<> {
+ let total = $names | length
+ $names | enumerate | par-each {|name|
+ print $"($name.index)/($total): ($name.item)"
+ http get $"https://crates.io/api/v1/crates/($name.item)" | get crate
+ }
+}
+
+# Add column for a dependency type
+def add_dep_type [dep_type: string, features: list<string>]: table<> -> table<> {
+ let input_table = $in
+ let table = read_tree_names $dep_type $features
+ $input_table | insert $"($dep_type)_dep" {|outer|
+ $table | any {|inner|
+ $inner.name == $outer.name and $inner.version == $outer.version
+ }
+ }
+}
+
+export def all_dep_info [] {
+ let features = [unix, feat_selinux]
+
+ let lock = open Cargo.lock | from toml | get package
+
+ $lock
+ # Add number of versions
+ | join ($lock | group-by name | transpose | update column1 { length } | rename name num_versions) name
+ # Add dependency types
+ | add_dep_type normal $features
+ | add_dep_type build $features
+ | add_dep_type dev $features
+ | insert used {|x| $x.normal_dep or $x.build_dep or $x.dev_dep}
+ # Add crates.io info
+ | join (read_crates_io ($lock.name | uniq)) name
+ # Add GH org or user info
+ # The organization is an indicator that crates should be treated as one dependency.
+ # However, there are also unrelated projects by a single organization, so it's not
+ # clear.
+ | insert organization {|x|
+ let repository = $x.repository?
+ if ($repository == null) { "" } else {
+ $repository | url parse | get path | path split | get 1
+ }
+ }
+ # Add repository (truncate everything after repo name)
+ # If we get a url like
+ # https://github.com/uutils/coreutils/tree/src/uu/ls
+ # we only keep
+ # uutils/coreutils
+ # The idea is that crates in the same repo definitely belong to the same project and should
+ # be treated as one dependency.
+ | insert repository_name {|x|
+ let repository = $x.repository?
+ if ($repository == null) { '' } else {
+ $repository
+ | url parse
+ | get path
+ | path split
+ | select 1 2
+ | path join
+ }
+ }
+}
diff --git a/util/gnu-json-result.py b/util/gnu-json-result.py
index 2f50a1963cb4bd179be5b085369fec3d20f9730f..c1adb3ffc8b5e6afd7b210515b9639d225856080 100644
--- a/util/gnu-json-result.py
+++ b/util/gnu-json-result.py
@@ -3,9 +3,9 @@ Extract the GNU logs into a JSON file.
"""
import json
-from pathlib import Path
+import re
import sys
-from os import environ
+from pathlib import Path
out = {}
@@ -18,9 +18,13 @@ for filepath in test_dir.glob("**/*.log"):
current[key] = {}
current = current[key]
try:
- with open(path) as f:
+ with open(path, errors="ignore") as f:
content = f.read()
- current[path.name] = content.split("\n")[-2].split(" ")[0]
+ result = re.search(
+ r"(PASS|FAIL|SKIP|ERROR) [^ ]+ \(exit status: \d+\)$", content
+ )
+ if result:
+ current[path.name] = result.group(1)
except:
pass
diff --git a/util/gnu-patches/tests_env_env-S.pl.patch b/util/gnu-patches/tests_env_env-S.pl.patch
new file mode 100644
index 0000000000000000000000000000000000000000..404a00ca60ec3f8fd303c86407b6d7760cf77e61
--- /dev/null
+++ b/util/gnu-patches/tests_env_env-S.pl.patch
@@ -0,0 +1,47 @@
+diff --git a/tests/env/env-S.pl b/tests/env/env-S.pl
+index 710ca82cf..af7cf6efa 100755
+--- a/tests/env/env-S.pl
++++ b/tests/env/env-S.pl
+@@ -209,27 +209,28 @@ my @Tests =
+ {ERR=>"$prog: no terminating quote in -S string\n"}],
+ ['err5', q[-S'A=B\\q'], {EXIT=>125},
+ {ERR=>"$prog: invalid sequence '\\q' in -S\n"}],
+- ['err6', q[-S'A=$B'], {EXIT=>125},
+- {ERR=>"$prog: only \${VARNAME} expansion is supported, error at: \$B\n"}],
++ ['err6', q[-S'A=$B echo hello'], {EXIT=>0},
++ {OUT=>"hello"}],
+ ['err7', q[-S'A=${B'], {EXIT=>125},
+- {ERR=>"$prog: only \${VARNAME} expansion is supported, " .
+- "error at: \${B\n"}],
++ {ERR=>"$prog" . qq[: variable name issue (at 5): Missing closing brace\n]}],
+ ['err8', q[-S'A=${B%B}'], {EXIT=>125},
+- {ERR=>"$prog: only \${VARNAME} expansion is supported, " .
+- "error at: \${B%B}\n"}],
++ {ERR=>"$prog" . qq[: variable name issue (at 5): Unexpected character: '%', expected a closing brace ('}') or colon (':')\n]}],
+ ['err9', q[-S'A=${9B}'], {EXIT=>125},
+- {ERR=>"$prog: only \${VARNAME} expansion is supported, " .
+- "error at: \${9B}\n"}],
++ {ERR=>"$prog" . qq[: variable name issue (at 4): Unexpected character: '9', expected variable name must not start with 0..9\n]}],
+
+ # Test incorrect shebang usage (extraneous whitespace).
+ ['err_sp2', q['-v -S cat -n'], {EXIT=>125},
+- {ERR=>"env: invalid option -- ' '\n" .
+- "env: use -[v]S to pass options in shebang lines\n" .
+- "Try 'env --help' for more information.\n"}],
++ {ERR=>"$prog: error: unexpected argument '- ' found\n\n" .
++ " tip: to pass '- ' as a value, use '-- - '\n\n" .
++ "Usage: $prog [OPTION]... [-] [NAME=VALUE]... [COMMAND [ARG]...]\n\n" .
++ "For more information, try '--help'.\n" .
++ "$prog: use -[v]S to pass options in shebang lines\n"}],
+ ['err_sp3', q['-v -S cat -n'], {EXIT=>125}, # embedded tab after -v
+- {ERR=>"env: invalid option -- '\t'\n" .
+- "env: use -[v]S to pass options in shebang lines\n" .
+- "Try 'env --help' for more information.\n"}],
++ {ERR=>"$prog: error: unexpected argument '-\t' found\n\n" .
++ " tip: to pass '-\t' as a value, use '-- -\t'\n\n" .
++ "Usage: $prog [OPTION]... [-] [NAME=VALUE]... [COMMAND [ARG]...]\n\n" .
++ "For more information, try '--help'.\n" .
++ "$prog: use -[v]S to pass options in shebang lines\n"}],
+
+ # Also diagnose incorrect shebang usage when failing to exec.
+ # This typically happens with:
diff --git a/util/gnu-patches/tests_factor_factor.pl.patch b/util/gnu-patches/tests_factor_factor.pl.patch
new file mode 100644
index 0000000000000000000000000000000000000000..fc8b988fea5276bc7bdd847c93803fa83893e518
--- /dev/null
+++ b/util/gnu-patches/tests_factor_factor.pl.patch
@@ -0,0 +1,21 @@
+diff --git a/tests/factor/factor.pl b/tests/factor/factor.pl
+index 6e612e418..f19c06ca0 100755
+--- a/tests/factor/factor.pl
++++ b/tests/factor/factor.pl
+@@ -61,12 +61,13 @@ my @Tests =
+ # Map newer glibc diagnostic to expected.
+ # Also map OpenBSD 5.1's "unknown option" to expected "invalid option".
+ {ERR_SUBST => q!s/'1'/1/;s/unknown/invalid/!},
+- {ERR => "$prog: invalid option -- 1\n"
+- . "Try '$prog --help' for more information.\n"},
++ {ERR => "error: unexpected argument '-1' found\n\n"
++ . " tip: to pass '-1' as a value, use '-- -1'\n\n"
++ . "Usage: factor [OPTION]... [NUMBER]...\n"},
+ {EXIT => 1}],
+ ['cont', 'a 4',
+ {OUT => "4: 2 2\n"},
+- {ERR => "$prog: 'a' is not a valid positive integer\n"},
++ {ERR => "$prog: warning: a: invalid digit found in string\n"},
+ {EXIT => 1}],
+ ['bug-2012-a', '465658903', {OUT => '15259 30517'}],
+ ['bug-2012-b', '2242724851', {OUT => '33487 66973'}],
diff --git a/util/publish.sh b/util/publish.sh
index 16fe2cbaa57b7e702520e149dcb16a347e432161..7207ba7fb91ca3a8547a060110c7d4432cc3d820 100755
--- a/util/publish.sh
+++ b/util/publish.sh
@@ -1,9 +1,26 @@
#!/bin/sh
+# spell-checker:ignore uuhelp
ARG=""
if test "$1" != "--do-it"; then
ARG="--dry-run --allow-dirty"
fi
+# Function to check if the crate is already published
+is_already_published() {
+ local crate_name=$1
+ local crate_version=$2
+
+ # Use the crates.io API to get the latest version of the crate
+ local latest_published_version
+ latest_published_version=$(curl -s https://crates.io/api/v1/crates/$crate_name | jq -r '.crate.max_version')
+
+ if [ "$latest_published_version" = "$crate_version" ]; then
+ return 0
+ else
+ return 1
+ fi
+}
+
# Figure out any dependencies between the util via Cargo.toml
# We store this as edges in a graph with each line:
# [dependent] [dependency]
@@ -34,20 +51,33 @@ TOTAL_ORDER=$(echo -e $PARTIAL_ORDER | tsort | tac)
# Remove the ROOT node from the start
TOTAL_ORDER=${TOTAL_ORDER#ROOT}
+CRATE_VERSION=$(grep '^version' Cargo.toml | head -n1 | cut -d '"' -f2)
+
set -e
-for dir in src/uucore_procs/ src/uucore src/uu/stdbuf/src/libstdbuf/; do
+for dir in src/uuhelp_parser/ src/uucore_procs/ src/uucore/ src/uu/stdbuf/src/libstdbuf/; do
(
cd "$dir"
+ CRATE_NAME=$(grep '^name =' "Cargo.toml" | head -n1 | cut -d '"' -f2)
#shellcheck disable=SC2086
- cargo publish $ARG || true
+ if ! is_already_published "$CRATE_NAME" "$CRATE_VERSION"; then
+ cargo publish $ARG
+ else
+ echo "Skip: $CRATE_NAME $CRATE_VERSION already published"
+ fi
)
+ sleep 2s
done
for p in $TOTAL_ORDER; do
(
cd "src/uu/$p"
+ CRATE_NAME=$(grep '^name =' "Cargo.toml" | head -n1 | cut -d '"' -f2)
#shellcheck disable=SC2086
- cargo publish $ARG || true
+ if ! is_already_published "$CRATE_NAME" "$CRATE_VERSION"; then
+ cargo publish $ARG
+ else
+ echo "Skip: $CRATE_NAME $CRATE_VERSION already published"
+ fi
)
done
diff --git a/util/remaining-gnu-error.py b/util/remaining-gnu-error.py
index c64ee974ef5049877d79968ae4e9d708d73f2754..20b3faee7fa0b7c23bbd38b7dbe87d410d675d02 100755
--- a/util/remaining-gnu-error.py
+++ b/util/remaining-gnu-error.py
@@ -8,17 +8,30 @@ import urllib
import os
import glob
import json
+import sys
base = "../gnu/tests/"
-urllib.request.urlretrieve(
- "https://raw.githubusercontent.com/uutils/coreutils-tracking/main/gnu-full-result.json",
- "result.json",
-)
+
+# Try to download the file, use local copy if download fails
+result_json = "result.json"
+try:
+ urllib.request.urlretrieve(
+ "https://raw.githubusercontent.com/uutils/coreutils-tracking/main/gnu-full-result.json",
+ result_json
+ )
+except Exception as e:
+ print(f"Failed to download the file: {e}")
+ if not os.path.exists(result_json):
+ print(f"Local file '{result_json}' not found. Exiting.")
+ sys.exit(1)
+ else:
+ print(f"Using local file '{result_json}'.")
types = ("/*/*.sh", "/*/*.pl", "/*/*.xpl")
tests = []
-error_or_skip_tests = []
+error_tests = []
+skip_tests = []
for files in types:
tests.extend(glob.glob(base + files))
@@ -31,11 +44,22 @@ def show_list(l):
tests = list(filter(lambda k: "factor" not in k, l))
for f in reversed(tests):
- print("%s: %s" % (f, os.stat(f).st_size))
+ if contains_require_root(f):
+ print("%s: %s / require_root" % (f, os.stat(f).st_size))
+ else:
+ print("%s: %s" % (f, os.stat(f).st_size))
print("")
print("%s tests remaining" % len(tests))
+def contains_require_root(file_path):
+ try:
+ with open(file_path, "r") as file:
+ return "require_root_" in file.read()
+ except IOError:
+ return False
+
+
with open("result.json", "r") as json_file:
data = json.load(json_file)
@@ -51,16 +75,29 @@ for d in data:
# the tests pass, we don't care anymore
if data[d][e] == "PASS":
- list_of_files.remove(a)
+ try:
+ list_of_files.remove(a)
+ except ValueError:
+ print("Could not find test '%s'. Maybe update the GNU repo?" % a)
+ sys.exit(1)
- # if it is SKIP or ERROR, show it
- if data[d][e] == "SKIP" or data[d][e] == "ERROR":
+ # if it is SKIP, show it
+ if data[d][e] == "SKIP":
list_of_files.remove(a)
- error_or_skip_tests.append(a)
+ skip_tests.append(a)
+ # if it is ERROR, show it
+ if data[d][e] == "ERROR":
+ list_of_files.remove(a)
+ error_tests.append(a)
-print("SKIP and ERROR tests:")
-show_list(error_or_skip_tests)
+print("===============")
+print("SKIP tests:")
+show_list(skip_tests)
+print("")
+print("===============")
+print("ERROR tests:")
+show_list(error_tests)
print("")
print("===============")
print("FAIL tests:")
diff --git a/util/run-gnu-test.sh b/util/run-gnu-test.sh
index f5c47e6450ac9d420082b3fe3b04875d4be6f53b..4148c3f96db5360b1d4728899acbd318377ce43e 100755
--- a/util/run-gnu-test.sh
+++ b/util/run-gnu-test.sh
@@ -1,15 +1,27 @@
-#!/bin/sh
+#!/usr/bin/env bash
# `run-gnu-test.bash [TEST]`
# run GNU test (or all tests if TEST is missing/null)
-#
-# UU_MAKE_PROFILE == 'debug' | 'release' ## build profile used for *uutils* build; may be supplied by caller, defaults to 'release'
-# spell-checker:ignore (env/vars) GNULIB SRCDIR SUBDIRS ; (utils) shellcheck
+# spell-checker:ignore (env/vars) GNULIB SRCDIR SUBDIRS OSTYPE ; (utils) shellcheck gnproc greadlink
# ref: [How the GNU coreutils are tested](https://www.pixelbeat.org/docs/coreutils-testing.html) @@ <https://archive.is/p2ITW>
# * note: to run a single test => `make check TESTS=PATH/TO/TEST/SCRIPT SUBDIRS=. VERBOSE=yes`
-ME_dir="$(dirname -- "$(readlink -fm -- "$0")")"
+# Use GNU version for make, nproc, readlink on *BSD
+case "$OSTYPE" in
+ *bsd*)
+ MAKE="gmake"
+ NPROC="gnproc"
+ READLINK="greadlink"
+ ;;
+ *)
+ MAKE="make"
+ NPROC="nproc"
+ READLINK="readlink"
+ ;;
+esac
+
+ME_dir="$(dirname -- "$("${READLINK}" -fm -- "$0")")"
REPO_main_dir="$(dirname -- "${ME_dir}")"
echo "ME_dir='${ME_dir}'"
@@ -20,7 +32,7 @@ set -e
### * config (from environment with fallback defaults); note: GNU and GNULIB are expected to be sibling repo directories
path_UUTILS=${path_UUTILS:-${REPO_main_dir}}
-path_GNU="$(readlink -fm -- "${path_GNU:-${path_UUTILS}/../gnu}")"
+path_GNU="$("${READLINK}" -fm -- "${path_GNU:-${path_UUTILS}/../gnu}")"
echo "path_UUTILS='${path_UUTILS}'"
echo "path_GNU='${path_GNU}'"
@@ -31,15 +43,27 @@ cd "${path_GNU}" && echo "[ pwd:'${PWD}' ]"
export RUST_BACKTRACE=1
-if test $# -ge 1; then
- # if set, run only the tests passed
- SPECIFIC_TESTS=""
- for t in "$@"; do
- SPECIFIC_TESTS="$SPECIFIC_TESTS $t"
- done
- # trim it
- SPECIFIC_TESTS=$(echo $SPECIFIC_TESTS| xargs)
- echo "Running specific tests: $SPECIFIC_TESTS"
+if test "$1" != "run-root"; then
+ if test $# -ge 1; then
+ # if set, run only the tests passed
+ SPECIFIC_TESTS=""
+ for t in "$@"; do
+
+ # Construct the full path
+ full_path="$path_GNU/$t"
+
+ # Check if the file exists with .sh, .pl extension or without any extension in the $path_GNU directory
+ if [ -f "$full_path" ] || [ -f "$full_path.sh" ] || [ -f "$full_path.pl" ]; then
+ SPECIFIC_TESTS="$SPECIFIC_TESTS $t"
+ else
+ echo "Error: Test file $full_path, $full_path.sh, or $full_path.pl does not exist!"
+ exit 1
+ fi
+ done
+ # trim it
+ SPECIFIC_TESTS=$(echo "$SPECIFIC_TESTS" | xargs)
+ echo "Running specific tests: $SPECIFIC_TESTS"
+ fi
fi
# * timeout used to kill occasionally errant/"stuck" processes (note: 'release' testing takes ~1 hour; 'debug' testing takes ~2.5 hours)
@@ -48,18 +72,18 @@ fi
#shellcheck disable=SC2086
if test "$1" != "run-root"; then
-# run the regular tests
+ # run the regular tests
if test $# -ge 1; then
- timeout -sKILL 4h make -j "$(nproc)" check TESTS="$SPECIFIC_TESTS" SUBDIRS=. RUN_EXPENSIVE_TESTS=yes RUN_VERY_EXPENSIVE_TESTS=yes VERBOSE=no gl_public_submodule_commit="" srcdir="${path_GNU}" || : # Kill after 4 hours in case something gets stuck in make
+ timeout -sKILL 4h "${MAKE}" -j "$("${NPROC}")" check TESTS="$SPECIFIC_TESTS" SUBDIRS=. RUN_EXPENSIVE_TESTS=yes RUN_VERY_EXPENSIVE_TESTS=yes VERBOSE=no gl_public_submodule_commit="" srcdir="${path_GNU}" || : # Kill after 4 hours in case something gets stuck in make
else
- timeout -sKILL 4h make -j "$(nproc)" check SUBDIRS=. RUN_EXPENSIVE_TESTS=yes RUN_VERY_EXPENSIVE_TESTS=yes VERBOSE=no gl_public_submodule_commit="" srcdir="${path_GNU}" || : # Kill after 4 hours in case something gets stuck in make
+ timeout -sKILL 4h "${MAKE}" -j "$("${NPROC}")" check SUBDIRS=. RUN_EXPENSIVE_TESTS=yes RUN_VERY_EXPENSIVE_TESTS=yes VERBOSE=no gl_public_submodule_commit="" srcdir="${path_GNU}" || : # Kill after 4 hours in case something gets stuck in make
fi
else
-# in case we would like to run tests requiring root
+ # in case we would like to run tests requiring root
if test -z "$1" -o "$1" == "run-root"; then
if test -n "$CI"; then
echo "Running check-root to run only root tests"
- sudo make -j "$(nproc)" check-root SUBDIRS=. RUN_EXPENSIVE_TESTS=yes RUN_VERY_EXPENSIVE_TESTS=yes VERBOSE=no gl_public_submodule_commit="" srcdir="${path_GNU}" TEST_SUITE_LOG="tests/test-suite-root.log" || :
+ sudo "${MAKE}" -j "$("${NPROC}")" check-root SUBDIRS=. RUN_EXPENSIVE_TESTS=yes RUN_VERY_EXPENSIVE_TESTS=yes VERBOSE=no gl_public_submodule_commit="" srcdir="${path_GNU}" TEST_SUITE_LOG="tests/test-suite-root.log" || :
fi
fi
-fi
\ No newline at end of file
+fi
diff --git a/util/show-code_coverage.sh b/util/show-code_coverage.sh
index 3f51462c904a6cf5e25418d4c97715ec04363f6a..8c6f5e20a6719e022df67624d69207ee30e9eee1 100755
--- a/util/show-code_coverage.sh
+++ b/util/show-code_coverage.sh
@@ -1,9 +1,19 @@
-#!/bin/sh
+#!/usr/bin/env bash
-# spell-checker:ignore (vars) OSID binfmt
+# spell-checker:ignore (vars) OSID OSTYPE binfmt greadlink
+
+# Use GNU coreutils for readlink on *BSD
+case "$OSTYPE" in
+ *bsd*)
+ READLINK="greadlink"
+ ;;
+ *)
+ READLINK="readlink"
+ ;;
+esac
ME="${0}"
-ME_dir="$(dirname -- "$(readlink -fm -- "${ME}")")"
+ME_dir="$(dirname -- "$("${READLINK}" -fm -- "${ME}")")"
REPO_main_dir="$(dirname -- "${ME_dir}")"
export COVERAGE_REPORT_DIR="${REPO_main_dir}/target/debug/coverage-nix"
diff --git a/util/show-utils.BAT b/util/show-utils.BAT
index 9fa5e2ffae46b5e2bb3cdab972cb6484556d83eb..f6d9007349c8f7a7720c456e5ef44f7934dbbf95 100644
--- a/util/show-utils.BAT
+++ b/util/show-utils.BAT
@@ -2,7 +2,7 @@
@echo off
@rem ::# spell-checker:ignore (CMD) ERRORLEVEL
-@rem ::# spell-checker:ignore (utils) cksum coreutils dircolors hashsum mkdir mktemp printenv printf readlink realpath relpath rmdir shuf tsort unexpand
+@rem ::# spell-checker:ignore (utils) cksum coreutils dircolors hashsum mkdir mktemp printenv printf readlink realpath rmdir shuf tsort unexpand
@rem ::# spell-checker:ignore (jq) deps startswith
set "ME=%~0"
@@ -12,7 +12,7 @@ set "ME_parent_dir=%~dp0.\.."
@rem refs: <https://forge.rust-lang.org/release/platform-support.html> , <https://docs.rs/platforms/0.2.1/platforms/platform/tier1/index.html>
@rem :: default ("Tier 1" cross-platform) utility list
-set "default_utils=base32 base64 basename cat cksum comm cp cut date dircolors dirname echo env expand expr factor false fmt fold hashsum head join link ln ls mkdir mktemp more mv nl od paste printenv printf ptx pwd readlink realpath relpath rm rmdir seq shred shuf sleep sort split sum tac tail tee test tr true truncate tsort unexpand uniq wc yes"
+set "default_utils=base32 base64 basename cat cksum comm cp cut date dircolors dirname echo env expand expr factor false fmt fold hashsum head join link ln ls mkdir mktemp more mv nl od paste printenv printf ptx pwd readlink realpath rm rmdir seq shred shuf sleep sort split sum tac tail tee test tr true truncate tsort unexpand uniq wc yes"
set "project_dir=%ME_parent_dir%"
cd "%project_dir%"
diff --git a/util/show-utils.sh b/util/show-utils.sh
index 0db72e1c4ed6df6032484512423a87cdc7ea1fd6..0a41698d930b54516dd015ba4e8d7714a5fab937 100755
--- a/util/show-utils.sh
+++ b/util/show-utils.sh
@@ -1,17 +1,28 @@
-#!/bin/sh
+#!/usr/bin/env bash
-# spell-checker:ignore (utils) cksum coreutils dircolors hashsum mkdir mktemp printenv printf readlink realpath relpath rmdir shuf tsort unexpand
+# spell-checker:ignore (shell) OSTYPE
+# spell-checker:ignore (utils) cksum coreutils dircolors hashsum mkdir mktemp printenv printf readlink realpath grealpath rmdir shuf tsort unexpand
# spell-checker:ignore (jq) deps startswith
+# Use GNU version for realpath on *BSD
+case "$OSTYPE" in
+ *bsd*)
+ REALPATH="grealpath"
+ ;;
+ *)
+ REALPATH="realpath"
+ ;;
+esac
+
ME="${0}"
ME_dir="$(dirname -- "${ME}")"
ME_parent_dir="$(dirname -- "${ME_dir}")"
-ME_parent_dir_abs="$(realpath -mP -- "${ME_parent_dir}")"
+ME_parent_dir_abs="$("${REALPATH}" -mP -- "${ME_parent_dir}" || "${REALPATH}" -- "${ME_parent_dir}")"
# refs: <https://forge.rust-lang.org/release/platform-support.html> , <https://docs.rs/platforms/0.2.1/platforms/platform/tier1/index.html>
# default ("Tier 1" cross-platform) utility list
-default_utils="base32 base64 basename cat cksum comm cp cut date dircolors dirname echo env expand expr factor false fmt fold hashsum head join link ln ls mkdir mktemp more mv nl od paste printenv printf ptx pwd readlink realpath relpath rm rmdir seq shred shuf sleep sort split sum tac tail tee test tr true truncate tsort unexpand uniq wc yes"
+default_utils="base32 base64 basename cat cksum comm cp cut date dircolors dirname echo env expand expr factor false fmt fold hashsum head join link ln ls mkdir mktemp more mv nl od paste printenv printf ptx pwd readlink realpath rm rmdir seq shred shuf sleep sort split sum tac tail tee test tr true truncate tsort unexpand uniq wc yes"
project_main_dir="${ME_parent_dir_abs}"
# printf 'project_main_dir="%s"\n' "${project_main_dir}"
@@ -22,6 +33,10 @@ cd "${project_main_dir}" &&
echo "WARN: missing \`jq\` (install with \`sudo apt install jq\`); falling back to default (only fully cross-platform) utility list" 1>&2
echo "$default_utils"
else
- cargo metadata "$*" --format-version 1 | jq -r "[.resolve.nodes[] | { id: .id, deps: [.deps[] | { name:.name, pkg:.pkg }] }] | .[] | select(.id|startswith(\"coreutils\")) | [.deps[] | select((.name|startswith(\"uu_\")) or (.pkg|startswith(\"uu_\")))] | [.[].pkg | match(\"^\\\w+\";\"g\")] | [.[].string | sub(\"^uu_\"; \"\")] | sort | join(\" \")"
- # cargo metadata "$*" --format-version 1 | jq -r "[.resolve.nodes[] | { id: .id, deps: [.deps[] | { name:.name, pkg:.pkg }] }] | .[] | select(.id|startswith(\"coreutils\")) | [.deps[] | select((.name|startswith(\"uu_\")) or (.pkg|startswith(\"uu_\")))] | [.[].pkg | match(\"^\\\w+\";\"g\")] | [.[].string] | sort | join(\" \")"
+ # Find 'coreutils' id with regex
+ # with cargo v1.76.0, id = "coreutils 0.0.26 (path+file://<coreutils local directory>)"
+ # with cargo >= v1.77.0
+ # - if local path != '<...>/coreutils' id = "path+file://<coreutils local directory>#coreutils@0.0.26"
+ # - if local path == '<...>/coreutils' id = "path+file://<parent directory>/coreutils#0.0.26"
+ cargo metadata "$@" --format-version 1 | jq -r '[.resolve.nodes[] | select(.id|match(".*coreutils[ |@|#]\\d+\\.\\d+\\.\\d+")) | .deps[] | select(.pkg|match("uu_")) | .name | sub("^uu_"; "")] | sort | join(" ")'
fi
diff --git a/util/size-experiment.py b/util/size-experiment.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b1ec0fce74b1cab72c78f1dba099a0b497eb92b
--- /dev/null
+++ b/util/size-experiment.py
@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+# spell-checker:ignore debuginfo
+import subprocess
+from itertools import product
+import shutil
+import os
+from collections import defaultdict
+from pprint import pprint
+
+# Set to false if you've only changed the analysis and do not want to recompile
+# the binaries.
+RECOMPILE = True
+
+STRIP_VALS = ["none", "debuginfo", "symbols"]
+PANIC_VALS = ["unwind", "abort"]
+OPT_LEVEL_VALS = [3, "s", "z"]
+LTO_VALS = ["off", "thin", "fat"]
+
+
+def config(name, val):
+ return ["--config", f"profile.release.{name}={val!r}"]
+
+
+sizes = {}
+
+for (strip, panic, opt, lto) in product(
+ STRIP_VALS, PANIC_VALS, OPT_LEVEL_VALS, LTO_VALS
+):
+ if RECOMPILE:
+ cmd = [
+ "cargo",
+ "build",
+ "--release",
+ "--features=unix",
+ *config("strip", strip),
+ *config("panic", panic),
+ *config("opt-level", opt),
+ *config("lto", lto),
+ ]
+ print("RUN:", " ".join(cmd))
+ res = subprocess.call(cmd)
+
+ shutil.copyfile(
+ "target/release/coreutils",
+ "-".join(["coreutils", strip, panic, str(opt), lto]),
+ )
+ print(res)
+
+ sizes[(strip, panic, opt, lto)] = os.path.getsize(
+ "-".join(["coreutils", strip, panic, str(opt), lto])
+ )
+
+changes_absolute = defaultdict(list)
+changes_percent = defaultdict(list)
+
+
+def with_val_at_idx(val, idx, other):
+ other = list(other)
+ other.insert(idx, val)
+ return tuple(other)
+
+
+def collect_diff(idx, name):
+ all_params = [STRIP_VALS, PANIC_VALS, OPT_LEVEL_VALS, LTO_VALS]
+ vals = all_params.pop(idx)
+ for other in product(*all_params):
+ baseline = sizes[with_val_at_idx(vals[0], idx, other)]
+ for val in vals[1:]:
+ changes = sizes[with_val_at_idx(val, idx, other)] - baseline
+ changes_absolute[f"{name}={val}"].append(changes)
+ changes_percent[f"{name}={val}"].append(changes / baseline * 100)
+
+
+collect_diff(0, "strip")
+collect_diff(1, "panic")
+collect_diff(2, "opt-level")
+collect_diff(3, "lto")
+
+
+def analyze(l):
+ return f"MIN: {float(min(l)):.3}, AVG: {float(sum(l)/len(l)):.3}, MAX: {float(max(l)):.3}"
+
+
+print("Absolute changes")
+pprint({k: analyze(v) for k, v in changes_absolute.items()})
+print()
+print("Percent changes")
+pprint({k: analyze(v) for k, v in changes_percent.items()})
+
+print()
+print(changes_percent["opt-level=s"])
+print(changes_percent["opt-level=z"])
diff --git a/util/update-version.sh b/util/update-version.sh
index 4b7b6d554e4b7e9e3ec47260572f538f6e4e76a5..faa48f9156461aaa6a52ed8addc5705d3e307459 100755
--- a/util/update-version.sh
+++ b/util/update-version.sh
@@ -1,4 +1,6 @@
#!/bin/sh
+# spell-checker:ignore uuhelp
+
# This is a stupid helper. I will mass replace all versions (including other crates)
# So, it should be triple-checked
@@ -7,12 +9,16 @@
# 2) run it: sh util/update-version.sh
# 3) Do a spot check with "git diff"
# 4) cargo test --release --features unix
-# 5) Run util/publish.sh in dry mode (it will fail as packages needs more recent version of uucore)
-# 6) Run util/publish.sh --do-it
-# 7) In some cases, you might have to fix dependencies and run import
+# 5) git commit -m "New release" (make sure it includes Cargo.lock)
+# 6) Run util/publish.sh in dry mode (it will fail as packages needs more recent version of uucore)
+# 7) Run util/publish.sh --do-it
+# 8) In some cases, you might have to fix dependencies and run import
+# 9) Tag the release - "git tag 0.0.X && git push --tags"
+# 10) Create the release on github https://github.com/uutils/coreutils/releases/new
+# 11) Make sure we have good release notes
-FROM="0.0.16"
-TO="0.0.17"
+FROM="0.0.26"
+TO="0.0.27"
PROGS=$(ls -1d src/uu/*/Cargo.toml src/uu/stdbuf/src/libstdbuf/Cargo.toml src/uucore/Cargo.toml Cargo.toml)
@@ -23,6 +29,9 @@ sed -i -e "s|version = \"$FROM\"|version = \"$TO\"|" $PROGS
# Update uucore_procs
sed -i -e "s|version = \"$FROM\"|version = \"$TO\"|" src/uucore_procs/Cargo.toml
+# Update uuhelp_parser
+sed -i -e "s|version = \"$FROM\"|version = \"$TO\"|" src/uuhelp_parser/Cargo.toml
+
# Update the stdbuf stuff
sed -i -e "s|libstdbuf = { version=\"$FROM\"|libstdbuf = { version=\"$TO\"|" src/uu/stdbuf/Cargo.toml
sed -i -e "s|= { optional=true, version=\"$FROM\", package=\"uu_|= { optional=true, version=\"$TO\", package=\"uu_|g" Cargo.toml
@@ -41,4 +50,3 @@ sed -i -e "s|uucore = { version=\">=$FROM\",|uucore = { version=\">=$TO\",|" $PR
# Update crates using uucore_procs
#shellcheck disable=SC2086
sed -i -e "s|uucore_procs = { version=\">=$FROM\",|uucore_procs = { version=\">=$TO\",|" $PROGS
-
diff --git a/util/why-skip.txt b/util/why-skip.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c790311c13d94d84f79024674d6f913d9eb156ed
--- /dev/null
+++ b/util/why-skip.txt
@@ -0,0 +1,98 @@
+# spell-checker:ignore epipe readdir restorecon SIGALRM capget bigtime rootfs enotsup
+
+= trapping SIGPIPE is not supported =
+tests/tail-2/pipe-f.sh
+tests/misc/seq-epipe.sh
+tests/misc/printf-surprise.sh
+tests/misc/env-signal-handler.sh
+
+= skipped test: breakpoint not hit =
+tests/tail-2/inotify-race2.sh
+tail-2/inotify-race.sh
+
+= internal test failure: maybe LD_PRELOAD doesn't work? =
+tests/rm/rm-readdir-fail.sh
+tests/rm/r-root.sh
+tests/df/skip-duplicates.sh
+tests/df/no-mtab-status.sh
+
+= LD_PRELOAD was ineffective? =
+tests/cp/nfs-removal-race.sh
+
+= failed to create hfs file system =
+tests/mv/hardlink-case.sh
+
+= temporarily disabled =
+tests/mkdir/writable-under-readonly.sh
+
+= this system lacks SMACK support =
+tests/mkdir/smack-root.sh
+tests/mkdir/smack-no-root.sh
+tests/id/smack.sh
+
+= this system lacks SELinux support =
+tests/mkdir/selinux.sh
+tests/mkdir/restorecon.sh
+tests/misc/selinux.sh
+tests/misc/chcon.sh
+tests/install/install-Z-selinux.sh
+tests/install/install-C-selinux.sh
+tests/id/no-context.sh
+tests/id/context.sh
+tests/cp/no-ctx.sh
+tests/cp/cp-a-selinux.sh
+
+= failed to set xattr of file =
+tests/misc/xattr.sh
+
+= timeout returned 142. SIGALRM not handled? =
+tests/misc/timeout-group.sh
+
+= FULL_PARTITION_TMPDIR not defined =
+tests/misc/tac-continue.sh
+
+= can't get window size =
+tests/misc/stty-row-col.sh
+
+= The Swedish locale with blank thousands separator is unavailable. =
+tests/misc/sort-h-thousands-sep.sh
+
+= this shell lacks ulimit support =
+tests/misc/csplit-heap.sh
+
+= multicall binary is disabled =
+tests/misc/coreutils.sh
+
+= your ls doesn't call capget =
+tests/ls/no-cap.sh
+
+
+= not running on GNU/Hurd =
+tests/id/gnu-zero-uids.sh
+
+= file system cannot represent big timestamps =
+tests/du/bigtime.sh
+
+= no rootfs in mtab =
+tests/df/skip-rootfs.sh
+
+= insufficient mount/ext2 support =
+tests/df/problematic-chars.sh
+tests/cp/cp-mv-enotsup-xattr.sh
+
+= 512 byte aligned O_DIRECT is not supported on this (file) system =
+tests/dd/direct.sh
+
+= skipped test: /usr/bin/touch -m -d '1998-01-15 23:00' didn't work =
+tests/misc/ls-time.sh
+
+= requires controlling input terminal =
+tests/misc/stty-pairs.sh
+tests/misc/stty.sh
+tests/misc/stty-invalid.sh
+
+= insufficient SEEK_DATA support =
+tests/cp/sparse-perf.sh
+tests/cp/sparse-extents.sh
+tests/cp/sparse-extents-2.sh
+tests/cp/sparse-2.sh