Publish binary from main (#163 )

fuzzing.yml: Avoid non reusable cache generation (#170 )
cmp: fix 32-bit usize overflow in test (#173 )
2026-06-10 15:48:59 -07:00 · 2026-03-07 22:04:19 +01:00 · 2026-03-07 18:39:56 +01:00 · 2026-03-07 18:35:57 +01:00 · 2026-03-07 15:12:18 +01:00 · 2026-03-07 14:55:10 +01:00
36 changed files with 8203 additions and 430 deletions
@@ -4,28 +4,38 @@ name: Basic CI

 env:
  CARGO_TERM_COLOR: always
+  CARGO_INCREMENTAL: 0

 jobs:
  check:
    name: cargo check
    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
      - run: cargo check

  test:
    name: cargo test
    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
+      - name: install GNU patch on MacOS
+        if: runner.os == 'macOS'
+        run: |
+          brew install gpatch
+          echo "/opt/homebrew/opt/gpatch/libexec/gnubin" >> "$GITHUB_PATH"
+      - name: set up PATH on Windows
+        # Needed to use GNU's patch.exe instead of Strawberry Perl patch
+        if: runner.os == 'Windows'
+        run: echo "C:\Program Files\Git\usr\bin" >> $env:GITHUB_PATH
      - run: cargo test

  fmt:
@@ -33,27 +43,55 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-      - run: rustup component add rustfmt
      - run: cargo fmt --all -- --check

  clippy:
    name: cargo clippy -- -D warnings
    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
-      - run: rustup component add clippy
      - run: cargo clippy -- -D warnings

+  gnu-testsuite:
+    permissions:
+      contents: write # Publish diffutils instead of discarding
+    name: GNU test suite
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: |
+          cargo build --config=profile.release.strip=true --profile=release #-fast
+          zstd -19 target/release/diffutils -o diffutils-x86_64-unknown-linux-gnu.zst
+      # do not fail, the report is merely informative (at least until all tests pass reliably)
+      - run: ./tests/run-upstream-testsuite.sh release || true
+        env:
+          TERM: xterm
+      - uses: actions/upload-artifact@v4
+        with:
+          name: test-results.json
+          path: tests/test-results.json
+      - run: ./tests/print-test-results.sh tests/test-results.json
+      - name: Publish latest commit
+        uses: softprops/action-gh-release@v2
+        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+        with:
+          tag_name: latest-commit
+          draft: false
+          prerelease: true
+          files: |
+            diffutils-x86_64-unknown-linux-gnu.zst
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
  coverage:
    name: Code Coverage
    runs-on: ${{ matrix.job.os }}
    strategy:
-      fail-fast: true
+      fail-fast: false
      matrix:
        job:
          - { os: ubuntu-latest  , features: unix }
@@ -62,35 +100,42 @@ jobs:
    steps:
    - uses: actions/checkout@v4
    - name: Initialize workflow variables
+      env:
+        # Use -Z
+        RUSTC_BOOTSTRAP: 1
      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; }
-        # 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
-        case ${{ matrix.job.os }} in windows-*) TOOLCHAIN="$TOOLCHAIN-x86_64-pc-windows-gnu" ;; esac;
-        # * use requested TOOLCHAIN if specified
-        if [ -n "${{ matrix.job.toolchain }}" ]; then TOOLCHAIN="${{ matrix.job.toolchain }}" ; fi
-        outputs TOOLCHAIN
        # target-specific options
-        # * CARGO_FEATURES_OPTION
-        CARGO_FEATURES_OPTION='--all -- --check' ;  ## default to '--all-features' for code coverage
        # * CODECOV_FLAGS
        CODECOV_FLAGS=$( echo "${{ matrix.job.os }}" | sed 's/[^[:alnum:]]/_/g' )
        outputs CODECOV_FLAGS

-    - name: rust toolchain ~ install
-      uses: dtolnay/rust-toolchain@nightly
+    - name: install GNU patch on MacOS
+      if: runner.os == 'macOS'
+      run: |
+        brew install gpatch
+        echo "/opt/homebrew/opt/gpatch/libexec/gnubin" >> "$GITHUB_PATH"
+    - name: set up PATH on Windows
+      # Needed to use GNU's patch.exe instead of Strawberry Perl patch
+      if: runner.os == 'Windows'
+      run: echo "C:\Program Files\Git\usr\bin" >> $env:GITHUB_PATH
    - name: Test
-      run: cargo test ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} --no-fail-fast
+      run: cargo test --all-features --no-fail-fast
      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"
+        RUSTFLAGS: "-Cinstrument-coverage -Zcoverage-options=branch -Ccodegen-units=1 -Copt-level=0 -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
        RUSTDOCFLAGS: "-Cpanic=abort"
+        LLVM_PROFILE_FILE: "diffutils-%p-%m.profraw"
+        # Use -Z
+        RUSTC_BOOTSTRAP: 1
    - name: "`grcov` ~ install"
+      env:
+        # Use -Z
+        RUSTC_BOOTSTRAP: 1
      id: build_grcov
      shell: bash
      run: |
@@ -117,16 +162,15 @@ jobs:
        COVERAGE_REPORT_FILE="${COVERAGE_REPORT_DIR}/lcov.info"
        mkdir -p "${COVERAGE_REPORT_DIR}"
        # display coverage files
-        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 --binary-path "${COVERAGE_REPORT_DIR}" | sort --unique
        # generate coverage report
-        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}" --binary-path "${COVERAGE_REPORT_DIR}" --branch
        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@v5
      with:
-        # token: ${{ secrets.CODECOV_TOKEN }}
-        file: ${{ steps.coverage.outputs.report }}
+        token: ${{ secrets.CODECOV_TOKEN }}
+        files: ${{ steps.coverage.outputs.report }}
        ## flags: IntegrationTests, UnitTests, ${{ steps.vars.outputs.CODECOV_FLAGS }}
        flags: ${{ steps.vars.outputs.CODECOV_FLAGS }}
        name: codecov-umbrella
@@ -0,0 +1,37 @@
+name: CodSpeed
+
+on:
+  push:
+    branches:
+      - "main"
+  pull_request:
+  # `workflow_dispatch` allows CodSpeed to trigger backtest
+  # performance analysis in order to generate initial data.
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  codspeed:
+    name: Run benchmarks
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup rust toolchain, cache and cargo-codspeed binary
+        uses: moonrepo/setup-rust@v0
+        with:
+          channel: stable
+          cache-target: release
+          bins: cargo-codspeed
+
+      - name: Build the benchmark target(s)
+        run: cargo codspeed build -m simulation
+
+      - name: Run the benchmarks
+        uses: CodSpeedHQ/action@v4
+        with:
+          mode: simulation
+          run: cargo codspeed run
@@ -0,0 +1,79 @@
+name: Fuzzing
+
+# spell-checker:ignore fuzzer
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: read
+
+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
+      - name: Install `cargo-fuzz`
+        run: |
+          echo "RUSTC_BOOTSTRAP=1" >> "${GITHUB_ENV}"
+          echo "CARGO_INCREMENTAL=0" >> "${GITHUB_ENV}"
+          cargo install cargo-fuzz --locked
+      - uses: Swatinem/rust-cache@v2
+        with:
+          shared-key: "cargo-fuzz-cache-key"
+          cache-directories: "fuzz/target"
+      - name: Run `cargo-fuzz build`
+        run: cargo 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_cmp, should_pass: true }
+          - { name: fuzz_cmp_args, should_pass: true }
+          - { name: fuzz_ed, should_pass: true }
+          - { name: fuzz_normal, should_pass: true }
+          - { name: fuzz_patch, should_pass: true }
+          - { name: fuzz_side, should_pass: true }
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install `cargo-fuzz`
+        run: |
+          echo "RUSTC_BOOTSTRAP=1" >> "${GITHUB_ENV}"
+          echo "CARGO_INCREMENTAL=0" >> "${GITHUB_ENV}"
+          cargo install cargo-fuzz --locked
+      - uses: Swatinem/rust-cache@v2
+        with:
+          shared-key: "cargo-fuzz-cache-key"
+          cache-directories: "fuzz/target"
+      - name: Restore Cached Corpus
+        uses: actions/cache/restore@v5
+        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 fuzz run ${{ matrix.test-target.name }} -- -max_total_time=${{ env.RUN_FOR }} -detect_leaks=0
+      - name: Save Corpus Cache
+        uses: actions/cache/save@v5
+        with:
+          key: corpus-cache-${{ matrix.test-target.name }}
+          path: |
+            fuzz/corpus/${{ matrix.test-target.name }}
@@ -0,0 +1,296 @@
+# This file was autogenerated by dist: https://axodotdev.github.io/cargo-dist
+#
+# Copyright 2022-2024, axodotdev
+# SPDX-License-Identifier: MIT or Apache-2.0
+#
+# CI that:
+#
+# * checks for a Git Tag that looks like a release
+# * builds artifacts with dist (archives, installers, hashes)
+# * uploads those artifacts to temporary workflow zip
+# * on success, uploads the artifacts to a GitHub Release
+#
+# Note that the GitHub Release will be created with a generated
+# title/body based on your changelogs.
+
+name: Release
+permissions:
+  "contents": "write"
+
+# This task will run whenever you push a git tag that looks like a version
+# like "1.0.0", "v0.1.0-prerelease.1", "my-app/0.1.0", "releases/v1.0.0", etc.
+# Various formats will be parsed into a VERSION and an optional PACKAGE_NAME, where
+# PACKAGE_NAME must be the name of a Cargo package in your workspace, and VERSION
+# must be a Cargo-style SemVer Version (must have at least major.minor.patch).
+#
+# If PACKAGE_NAME is specified, then the announcement will be for that
+# package (erroring out if it doesn't have the given version or isn't dist-able).
+#
+# If PACKAGE_NAME isn't specified, then the announcement will be for all
+# (dist-able) packages in the workspace with that version (this mode is
+# intended for workspaces with only one dist-able package, or with all dist-able
+# packages versioned/released in lockstep).
+#
+# If you push multiple tags at once, separate instances of this workflow will
+# spin up, creating an independent announcement for each one. However, GitHub
+# will hard limit this to 3 tags per commit, as it will assume more tags is a
+# mistake.
+#
+# If there's a prerelease-style suffix to the version, then the release(s)
+# will be marked as a prerelease.
+on:
+  pull_request:
+  push:
+    tags:
+      - '**[0-9]+.[0-9]+.[0-9]+*'
+
+jobs:
+  # Run 'dist plan' (or host) to determine what tasks we need to do
+  plan:
+    runs-on: "ubuntu-22.04"
+    outputs:
+      val: ${{ steps.plan.outputs.manifest }}
+      tag: ${{ !github.event.pull_request && github.ref_name || '' }}
+      tag-flag: ${{ !github.event.pull_request && format('--tag={0}', github.ref_name) || '' }}
+      publishing: ${{ !github.event.pull_request }}
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+          submodules: recursive
+      - name: Install dist
+        # we specify bash to get pipefail; it guards against the `curl` command
+        # failing. otherwise `sh` won't catch that `curl` returned non-0
+        shell: bash
+        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.30.3/cargo-dist-installer.sh | sh"
+      - name: Cache dist
+        uses: actions/upload-artifact@v4
+        with:
+          name: cargo-dist-cache
+          path: ~/.cargo/bin/dist
+      # sure would be cool if github gave us proper conditionals...
+      # so here's a doubly-nested ternary-via-truthiness to try to provide the best possible
+      # functionality based on whether this is a pull_request, and whether it's from a fork.
+      # (PRs run on the *source* but secrets are usually on the *target* -- that's *good*
+      # but also really annoying to build CI around when it needs secrets to work right.)
+      - id: plan
+        run: |
+          dist ${{ (!github.event.pull_request && format('host --steps=create --tag={0}', github.ref_name)) || 'plan' }} --output-format=json > plan-dist-manifest.json
+          echo "dist ran successfully"
+          cat plan-dist-manifest.json
+          echo "manifest=$(jq -c "." plan-dist-manifest.json)" >> "$GITHUB_OUTPUT"
+      - name: "Upload dist-manifest.json"
+        uses: actions/upload-artifact@v4
+        with:
+          name: artifacts-plan-dist-manifest
+          path: plan-dist-manifest.json
+
+  # Build and packages all the platform-specific things
+  build-local-artifacts:
+    name: build-local-artifacts (${{ join(matrix.targets, ', ') }})
+    # Let the initial task tell us to not run (currently very blunt)
+    needs:
+      - plan
+    if: ${{ fromJson(needs.plan.outputs.val).ci.github.artifacts_matrix.include != null && (needs.plan.outputs.publishing == 'true' || fromJson(needs.plan.outputs.val).ci.github.pr_run_mode == 'upload') }}
+    strategy:
+      fail-fast: false
+      # Target platforms/runners are computed by dist in create-release.
+      # Each member of the matrix has the following arguments:
+      #
+      # - runner: the github runner
+      # - dist-args: cli flags to pass to dist
+      # - install-dist: expression to run to install dist on the runner
+      #
+      # Typically there will be:
+      # - 1 "global" task that builds universal installers
+      # - N "local" tasks that build each platform's binaries and platform-specific installers
+      matrix: ${{ fromJson(needs.plan.outputs.val).ci.github.artifacts_matrix }}
+    runs-on: ${{ matrix.runner }}
+    container: ${{ matrix.container && matrix.container.image || null }}
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      BUILD_MANIFEST_NAME: target/distrib/${{ join(matrix.targets, '-') }}-dist-manifest.json
+    steps:
+      - name: enable windows longpaths
+        run: |
+          git config --global core.longpaths true
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+          submodules: recursive
+      - name: Install Rust non-interactively if not already installed
+        if: ${{ matrix.container }}
+        run: |
+          if ! command -v cargo > /dev/null 2>&1; then
+            curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+            echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+          fi
+      - name: Install dist
+        run: ${{ matrix.install_dist.run }}
+      # Get the dist-manifest
+      - name: Fetch local artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: artifacts-*
+          path: target/distrib/
+          merge-multiple: true
+      - name: Install dependencies
+        run: |
+          ${{ matrix.packages_install }}
+      - name: Build artifacts
+        run: |
+          # Actually do builds and make zips and whatnot
+          dist build ${{ needs.plan.outputs.tag-flag }} --print=linkage --output-format=json ${{ matrix.dist_args }} > dist-manifest.json
+          echo "dist ran successfully"
+      - id: cargo-dist
+        name: Post-build
+        # We force bash here just because github makes it really hard to get values up
+        # to "real" actions without writing to env-vars, and writing to env-vars has
+        # inconsistent syntax between shell and powershell.
+        shell: bash
+        run: |
+          # Parse out what we just built and upload it to scratch storage
+          echo "paths<<EOF" >> "$GITHUB_OUTPUT"
+          dist print-upload-files-from-manifest --manifest dist-manifest.json >> "$GITHUB_OUTPUT"
+          echo "EOF" >> "$GITHUB_OUTPUT"
+
+          cp dist-manifest.json "$BUILD_MANIFEST_NAME"
+      - name: "Upload artifacts"
+        uses: actions/upload-artifact@v4
+        with:
+          name: artifacts-build-local-${{ join(matrix.targets, '_') }}
+          path: |
+            ${{ steps.cargo-dist.outputs.paths }}
+            ${{ env.BUILD_MANIFEST_NAME }}
+
+  # Build and package all the platform-agnostic(ish) things
+  build-global-artifacts:
+    needs:
+      - plan
+      - build-local-artifacts
+    runs-on: "ubuntu-22.04"
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      BUILD_MANIFEST_NAME: target/distrib/global-dist-manifest.json
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+          submodules: recursive
+      - name: Install cached dist
+        uses: actions/download-artifact@v4
+        with:
+          name: cargo-dist-cache
+          path: ~/.cargo/bin/
+      - run: chmod +x ~/.cargo/bin/dist
+      # Get all the local artifacts for the global tasks to use (for e.g. checksums)
+      - name: Fetch local artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: artifacts-*
+          path: target/distrib/
+          merge-multiple: true
+      - id: cargo-dist
+        shell: bash
+        run: |
+          dist build ${{ needs.plan.outputs.tag-flag }} --output-format=json "--artifacts=global" > dist-manifest.json
+          echo "dist ran successfully"
+
+          # Parse out what we just built and upload it to scratch storage
+          echo "paths<<EOF" >> "$GITHUB_OUTPUT"
+          jq --raw-output ".upload_files[]" dist-manifest.json >> "$GITHUB_OUTPUT"
+          echo "EOF" >> "$GITHUB_OUTPUT"
+
+          cp dist-manifest.json "$BUILD_MANIFEST_NAME"
+      - name: "Upload artifacts"
+        uses: actions/upload-artifact@v4
+        with:
+          name: artifacts-build-global
+          path: |
+            ${{ steps.cargo-dist.outputs.paths }}
+            ${{ env.BUILD_MANIFEST_NAME }}
+  # Determines if we should publish/announce
+  host:
+    needs:
+      - plan
+      - build-local-artifacts
+      - build-global-artifacts
+    # Only run if we're "publishing", and only if plan, local and global didn't fail (skipped is fine)
+    if: ${{ always() && needs.plan.result == 'success' && needs.plan.outputs.publishing == 'true' && (needs.build-global-artifacts.result == 'skipped' || needs.build-global-artifacts.result == 'success') && (needs.build-local-artifacts.result == 'skipped' || needs.build-local-artifacts.result == 'success') }}
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    runs-on: "ubuntu-22.04"
+    outputs:
+      val: ${{ steps.host.outputs.manifest }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+          submodules: recursive
+      - name: Install cached dist
+        uses: actions/download-artifact@v4
+        with:
+          name: cargo-dist-cache
+          path: ~/.cargo/bin/
+      - run: chmod +x ~/.cargo/bin/dist
+      # Fetch artifacts from scratch-storage
+      - name: Fetch artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: artifacts-*
+          path: target/distrib/
+          merge-multiple: true
+      - id: host
+        shell: bash
+        run: |
+          dist host ${{ needs.plan.outputs.tag-flag }} --steps=upload --steps=release --output-format=json > dist-manifest.json
+          echo "artifacts uploaded and released successfully"
+          cat dist-manifest.json
+          echo "manifest=$(jq -c "." dist-manifest.json)" >> "$GITHUB_OUTPUT"
+      - name: "Upload dist-manifest.json"
+        uses: actions/upload-artifact@v4
+        with:
+          # Overwrite the previous copy
+          name: artifacts-dist-manifest
+          path: dist-manifest.json
+      # Create a GitHub Release while uploading all files to it
+      - name: "Download GitHub Artifacts"
+        uses: actions/download-artifact@v4
+        with:
+          pattern: artifacts-*
+          path: artifacts
+          merge-multiple: true
+      - name: Cleanup
+        run: |
+          # Remove the granular manifests
+          rm -f artifacts/*-dist-manifest.json
+      - name: Create GitHub Release
+        env:
+          PRERELEASE_FLAG: "${{ fromJson(steps.host.outputs.manifest).announcement_is_prerelease && '--prerelease' || '' }}"
+          ANNOUNCEMENT_TITLE: "${{ fromJson(steps.host.outputs.manifest).announcement_title }}"
+          ANNOUNCEMENT_BODY: "${{ fromJson(steps.host.outputs.manifest).announcement_github_body }}"
+          RELEASE_COMMIT: "${{ github.sha }}"
+        run: |
+          # Write and read notes from a file to avoid quoting breaking things
+          echo "$ANNOUNCEMENT_BODY" > $RUNNER_TEMP/notes.txt
+
+          gh release create "${{ needs.plan.outputs.tag }}" --target "$RELEASE_COMMIT" $PRERELEASE_FLAG --title "$ANNOUNCEMENT_TITLE" --notes-file "$RUNNER_TEMP/notes.txt" artifacts/*
+
+  announce:
+    needs:
+      - plan
+      - host
+    # use "always() && ..." to allow us to wait for all publish jobs while
+    # still allowing individual publish jobs to skip themselves (for prereleases).
+    # "host" however must run to completion, no skipping allowed!
+    if: ${{ always() && needs.host.result == 'success' }}
+    runs-on: "ubuntu-22.04"
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+          submodules: recursive
@@ -1,6 +1,6 @@
 [package]
 name = "diffutils"
-version = "0.3.0"
+version = "0.5.0"
 edition = "2021"
 description = "A CLI app for generating diff files"
 license = "MIT OR Apache-2.0"
@@ -15,7 +15,42 @@ name = "diffutils"
 path = "src/main.rs"

 [dependencies]
-diff = "0.1.10"
+chrono = "0.4.38"
+diff = "0.1.13"
+itoa = "1.0.11"
+regex = "1.10.4"
+same-file = "1.0.6"
+unicode-width = "0.2.0"

 [dev-dependencies]
-pretty_assertions = "1"
+assert_cmd = "2.0.14"
+divan = { version = "4.3.0", package = "codspeed-divan-compat" }
+pretty_assertions = "1.4.0"
+predicates = "3.1.0"
+rand = "0.10.0"
+tempfile = "3.26.0"
+
+[profile.release]
+lto = "thin"
+codegen-units = 1
+
+[profile.release-fast]
+inherits = "release"
+panic = "abort"
+
+# The profile that 'dist' will build with
+[profile.dist]
+inherits = "release"
+lto = "thin"
+
+[[bench]]
+name = "bench_diffutils"
+path = "benches/bench-diffutils.rs"
+harness = false
+
+[features]
+# default = ["feat_bench_not_diff"]
+# Turn bench for diffutils cmp off
+feat_bench_not_cmp = []
+# Turn bench for diffutils diff off
+feat_bench_not_diff = []
@@ -1,3 +1,6 @@
+Copyright (c) Michael Howell
+Copyright (c) uutils developers
+
                              Apache License
                        Version 2.0, January 2004
                     http://www.apache.org/licenses/
@@ -1,3 +1,6 @@
+Copyright (c) Michael Howell
+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 the
@@ -1,58 +1,57 @@
-The goal of this package is to be a dropped in replacement for the [diffutils commands](https://www.gnu.org/software/diffutils/) in Rust.
+[![Crates.io](https://img.shields.io/crates/v/diffutils.svg)](https://crates.io/crates/diffutils)
+[![Discord](https://img.shields.io/badge/discord-join-7289DA.svg?logo=discord&longCache=true&style=flat)](https://discord.gg/wQVJbvJ)
+[![License](http://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/uutils/diffutils/blob/main/LICENSE)
+[![dependency status](https://deps.rs/repo/github/uutils/diffutils/status.svg)](https://deps.rs/repo/github/uutils/diffutils)
+[![CodSpeed](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/uutils/diffutils?utm_source=badge)

+[![CodeCov](https://codecov.io/gh/uutils/diffutils/branch/main/graph/badge.svg)](https://codecov.io/gh/uutils/diffutils)
+
+The goal of this package is to be a drop-in replacement for the [diffutils commands](https://www.gnu.org/software/diffutils/) (diff, cmp, diff3, sdiff) in Rust.

 Based on the incomplete diff generator in https://github.com/rust-lang/rust/blob/master/src/tools/compiletest/src/runtest.rs, and made to be compatible with GNU's diff and patch tools.

+
+## Installation
+
+Ensure you have Rust installed on your system. You can install Rust through [rustup](https://rustup.rs/).
+
+Clone the repository and build the project using Cargo:
+
+```bash
+git clone https://github.com/uutils/diffutils.git
+cd diffutils
+cargo build --release
 ```
-~/diffutils$ cargo run -- diff -u3 Cargo.lock Cargo.toml
+
+## Example
+
+```bash
+
+cat <<EOF >fruits_old.txt
+Apple
+Banana
+Cherry
+EOF
+
+cat <<EOF >fruits_new.txt
+Apple
+Fig
+Cherry
+EOF
+
+$ cargo run -- -u fruits_old.txt fruits_new.txt
    Finished dev [unoptimized + debuginfo] target(s) in 0.00s
-     Running `target/debug/diff -u3 Cargo.lock Cargo.toml`
--- Cargo.lock
-+++ Cargo.toml
-@@ -1,39 +1,7 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "context-diff"
-version = "0.1.0"
-dependencies = [
- "diff 0.1.12",
-]
-
-[[package]]
-name = "diff"
-version = "0.1.0"
-dependencies = [
- "context-diff",
- "normal-diff",
- "unified-diff",
-]
-
-[[package]]
-name = "diff"
-version = "0.1.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e25ea47919b1560c4e3b7fe0aaab9becf5b84a10325ddf7db0f0ba5e1026499"
-
-[[package]]
-name = "normal-diff"
-version = "0.1.0"
-dependencies = [
- "diff 0.1.12",
-]
-
-[[package]]
-name = "unified-diff"
-version = "0.3.0"
-dependencies = [
- "diff 0.1.12",
-+[workspace]
-+members = [
-+    "lib/unified-diff",
-+    "lib/context-diff",
-+    "lib/normal-diff",
-+    "bin/diff",
- ]
+     Running `target/debug/diffutils -u fruits_old.txt fruits_new.txt`
+--- fruits_old.txt
+++ fruits_new.txt
+@@ -1,3 +1,3 @@
+ Apple
+-Banana
+Fig
+ Cherry
+
 ```
+
+## License
+
+diffutils is licensed under the MIT and Apache Licenses - see the `LICENSE-MIT` or `LICENSE-APACHE` files for details
@@ -0,0 +1,377 @@
+// This file is part of the uutils diffutils package.
+//
+// For the full copyright and license information, please view the LICENSE-*
+// files that was distributed with this source code.
+
+//! Benches for all utils in diffutils.
+//!
+//! There is a file generator included to create files of different sizes for comparison. \
+//! Set the TEMP_DIR const to keep the files. df_to_ files have small changes in them, search for '#'. \
+//! File generation up to 1 GB is really fast, Benchmarking above 100 MB takes very long.
+
+/// Generate test files with these sizes in KB.
+const FILE_SIZE_KILO_BYTES: [u64; 4] = [100, 1 * MB, 10 * MB, 25 * MB];
+// const FILE_SIZE_KILO_BYTES: [u64; 3] = [100, 1 * MB, 5 * MB];
+// Empty String to use TempDir (files will be removed after test) or specify dir to keep generated files
+const TEMP_DIR: &str = "";
+const NUM_DIFF: u64 = 4;
+// just for FILE_SIZE_KILO_BYTES
+const MB: u64 = 1_000;
+const CHANGE_CHAR: u8 = b'#';
+
+#[cfg(not(feature = "feat_bench_not_cmp"))]
+mod diffutils_cmp {
+    use std::hint::black_box;
+
+    use diffutilslib::cmp;
+    use divan::Bencher;
+
+    use crate::{binary, prepare::*, FILE_SIZE_KILO_BYTES};
+
+    #[divan::bench(args = FILE_SIZE_KILO_BYTES)]
+    fn cmp_compare_files_equal(bencher: Bencher, kb: u64) {
+        let (from, to) = get_context().get_test_files_equal(kb);
+        let cmd = format!("cmp {from} {to}");
+        let opts = str_to_options(&cmd).into_iter().peekable();
+        let params = cmp::parse_params(opts).unwrap();
+
+        bencher
+            // .with_inputs(|| prepare::cmp_params_identical_testfiles(lines))
+            .with_inputs(|| params.clone())
+            .bench_refs(|params| black_box(cmp::cmp(&params).unwrap()));
+    }
+
+    // bench the actual compare; cmp exits on first difference
+    #[divan::bench(args = FILE_SIZE_KILO_BYTES)]
+    fn cmp_compare_files_different(bencher: Bencher, bytes: u64) {
+        let (from, to) = get_context().get_test_files_different(bytes);
+        let cmd = format!("cmp {from} {to} -s");
+        let opts = str_to_options(&cmd).into_iter().peekable();
+        let params = cmp::parse_params(opts).unwrap();
+
+        bencher
+            // .with_inputs(|| prepare::cmp_params_identical_testfiles(lines))
+            .with_inputs(|| params.clone())
+            .bench_refs(|params| black_box(cmp::cmp(&params).unwrap()));
+    }
+
+    // bench original GNU cmp
+    #[divan::bench(args = FILE_SIZE_KILO_BYTES)]
+    fn cmd_cmp_gnu_equal(bencher: Bencher, bytes: u64) {
+        let (from, to) = get_context().get_test_files_equal(bytes);
+        let args_str = format!("{from} {to}");
+        bencher
+            // .with_inputs(|| prepare::cmp_params_identical_testfiles(lines))
+            .with_inputs(|| args_str.clone())
+            .bench_refs(|cmd_args| binary::bench_binary("cmp", cmd_args));
+    }
+
+    // bench the compiled release version
+    #[divan::bench(args = FILE_SIZE_KILO_BYTES)]
+    fn cmd_cmp_release_equal(bencher: Bencher, bytes: u64) {
+        let (from, to) = get_context().get_test_files_equal(bytes);
+        let args_str = format!("cmp {from} {to}");
+
+        bencher
+            // .with_inputs(|| prepare::cmp_params_identical_testfiles(lines))
+            .with_inputs(|| args_str.clone())
+            .bench_refs(|cmd_args| binary::bench_binary("target/release/diffutils", cmd_args));
+    }
+}
+
+#[cfg(not(feature = "feat_bench_not_diff"))]
+mod diffutils_diff {
+    // use std::hint::black_box;
+
+    use crate::{binary, prepare::*, FILE_SIZE_KILO_BYTES};
+    // use diffutilslib::params;
+    use divan::Bencher;
+
+    // bench the actual compare
+    // TODO diff does not have a diff function
+    //     #[divan::bench(args = [100_000,10_000])]
+    //     fn diff_compare_files(bencher: Bencher, bytes: u64) {
+    //         let (from, to) = gen_testfiles(lines, 0, "id");
+    //         let cmd = format!("cmp {from} {to}");
+    //         let opts = str_to_options(&cmd).into_iter().peekable();
+    //         let params = params::parse_params(opts).unwrap();
+    //
+    //         bencher
+    //             // .with_inputs(|| prepare::cmp_params_identical_testfiles(lines))
+    //             .with_inputs(|| params.clone())
+    //             .bench_refs(|params| diff::diff(&params).unwrap());
+    //     }
+
+    // bench original GNU diff
+    #[divan::bench(args = FILE_SIZE_KILO_BYTES)]
+    fn cmd_diff_gnu_equal(bencher: Bencher, bytes: u64) {
+        let (from, to) = get_context().get_test_files_equal(bytes);
+        let args_str = format!("{from} {to}");
+        bencher
+            // .with_inputs(|| prepare::cmp_params_identical_testfiles(lines))
+            .with_inputs(|| args_str.clone())
+            .bench_refs(|cmd_args| binary::bench_binary("diff", cmd_args));
+    }
+
+    // bench the compiled release version
+    #[divan::bench(args = FILE_SIZE_KILO_BYTES)]
+    fn cmd_diff_release_equal(bencher: Bencher, bytes: u64) {
+        let (from, to) = get_context().get_test_files_equal(bytes);
+        let args_str = format!("diff {from} {to}");
+
+        bencher
+            // .with_inputs(|| prepare::cmp_params_identical_testfiles(lines))
+            .with_inputs(|| args_str.clone())
+            .bench_refs(|cmd_args| binary::bench_binary("target/release/diffutils", cmd_args));
+    }
+}
+
+mod parser {
+    use std::hint::black_box;
+
+    use diffutilslib::{cmp, params};
+    use divan::Bencher;
+
+    use crate::prepare::str_to_options;
+
+    // bench the time it takes to parse the command line arguments
+    #[divan::bench]
+    fn cmp_parser(bencher: Bencher) {
+        let cmd = "cmd file_1.txt file_2.txt -bl n10M --ignore-initial=100KiB:1MiB";
+        let args = str_to_options(&cmd).into_iter().peekable();
+        bencher
+            .with_inputs(|| args.clone())
+            .bench_values(|data| black_box(cmp::parse_params(data)));
+    }
+
+    // // test the impact on the benchmark if not converting the cmd to Vec<OsString> (doubles for parse)
+    // #[divan::bench]
+    // fn cmp_parser_no_prepare() {
+    //     let cmd = "cmd file_1.txt file_2.txt -bl n10M --ignore-initial=100KiB:1MiB";
+    //     let args = str_to_options(&cmd).into_iter().peekable();
+    //     let _ = cmp::parse_params(args);
+    // }
+
+    // bench the time it takes to parse the command line arguments
+    #[divan::bench]
+    fn diff_parser(bencher: Bencher) {
+        let cmd = "diff file_1.txt file_2.txt -s --brief --expand-tabs --width=100";
+        let args = str_to_options(&cmd).into_iter().peekable();
+        bencher
+            .with_inputs(|| args.clone())
+            .bench_values(|data| black_box(params::parse_params(data)));
+    }
+}
+
+mod prepare {
+    use std::{
+        ffi::OsString,
+        fs::{self, File},
+        io::{BufWriter, Write},
+        path::Path,
+        sync::OnceLock,
+    };
+
+    use rand::RngExt;
+    use tempfile::TempDir;
+
+    use crate::{CHANGE_CHAR, FILE_SIZE_KILO_BYTES, NUM_DIFF, TEMP_DIR};
+
+    // file lines and .txt will be added
+    const FROM_FILE: &str = "from_file";
+    const TO_FILE: &str = "to_file";
+    const LINE_LENGTH: usize = 60;
+
+    /// Contains test data (file names) which only needs to be created once.
+    #[derive(Debug, Default)]
+    pub struct BenchContext {
+        pub tmp_dir: Option<TempDir>,
+        pub dir: String,
+        pub files_equal: Vec<(String, String)>,
+        pub files_different: Vec<(String, String)>,
+    }
+
+    impl BenchContext {
+        pub fn get_path(&self) -> &Path {
+            match &self.tmp_dir {
+                Some(tmp) => tmp.path(),
+                None => Path::new(&self.dir),
+            }
+        }
+
+        pub fn get_test_files_equal(&self, kb: u64) -> &(String, String) {
+            let p = FILE_SIZE_KILO_BYTES.iter().position(|f| *f == kb).unwrap();
+            &self.files_equal[p]
+        }
+
+        #[allow(unused)]
+        pub fn get_test_files_different(&self, kb: u64) -> &(String, String) {
+            let p = FILE_SIZE_KILO_BYTES.iter().position(|f| *f == kb).unwrap();
+            &self.files_different[p]
+        }
+    }
+
+    // Since each bench function is separate in Divan it is more difficult to dynamically create test data.
+    // This keeps the TempDir alive until the program exits and generates the files only once.
+    static SHARED_CONTEXT: OnceLock<BenchContext> = OnceLock::new();
+    /// Creates the test files once and provides them to all tests.
+    pub fn get_context() -> &'static BenchContext {
+        SHARED_CONTEXT.get_or_init(|| {
+            let mut ctx = BenchContext::default();
+            if TEMP_DIR.is_empty() {
+                let tmp_dir = TempDir::new().expect("Failed to create temp dir");
+                ctx.tmp_dir = Some(tmp_dir);
+            } else {
+                // uses current directory, the generated files are kept
+                let path = Path::new(TEMP_DIR);
+                if !path.exists() {
+                    fs::create_dir_all(path).expect("Path {path} could not be created");
+                }
+                ctx.dir = TEMP_DIR.to_string();
+            };
+
+            // generate test bytes
+            for kb in FILE_SIZE_KILO_BYTES {
+                let f = generate_test_files_bytes(ctx.get_path(), kb * 1000, 0, "eq")
+                    .expect("generate_test_files failed");
+                ctx.files_equal.push(f);
+                let f = generate_test_files_bytes(ctx.get_path(), kb * 1000, NUM_DIFF, "df")
+                    .expect("generate_test_files failed");
+                ctx.files_different.push(f);
+            }
+
+            ctx
+        })
+    }
+
+    pub fn str_to_options(opt: &str) -> Vec<OsString> {
+        let s: Vec<OsString> = opt
+            .split(" ")
+            .into_iter()
+            .filter(|s| !s.is_empty())
+            .map(|s| OsString::from(s))
+            .collect();
+
+        s
+    }
+
+    /// Generates two test files for comparison with <bytes> size.
+    ///
+    /// Each line consists of 10 words with 5 letters, giving a line length of 60 bytes.
+    /// If num_differences is set, '#' will be inserted between the first two words of a line,
+    /// evenly spaced in the file. 1 will add the change in the last line, so the comparison takes longest.
+    fn generate_test_files_bytes(
+        dir: &Path,
+        bytes: u64,
+        num_differences: u64,
+        id: &str,
+    ) -> std::io::Result<(String, String)> {
+        let id = if id.is_empty() {
+            "".to_string()
+        } else {
+            format!("{id}_")
+        };
+        let f1 = format!("{id}{FROM_FILE}_{bytes}.txt");
+        let f2 = format!("{id}{TO_FILE}_{bytes}.txt");
+        let from_path = dir.join(f1);
+        let to_path = dir.join(f2);
+
+        generate_file_bytes(&from_path, &to_path, bytes, num_differences)?;
+
+        Ok((
+            from_path.to_string_lossy().to_string(),
+            to_path.to_string_lossy().to_string(),
+        ))
+    }
+
+    fn generate_file_bytes(
+        from_name: &Path,
+        to_name: &Path,
+        bytes: u64,
+        num_differences: u64,
+    ) -> std::io::Result<()> {
+        let file_from = File::create(from_name)?;
+        let file_to = File::create(to_name)?;
+        // for int division, lines will be smaller than requested bytes
+        let n_lines = bytes / LINE_LENGTH as u64;
+        let change_every_n_lines = if num_differences == 0 {
+            0
+        } else {
+            let c = n_lines / num_differences;
+            if c == 0 {
+                1
+            } else {
+                c
+            }
+        };
+        // Use a larger 128KB buffer for massive files
+        let mut writer_from = BufWriter::with_capacity(128 * 1024, file_from);
+        let mut writer_to = BufWriter::with_capacity(128 * 1024, file_to);
+        let mut rng = rand::rng();
+
+        // Each line: (5 chars * 10 words) + 9 spaces + 1 newline = 60 bytes
+        let mut line_buffer = [b' '; 60];
+        line_buffer[59] = b'\n'; // Set the newline once at the end
+
+        for i in (0..n_lines).rev() {
+            // Fill only the letter positions, skipping spaces and the newline
+            for word_idx in 0..10 {
+                let start = word_idx * 6; // Each word + space block is 6 bytes
+                for i in 0..5 {
+                    line_buffer[start + i] = rng.random_range(b'a'..b'z' + 1);
+                }
+            }
+
+            // Write the raw bytes directly to both files
+            writer_from.write_all(&line_buffer)?;
+            // make changes in the file
+            if num_differences == 0 {
+                writer_to.write_all(&line_buffer)?;
+            } else {
+                if i % change_every_n_lines == 0 && n_lines - i > 2 {
+                    line_buffer[5] = CHANGE_CHAR;
+                }
+                writer_to.write_all(&line_buffer)?;
+                line_buffer[5] = b' ';
+            }
+        }
+
+        // create last line
+        let missing = (bytes - n_lines as u64 * LINE_LENGTH as u64) as usize;
+        if missing > 0 {
+            for word_idx in 0..10 {
+                let start = word_idx * 6; // Each word + space block is 6 bytes
+                for i in 0..5 {
+                    line_buffer[start + i] = rng.random_range(b'a'..b'z' + 1);
+                }
+            }
+            line_buffer[missing - 1] = b'\n';
+            writer_from.write_all(&line_buffer[0..missing])?;
+            writer_to.write_all(&line_buffer[0..missing])?;
+        }
+
+        writer_from.flush()?;
+        writer_to.flush()?;
+
+        Ok(())
+    }
+}
+
+mod binary {
+    use std::process::Command;
+
+    use crate::prepare::str_to_options;
+
+    pub fn bench_binary(program: &str, cmd_args: &str) -> std::process::ExitStatus {
+        let args = str_to_options(cmd_args);
+        Command::new(program)
+            .args(args)
+            .status()
+            .expect("Failed to execute binary")
+    }
+}
+
+fn main() {
+    // Run registered benchmarks.
+    divan::main();
+}
@@ -0,0 +1,13 @@
+[workspace]
+members = ["cargo:."]
+
+# Config for 'dist'
+[dist]
+# The preferred dist version to use in CI (Cargo.toml SemVer syntax)
+cargo-dist-version = "0.30.3"
+# CI backends to support
+ci = "github"
+# The installers to generate for each app
+installers = []
+# Target platforms to build apps for (Rust target-triple syntax)
+targets = ["aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"]
@@ -0,0 +1,474 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "arbitrary"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "bumpalo"
+version = "3.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510"
+
+[[package]]
+name = "cc"
+version = "1.2.51"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a0aeaff4ff1a90589618835a598e545176939b97874f7abc7851caa0618f203"
+dependencies = [
+ "find-msvc-tools",
+ "jobserver",
+ "libc",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "chrono"
+version = "0.4.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2"
+dependencies = [
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "wasm-bindgen",
+ "windows-link",
+]
+
+[[package]]
+name = "const_format"
+version = "0.2.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7faa7469a93a566e9ccc1c73fe783b4a65c274c5ace346038dca9c39fe0030ad"
+dependencies = [
+ "const_format_proc_macros",
+]
+
+[[package]]
+name = "const_format_proc_macros"
+version = "0.2.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d57c2eccfb16dbac1f4e61e206105db5820c9d26c3c472bc17c774259ef7744"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "diff"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
+
+[[package]]
+name = "diffutils"
+version = "0.5.0"
+dependencies = [
+ "chrono",
+ "const_format",
+ "diff",
+ "itoa",
+ "regex",
+ "same-file",
+ "unicode-width",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "645cbb3a84e60b7531617d5ae4e57f7e27308f6445f5abf653209ea76dec8dff"
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasip2",
+]
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.64"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33e57f83510bb73707521ebaffa789ec8caf86f9657cad665b092b581d40e9fb"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+
+[[package]]
+name = "jobserver"
+version = "0.1.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
+dependencies = [
+ "getrandom",
+ "libc",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.83"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "464a3709c7f55f1f721e5389aa6ea4e3bc6aba669353300af094b29ffbdde1d8"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.178"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
+
+[[package]]
+name = "libfuzzer-sys"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f12a681b7dd8ce12bff52488013ba614b869148d54dd79836ab85aafdd53f08d"
+dependencies = [
+ "arbitrary",
+ "cc",
+]
+
+[[package]]
+name = "log"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+
+[[package]]
+name = "memchr"
+version = "2.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9695f8df41bb4f3d222c95a67532365f569318332d03d5f3f67f37b20e6ebdf0"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "regex"
+version = "1.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "syn"
+version = "2.0.112"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21f182278bf2d2bcb3c88b1b08a37df029d71ce3d3ae26168e3c653b213b99d4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+
+[[package]]
+name = "unicode-width"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "unified-diff-fuzz"
+version = "0.0.0"
+dependencies = [
+ "diffutils",
+ "libfuzzer-sys",
+]
+
+[[package]]
+name = "wasip2"
+version = "1.0.1+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d759f433fa64a2d763d1340820e46e111a7a5ab75f993d1852d70b03dbb80fd"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48cb0d2638f8baedbc542ed444afc0644a29166f1595371af4fecf8ce1e7eeb3"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cefb59d5cd5f92d9dcf80e4683949f15ca4b511f4ac0a6e14d4e1ac60c6ecd40"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cbc538057e648b67f72a982e708d485b2efa771e1ac05fec311f9f63e5800db4"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
@@ -9,13 +9,25 @@ edition = "2018"
 cargo-fuzz = true

 [dependencies]
-libfuzzer-sys = "0.3"
+libfuzzer-sys = "0.4.7"
 diffutils = { path = "../" }

 # Prevent this from interfering with workspaces
 [workspace]
 members = ["."]

+[[bin]]
+name = "fuzz_cmp"
+path = "fuzz_targets/fuzz_cmp.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_cmp_args"
+path = "fuzz_targets/fuzz_cmp_args.rs"
+test = false
+doc = false
+
 [[bin]]
 name = "fuzz_patch"
 path = "fuzz_targets/fuzz_patch.rs"
@@ -35,4 +47,8 @@ path = "fuzz_targets/fuzz_ed.rs"
 test = false
 doc = false

-
+[[bin]]
+name = "fuzz_side"
+path = "fuzz_targets/fuzz_side.rs"
+test = false
+doc = false
@@ -0,0 +1,36 @@
+"-l"
+"--verbose"
+"-b"
+"--print-bytes"
+"-lb"
+"-bl"
+"-n"
+"--bytes"
+"--bytes="
+"--bytes=1024"
+"--bytes=99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
+"-i"
+"--ignore-initial"
+"--ignore-initial="
+"--ignore-initial=1024"
+"--ignore-initial=99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999:9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
+"-s"
+"-q"
+"--quiet"
+"--silent"
+"-"
+"--"
+"1kB"
+"1G"
+"1GB"
+"1T"
+"1TB"
+"1P"
+"1PB"
+"1Z"
+"1ZB"
+"1Y"
+"1YB"
+"1Y"
+"0"
+"1:2"
@@ -0,0 +1,51 @@
+#![no_main]
+#[macro_use]
+extern crate libfuzzer_sys;
+use diffutilslib::cmp::{self, Cmp};
+
+use std::ffi::OsString;
+use std::fs::File;
+use std::io::Write;
+
+fn os(s: &str) -> OsString {
+    OsString::from(s)
+}
+
+fuzz_target!(|x: (Vec<u8>, Vec<u8>)| {
+    let args = vec!["cmp", "-l", "-b", "target/fuzz.cmp.a", "target/fuzz.cmp.b"]
+        .into_iter()
+        .map(|s| os(s))
+        .peekable();
+
+    let (from, to) = x;
+
+    File::create("target/fuzz.cmp.a")
+        .unwrap()
+        .write_all(&from)
+        .unwrap();
+
+    File::create("target/fuzz.cmp.b")
+        .unwrap()
+        .write_all(&to)
+        .unwrap();
+
+    let params =
+        cmp::parse_params(args).unwrap_or_else(|e| panic!("Failed to parse params: {}", e));
+    let ret = cmp::cmp(&params);
+    if from == to && !matches!(ret, Ok(Cmp::Equal)) {
+        panic!(
+            "target/fuzz.cmp.a and target/fuzz.cmp.b are equal, but cmp returned {:?}.",
+            ret
+        );
+    } else if from != to && !matches!(ret, Ok(Cmp::Different)) {
+        panic!(
+            "target/fuzz.cmp.a and target/fuzz.cmp.b are different, but cmp returned {:?}.",
+            ret
+        );
+    } else if ret.is_err() {
+        panic!(
+            "target/fuzz.cmp.a and target/fuzz.cmp.b caused cmp to error ({:?}).",
+            ret
+        );
+    }
+});
@@ -0,0 +1,23 @@
+#![no_main]
+#[macro_use]
+extern crate libfuzzer_sys;
+use diffutilslib::cmp;
+
+use libfuzzer_sys::Corpus;
+use std::ffi::OsString;
+
+fn os(s: &str) -> OsString {
+    OsString::from(s)
+}
+
+fuzz_target!(|x: Vec<OsString>| -> Corpus {
+    if x.len() > 6 {
+        // Make sure we try to parse an option when we get longer args. x[0] will be
+        // the executable name.
+        if ![os("-l"), os("-b"), os("-s"), os("-n"), os("-i")].contains(&x[1]) {
+            return Corpus::Reject;
+        }
+    }
+    let _ = cmp::parse_params(x.into_iter().peekable());
+    Corpus::Keep
+});
@@ -1,11 +1,19 @@
 #![no_main]
 #[macro_use]
 extern crate libfuzzer_sys;
-use diffutils::{ed_diff, normal_diff, unified_diff};
+use diffutilslib::ed_diff;
+use diffutilslib::ed_diff::DiffError;
+use diffutilslib::params::Params;
 use std::fs::{self, File};
 use std::io::Write;
 use std::process::Command;

+fn diff_w(expected: &[u8], actual: &[u8], filename: &str) -> Result<Vec<u8>, DiffError> {
+    let mut output = ed_diff::diff(expected, actual, &Params::default())?;
+    writeln!(&mut output, "w {filename}").unwrap();
+    Ok(output)
+}
+
 fuzz_target!(|x: (Vec<u8>, Vec<u8>)| {
    let (mut from, mut to) = x;
    from.push(b'\n');
@@ -30,7 +38,7 @@ fuzz_target!(|x: (Vec<u8>, Vec<u8>)| {
    } else {
        return;
    }
-    let diff = ed_diff::diff_w(&from, &to, "target/fuzz.file").unwrap();
+    let diff = diff_w(&from, &to, "target/fuzz.file").unwrap();
    File::create("target/fuzz.file.original")
        .unwrap()
        .write_all(&from)
@@ -1,7 +1,8 @@
 #![no_main]
 #[macro_use]
 extern crate libfuzzer_sys;
-use diffutils::{normal_diff, unified_diff};
+use diffutilslib::normal_diff;
+use diffutilslib::params::Params;

 use std::fs::{self, File};
 use std::io::Write;
@@ -21,7 +22,7 @@ fuzz_target!(|x: (Vec<u8>, Vec<u8>)| {
    } else {
        return
    }*/
-    let diff = normal_diff::diff(&from, &to);
+    let diff = normal_diff::diff(&from, &to, &Params::default());
    File::create("target/fuzz.file.original")
        .unwrap()
        .write_all(&from)
@@ -1,7 +1,8 @@
 #![no_main]
 #[macro_use]
 extern crate libfuzzer_sys;
-use diffutils::{normal_diff, unified_diff};
+use diffutilslib::params::Params;
+use diffutilslib::unified_diff;
 use std::fs::{self, File};
 use std::io::Write;
 use std::process::Command;
@@ -22,10 +23,13 @@ fuzz_target!(|x: (Vec<u8>, Vec<u8>, u8)| {
    }*/
    let diff = unified_diff::diff(
        &from,
-        "a/fuzz.file",
        &to,
-        "target/fuzz.file",
-        context as usize,
+        &Params {
+            from: "a/fuzz.file".into(),
+            to: "target/fuzz.file".into(),
+            context_count: context as usize,
+            ..Default::default()
+        }
    );
    File::create("target/fuzz.file.original")
        .unwrap()
@@ -0,0 +1,42 @@
+#![no_main]
+#[macro_use]
+extern crate libfuzzer_sys;
+
+use diffutilslib::side_diff;
+
+use std::fs::File;
+use std::io::Write;
+use diffutilslib::params::Params;
+
+fuzz_target!(|x: (Vec<u8>, Vec<u8>, /* usize, usize */ bool)| {
+    let (original, new, /* width, tabsize, */ expand) = x;
+
+    // if width == 0 || tabsize == 0 {
+    //     return;
+    // }
+
+    let params = Params {
+        // width,
+        // tabsize,
+        expand_tabs: expand,
+        ..Default::default()
+    };
+    let mut output_buf = vec![];
+    side_diff::diff(&original, &new, &mut output_buf, &params);
+    File::create("target/fuzz.file.original")
+        .unwrap()
+        .write_all(&original)
+        .unwrap();
+    File::create("target/fuzz.file.new")
+        .unwrap()
+        .write_all(&new)
+        .unwrap();
+    File::create("target/fuzz.file")
+        .unwrap()
+        .write_all(&original)
+        .unwrap();
+    File::create("target/fuzz.diff")
+        .unwrap()
+        .write_all(&output_buf)
+        .unwrap();
+});
--- a/Show More
+++ b/Show More