Bump MSRV to 1.66

Correctly handle discontinuous input i.e. stdin

.github/workflows/CICD.yml

@@ -1,8 +1,8 @@
 name: CICD
 
 env:
-  MIN_SUPPORTED_RUST_VERSION: "1.56.0"
   CICD_INTERMEDIATES_DIR: "_cicd-intermediates"
+  MSRV_FEATURES: ""
 
 on:
   workflow_dispatch:
@@ -14,84 +14,102 @@ on:
       - '*'
 
 jobs:
+  crate_metadata:
+    name: Extract crate metadata
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Extract crate information
+      id: crate_metadata
+      run: |
+        cargo metadata --no-deps --format-version 1 | jq -r '"name=" + .packages[0].name' | tee -a $GITHUB_OUTPUT
+        cargo metadata --no-deps --format-version 1 | jq -r '"version=" + .packages[0].version' | tee -a $GITHUB_OUTPUT
+        cargo metadata --no-deps --format-version 1 | jq -r '"maintainer=" + .packages[0].authors[0]' | tee -a $GITHUB_OUTPUT
+        cargo metadata --no-deps --format-version 1 | jq -r '"homepage=" + .packages[0].homepage' | tee -a $GITHUB_OUTPUT
+        cargo metadata --no-deps --format-version 1 | jq -r '"msrv=" + .packages[0].rust_version' | tee -a $GITHUB_OUTPUT
+    outputs:
+      name: ${{ steps.crate_metadata.outputs.name }}
+      version: ${{ steps.crate_metadata.outputs.version }}
+      maintainer: ${{ steps.crate_metadata.outputs.maintainer }}
+      homepage: ${{ steps.crate_metadata.outputs.homepage }}
+      msrv: ${{ steps.crate_metadata.outputs.msrv }}
+
+  ensure_cargo_fmt:
+    name: Ensure 'cargo fmt' has been run
+    runs-on: ubuntu-20.04
+    steps:
+    - uses: dtolnay/rust-toolchain@stable
+      with:
+        components: rustfmt
+    - uses: actions/checkout@v3
+    - run: cargo fmt -- --check
+
   min_version:
     name: Minimum supported rust version
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
+    needs: crate_metadata
     steps:
     - name: Checkout source code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
 
-    - name: Install rust toolchain (v${{ env.MIN_SUPPORTED_RUST_VERSION }})
+    - name: Install rust toolchain (v${{ needs.crate_metadata.outputs.msrv }})
-      uses: actions-rs/toolchain@v1
+      uses: dtolnay/rust-toolchain@master
       with:
-        toolchain: ${{ env.MIN_SUPPORTED_RUST_VERSION }}
+        toolchain: ${{ needs.crate_metadata.outputs.msrv }}
-        default: true
+        components: clippy
-        profile: minimal # minimal component installation (ie, no documentation)
-        components: clippy, rustfmt
-
-    - name: Ensure `cargo fmt` has been run
-      uses: actions-rs/cargo@v1
-      with:
-        command: fmt
-        args: -- --check
-
     - name: Run clippy (on minimum supported rust version to prevent warnings we can't fix)
-      uses: actions-rs/cargo@v1
+      run: cargo clippy --locked --all-targets ${{ env.MSRV_FEATURES }}
-      with:
-        command: clippy
-        args: --locked --all-targets
-
     - name: Run tests
-      uses: actions-rs/cargo@v1
+      run: cargo test --locked ${{ env.MSRV_FEATURES }}
-      with:
-        command: test
-        args: --locked
 
   build:
-    name: ${{ matrix.job.os }} (${{ matrix.job.target }})
+    name: ${{ matrix.job.target }} (${{ matrix.job.os }})
     runs-on: ${{ matrix.job.os }}
+    needs: crate_metadata
     strategy:
       fail-fast: false
       matrix:
         job:
-          - { os: ubuntu-18.04, target: arm-unknown-linux-gnueabihf , use-cross: true }
+          - { target: aarch64-unknown-linux-gnu   , os: ubuntu-20.04, use-cross: true }
-          - { os: ubuntu-18.04, target: aarch64-unknown-linux-gnu   , use-cross: true }
+          - { target: arm-unknown-linux-gnueabihf , os: ubuntu-20.04, use-cross: true }
-          - { os: ubuntu-18.04, target: i686-unknown-linux-gnu      , use-cross: true }
+          - { target: arm-unknown-linux-musleabihf, os: ubuntu-20.04, use-cross: true }
-          - { os: ubuntu-18.04, target: i686-unknown-linux-musl     , use-cross: true }
+          - { target: i686-pc-windows-msvc        , os: windows-2019                  }
-          - { os: ubuntu-18.04, target: x86_64-unknown-linux-gnu    }
+          - { target: i686-unknown-linux-gnu      , os: ubuntu-20.04, use-cross: true }
-          - { os: ubuntu-18.04, target: x86_64-unknown-linux-musl   , use-cross: true }
+          - { target: i686-unknown-linux-musl     , os: ubuntu-20.04, use-cross: true }
-          - { os: macos-10.15 , target: x86_64-apple-darwin         }
+          - { target: x86_64-apple-darwin         , os: macos-12                      }
-          # - { os: windows-2019, target: i686-pc-windows-gnu         }  ## disabled; error: linker `i686-w64-mingw32-gcc` not found
+          - { target: x86_64-pc-windows-gnu       , os: windows-2019                  }
-          - { os: windows-2019, target: i686-pc-windows-msvc        }
+          - { target: x86_64-pc-windows-msvc      , os: windows-2019                  }
-          - { os: windows-2019, target: x86_64-pc-windows-gnu       }
+          - { target: x86_64-unknown-linux-gnu    , os: ubuntu-20.04, use-cross: true }
-          - { os: windows-2019, target: x86_64-pc-windows-msvc      }
+          - { target: x86_64-unknown-linux-musl   , os: ubuntu-20.04, use-cross: true }
+    env:
+      BUILD_CMD: cargo
     steps:
     - name: Checkout source code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
 
     - name: Install prerequisites
       shell: bash
       run: |
         case ${{ matrix.job.target }} in
-          arm-unknown-linux-gnueabihf) sudo apt-get -y update ; sudo apt-get -y install gcc-arm-linux-gnueabihf ;;
+          arm-unknown-linux-*) 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 ;;
         esac
 
-    - name: Extract crate information
-      shell: bash
-      run: |
-        echo "PROJECT_NAME=$(sed -n 's/^name = "\(.*\)"/\1/p' Cargo.toml | head -n1)" >> $GITHUB_ENV
-        echo "PROJECT_VERSION=$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -n1)" >> $GITHUB_ENV
-        echo "PROJECT_MAINTAINER=$(sed -n 's/^authors = \["\(.*\)"\]/\1/p' Cargo.toml)" >> $GITHUB_ENV
-        echo "PROJECT_HOMEPAGE=$(sed -n 's/^homepage = "\(.*\)"/\1/p' Cargo.toml)" >> $GITHUB_ENV
-
     - name: Install Rust toolchain
-      uses: actions-rs/toolchain@v1
+      uses: dtolnay/rust-toolchain@stable
       with:
-        toolchain: stable
+        targets: ${{ matrix.job.target }}
-        target: ${{ matrix.job.target }}
+
-        override: true
+    - name: Install cross
-        profile: minimal # minimal component installation (ie, no documentation)
+      if: matrix.job.use-cross
+      uses: taiki-e/install-action@v2
+      with:
+        tool: cross
+
+    - name: Overwrite build command env variable
+      if: matrix.job.use-cross
+      shell: bash
+      run: echo "BUILD_CMD=cross" >> $GITHUB_ENV
 
     - name: Show version information (Rust, cargo, GCC)
       shell: bash
@@ -104,21 +122,16 @@ jobs:
         rustc -V
 
     - name: Build
-      uses: actions-rs/cargo@v1
+      shell: bash
-      with:
+      run: $BUILD_CMD build --locked --release --target=${{ matrix.job.target }}
-        use-cross: ${{ matrix.job.use-cross }}
-        command: build
-        args: --release --target=${{ matrix.job.target }}
 
     - name: Run example
-      uses: actions-rs/cargo@v1
+      if: ${{ !matrix.job.use-cross }}
-      with:
+      shell: bash
-        use-cross: ${{ matrix.job.use-cross }}
+      run: $BUILD_CMD run --release --target=${{ matrix.job.target }} --example=simple
-        command: run
-        args: --release --target=${{ matrix.job.target }} --example=simple
 
-    - name: Strip debug information from executable
+    - name: Set binary name & path
-      id: strip
+      id: bin
       shell: bash
       run: |
         # Figure out suffix of binary
@@ -127,31 +140,13 @@ jobs:
           *-pc-windows-*) EXE_suffix=".exe" ;;
         esac;
 
-        # Figure out what strip tool to use if any
-        STRIP="strip"
-        case ${{ matrix.job.target }} in
-          arm-unknown-linux-gnueabihf) STRIP="arm-linux-gnueabihf-strip" ;;
-          aarch64-unknown-linux-gnu) STRIP="aarch64-linux-gnu-strip" ;;
-          *-pc-windows-msvc) STRIP="" ;;
-        esac;
-
         # Setup paths
-        BIN_DIR="${{ env.CICD_INTERMEDIATES_DIR }}/stripped-release-bin/"
+        BIN_NAME="${{ needs.crate_metadata.outputs.name }}${EXE_suffix}"
-        mkdir -p "${BIN_DIR}"
+        BIN_PATH="target/${{ matrix.job.target }}/release/${BIN_NAME}"
-        BIN_NAME="${{ env.PROJECT_NAME }}${EXE_suffix}"
-        BIN_PATH="${BIN_DIR}/${BIN_NAME}"
 
-        # Copy the release build binary to the result location
+        # Let subsequent steps know where to find the binary
-        cp "target/${{ matrix.job.target }}/release/${BIN_NAME}" "${BIN_DIR}"
+        echo "BIN_PATH=${BIN_PATH}" >> $GITHUB_OUTPUT
-
+        echo "BIN_NAME=${BIN_NAME}" >> $GITHUB_OUTPUT
-        # Also strip if possible
-        if [ -n "${STRIP}" ]; then
-          "${STRIP}" "${BIN_PATH}"
-        fi
-
-        # Let subsequent steps know where to find the (stripped) bin
-        echo ::set-output name=BIN_PATH::${BIN_PATH}
-        echo ::set-output name=BIN_NAME::${BIN_NAME}
 
     - name: Set testing options
       id: test-options
@@ -159,44 +154,41 @@ jobs:
       run: |
         # test only library unit tests and binary for arm-type targets
         unset CARGO_TEST_OPTIONS
-        unset CARGO_TEST_OPTIONS ; case ${{ matrix.job.target }} in arm-* | aarch64-*) CARGO_TEST_OPTIONS="--lib --bin ${PROJECT_NAME}" ;; esac;
+        unset CARGO_TEST_OPTIONS ; case ${{ matrix.job.target }} in arm-* | aarch64-*) CARGO_TEST_OPTIONS="--lib --bin ${{ needs.crate_metadata.outputs.name }}" ;; esac;
-        echo ::set-output name=CARGO_TEST_OPTIONS::${CARGO_TEST_OPTIONS}
+        echo "CARGO_TEST_OPTIONS=${CARGO_TEST_OPTIONS}" >> $GITHUB_OUTPUT
 
     - name: Run tests
-      uses: actions-rs/cargo@v1
+      shell: bash
-      with:
+      run: $BUILD_CMD test --locked --target=${{ matrix.job.target }} ${{ steps.test-options.outputs.CARGO_TEST_OPTIONS}}
-        use-cross: ${{ matrix.job.use-cross }}
-        command: test
-        args: --target=${{ matrix.job.target }} ${{ steps.test-options.outputs.CARGO_TEST_OPTIONS}}
 
     - name: Setup Pandoc
       uses: r-lib/actions/setup-pandoc@v2
 
     - name: Generate man page
-      run: pandoc -s -f markdown -t man -o "doc/${{ env.PROJECT_NAME }}.1" "doc/${{ env.PROJECT_NAME }}.1.md"
+      run: pandoc -s -f markdown -t man -o "doc/${{ needs.crate_metadata.outputs.name }}.1" "doc/${{ needs.crate_metadata.outputs.name }}.1.md"
 
     - name: Create tarball
       id: package
       shell: bash
       run: |
         PKG_suffix=".tar.gz" ; case ${{ matrix.job.target }} in *-pc-windows-*) PKG_suffix=".zip" ;; esac;
-        PKG_BASENAME=${PROJECT_NAME}-v${PROJECT_VERSION}-${{ matrix.job.target }}
+        PKG_BASENAME=${{ needs.crate_metadata.outputs.name }}-v${{ needs.crate_metadata.outputs.version }}-${{ matrix.job.target }}
         PKG_NAME=${PKG_BASENAME}${PKG_suffix}
-        echo ::set-output name=PKG_NAME::${PKG_NAME}
+        echo "PKG_NAME=${PKG_NAME}" >> $GITHUB_OUTPUT
 
         PKG_STAGING="${{ env.CICD_INTERMEDIATES_DIR }}/package"
         ARCHIVE_DIR="${PKG_STAGING}/${PKG_BASENAME}/"
         mkdir -p "${ARCHIVE_DIR}"
 
         # Binary
-        cp "${{ steps.strip.outputs.BIN_PATH }}" "$ARCHIVE_DIR"
+        cp "${{ steps.bin.outputs.BIN_PATH }}" "$ARCHIVE_DIR"
-
-        # Man page
-        cp "doc/${{ env.PROJECT_NAME }}.1" "$ARCHIVE_DIR"
 
         # README, LICENSE and CHANGELOG files
         cp "README.md" "LICENSE-MIT" "LICENSE-APACHE" "CHANGELOG.md" "$ARCHIVE_DIR"
 
+        # Man page
+        cp "doc/${{ needs.crate_metadata.outputs.name }}.1" "$ARCHIVE_DIR"
+
         # base compressed package
         pushd "${PKG_STAGING}/" >/dev/null
         case ${{ matrix.job.target }} in
@@ -206,7 +198,7 @@ jobs:
         popd >/dev/null
 
         # Let subsequent steps know where to find the compressed package
-        echo ::set-output name=PKG_PATH::"${PKG_STAGING}/${PKG_NAME}"
+        echo "PKG_PATH=${PKG_STAGING}/${PKG_NAME}" >> $GITHUB_OUTPUT
 
     - name: Create Debian package
       id: debian-package
@@ -218,10 +210,10 @@ jobs:
         DPKG_DIR="${DPKG_STAGING}/dpkg"
         mkdir -p "${DPKG_DIR}"
 
-        DPKG_BASENAME=${PROJECT_NAME}
+        DPKG_BASENAME=${{ needs.crate_metadata.outputs.name }}
-        DPKG_CONFLICTS=${PROJECT_NAME}-musl
+        DPKG_CONFLICTS=${{ needs.crate_metadata.outputs.name }}-musl
-        case ${{ matrix.job.target }} in *-musl) DPKG_BASENAME=${PROJECT_NAME}-musl ; DPKG_CONFLICTS=${PROJECT_NAME} ;; esac;
+        case ${{ matrix.job.target }} in *-musl) DPKG_BASENAME=${{ needs.crate_metadata.outputs.name }}-musl ; DPKG_CONFLICTS=${{ needs.crate_metadata.outputs.name }} ;; esac;
-        DPKG_VERSION=${PROJECT_VERSION}
+        DPKG_VERSION=${{ needs.crate_metadata.outputs.version }}
 
         unset DPKG_ARCH
         case ${{ matrix.job.target }} in
@@ -233,14 +225,14 @@ jobs:
         esac;
 
         DPKG_NAME="${DPKG_BASENAME}_${DPKG_VERSION}_${DPKG_ARCH}.deb"
-        echo ::set-output name=DPKG_NAME::${DPKG_NAME}
+        echo "DPKG_NAME=${DPKG_NAME}" >> $GITHUB_OUTPUT
 
         # Binary
-        install -Dm755 "${{ steps.strip.outputs.BIN_PATH }}" "${DPKG_DIR}/usr/bin/${{ steps.strip.outputs.BIN_NAME }}"
+        install -Dm755 "${{ steps.bin.outputs.BIN_PATH }}" "${DPKG_DIR}/usr/bin/${{ steps.bin.outputs.BIN_NAME }}"
 
         # Man page
-        install -Dm644 "doc/${{ env.PROJECT_NAME }}.1" "${DPKG_DIR}/usr/share/man/man1/${{ env.PROJECT_NAME }}.1"
+        install -Dm644 'doc/${{ needs.crate_metadata.outputs.name }}.1' "${DPKG_DIR}/usr/share/man/man1/${{ needs.crate_metadata.outputs.name }}.1"
-        gzip -n --best "${DPKG_DIR}/usr/share/man/man1/${{ env.PROJECT_NAME }}.1"
+        gzip -n --best "${DPKG_DIR}/usr/share/man/man1/${{ needs.crate_metadata.outputs.name }}.1"
 
         # README and LICENSE
         install -Dm644 "README.md" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/README.md"
@@ -251,12 +243,12 @@ jobs:
 
         cat > "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/copyright" <<EOF
         Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
-        Upstream-Name: ${{ env.PROJECT_NAME }}
+        Upstream-Name: ${{ needs.crate_metadata.outputs.name }}
-        Source: ${{ env.PROJECT_HOMEPAGE }}
+        Source: ${{ needs.crate_metadata.outputs.homepage }}
 
         Files: *
-        Copyright: ${{ env.PROJECT_MAINTAINER }}
+        Copyright: ${{ needs.crate_metadata.outputs.maintainer }}
-        Copyright: $COPYRIGHT_YEARS ${{ env.PROJECT_MAINTAINER }}
+        Copyright: $COPYRIGHT_YEARS ${{ needs.crate_metadata.outputs.maintainer }}
         License: Apache-2.0 or MIT
 
         License: Apache-2.0
@@ -297,16 +289,16 @@ jobs:
         Version: ${DPKG_VERSION}
         Section: utils
         Priority: optional
-        Maintainer: ${{ env.PROJECT_MAINTAINER }}
+        Maintainer: ${{ needs.crate_metadata.outputs.maintainer }}
-        Homepage: ${{ env.PROJECT_HOMEPAGE }}
+        Homepage: ${{ needs.crate_metadata.outputs.homepage }}
         Architecture: ${DPKG_ARCH}
-        Provides: ${{ env.PROJECT_NAME }}
+        Provides: ${{ needs.crate_metadata.outputs.name }}
         Conflicts: ${DPKG_CONFLICTS}
-        Description: colorized hex viewer for the terminal.
+        Description: A command-line benchmarking tool
         EOF
 
         DPKG_PATH="${DPKG_STAGING}/${DPKG_NAME}"
-        echo ::set-output name=DPKG_PATH::${DPKG_PATH}
+        echo "DPKG_PATH=${DPKG_PATH}" >> $GITHUB_OUTPUT
 
         # build dpkg
         fakeroot dpkg-deb --build "${DPKG_DIR}" "${DPKG_PATH}"
@@ -329,7 +321,7 @@ jobs:
       shell: bash
       run: |
         unset IS_RELEASE ; if [[ $GITHUB_REF =~ ^refs/tags/v[0-9].* ]]; then IS_RELEASE='true' ; fi
-        echo ::set-output name=IS_RELEASE::${IS_RELEASE}
+        echo "IS_RELEASE=${IS_RELEASE}" >> $GITHUB_OUTPUT
 
     - name: Publish archives and packages
       uses: softprops/action-gh-release@v1

CHANGELOG.md

@@ -1,19 +1,68 @@
-# unreleased
+# v0.13.1
-
-## Changes
-
-
-## Features
-
 
 ## Bugfixes
 
+- Correctly handle discontinuous input (stdin), see #196 and #197 (@sharifhsn)
+
+# v0.13.0
+
+## Features
+
+- Support both little and big Endian dumps using `--endianness={little,big}`, see #189 and #104 (@RinHizakura)
+
+## Changes
+
+- **Breaking**: Changed the meaning of the short flag `-C` to be consistent with `hexdump -C`. Previously, this would *hide* the character panel, but now `-C` *shows* the character panel, in case it has been previously (e.g. in an `alias`) disabled with `--no-characters`, see #187 (@sharkdp)
+
+## `hexyl` as a library
+
+- New `endianness` method for `PrinterBuilder`
+
+
+# v0.12.0
+
+## Features
+
+- Only show one panel by default if the terminal width is not wide enough for two panels, see #182 (@sharkdp)
+- Respect the `NO_COLOR` environment variable, see #179 (@sharifhsn)
+
+## Bugfixes
+
+- Do not fail with an error if `--panels=auto` is used and the output is piped, see #184 (@sharkdp)
+
+## Changes
+
+- Breaking: For `xxd`-compatibility reasons, `--group_bytes` has been renamed to `--group-size` (with an `--groupsize` alias), see #121 (@sharkdp)
+
+## `hexyl` as a library
+
+- Breaking: `num_group_bytes` has been renamed to `group_size`.
+
+
+# v0.11.0
+
+## Features
+
+- Significantly improved performance, see #173 and #176 (@sharifhsn)
+- Added variable panels through the `--panels` and `--terminal-width` flags, see [#13](https://github.com/sharkdp/hexyl/issues/13) and [#164](https://github.com/sharkdp/hexyl/pull/164) (@sharifhsn)
+- Added new `--group-bytes`/`-g` option, see #104 and #170 (@RinHizakura)
+- Added new `--base B` option (where `B` can be `binary`, `octal`, `decimal` or `hexadecimal`), see #147 and #178 (@sharifhsn)
+- Show actual zero bytes as `⋄` in the character panel (previously: `0`), in order not to confuse them with ASCII
+  `0` bytes if colors are deactivated. Closes #166 (@sharkdp)
+
+## `hexyl` as a library
+
+- Breaking change: `Printer::new` is deprecated as a part of the public API. Alternatively, you can now construct a `Printer` using the `PrinterBuilder` builder API, see [#168](https://github.com/sharkdp/hexyl/pull/168). (@sharifhsn)
 
 ## Other
 
+- More tests for the squeezing feature, see #177 (@mkatychev)
 
-## Packaging
+## Thank you
 
+Special thanks go to @sharifhsn, not just for the new features,
+bugfixes and performance improvements. But also for many internal
+improvements of the code base and other maintenance tasks.
 
 
 # v0.10.0

Cargo.lock

@@ -4,53 +4,83 @@ version = 3
 
 [[package]]
 name = "aho-corasick"
-version = "0.7.18"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
+checksum = "43f6cb1bf222025340178f382c426f13757b2960e89779dfcb319c32542a5a41"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
-name = "ansi_term"
+name = "anstream"
-version = "0.12.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
+checksum = "0ca84f3628370c59db74ee214b3263d58f9aadd9b4fe7e711fd87dc452b7f163"
 dependencies = [
- "winapi",
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is-terminal",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a30da5c5f2d5e72842e00bcb57657162cdabef0931f40e2deb9b4140440cecd"
+
+[[package]]
+name = "anstyle-parse"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "938874ff5980b03a87c5524b3ae5b59cf99b1d6bc836848df7bc5ada9643c333"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ca11d4be1bab0c8bc8734a9aa7bf4ee8316d462a08c6ac5052f888fef5b494b"
+dependencies = [
+ "windows-sys",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "180abfa45703aebe0093f79badacc01b8fd4ea2e35118747e5811127f926e188"
+dependencies = [
+ "anstyle",
+ "windows-sys",
 ]
 
 [[package]]
 name = "anyhow"
-version = "1.0.57"
+version = "1.0.72"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08f9b8508dccb7687a1d6c4ce66b2b0ecef467c94667de27d8d7fe1f8d2a9cdc"
+checksum = "3b13c32d80ecc7ab747b80c3784bce54ee8a7a0cc4fbda9bf4cda2cf6fe90854"
 
 [[package]]
 name = "assert_cmd"
-version = "2.0.4"
+version = "2.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93ae1ddd39efd67689deb1979d80bad3bf7f2b09c6e6117c8d1f2443b5e2f83e"
+checksum = "88903cb14723e4d4003335bb7f8a14f27691649105346a0f0957466c096adfe6"
 dependencies = [
+ "anstyle",
  "bstr",
  "doc-comment",
- "predicates",
+ "predicates 3.0.3",
  "predicates-core",
  "predicates-tree",
  "wait-timeout",
 ]
 
-[[package]]
-name = "atty"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
-dependencies = [
- "hermit-abi",
- "libc",
- "winapi",
-]
-
 [[package]]
 name = "autocfg"
 version = "1.1.0"
@@ -64,62 +94,89 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
-name = "bstr"
+name = "bitflags"
-version = "0.2.17"
+version = "2.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223"
+checksum = "630be753d4e58660abd17930c71b647fe46c27ea6b63cc59e1e3851406972e42"
+
+[[package]]
+name = "bstr"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6798148dccfbff0fae41c7574d2fa8f1ef3492fba0face179de5d8d447d67b05"
 dependencies = [
- "lazy_static",
  "memchr",
  "regex-automata",
+ "serde",
 ]
 
 [[package]]
-name = "clap"
+name = "cc"
-version = "3.1.18"
+version = "1.0.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2dbdf4bdacb33466e854ce889eee8dfd5729abf7ccd7664d0a2d60cd384440b"
+checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
+
+[[package]]
+name = "clap"
+version = "4.3.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fd304a20bff958a57f04c4e96a2e7594cc4490a0e809cbd48bb6437edaa452d"
 dependencies = [
- "atty",
+ "clap_builder",
- "bitflags",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.3.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01c6a3f08f1fe5662a35cfe393aec09c4df95f60ee93b7556505260f75eee9e1"
+dependencies = [
+ "anstream",
+ "anstyle",
  "clap_lex",
- "indexmap",
+ "once_cell",
- "lazy_static",
  "strsim",
- "termcolor",
  "terminal_size",
- "textwrap",
 ]
 
 [[package]]
 name = "clap_lex"
-version = "0.2.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a37c35f1112dad5e6e0b1adaff798507497a18fceeb30cceb3bae7d1427b9213"
+checksum = "2da6da31387c7e4ef160ffab6d5e7f00c42626fe39aea70a7b0f1773f7dd6c1b"
-dependencies = [
+
- "os_str_bytes",
+[[package]]
-]
+name = "colorchoice"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
 
 [[package]]
 name = "const_format"
-version = "0.2.23"
+version = "0.2.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0936ffe6d0c8d6a51b3b0a73b2acbe925d786f346cf45bfddc8341d79fb7dc8a"
+checksum = "c990efc7a285731f9a4378d81aff2f0e85a2c8781a05ef0f8baa8dac54d0ff48"
 dependencies = [
  "const_format_proc_macros",
 ]
 
 [[package]]
 name = "const_format_proc_macros"
-version = "0.2.22"
+version = "0.2.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef196d5d972878a48da7decb7686eded338b4858fbabeed513d63a7c98b2b82d"
+checksum = "e026b6ce194a874cb9cf32cd5772d1ef9767cc8fcb5765948d74f37a9d8b2bf6"
 dependencies = [
  "proc-macro2",
  "quote",
  "unicode-xid",
 ]
 
+[[package]]
+name = "diff"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
+
 [[package]]
 name = "difflib"
 version = "0.4.0"
@@ -134,9 +191,30 @@ checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
 
 [[package]]
 name = "either"
-version = "1.6.1"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
+checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"
+
+[[package]]
+name = "errno"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bcfec3a70f97c962c307b2d2c56e358cf1d00b558d74262b5f929ee8cc7e73a"
+dependencies = [
+ "errno-dragonfly",
+ "libc",
+ "windows-sys",
+]
+
+[[package]]
+name = "errno-dragonfly"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
+dependencies = [
+ "cc",
+ "libc",
+]
 
 [[package]]
 name = "float-cmp"
@@ -147,66 +225,83 @@ dependencies = [
  "num-traits",
 ]
 
-[[package]]
-name = "hashbrown"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
-
 [[package]]
 name = "hermit-abi"
-version = "0.1.19"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+checksum = "443144c8cdadd93ebf52ddb4056d257f5b52c04d3c804e657d19eb73fc33668b"
-dependencies = [
- "libc",
-]
 
 [[package]]
 name = "hexyl"
-version = "0.10.0"
+version = "0.13.1"
 dependencies = [
- "ansi_term",
  "anyhow",
  "assert_cmd",
- "atty",
  "clap",
  "const_format",
  "libc",
- "predicates",
+ "owo-colors",
+ "predicates 2.1.5",
+ "pretty_assertions",
+ "supports-color",
+ "terminal_size",
  "thiserror",
 ]
 
 [[package]]
-name = "indexmap"
+name = "io-lifetimes"
-version = "1.8.1"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f647032dfaa1f8b6dc29bd3edb7bbef4861b8b8007ebb118d6db284fd59f6ee"
+checksum = "eae7b9aee968036d54dce06cebaefd919e4472e753296daccd6d344e3e2df0c2"
 dependencies = [
- "autocfg",
+ "hermit-abi",
- "hashbrown",
+ "libc",
+ "windows-sys",
 ]
 
 [[package]]
-name = "itertools"
+name = "is-terminal"
-version = "0.10.3"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9a9d19fa1e79b6215ff29b9d6880b706147f16e9b1dbb1e4e5947b5b02bc5e3"
+checksum = "cb0889898416213fab133e1d33a0e5858a48177452750691bde3666d0fdbaf8b"
+dependencies = [
+ "hermit-abi",
+ "rustix 0.38.4",
+ "windows-sys",
+]
+
+[[package]]
+name = "is_ci"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "616cde7c720bb2bb5824a224687d8f77bfd38922027f01d825cd7453be5099fb"
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
 dependencies = [
  "either",
 ]
 
 [[package]]
-name = "lazy_static"
+name = "libc"
-version = "1.4.0"
+version = "0.2.147"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3"
 
 [[package]]
-name = "libc"
+name = "linux-raw-sys"
-version = "0.2.126"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836"
+checksum = "ef53942eb7bf7ff43a617b3e2c1c4a5ecf5944a7c1bc12d7ee39bbb15e5c1519"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09fc20d2ca12cb9f044c93e3bd6d32d523e6e2ec3db4f7b2939cd99026ecd3f0"
 
 [[package]]
 name = "memchr"
@@ -222,24 +317,30 @@ checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be"
 
 [[package]]
 name = "num-traits"
-version = "0.2.15"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+checksum = "f30b0abd723be7e2ffca1272140fac1a2f084c77ec3e123c192b66af1ee9e6c2"
 dependencies = [
  "autocfg",
 ]
 
 [[package]]
-name = "os_str_bytes"
+name = "once_cell"
-version = "6.0.1"
+version = "1.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "029d8d0b2f198229de29dca79676f2738ff952edf3fde542eb8bf94d8c21b435"
+checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
+
+[[package]]
+name = "owo-colors"
+version = "3.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1b04fb49957986fdce4d6ee7a65027d55d4b6d2265e5848bbb507b58ccfdb6f"
 
 [[package]]
 name = "predicates"
-version = "2.1.1"
+version = "2.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5aab5be6e4732b473071984b3164dbbfb7a3674d30ea5ff44410b6bcd960c3c"
+checksum = "59230a63c37f3e18569bdb90e4a89cbf5bf8b06fea0b84e65ea10cc4df47addd"
 dependencies = [
  "difflib",
  "float-cmp",
@@ -250,44 +351,78 @@ dependencies = [
 ]
 
 [[package]]
-name = "predicates-core"
+name = "predicates"
-version = "1.0.3"
+version = "3.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da1c2388b1513e1b605fcec39a95e0a9e8ef088f71443ef37099fa9ae6673fcb"
+checksum = "09963355b9f467184c04017ced4a2ba2d75cbcb4e7462690d388233253d4b1a9"
+dependencies = [
+ "anstyle",
+ "difflib",
+ "itertools",
+ "predicates-core",
+]
+
+[[package]]
+name = "predicates-core"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b794032607612e7abeb4db69adb4e33590fa6cf1149e95fd7cb00e634b92f174"
 
 [[package]]
 name = "predicates-tree"
-version = "1.0.5"
+version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d86de6de25020a36c6d3643a86d9a6a9f552107c0559c60ea03551b5e16c032"
+checksum = "368ba315fb8c5052ab692e68a0eefec6ec57b23a36959c14496f0b0df2c0cecf"
 dependencies = [
  "predicates-core",
  "termtree",
 ]
 
 [[package]]
-name = "proc-macro2"
+name = "pretty_assertions"
-version = "1.0.39"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c54b25569025b7fc9651de43004ae593a75ad88543b17178aa5e1b9c4f15f56f"
+checksum = "af7cee1a6c8a5b9208b3cb1061f10c0cb689087b3d8ce85fb9d2dd7a29b6ba66"
+dependencies = [
+ "diff",
+ "yansi",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.66"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18fb31db3f9bddb2ea821cde30a9f70117e3f119938b5ee630b7403aa6e2ead9"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.18"
+version = "1.0.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1feb54ed693b93a84e14094943b84b7c4eae204c512b7ccb95ab0c66d278ad1"
+checksum = "50f3b39ccfb720540debaa0164757101c08ecb8d326b15358ce76a62c7e85965"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
 name = "regex"
-version = "1.5.6"
+version = "1.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d83f127d94bdbcda4c8cc2e50f6f84f4b611f69c902699ca385a39c3a75f9ff1"
+checksum = "b2eae68fc220f7cf2532e4494aded17545fce192d59cd996e0fe7887f4ceb575"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39354c10dd07468c2e73926b23bb9c2caca74c5501e38a35da70406f1d923310"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -295,16 +430,43 @@ dependencies = [
 ]
 
 [[package]]
-name = "regex-automata"
+name = "regex-syntax"
-version = "0.1.10"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
+checksum = "e5ea92a5b6195c6ef2a0295ea818b312502c6fc94dde986c5553242e18fd4ce2"
 
 [[package]]
-name = "regex-syntax"
+name = "rustix"
-version = "0.6.26"
+version = "0.37.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49b3de9ec5dc0a3417da371aab17d729997c15010e7fd24ff707773a33bddb64"
+checksum = "4d69718bf81c6127a49dc64e44a742e8bb9213c0ff8869a22c308f84c1d4ab06"
+dependencies = [
+ "bitflags 1.3.2",
+ "errno",
+ "io-lifetimes",
+ "libc",
+ "linux-raw-sys 0.3.8",
+ "windows-sys",
+]
+
+[[package]]
+name = "rustix"
+version = "0.38.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a962918ea88d644592894bc6dc55acc6c0956488adcebbfb6e273506b7fd6e5"
+dependencies = [
+ "bitflags 2.3.3",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.4.3",
+ "windows-sys",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.175"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d25439cd7397d044e2748a6fe2432b5e85db703d6d097bd014b3c0ad1ebff0b"
 
 [[package]]
 name = "strsim"
@@ -313,64 +475,56 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
 
 [[package]]
-name = "syn"
+name = "supports-color"
-version = "1.0.95"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbaf6116ab8924f39d52792136fb74fd60a80194cf1b1c6ffa6453eef1c3f942"
+checksum = "4950e7174bffabe99455511c39707310e7e9b440364a2fcb1cc21521be57b354"
+dependencies = [
+ "is-terminal",
+ "is_ci",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b60f673f44a8255b9c8c657daf66a596d435f2da81a555b06dc644d080ba45e0"
 dependencies = [
  "proc-macro2",
  "quote",
  "unicode-ident",
 ]
 
-[[package]]
-name = "termcolor"
-version = "1.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
-dependencies = [
- "winapi-util",
-]
-
 [[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",
+ "rustix 0.37.23",
- "winapi",
+ "windows-sys",
 ]
 
 [[package]]
 name = "termtree"
-version = "0.2.4"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "507e9898683b6c43a9aa55b64259b721b52ba226e0f3779137e50ad114a4c90b"
+checksum = "3369f5ac52d5eb6ab48c6b4ffdc8efbcad6b89c765749064ba298f2c68a16a76"
-
-[[package]]
-name = "textwrap"
-version = "0.15.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb"
-dependencies = [
- "terminal_size",
-]
 
 [[package]]
 name = "thiserror"
-version = "1.0.31"
+version = "1.0.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd829fe32373d27f76265620b5309d0340cb8550f523c1dda251d6298069069a"
+checksum = "611040a08a0439f8248d1990b111c95baa9c704c805fa1f62104b39655fd7f90"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.31"
+version = "1.0.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0396bc89e626244658bef819e22d0cc459e795a5ebe878e6ec336d1674a8d79a"
+checksum = "090198534930841fab3a5d1bb637cde49e339654e606195f8d9c76eeb081dc96"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -379,15 +533,21 @@ dependencies = [
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.0"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d22af068fba1eb5edcb4aea19d382b2a3deb4c8f9d475c589b6ada9e0fd493ee"
+checksum = "301abaae475aa91687eb82514b328ab47a211a533026cb25fc3e519b86adfc3c"
 
 [[package]]
 name = "unicode-xid"
-version = "0.2.3"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "957e51f3646910546462e67d5f7599b9e4fb8acdd304b087a6494730f9eebf04"
+checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
 
 [[package]]
 name = "wait-timeout"
@@ -399,32 +559,73 @@ dependencies = [
 ]
 
 [[package]]
-name = "winapi"
+name = "windows-sys"
-version = "0.3.9"
+version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
 dependencies = [
- "winapi-i686-pc-windows-gnu",
+ "windows-targets",
- "winapi-x86_64-pc-windows-gnu",
 ]
 
 [[package]]
-name = "winapi-i686-pc-windows-gnu"
+name = "windows-targets"
-version = "0.4.0"
+version = "0.48.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+checksum = "05d4b17490f70499f20b9e791dcf6a299785ce8af4d709018206dc5b4953e95f"
-
-[[package]]
-name = "winapi-util"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
 dependencies = [
- "winapi",
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
 ]
 
 [[package]]
-name = "winapi-x86_64-pc-windows-gnu"
+name = "windows_aarch64_gnullvm"
-version = "0.4.0"
+version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
+
+[[package]]
+name = "yansi"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"

Cargo.toml

@@ -7,25 +7,28 @@ license = "MIT/Apache-2.0"
 name = "hexyl"
 readme = "README.md"
 repository = "https://github.com/sharkdp/hexyl"
-version = "0.10.0"
+version = "0.13.1"
 edition = "2021"
+rust-version = "1.66"
 
 [dependencies]
-ansi_term = "0.12"
 anyhow = "1.0"
-atty = "0.2"
 const_format = "0.2"
 libc = "0.2"
+owo-colors = "3"
+supports-color = "2"
 thiserror = "1.0"
+terminal_size = "0.2"
 
 [dependencies.clap]
-version = "3"
+version = "4"
 default-features = false
-features = ["std", "suggestions", "color", "wrap_help", "cargo"]
+features = ["std", "suggestions", "color", "wrap_help", "cargo", "help", "usage", "error-context"]
 
 [dev-dependencies]
 assert_cmd = "2.0"
 predicates = "2.0"
+pretty_assertions = "1.3.0"
 
 [profile.release]
 lto = true

README.md

@@ -17,6 +17,20 @@ of bytes (NULL bytes, printable ASCII characters, ASCII whitespace characters, o
 
 ![](https://i.imgur.com/f8nm8g6.png)
 
+## Color Reference
+
+|Type of Byte|Color|ANSI Code |
+|---|---|---|
+|NULL|![#555753](https://placehold.co/10x10/555753/555753.png) Bright Black|90|
+|OFFSET|![#555753](https://placehold.co/10x10/555753/555753.png) Bright Black|90|
+|ASCII Printable|![#06989a](https://placehold.co/10x10/06989a/06989a.png) Cyan|36|
+|ASCII Whitespace|![#4e9a06](https://placehold.co/10x10/4e9a06/4e9a06.png) Green|32|
+|ASCII Other|![#4e9a06](https://placehold.co/10x10/4e9a06/4e9a06.png) Green|32|
+|Non-ASCII|![#c4a000](https://placehold.co/10x10/c4a000/c4a000.png) Yellow|33|
+
+*Colors taken from the Ubuntu terminal color scheme, they could look different in your terminal*
+
+
 ## Installation
 
 ### On Ubuntu
@@ -31,7 +45,7 @@ If you use an older version of Ubuntu, you can download
 the latest `.deb` package from the release page and install it via:
 
 ``` bash
-sudo dpkg -i hexyl_0.10.0_amd64.deb  # adapt version number and architecture
+sudo dpkg -i hexyl_0.13.1_amd64.deb  # adapt version number and architecture
 ```
 
 ### On Debian
@@ -44,6 +58,14 @@ sudo apt-get install hexyl
 If you run an older version of Debian, see above for instructions on how to
 manually install `hexyl`.
 
+### On Fedora
+
+If you run Fedora 35 or newer, you can install the [officially maintained Fedora package](https://packages.fedoraproject.org/pkgs/rust-hexyl/hexyl):
+
+```bash
+sudo dnf install hexyl
+```
+
 ### On Arch Linux
 
 You can install `hexyl` from [the official package repository](https://www.archlinux.org/packages/community/x86_64/hexyl/):

doc/hexyl.1.md

@@ -1,6 +1,6 @@
-% HEXYL(1) hexyl 0.10.0 | General Commands Manual
+% HEXYL(1) hexyl 0.12.0 | General Commands Manual
 %
-% 2022-03-23
+% 2022-12-05
 
 <!--
 This man page is written in Pandoc's Markdown.
@@ -121,6 +121,9 @@ Source repository:
 Print a given file:
 :   $ **hexyl small.png**
 
+Print and view a given file in the terminal pager:
+:   $ **hexyl big.png | less -r**
+
 Print the first 256 bytes of a given special file:
 :   $ **hexyl -n 256 /dev/urandom**
 

examples/simple.rs

@@ -1,6 +1,6 @@
 use std::io;
 
-use hexyl::{BorderStyle, Printer};
+use hexyl::{BorderStyle, PrinterBuilder};
 
 fn main() {
     let input = vec![
@@ -11,19 +11,14 @@ fn main() {
     let stdout = io::stdout();
     let mut handle = stdout.lock();
 
-    let show_color = true;
+    let mut printer = PrinterBuilder::new(&mut handle)
-    let show_char_panel = true;
+        .show_color(true)
-    let show_position_panel = true;
+        .show_char_panel(true)
-    let use_squeezing = false;
+        .show_position_panel(true)
-    let border_style = BorderStyle::Unicode;
+        .with_border_style(BorderStyle::Unicode)
-
+        .enable_squeezing(false)
-    let mut printer = Printer::new(
+        .num_panels(2)
-        &mut handle,
+        .group_size(1)
-        show_color,
+        .build();
-        show_char_panel,
-        show_position_panel,
-        border_style,
-        use_squeezing,
-    );
     printer.print_all(&input[..]).unwrap();
 }

src/bin/hexyl.rs

@@ -3,26 +3,26 @@ extern crate clap;
 
 use std::convert::TryFrom;
 use std::fs::File;
-use std::io::{self, prelude::*, SeekFrom};
+use std::io::{self, prelude::*, BufWriter, SeekFrom};
-use std::num::NonZeroI64;
+use std::num::{NonZeroI64, NonZeroU64, NonZeroU8};
 
-use clap::{crate_name, crate_version, AppSettings, Arg, ColorChoice, Command};
+use clap::builder::ArgPredicate;
+use clap::{crate_name, crate_version, Arg, ArgAction, ColorChoice, Command};
 
-use atty::Stream;
+use anyhow::{anyhow, Context, Result};
-
-use anyhow::{anyhow, Context, Error as AnyhowError};
 
 use const_format::formatcp;
 
 use thiserror::Error as ThisError;
 
-use hexyl::{BorderStyle, Input, Printer};
+use terminal_size::terminal_size;
+
+use hexyl::{Base, BorderStyle, Endianness, Input, PrinterBuilder};
 
 const DEFAULT_BLOCK_SIZE: i64 = 512;
 
-fn run() -> Result<(), AnyhowError> {
+fn run() -> Result<()> {
     let command = Command::new(crate_name!())
-        .setting(AppSettings::DeriveDisplayOrder)
         .color(ColorChoice::Auto)
         .max_term_width(90)
         .version(crate_version!())
@@ -35,7 +35,7 @@ fn run() -> Result<(), AnyhowError> {
             Arg::new("length")
                 .short('n')
                 .long("length")
-                .takes_value(true)
+                .num_args(1)
                 .value_name("N")
                 .help(
                     "Only read N bytes from the input. The N argument can also include a \
@@ -49,7 +49,7 @@ fn run() -> Result<(), AnyhowError> {
             Arg::new("bytes")
                 .short('c')
                 .long("bytes")
-                .takes_value(true)
+                .num_args(1)
                 .value_name("N")
                 .conflicts_with("length")
                 .help("An alias for -n/--length"),
@@ -57,9 +57,9 @@ fn run() -> Result<(), AnyhowError> {
         .arg(
             Arg::new("count")
                 .short('l')
-                .takes_value(true)
+                .num_args(1)
                 .value_name("N")
-                .conflicts_with_all(&["length", "bytes"])
+                .conflicts_with_all(["length", "bytes"])
                 .hide(true)
                 .help("Yet another alias for -n/--length"),
         )
@@ -67,7 +67,7 @@ fn run() -> Result<(), AnyhowError> {
             Arg::new("skip")
                 .short('s')
                 .long("skip")
-                .takes_value(true)
+                .num_args(1)
                 .value_name("N")
                 .help(
                     "Skip the first N bytes of the input. The N argument can also include \
@@ -78,7 +78,7 @@ fn run() -> Result<(), AnyhowError> {
         .arg(
             Arg::new("block_size")
                 .long("block-size")
-                .takes_value(true)
+                .num_args(1)
                 .value_name("SIZE")
                 .help(formatcp!(
                     "Sets the size of the `block` unit to SIZE (default is {}).\n\
@@ -90,6 +90,7 @@ fn run() -> Result<(), AnyhowError> {
             Arg::new("nosqueezing")
                 .short('v')
                 .long("no-squeezing")
+                .action(ArgAction::SetFalse)
                 .help(
                     "Displays all input data. Otherwise any number of groups of output \
                      lines which would be identical to the preceding group of lines, are \
@@ -99,49 +100,58 @@ fn run() -> Result<(), AnyhowError> {
         .arg(
             Arg::new("color")
                 .long("color")
-                .takes_value(true)
+                .num_args(1)
                 .value_name("WHEN")
-                .possible_values(&["always", "auto", "never"])
+                .value_parser(["always", "auto", "never"])
-                .default_value_if("plain", None, Some("never"))
+                .default_value_if("plain", ArgPredicate::IsPresent, Some("never"))
                 .default_value("always")
                 .help(
                     "When to use colors. The auto-mode only displays colors if the output \
                      goes to an interactive terminal",
                 ),
         )
-        .arg(Arg::new("plain").short('p').long("plain").help(
-            "Display output with --no-characters, --no-position, --border=none, and --color=never.",
-        ))
         .arg(
             Arg::new("border")
                 .long("border")
-                .takes_value(true)
+                .num_args(1)
                 .value_name("STYLE")
-                .possible_values(&["unicode", "ascii", "none"])
+                .value_parser(["unicode", "ascii", "none"])
-                .default_value_if("plain", None, Some("none"))
+                .default_value_if("plain", ArgPredicate::IsPresent, Some("none"))
                 .default_value("unicode")
                 .help(
                     "Whether to draw a border with Unicode characters, ASCII characters, \
                     or none at all",
                 ),
         )
+        .arg(Arg::new("plain").short('p').long("plain").action(ArgAction::SetTrue).help(
+            "Display output with --no-characters, --no-position, --border=none, and --color=never.",
+        ))
         .arg(
             Arg::new("no_chars")
-                .short('C')
                 .long("no-characters")
-                .help("Whether to display the character panel on the right."),
+                .action(ArgAction::SetFalse)
+                .help("Do not show the character panel on the right."),
+        )
+        .arg(
+            Arg::new("chars")
+                .short('C')
+                .long("characters")
+                .overrides_with("no_chars")
+                .action(ArgAction::SetTrue)
+                .help("Show the character panel on the right. This is the default, unless --no-characters has been specified."),
         )
         .arg(
             Arg::new("no_position")
                 .short('P')
                 .long("no-position")
+                .action(ArgAction::SetFalse)
                 .help("Whether to display the position panel on the left."),
         )
         .arg(
             Arg::new("display_offset")
                 .short('o')
                 .long("display-offset")
-                .takes_value(true)
+                .num_args(1)
                 .value_name("N")
                 .help(
                     "Add N bytes to the displayed file position. The N argument can also \
@@ -149,19 +159,94 @@ fn run() -> Result<(), AnyhowError> {
                     A negative value is valid and calculates an offset relative to the \
                     end of the file.",
                 ),
+        )
+        .arg(
+            Arg::new("panels")
+                .long("panels")
+                .num_args(1)
+                .value_name("N")
+                .help(
+                    "Sets the number of hex data panels to be displayed. \
+                    `--panels=auto` will display the maximum number of hex data panels \
+                    based on the current terminal width. By default, hexyl will show \
+                    two panels, unless the terminal is not wide enough for that.",
+                ),
+        )
+        .arg(
+            Arg::new("group_size")
+                .short('g')
+                .long("group-size")
+                .alias("groupsize")
+                .num_args(1)
+                .value_name("N")
+                .help(
+                    "Number of bytes/octets that should be grouped together. \
+                    Possible group sizes are 1, 2, 4, 8. The default is 1. You \
+                    can use the '--endianness' option to control the ordering of \
+                    the bytes within a group. '--groupsize' can be used as an \
+                    alias (xxd-compatibility).",
+                ),
+        )
+        .arg(
+            Arg::new("endianness")
+                .long("endianness")
+                .num_args(1)
+                .value_name("FORMAT")
+                .value_parser(["big", "little"])
+                .default_value("big")
+                .help(
+                    "Whether to print out groups in little-endian or big-endian \
+                     format. This option only has an effect if the '--group-size' \
+                     is larger than 1. '-e' can be used as an alias for \
+                     '--endianness=little'.",
+                ),
+        )
+        .arg(
+            Arg::new("little_endian_format")
+                .short('e')
+                .action(ArgAction::SetTrue)
+                .overrides_with("endianness")
+                .hide(true)
+                .help("An alias for '--endianness=little'."),
+        )
+        .arg(
+            Arg::new("base")
+                .short('b')
+                .long("base")
+                .num_args(1)
+                .value_name("B")
+                .help(
+                    "Sets the base used for the bytes. The possible options are \
+                    binary, octal, decimal, and hexadecimal. The default base \
+                    is hexadecimal."
+                )
+        )
+        .arg(
+            Arg::new("terminal_width")
+                .long("terminal-width")
+                .num_args(1)
+                .value_name("N")
+                .conflicts_with("panels")
+                .help(
+                    "Sets the number of terminal columns to be displayed.\nSince the terminal \
+                    width may not be an evenly divisible by the width per hex data column, this \
+                    will use the greatest number of hex data panels that can fit in the requested \
+                    width but still leave some space to the right.\nCannot be used with other \
+                    width-setting options.",
+                ),
         );
 
     let matches = command.get_matches();
 
     let stdin = io::stdin();
 
-    let mut reader = match matches.value_of("FILE") {
+    let mut reader = match matches.get_one::<String>("FILE") {
         Some(filename) => Input::File(File::open(filename)?),
         None => Input::Stdin(stdin.lock()),
     };
 
     let block_size = matches
-        .value_of("block_size")
+        .get_one::<String>("block_size")
         .map(|bs| {
             if let Some(hex_number) = try_parse_as_hex_number(bs) {
                 return hex_number.map_err(|e| anyhow!(e)).and_then(|x| {
@@ -186,7 +271,7 @@ fn run() -> Result<(), AnyhowError> {
         .unwrap_or_else(|| PositiveI64::new(DEFAULT_BLOCK_SIZE).unwrap());
 
     let skip_arg = matches
-        .value_of("skip")
+        .get_one::<String>("skip")
         .map(|s| {
             parse_byte_offset(s, block_size).context(anyhow!(
                 "failed to parse `--skip` arg {:?} as byte count",
@@ -215,16 +300,16 @@ fn run() -> Result<(), AnyhowError> {
         0
     };
 
-    let parse_byte_count = |s| -> Result<u64, AnyhowError> {
+    let parse_byte_count = |s| -> Result<u64> {
         Ok(parse_byte_offset(s, block_size)?
             .assume_forward_offset_from_start()?
             .into())
     };
 
     let mut reader = if let Some(length) = matches
-        .value_of("length")
+        .get_one::<String>("length")
-        .or_else(|| matches.value_of("bytes"))
+        .or_else(|| matches.get_one::<String>("bytes"))
-        .or_else(|| matches.value_of("count"))
+        .or_else(|| matches.get_one::<String>("count"))
         .map(|s| {
             parse_byte_count(s).context(anyhow!(
                 "failed to parse `--length` arg {:?} as byte count",
@@ -238,26 +323,30 @@ fn run() -> Result<(), AnyhowError> {
         reader.into_inner()
     };
 
-    let show_color = match matches.value_of("color") {
+    let show_color = match matches.get_one::<String>("color").map(String::as_ref) {
         Some("never") => false,
-        Some("auto") => atty::is(Stream::Stdout),
+        Some("always") => true,
-        _ => true,
+        _ => supports_color::on(supports_color::Stream::Stdout)
+            .map(|level| level.has_basic)
+            .unwrap_or(false),
     };
 
-    let border_style = match matches.value_of("border") {
+    let border_style = match matches.get_one::<String>("border").map(String::as_ref) {
         Some("unicode") => BorderStyle::Unicode,
         Some("ascii") => BorderStyle::Ascii,
         _ => BorderStyle::None,
     };
 
-    let squeeze = !matches.is_present("nosqueezing");
+    let &squeeze = matches.get_one::<bool>("nosqueezing").unwrap_or(&true);
 
-    let show_char_panel = !matches.is_present("no_chars") && !matches.is_present("plain");
+    let show_char_panel = *matches.get_one::<bool>("no_chars").unwrap_or(&true)
+        && !matches.get_one::<bool>("plain").unwrap_or(&false);
 
-    let show_position_panel = !matches.is_present("no_position") && !matches.is_present("plain");
+    let show_position_panel = *matches.get_one::<bool>("no_position").unwrap_or(&true)
+        && !matches.get_one::<bool>("plain").unwrap_or(&false);
 
     let display_offset: u64 = matches
-        .value_of("display_offset")
+        .get_one::<String>("display_offset")
         .map(|s| {
             parse_byte_count(s).context(anyhow!(
                 "failed to parse `--display-offset` arg {:?} as byte count",
@@ -267,17 +356,130 @@ fn run() -> Result<(), AnyhowError> {
         .transpose()?
         .unwrap_or(0);
 
-    let stdout = io::stdout();
+    let max_panels_fn = |terminal_width: u64, base_digits: u64, group_size: u64| {
-    let mut stdout_lock = stdout.lock();
+        let offset = if show_position_panel { 10 } else { 1 };
+        let col_width = if show_char_panel {
+            ((8 / group_size) * (base_digits * group_size + 1)) + 2 + 8
+        } else {
+            ((8 / group_size) * (base_digits * group_size + 1)) + 2
+        };
+        if (terminal_width - offset) / col_width < 1 {
+            1
+        } else {
+            (terminal_width - offset) / col_width
+        }
+    };
 
-    let mut printer = Printer::new(
+    let base = if let Some(base) = matches.get_one::<String>("base")
-        &mut stdout_lock,
+    .map(|s| {
-        show_color,
+        if let Ok(base_num) = s.parse::<u8>() {
-        show_char_panel,
+            match base_num {
-        show_position_panel,
+                2 => Ok(Base::Binary),
-        border_style,
+                8 => Ok(Base::Octal),
-        squeeze,
+                10 => Ok(Base::Decimal),
-    );
+                16 => Ok(Base::Hexadecimal),
+                _ => Err(anyhow!("The number provided is not a valid base. Valid bases are 2, 8, 10, and 16.")),
+            }
+        } else {
+            match s.as_str() {
+                "b" | "bin" | "binary" => Ok(Base::Binary),
+                "o" | "oct" | "octal" => Ok(Base::Octal),
+                "d" | "dec" | "decimal" => Ok(Base::Decimal),
+                "x" | "hex" | "hexadecimal" => Ok(Base::Hexadecimal),
+                _ => Err(anyhow!("The base provided is not valid. Valid bases are \"b\", \"o\", \"d\", and \"x\"."))
+            }
+        }
+    }).transpose()? {
+        base
+    } else {
+        Base::Hexadecimal
+    };
+
+    let base_digits = match base {
+        Base::Binary => 8,
+        Base::Octal => 3,
+        Base::Decimal => 3,
+        Base::Hexadecimal => 2,
+    };
+
+    let group_size = if let Some(group_size) = matches
+        .get_one::<String>("group_size")
+        .map(|s| {
+            s.parse::<NonZeroU8>().map(u8::from).context(anyhow!(
+                "Failed to parse `--group-size`/`-g` argument {:?} as unsigned nonzero integer",
+                s
+            ))
+        })
+        .transpose()?
+    {
+        if (group_size <= 8) && ((group_size & (group_size - 1)) == 0) {
+            group_size
+        } else {
+            return Err(anyhow!(
+                "Possible sizes for the `--group-size`/`-g` option are 1, 2, 4 or 8. "
+            ));
+        }
+    } else {
+        1
+    };
+
+    let terminal_width = terminal_size().map(|s| s.0 .0 as u64).unwrap_or(80);
+
+    let panels = if matches.get_one::<String>("panels").map(String::as_ref) == Some("auto") {
+        max_panels_fn(terminal_width, base_digits, group_size.into())
+    } else if let Some(panels) = matches
+        .get_one::<String>("panels")
+        .map(|s| {
+            s.parse::<NonZeroU64>().map(u64::from).context(anyhow!(
+                "failed to parse `--panels` arg {:?} as unsigned nonzero integer",
+                s
+            ))
+        })
+        .transpose()?
+    {
+        panels
+    } else if let Some(terminal_width) = matches
+        .get_one::<String>("terminal_width")
+        .map(|s| {
+            s.parse::<NonZeroU64>().map(u64::from).context(anyhow!(
+                "failed to parse `--terminal-width` arg {:?} as unsigned nonzero integer",
+                s
+            ))
+        })
+        .transpose()?
+    {
+        max_panels_fn(terminal_width, base_digits, group_size.into())
+    } else {
+        std::cmp::min(
+            2,
+            max_panels_fn(terminal_width, base_digits, group_size.into()),
+        )
+    };
+
+    let little_endian_format = *matches.get_one::<bool>("little_endian_format").unwrap();
+    let endianness = matches.get_one::<String>("endianness");
+    let endianness = match (
+        endianness.map(|s| s.as_ref()).unwrap(),
+        little_endian_format,
+    ) {
+        (_, true) | ("little", _) => Endianness::Little,
+        ("big", _) => Endianness::Big,
+        _ => unreachable!(),
+    };
+    let stdout = io::stdout();
+    let mut stdout_lock = BufWriter::new(stdout.lock());
+
+    let mut printer = PrinterBuilder::new(&mut stdout_lock)
+        .show_color(show_color)
+        .show_char_panel(show_char_panel)
+        .show_position_panel(show_position_panel)
+        .with_border_style(border_style)
+        .enable_squeezing(squeeze)
+        .num_panels(panels)
+        .group_size(group_size)
+        .with_base(base)
+        .endianness(endianness)
+        .build();
     printer.display_offset(skip_offset + display_offset);
     printer.print_all(&mut reader).map_err(|e| anyhow!(e))?;
 
@@ -285,14 +487,15 @@ fn run() -> Result<(), AnyhowError> {
 }
 
 fn main() {
-    // Enable ANSI support for Windows
-    #[cfg(windows)]
-    let _ = ansi_term::enable_ansi_support();
-
     let result = run();
 
     if let Err(err) = result {
-        eprintln!("Error: {:?}", err);
+        if let Some(io_error) = err.downcast_ref::<io::Error>() {
+            if io_error.kind() == ::std::io::ErrorKind::BrokenPipe {
+                std::process::exit(0);
+            }
+        }
+        eprintln!("Error: {err:?}");
         std::process::exit(1);
     }
 }

src/squeezer.rs

@@ -1,407 +0,0 @@
-#[derive(Debug, PartialEq)]
-enum SqueezeState {
-    /// not enabled
-    Disabled,
-    /// Will be set from all states if equal condition can't be hold up.
-    /// Set if previous byte is not equal the current processed byte.
-    NoSqueeze,
-    /// Valid for a whole line to identify if it is candidate for squeezing
-    Probe,
-    /// Squeeze line parsing is active, but EOL is not reached yet
-    SqueezeActive,
-    /// Squeeze line, EOL is reached, will influence the action
-    Squeeze,
-    /// same as Squeeze, however this is only for the first line after
-    /// the squeeze candidate has been set.
-    SqueezeFirstLine,
-    /// same as SqueezeActive, however this is only for the first line after
-    /// the squeeze candidate has been set.
-    SqueezeActiveFirstLine,
-}
-
-pub struct Squeezer {
-    state: SqueezeState,
-    byte: u8,
-}
-
-#[derive(Debug, PartialEq)]
-pub enum SqueezeAction {
-    Ignore,
-    Print,
-    Delete,
-}
-
-/// line size
-const LSIZE: u64 = 16;
-
-impl Squeezer {
-    pub fn new(enabled: bool) -> Squeezer {
-        Squeezer {
-            state: if enabled {
-                SqueezeState::Probe
-            } else {
-                SqueezeState::Disabled
-            },
-            byte: 0,
-        }
-    }
-
-    pub fn process(&mut self, b: u8, i: u64) {
-        use self::SqueezeState::*;
-        if self.state == Disabled {
-            return;
-        }
-        let eq = b == self.byte;
-
-        if i % LSIZE == 0 {
-            if !eq {
-                self.state = Probe;
-            } else {
-                self.state = match self.state {
-                    NoSqueeze => Probe,
-                    Probe => SqueezeActiveFirstLine,
-                    SqueezeActiveFirstLine => SqueezeFirstLine,
-                    SqueezeFirstLine => SqueezeActive,
-                    SqueezeActive => Squeeze,
-                    Squeeze => SqueezeActive,
-                    Disabled => Disabled,
-                };
-            }
-        } else if !eq {
-            if i % LSIZE == 1 {
-                self.state = Probe;
-            } else if i % LSIZE != 1 {
-                self.state = NoSqueeze;
-            }
-        }
-
-        self.byte = b;
-    }
-
-    pub fn active(&self) -> bool {
-        use self::SqueezeState::*;
-        matches!(
-            self.state,
-            Squeeze | SqueezeActive | SqueezeFirstLine | SqueezeActiveFirstLine
-        )
-    }
-
-    pub fn action(&self) -> SqueezeAction {
-        match self.state {
-            SqueezeState::SqueezeFirstLine => SqueezeAction::Print,
-            SqueezeState::Squeeze => SqueezeAction::Delete,
-            _ => SqueezeAction::Ignore,
-        }
-    }
-
-    pub fn advance(&mut self) {
-        match self.state {
-            SqueezeState::SqueezeFirstLine => {
-                self.state = SqueezeState::SqueezeActive;
-            }
-            SqueezeState::Squeeze => {
-                self.state = SqueezeState::SqueezeActive;
-            }
-            _ => {}
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    const LSIZE_USIZE: usize = LSIZE as usize;
-
-    #[test]
-    fn three_same_lines() {
-        const LINES: usize = 3;
-        let v = vec![0u8; LINES * LSIZE_USIZE];
-        let mut s = Squeezer::new(true);
-        // just initialized
-        assert_eq!(s.action(), SqueezeAction::Ignore);
-        s.advance();
-
-        let exp = vec![
-            SqueezeAction::Ignore, // first line, print as is
-            SqueezeAction::Print,  // print squeeze symbol
-            SqueezeAction::Delete, // delete reoccurring line
-        ];
-
-        let mut idx = 1;
-        for (line, z) in v.chunks(LSIZE_USIZE).enumerate() {
-            for i in z {
-                s.process(*i, idx);
-                idx += 1;
-            }
-            let action = s.action();
-            s.advance();
-            assert_eq!(action, exp[line]);
-        }
-    }
-
-    #[test]
-    fn incomplete_while_squeeze() {
-        // fourth line only has 12 bytes and should be printed
-        let v = vec![0u8; 3 * LSIZE_USIZE + 12];
-        let mut s = Squeezer::new(true);
-        // just initialized
-        assert_eq!(s.action(), SqueezeAction::Ignore);
-        s.advance();
-
-        let exp = vec![
-            SqueezeAction::Ignore, // first line, print as is
-            SqueezeAction::Print,  // print squeeze symbol
-            SqueezeAction::Delete, // delete reoccurring line
-            SqueezeAction::Ignore, // last line only 12 bytes, print it
-        ];
-
-        let mut idx = 1;
-        for (line, z) in v.chunks(LSIZE_USIZE).enumerate() {
-            for i in z {
-                s.process(*i, idx);
-                idx += 1;
-            }
-            assert_eq!(s.action(), exp[line]);
-            s.advance();
-        }
-    }
-
-    #[test]
-    /// all three lines are different, print all
-    fn three_different_lines() {
-        let mut v: Vec<u8> = vec![];
-        v.extend(vec![0u8; 16]);
-        v.extend(vec![1u8; 16]);
-        v.extend(vec![2u8; 16]);
-
-        let mut s = Squeezer::new(true);
-        // just initialized
-        assert_eq!(s.action(), SqueezeAction::Ignore);
-        s.advance();
-
-        let exp = vec![
-            SqueezeAction::Ignore, // first line, print as is
-            SqueezeAction::Ignore, // different
-            SqueezeAction::Ignore, // different
-        ];
-
-        let mut idx = 1;
-        for (line, z) in v.chunks(LSIZE_USIZE).enumerate() {
-            for i in z {
-                s.process(*i, idx);
-                idx += 1;
-            }
-            let action = s.action();
-            assert_eq!(action, exp[line]);
-            s.advance();
-        }
-    }
-
-    #[test]
-    /// first two lines same, hence squeeze symbol, third line diff, hence
-    /// print
-    fn one_squeeze_no_delete() {
-        const LINES: usize = 3;
-        let mut v = vec![0u8; (LINES - 1) * LSIZE_USIZE];
-        v.extend(vec![1u8; 16]);
-
-        let mut s = Squeezer::new(true);
-        // just initialized
-        assert_eq!(s.action(), SqueezeAction::Ignore);
-        s.advance();
-
-        let exp = vec![
-            SqueezeAction::Ignore, // first line, print as is
-            SqueezeAction::Print,  // print squeeze symbol
-            SqueezeAction::Ignore, // different lines, print again
-        ];
-
-        let mut idx = 1;
-        for (line, z) in v.chunks(LSIZE_USIZE).enumerate() {
-            for i in z {
-                s.process(*i, idx);
-                idx += 1;
-            }
-            let action = s.action();
-            s.advance();
-            assert_eq!(action, exp[line]);
-        }
-    }
-
-    #[test]
-    /// First line all eq, 2nd half eq with first line, then change
-    fn second_line_different() {
-        const LINES: usize = 2;
-        let mut v = vec![0u8; (LINES - 1) * LSIZE_USIZE];
-        v.extend(vec![0u8; 8]);
-        v.extend(vec![1u8; 8]);
-
-        let mut s = Squeezer::new(true);
-        // just initialized
-        assert_eq!(s.action(), SqueezeAction::Ignore);
-        s.advance();
-
-        let exp = vec![
-            SqueezeAction::Ignore, // first line, print as is
-            SqueezeAction::Ignore, // print squeeze symbol
-        ];
-
-        let mut idx = 1;
-        for (line, z) in v.chunks(LSIZE_USIZE).enumerate() {
-            for i in z {
-                s.process(*i, idx);
-                idx += 1;
-            }
-            let action = s.action();
-            s.advance();
-            assert_eq!(action, exp[line]);
-        }
-    }
-
-    #[test]
-    /// all three lines never become squeeze candidate (diff within line)
-    fn never_squeeze_candidate() {
-        let mut v = vec![];
-        v.extend(vec![0u8; 8]);
-        v.extend(vec![1u8; 8]);
-        v.extend(vec![0u8; 8]);
-        v.extend(vec![1u8; 8]);
-        v.extend(vec![0u8; 8]);
-        v.extend(vec![1u8; 8]);
-
-        let mut s = Squeezer::new(true);
-        // just initialized
-        assert_eq!(s.action(), SqueezeAction::Ignore);
-        s.advance();
-
-        let exp = vec![
-            SqueezeAction::Ignore, // first line, print as is
-            SqueezeAction::Ignore, // print squeeze symbol
-            SqueezeAction::Ignore, // print squeeze symbol
-        ];
-
-        let mut idx = 1;
-        for (line, z) in v.chunks(LSIZE_USIZE).enumerate() {
-            for i in z {
-                s.process(*i, idx);
-                idx += 1;
-            }
-            let action = s.action();
-            s.advance();
-            assert_eq!(action, exp[line]);
-        }
-    }
-
-    #[test]
-    fn mix_everything() {
-        let mut v = vec![];
-        v.extend(vec![10u8; 16]); // print
-        v.extend(vec![20u8; 16]); // print
-        v.extend(vec![0u8; 16]); // print
-        v.extend(vec![0u8; 16]); // *
-        v.extend(vec![10u8; 16]); // print
-        v.extend(vec![20u8; 16]); // print
-        v.extend(vec![0u8; 16]); // print
-        v.extend(vec![0u8; 16]); // *
-        v.extend(vec![0u8; 16]); // delete
-        v.extend(vec![0u8; 16]); // delete*
-        v.extend(vec![20u8; 16]); // print
-        v.extend(vec![0u8; 12]); // print, only 12 bytes
-
-        let mut s = Squeezer::new(true);
-        // just initialized
-        assert_eq!(s.action(), SqueezeAction::Ignore);
-        s.advance();
-
-        let exp = vec![
-            SqueezeAction::Ignore,
-            SqueezeAction::Ignore,
-            SqueezeAction::Ignore,
-            SqueezeAction::Print,
-            SqueezeAction::Ignore,
-            SqueezeAction::Ignore,
-            SqueezeAction::Ignore,
-            SqueezeAction::Print,
-            SqueezeAction::Delete,
-            SqueezeAction::Delete,
-            SqueezeAction::Ignore,
-            SqueezeAction::Ignore,
-        ];
-
-        let mut idx = 1;
-        for (line, z) in v.chunks(LSIZE_USIZE).enumerate() {
-            for i in z {
-                s.process(*i, idx);
-                idx += 1;
-            }
-            let action = s.action();
-            s.advance();
-            assert_eq!(action, exp[line]);
-        }
-    }
-
-    #[test]
-    fn last_char_diff() {
-        // see issue #62
-        let mut v = vec![];
-        v.extend(vec![20u8; 16]);
-        v.extend(vec![20u8; 15]);
-        v.push(61);
-        v.extend(vec![20u8; 16]);
-        v.extend(vec![20u8; 16]);
-
-        let mut s = Squeezer::new(true);
-        // just initialized
-        assert_eq!(s.action(), SqueezeAction::Ignore);
-        s.advance();
-
-        let exp = vec![
-            SqueezeAction::Ignore, // print as is
-            SqueezeAction::Ignore, // print as is
-            SqueezeAction::Ignore, // print as is
-            SqueezeAction::Print,  // print '*' char
-        ];
-
-        let mut idx = 1;
-        for (line, z) in v.chunks(LSIZE_USIZE).enumerate() {
-            for i in z {
-                s.process(*i, idx);
-                idx += 1;
-            }
-            assert_eq!(s.action(), exp[line]);
-            s.advance();
-        }
-    }
-
-    #[test]
-    fn first_char_diff() {
-        // see issue #62
-        let mut v = vec![];
-        v.extend(vec![20u8; 16]);
-        v.push(61);
-        v.extend(vec![20u8; 15]);
-        v.extend(vec![20u8; 16]);
-
-        let mut s = Squeezer::new(true);
-        // just initialized
-        assert_eq!(s.action(), SqueezeAction::Ignore);
-        s.advance();
-
-        let exp = vec![
-            SqueezeAction::Ignore, // print as is
-            SqueezeAction::Ignore, // print as is
-            SqueezeAction::Ignore, // print as is
-        ];
-
-        let mut idx = 1;
-        for (line, z) in v.chunks(LSIZE_USIZE).enumerate() {
-            for i in z {
-                s.process(*i, idx);
-                idx += 1;
-            }
-            assert_eq!(s.action(), exp[line]);
-            s.advance();
-        }
-    }
-}

tests/integration_tests.rs

@@ -5,6 +5,26 @@ fn hexyl() -> Command {
     cmd.current_dir("tests/examples");
     cmd
 }
+trait PrettyAssert<S>
+where
+    S: AsRef<str>,
+{
+    fn pretty_stdout(self, other: S);
+}
+
+// https://github.com/assert-rs/assert_cmd/issues/121#issuecomment-849937376
+//
+impl<S> PrettyAssert<S> for assert_cmd::assert::Assert
+where
+    S: AsRef<str>,
+{
+    fn pretty_stdout(self, other: S) {
+        println!("{}", other.as_ref().len());
+        let self_str = String::from_utf8(self.get_output().stdout.clone()).unwrap();
+        println!("{}", self_str.len());
+        pretty_assertions::assert_eq!(self_str, other.as_ref());
+    }
+}
 
 mod basic {
     use super::hexyl;
@@ -51,7 +71,7 @@ mod basic {
         .success()
         .stdout(
             "┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐\n\
-             │        │ No content to print     │                         │        │        │\n\
+             │        │ No content              │                         │        │        │\n\
              └────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘\n",
         );
     }
@@ -70,8 +90,8 @@ mod length {
         .success()
         .stdout(
             "┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐\n\
-             │00000000│ 7f 45 4c 46 02 01 01 00 ┊ 00 00 00 00 00 00 00 00 │•ELF•••0┊00000000│\n\
+             │00000000│ 7f 45 4c 46 02 01 01 00 ┊ 00 00 00 00 00 00 00 00 │•ELF•••⋄┊⋄⋄⋄⋄⋄⋄⋄⋄│\n\
-             │00000010│ 02 00 3e 00 01 00 00 00 ┊ 00 10 40 00 00 00 00 00 │•0>0•000┊0•@00000│\n\
+             │00000010│ 02 00 3e 00 01 00 00 00 ┊ 00 10 40 00 00 00 00 00 │•⋄>⋄•⋄⋄⋄┊⋄•@⋄⋄⋄⋄⋄│\n\
              └────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘\n",
         );
     }
@@ -140,7 +160,7 @@ mod skip {
         .success()
         .stdout(
             "┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐\n\
-             │        │ No content to print     │                         │        │        │\n\
+             │        │ No content              │                         │        │        │\n\
              └────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘\n",
         );
     }
@@ -203,7 +223,7 @@ mod display_offset {
         .success()
         .stdout(
             "┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐\n\
-             │00000030│ 02 00 3e 00 01 00 00 00 ┊ 00 10 40 00 00 00 00 00 │•0>0•000┊0•@00000│\n\
+             │00000030│ 02 00 3e 00 01 00 00 00 ┊ 00 10 40 00 00 00 00 00 │•⋄>⋄•⋄⋄⋄┊⋄•@⋄⋄⋄⋄⋄│\n\
              └────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘\n",
         );
     }
@@ -271,3 +291,330 @@ mod display_settings {
             );
     }
 }
+
+mod group_and_endianness {
+    use super::hexyl;
+    use super::PrettyAssert;
+
+    #[test]
+    fn group_2_bytes_be() {
+        hexyl()
+            .arg("ascii")
+            .arg("--color=never")
+            .arg("--group-size=2")
+            .assert()
+            .success()
+            .stdout(
+                "┌────────┬─────────────────────┬─────────────────────┬────────┬────────┐\n\
+                 │00000000│ 3031 3233 3435 3637 ┊ 3839 6162 6364 650a │01234567┊89abcde_│\n\
+                 └────────┴─────────────────────┴─────────────────────┴────────┴────────┘\n",
+            );
+    }
+
+    #[test]
+    fn group_2_bytes_le() {
+        hexyl()
+            .arg("ascii")
+            .arg("--color=never")
+            .arg("--group-size=2")
+            .arg("--endianness=little")
+            .assert()
+            .success()
+            .stdout(
+                "┌────────┬─────────────────────┬─────────────────────┬────────┬────────┐\n\
+                 │00000000│ 3130 3332 3534 3736 ┊ 3938 6261 6463 0a65 │01234567┊89abcde_│\n\
+                 └────────┴─────────────────────┴─────────────────────┴────────┴────────┘\n",
+            );
+    }
+
+    #[test]
+    fn group_4_bytes_be() {
+        hexyl()
+            .arg("ascii")
+            .arg("--color=never")
+            .arg("--group-size=4")
+            .assert()
+            .success()
+            .stdout(
+                "┌────────┬───────────────────┬───────────────────┬────────┬────────┐\n\
+                 │00000000│ 30313233 34353637 ┊ 38396162 6364650a │01234567┊89abcde_│\n\
+                 └────────┴───────────────────┴───────────────────┴────────┴────────┘\n",
+            );
+    }
+
+    #[test]
+    fn group_4_bytes_le() {
+        hexyl()
+            .arg("ascii")
+            .arg("--color=never")
+            .arg("--group-size=4")
+            .arg("--endianness=little")
+            .assert()
+            .success()
+            .stdout(
+                "┌────────┬───────────────────┬───────────────────┬────────┬────────┐\n\
+                 │00000000│ 33323130 37363534 ┊ 62613938 0a656463 │01234567┊89abcde_│\n\
+                 └────────┴───────────────────┴───────────────────┴────────┴────────┘\n",
+            );
+    }
+
+    #[test]
+    fn group_8_bytes_be() {
+        hexyl()
+            .arg("ascii")
+            .arg("--color=never")
+            .arg("--group-size=8")
+            .assert()
+            .success()
+            .stdout(
+                "┌────────┬──────────────────┬──────────────────┬────────┬────────┐\n\
+                 │00000000│ 3031323334353637 ┊ 383961626364650a │01234567┊89abcde_│\n\
+                 └────────┴──────────────────┴──────────────────┴────────┴────────┘\n",
+            );
+    }
+
+    #[test]
+    fn group_8_bytes_le() {
+        hexyl()
+            .arg("ascii")
+            .arg("--color=never")
+            .arg("--group-size=8")
+            .arg("--endianness=little")
+            .assert()
+            .success()
+            .stdout(
+                "┌────────┬──────────────────┬──────────────────┬────────┬────────┐\n\
+                 │00000000│ 3736353433323130 ┊ 0a65646362613938 │01234567┊89abcde_│\n\
+                 └────────┴──────────────────┴──────────────────┴────────┴────────┘\n",
+            );
+    }
+
+    #[test]
+    fn group_size_plain() {
+        hexyl()
+            .arg("ascii")
+            .arg("--color=never")
+            .arg("--plain")
+            .arg("--group-size=2")
+            .assert()
+            .success()
+            .stdout("  3031 3233 3435 3637   3839 6162 6364 650a  \n");
+    }
+
+    #[test]
+    fn group_size_fill_space() {
+        hexyl()
+            .arg("--color=never")
+            .arg("--group-size=2")
+            .write_stdin("abc")
+            .assert()
+            .success()
+            .stdout(
+                "┌────────┬─────────────────────┬─────────────────────┬────────┬────────┐\n\
+                 │00000000│ 6162 63             ┊                     │abc     ┊        │\n\
+                 └────────┴─────────────────────┴─────────────────────┴────────┴────────┘\n",
+            );
+    }
+
+    #[test]
+    fn group_size_invalid() {
+        hexyl()
+            .arg("ascii")
+            .arg("--color=never")
+            .arg("--plain")
+            .arg("--group-size=3")
+            .assert()
+            .failure();
+    }
+    #[test]
+    fn squeeze_no_chars() {
+        hexyl()
+            .arg("hello_world_elf64")
+            .arg("--color=never")
+            .arg("--skip=1024")
+            .arg("--length=4096")
+            .arg("--no-characters")
+            .assert()
+            .success()
+            .pretty_stdout(
+                "\
+┌────────┬─────────────────────────┬─────────────────────────┐
+│00000400│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │
+│*       │                         ┊                         │
+│00001000│ ba 0e 00 00 00 b9 00 20 ┊ 40 00 bb 01 00 00 00 b8 │
+│00001010│ 04 00 00 00 cd 80 b8 01 ┊ 00 00 00 cd 80 00 00 00 │
+│00001020│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │
+│*       │                         ┊                         │
+│00001400│                         ┊                         │
+└────────┴─────────────────────────┴─────────────────────────┘
+",
+            );
+    }
+    #[test]
+    fn squeeze_no_chars_one_panel() {
+        hexyl()
+            .arg("hello_world_elf64")
+            .arg("--color=never")
+            .arg("--skip=1024")
+            .arg("--length=4096")
+            .arg("--no-characters")
+            .arg("--panels=1")
+            .assert()
+            .success()
+            .pretty_stdout(
+                "\
+┌────────┬─────────────────────────┐
+│00000400│ 00 00 00 00 00 00 00 00 │
+│*       │                         │
+│00001000│ ba 0e 00 00 00 b9 00 20 │
+│00001008│ 40 00 bb 01 00 00 00 b8 │
+│00001010│ 04 00 00 00 cd 80 b8 01 │
+│00001018│ 00 00 00 cd 80 00 00 00 │
+│00001020│ 00 00 00 00 00 00 00 00 │
+│*       │                         │
+│00001400│                         │
+└────────┴─────────────────────────┘
+",
+            );
+    }
+    #[test]
+    fn squeeze_no_position() {
+        hexyl()
+            .arg("hello_world_elf64")
+            .arg("--color=never")
+            .arg("--skip=1024")
+            .arg("--length=4096")
+            .arg("--no-position")
+            .assert()
+            .success()
+            .pretty_stdout(
+                "\
+┌─────────────────────────┬─────────────────────────┬────────┬────────┐
+│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄│
+│*                        ┊                         │        ┊        │
+│ ba 0e 00 00 00 b9 00 20 ┊ 40 00 bb 01 00 00 00 b8 │ו⋄⋄⋄×⋄ ┊@⋄ו⋄⋄⋄×│
+│ 04 00 00 00 cd 80 b8 01 ┊ 00 00 00 cd 80 00 00 00 │•⋄⋄⋄××ו┊⋄⋄⋄××⋄⋄⋄│
+│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄│
+│*                        ┊                         │        ┊        │
+│*                        ┊                         │        ┊        │
+└─────────────────────────┴─────────────────────────┴────────┴────────┘
+",
+            );
+    }
+    #[test]
+    fn squeeze_no_position_one_panel() {
+        hexyl()
+            .arg("hello_world_elf64")
+            .arg("--color=never")
+            .arg("--skip=1024")
+            .arg("--length=4096")
+            .arg("--no-position")
+            .arg("--panels=1")
+            .assert()
+            .success()
+            .pretty_stdout(
+                "\
+┌─────────────────────────┬────────┐
+│ 00 00 00 00 00 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄│
+│*                        │        │
+│ ba 0e 00 00 00 b9 00 20 │ו⋄⋄⋄×⋄ │
+│ 40 00 bb 01 00 00 00 b8 │@⋄ו⋄⋄⋄×│
+│ 04 00 00 00 cd 80 b8 01 │•⋄⋄⋄××ו│
+│ 00 00 00 cd 80 00 00 00 │⋄⋄⋄××⋄⋄⋄│
+│ 00 00 00 00 00 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄│
+│*                        │        │
+│*                        │        │
+└─────────────────────────┴────────┘
+",
+            );
+    }
+    #[test]
+    fn squeeze_odd_panels_remainder_bytes() {
+        hexyl()
+            .arg("hello_world_elf64")
+            .arg("--color=never")
+            .arg("--skip=1024")
+            .arg("--length=4092") // 4 byte remainder
+            .arg("--panels=3")
+            .assert()
+            .success()
+            .pretty_stdout(
+                "\
+┌────────┬─────────────────────────┬─────────────────────────┬─────────────────────────┬────────┬────────┬────────┐
+│00000400│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄│
+│*       │                         ┊                         ┊                         │        ┊        ┊        │
+│00001000│ ba 0e 00 00 00 b9 00 20 ┊ 40 00 bb 01 00 00 00 b8 ┊ 04 00 00 00 cd 80 b8 01 │ו⋄⋄⋄×⋄ ┊@⋄ו⋄⋄⋄×┊•⋄⋄⋄××ו│
+│00001018│ 00 00 00 cd 80 00 00 00 ┊ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │⋄⋄⋄××⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄│
+│00001030│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄│
+│*       │                         ┊                         ┊                         │        ┊        ┊        │
+│000013f0│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00             ┊                         │⋄⋄⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄    ┊        │
+└────────┴─────────────────────────┴─────────────────────────┴─────────────────────────┴────────┴────────┴────────┘
+",
+            );
+    }
+
+    #[test]
+    fn squeeze_plain() {
+        hexyl()
+            .arg("hello_world_elf64")
+            .arg("--color=never")
+            .arg("--skip=1024")
+            .arg("--length=4096")
+            .arg("--plain")
+            .assert()
+            .success()
+            .pretty_stdout(
+                "  \
+  00 00 00 00 00 00 00 00   00 00 00 00 00 00 00 00  
+ *                                                   
+  ba 0e 00 00 00 b9 00 20   40 00 bb 01 00 00 00 b8  
+  04 00 00 00 cd 80 b8 01   00 00 00 cd 80 00 00 00  
+  00 00 00 00 00 00 00 00   00 00 00 00 00 00 00 00  
+ *                                                   
+ *                                                   
+",
+            );
+    }
+
+    #[test]
+    fn squeeze_plain_remainder() {
+        hexyl()
+            .arg("hello_world_elf64")
+            .arg("--color=never")
+            .arg("--skip=1024")
+            .arg("--length=4092") // 4 byte remainder
+            .arg("--plain")
+            .assert()
+            .success()
+            .pretty_stdout(
+                "  \
+  00 00 00 00 00 00 00 00   00 00 00 00 00 00 00 00  
+ *                                                   
+  ba 0e 00 00 00 b9 00 20   40 00 bb 01 00 00 00 b8  
+  04 00 00 00 cd 80 b8 01   00 00 00 cd 80 00 00 00  
+  00 00 00 00 00 00 00 00   00 00 00 00 00 00 00 00  
+ *                                                   
+  00 00 00 00 00 00 00 00   00 00 00 00              
+",
+            );
+    }
+}
+
+mod base {
+    use super::hexyl;
+    use super::PrettyAssert;
+
+    #[test]
+    fn base2() {
+        hexyl()
+            .arg("ascii")
+            .arg("--plain")
+            .arg("--base=binary")
+            .assert()
+            .success()
+            .pretty_stdout(
+                "  00110000 00110001 00110010 00110011 00110100 00110101 00110110 00110111  \n  \
+                   00111000 00111001 01100001 01100010 01100011 01100100 01100101 00001010  \n",
+            );
+    }
+}