Fix typos

Move test assertions in the cfg block where they belong (fixes #3)

.github/workflows/ci.yml

@@ -10,6 +10,7 @@ jobs:
     name: cargo check
     runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: false
       matrix:
         os: [ubuntu-latest, macOS-latest, windows-latest]
     steps:
@@ -21,11 +22,16 @@ jobs:
     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: 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:
@@ -41,6 +47,7 @@ jobs:
     name: cargo clippy -- -D warnings
     runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: false
       matrix:
         os: [ubuntu-latest, macOS-latest, windows-latest]
     steps:
@@ -49,11 +56,28 @@ jobs:
       - run: rustup component add clippy
       - run: cargo clippy -- -D warnings
 
+  gnu-testsuite:
+    name: GNU test suite
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - run: cargo build --release
+      # 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
+
   coverage:
     name: Code Coverage
     runs-on: ${{ matrix.job.os }}
     strategy:
-      fail-fast: true
+      fail-fast: false
       matrix:
         job:
           - { os: ubuntu-latest  , features: unix }
@@ -83,6 +107,10 @@ jobs:
 
     - name: rust toolchain ~ install
       uses: dtolnay/rust-toolchain@nightly
+    - 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
       env:
@@ -122,10 +150,9 @@ jobs:
         grcov . --output-type lcov --output-path "${COVERAGE_REPORT_FILE}" --branch --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()"
         echo "report=${COVERAGE_REPORT_FILE}" >> $GITHUB_OUTPUT
     - name: Upload coverage results (to Codecov.io)
-      uses: codecov/codecov-action@v3
-      # if: steps.vars.outputs.HAS_CODECOV_TOKEN
+      uses: codecov/codecov-action@v4
       with:
-        # token: ${{ secrets.CODECOV_TOKEN }}
+        token: ${{ secrets.CODECOV_TOKEN }}
         file: ${{ steps.coverage.outputs.report }}
         ## flags: IntegrationTests, UnitTests, ${{ steps.vars.outputs.CODECOV_FLAGS }}
         flags: ${{ steps.vars.outputs.CODECOV_FLAGS }}

.github/workflows/fuzzing.yml

@@ -0,0 +1,72 @@
+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
+      - uses: dtolnay/rust-toolchain@nightly
+      - name: Install `cargo-fuzz`
+        run: cargo install cargo-fuzz
+      - uses: Swatinem/rust-cache@v2
+        with:
+          shared-key: "cargo-fuzz-cache-key"
+          cache-directories: "fuzz/target"
+      - name: Run `cargo-fuzz build`
+        run: cargo +nightly fuzz build
+
+  fuzz-run:
+    needs: fuzz-build
+    name: Run the fuzzers
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    env:
+      RUN_FOR: 60
+    strategy:
+      matrix:
+        test-target:
+          - { name: fuzz_ed, should_pass: true }
+          - { name: fuzz_normal, should_pass: true }
+          - { name: fuzz_patch, should_pass: true }
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@nightly
+      - name: Install `cargo-fuzz`
+        run: cargo install cargo-fuzz
+      - uses: Swatinem/rust-cache@v2
+        with:
+          shared-key: "cargo-fuzz-cache-key"
+          cache-directories: "fuzz/target"
+      - name: Restore Cached Corpus
+        uses: actions/cache/restore@v4
+        with:
+          key: corpus-cache-${{ matrix.test-target.name }}
+          path: |
+            fuzz/corpus/${{ matrix.test-target.name }}
+      - name: Run ${{ matrix.test-target.name }} for XX seconds
+        shell: bash
+        continue-on-error: ${{ !matrix.test-target.name.should_pass }}
+        run: |
+          cargo +nightly fuzz run ${{ matrix.test-target.name }} -- -max_total_time=${{ env.RUN_FOR }} -detect_leaks=0
+      - name: Save Corpus Cache
+        uses: actions/cache/save@v4
+        with:
+          key: corpus-cache-${{ matrix.test-target.name }}
+          path: |
+            fuzz/corpus/${{ matrix.test-target.name }}

.github/workflows/release.yml

@@ -0,0 +1,266 @@
+# Copyright 2022-2023, axodotdev
+# SPDX-License-Identifier: MIT or Apache-2.0
+#
+# CI that:
+#
+# * checks for a Git Tag that looks like a release
+# * builds artifacts with cargo-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 cargo-dist-able).
+#
+# If PACKAGE_NAME isn't specified, then the announcement will be for all
+# (cargo-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:
+  push:
+    tags:
+      - '**[0-9]+.[0-9]+.[0-9]+*'
+  pull_request:
+
+jobs:
+  # Run 'cargo dist plan' (or host) to determine what tasks we need to do
+  plan:
+    runs-on: ubuntu-latest
+    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:
+          submodules: recursive
+      - name: Install cargo-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.12.0/cargo-dist-installer.sh | sh"
+      # 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: |
+          cargo dist ${{ (!github.event.pull_request && format('host --steps=create --tag={0}', github.ref_name)) || 'plan' }} --output-format=json > plan-dist-manifest.json
+          echo "cargo 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 cargo-dist in create-release.
+      # Each member of the matrix has the following arguments:
+      #
+      # - runner: the github runner
+      # - dist-args: cli flags to pass to cargo dist
+      # - install-dist: expression to run to install cargo-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 }}
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      BUILD_MANIFEST_NAME: target/distrib/${{ join(matrix.targets, '-') }}-dist-manifest.json
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - uses: swatinem/rust-cache@v2
+      - name: Install cargo-dist
+        run: ${{ matrix.install_dist }}
+      # 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
+          cargo dist build ${{ needs.plan.outputs.tag-flag }} --print=linkage --output-format=json ${{ matrix.dist_args }} > dist-manifest.json
+          echo "cargo 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"
+          jq --raw-output ".artifacts[]?.path | select( . != null )" 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-20.04"
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      BUILD_MANIFEST_NAME: target/distrib/global-dist-manifest.json
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Install cargo-dist
+        shell: bash
+        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.12.0/cargo-dist-installer.sh | sh"
+      # 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: |
+          cargo dist build ${{ needs.plan.outputs.tag-flag }} --output-format=json "--artifacts=global" > dist-manifest.json
+          echo "cargo dist ran successfully"
+
+          # Parse out what we just built and upload it to scratch storage
+          echo "paths<<EOF" >> "$GITHUB_OUTPUT"
+          jq --raw-output ".artifacts[]?.path | select( . != null )" 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 local and global didn't fail (skipped is fine)
+    if: ${{ always() && 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-20.04"
+    outputs:
+      val: ${{ steps.host.outputs.manifest }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Install cargo-dist
+        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.12.0/cargo-dist-installer.sh | sh"
+      # Fetch artifacts from scratch-storage
+      - name: Fetch artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: artifacts-*
+          path: target/distrib/
+          merge-multiple: true
+      # This is a harmless no-op for Github Releases, hosting for that happens in "announce"
+      - id: host
+        shell: bash
+        run: |
+          cargo 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
+  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-20.04"
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - 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
+        uses: ncipollo/release-action@v1
+        with:
+          tag: ${{ needs.plan.outputs.tag }}
+          name: ${{ fromJson(needs.host.outputs.val).announcement_title }}
+          body: ${{ fromJson(needs.host.outputs.val).announcement_github_body }}
+          prerelease: ${{ fromJson(needs.host.outputs.val).announcement_is_prerelease }}
+          artifacts: "artifacts/*"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "diffutils"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2021"
 description = "A CLI app for generating diff files"
 license = "MIT OR Apache-2.0"
@@ -15,7 +15,32 @@ name = "diffutils"
 path = "src/main.rs"
 
 [dependencies]
-diff = "0.1.10"
+chrono = "0.4.38"
+diff = "0.1.13"
+regex = "1.10.4"
+same-file = "1.0.6"
+unicode-width = "0.1.11"
 
 [dev-dependencies]
 pretty_assertions = "1"
+assert_cmd = "2.0.14"
+predicates = "3.1.0"
+tempfile = "3.10.1"
+
+# The profile that 'cargo dist' will build with
+[profile.dist]
+inherits = "release"
+lto = "thin"
+
+# Config for 'cargo dist'
+[workspace.metadata.dist]
+# The preferred cargo-dist version to use in CI (Cargo.toml SemVer syntax)
+cargo-dist-version = "0.12.0"
+# 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", "x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"]
+# Publish jobs to run in CI
+pr-run-mode = "plan"

README.md

@@ -1,58 +1,56 @@
-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)
 
+[![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/) 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

fuzz/Cargo.toml

@@ -9,7 +9,7 @@ edition = "2018"
 cargo-fuzz = true
 
 [dependencies]
-libfuzzer-sys = "0.3"
+libfuzzer-sys = "0.4"
 diffutils = { path = "../" }
 
 # Prevent this from interfering with workspaces

fuzz/fuzz_targets/fuzz_ed.rs

@@ -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)

fuzz/fuzz_targets/fuzz_normal.rs

@@ -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)

fuzz/fuzz_targets/fuzz_patch.rs

@@ -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()

renovate.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:recommended"
+  ]
+}

src/context_diff.rs

@@ -6,6 +6,10 @@
 use std::collections::VecDeque;
 use std::io::Write;
 
+use crate::params::Params;
+use crate::utils::do_write_line;
+use crate::utils::get_modification_time;
+
 #[derive(Debug, PartialEq)]
 pub enum DiffLine {
     Context(Vec<u8>),
@@ -41,7 +45,12 @@ impl Mismatch {
 }
 
 // Produces a diff between the expected output and actual output.
-fn make_diff(expected: &[u8], actual: &[u8], context_size: usize) -> Vec<Mismatch> {
+fn make_diff(
+    expected: &[u8],
+    actual: &[u8],
+    context_size: usize,
+    stop_early: bool,
+) -> Vec<Mismatch> {
     let mut line_number_expected = 1;
     let mut line_number_actual = 1;
     let mut context_queue: VecDeque<&[u8]> = VecDeque::with_capacity(context_size);
@@ -191,6 +200,10 @@ fn make_diff(expected: &[u8], actual: &[u8], context_size: usize) -> Vec<Mismatc
                 line_number_actual += 1;
             }
         }
+        if stop_early && !results.is_empty() {
+            // Optimization: stop analyzing the files as soon as there are any differences
+            return results;
+        }
     }
 
     results.push(mismatch);
@@ -254,18 +267,24 @@ fn make_diff(expected: &[u8], actual: &[u8], context_size: usize) -> Vec<Mismatc
 }
 
 #[must_use]
-pub fn diff(
-    expected: &[u8],
-    expected_filename: &str,
-    actual: &[u8],
-    actual_filename: &str,
-    context_size: usize,
-) -> Vec<u8> {
-    let mut output = format!("*** {expected_filename}\t\n--- {actual_filename}\t\n").into_bytes();
-    let diff_results = make_diff(expected, actual, context_size);
+pub fn diff(expected: &[u8], actual: &[u8], params: &Params) -> Vec<u8> {
+    let from_modified_time = get_modification_time(&params.from.to_string_lossy());
+    let to_modified_time = get_modification_time(&params.to.to_string_lossy());
+    let mut output = format!(
+        "*** {0}\t{1}\n--- {2}\t{3}\n",
+        params.from.to_string_lossy(),
+        from_modified_time,
+        params.to.to_string_lossy(),
+        to_modified_time
+    )
+    .into_bytes();
+    let diff_results = make_diff(expected, actual, params.context_count, params.brief);
     if diff_results.is_empty() {
         return Vec::new();
-    };
+    }
+    if params.brief {
+        return output;
+    }
     for result in diff_results {
         let mut line_number_expected = result.line_number_expected;
         let mut line_number_actual = result.line_number_actual;
@@ -301,17 +320,20 @@ pub fn diff(
                 match line {
                     DiffLine::Context(e) => {
                         write!(output, "  ").expect("write to Vec is infallible");
-                        output.write_all(&e).expect("write to Vec is infallible");
+                        do_write_line(&mut output, &e, params.expand_tabs, params.tabsize)
+                            .expect("write to Vec is infallible");
                         writeln!(output).unwrap();
                     }
                     DiffLine::Change(e) => {
                         write!(output, "! ").expect("write to Vec is infallible");
-                        output.write_all(&e).expect("write to Vec is infallible");
+                        do_write_line(&mut output, &e, params.expand_tabs, params.tabsize)
+                            .expect("write to Vec is infallible");
                         writeln!(output).unwrap();
                     }
                     DiffLine::Add(e) => {
                         write!(output, "- ").expect("write to Vec is infallible");
-                        output.write_all(&e).expect("write to Vec is infallible");
+                        do_write_line(&mut output, &e, params.expand_tabs, params.tabsize)
+                            .expect("write to Vec is infallible");
                         writeln!(output).unwrap();
                     }
                 }
@@ -328,17 +350,20 @@ pub fn diff(
                 match line {
                     DiffLine::Context(e) => {
                         write!(output, "  ").expect("write to Vec is infallible");
-                        output.write_all(&e).expect("write to Vec is infallible");
+                        do_write_line(&mut output, &e, params.expand_tabs, params.tabsize)
+                            .expect("write to Vec is infallible");
                         writeln!(output).unwrap();
                     }
                     DiffLine::Change(e) => {
                         write!(output, "! ").expect("write to Vec is infallible");
-                        output.write_all(&e).expect("write to Vec is infallible");
+                        do_write_line(&mut output, &e, params.expand_tabs, params.tabsize)
+                            .expect("write to Vec is infallible");
                         writeln!(output).unwrap();
                     }
                     DiffLine::Add(e) => {
                         write!(output, "+ ").expect("write to Vec is infallible");
-                        output.write_all(&e).expect("write to Vec is infallible");
+                        do_write_line(&mut output, &e, params.expand_tabs, params.tabsize)
+                            .expect("write to Vec is infallible");
                         writeln!(output).unwrap();
                     }
                 }
@@ -404,8 +429,16 @@ mod tests {
                                 }
                                 // This test diff is intentionally reversed.
                                 // We want it to turn the alef into bet.
-                                let diff =
-                                    diff(&alef, "a/alef", &bet, &format!("{target}/alef"), 2);
+                                let diff = diff(
+                                    &alef,
+                                    &bet,
+                                    &Params {
+                                        from: "a/alef".into(),
+                                        to: (&format!("{target}/alef")).into(),
+                                        context_count: 2,
+                                        ..Default::default()
+                                    },
+                                );
                                 File::create(&format!("{target}/ab.diff"))
                                     .unwrap()
                                     .write_all(&diff)
@@ -422,7 +455,7 @@ mod tests {
                                     .stdin(File::open(&format!("{target}/ab.diff")).unwrap())
                                     .output()
                                     .unwrap();
-                                assert!(output.status.success(), "{:?}", output);
+                                assert!(output.status.success(), "{output:?}");
                                 //println!("{}", String::from_utf8_lossy(&output.stdout));
                                 //println!("{}", String::from_utf8_lossy(&output.stderr));
                                 let alef = fs::read(&format!("{target}/alef")).unwrap();
@@ -477,8 +510,16 @@ mod tests {
                                 }
                                 // This test diff is intentionally reversed.
                                 // We want it to turn the alef into bet.
-                                let diff =
-                                    diff(&alef, "a/alef_", &bet, &format!("{target}/alef_"), 2);
+                                let diff = diff(
+                                    &alef,
+                                    &bet,
+                                    &Params {
+                                        from: "a/alef_".into(),
+                                        to: (&format!("{target}/alef_")).into(),
+                                        context_count: 2,
+                                        ..Default::default()
+                                    },
+                                );
                                 File::create(&format!("{target}/ab_.diff"))
                                     .unwrap()
                                     .write_all(&diff)
@@ -495,7 +536,7 @@ mod tests {
                                     .stdin(File::open(&format!("{target}/ab_.diff")).unwrap())
                                     .output()
                                     .unwrap();
-                                assert!(output.status.success(), "{:?}", output);
+                                assert!(output.status.success(), "{output:?}");
                                 //println!("{}", String::from_utf8_lossy(&output.stdout));
                                 //println!("{}", String::from_utf8_lossy(&output.stderr));
                                 let alef = fs::read(&format!("{target}/alef_")).unwrap();
@@ -553,8 +594,16 @@ mod tests {
                                 };
                                 // This test diff is intentionally reversed.
                                 // We want it to turn the alef into bet.
-                                let diff =
-                                    diff(&alef, "a/alefx", &bet, &format!("{target}/alefx"), 2);
+                                let diff = diff(
+                                    &alef,
+                                    &bet,
+                                    &Params {
+                                        from: "a/alefx".into(),
+                                        to: (&format!("{target}/alefx")).into(),
+                                        context_count: 2,
+                                        ..Default::default()
+                                    },
+                                );
                                 File::create(&format!("{target}/abx.diff"))
                                     .unwrap()
                                     .write_all(&diff)
@@ -571,7 +620,7 @@ mod tests {
                                     .stdin(File::open(&format!("{target}/abx.diff")).unwrap())
                                     .output()
                                     .unwrap();
-                                assert!(output.status.success(), "{:?}", output);
+                                assert!(output.status.success(), "{output:?}");
                                 //println!("{}", String::from_utf8_lossy(&output.stdout));
                                 //println!("{}", String::from_utf8_lossy(&output.stderr));
                                 let alef = fs::read(&format!("{target}/alefx")).unwrap();
@@ -632,8 +681,16 @@ mod tests {
                                 }
                                 // This test diff is intentionally reversed.
                                 // We want it to turn the alef into bet.
-                                let diff =
-                                    diff(&alef, "a/alefr", &bet, &format!("{target}/alefr"), 2);
+                                let diff = diff(
+                                    &alef,
+                                    &bet,
+                                    &Params {
+                                        from: "a/alefr".into(),
+                                        to: (&format!("{target}/alefr")).into(),
+                                        context_count: 2,
+                                        ..Default::default()
+                                    },
+                                );
                                 File::create(&format!("{target}/abr.diff"))
                                     .unwrap()
                                     .write_all(&diff)
@@ -650,7 +707,7 @@ mod tests {
                                     .stdin(File::open(&format!("{target}/abr.diff")).unwrap())
                                     .output()
                                     .unwrap();
-                                assert!(output.status.success(), "{:?}", output);
+                                assert!(output.status.success(), "{output:?}");
                                 //println!("{}", String::from_utf8_lossy(&output.stdout));
                                 //println!("{}", String::from_utf8_lossy(&output.stderr));
                                 let alef = fs::read(&format!("{target}/alefr")).unwrap();
@@ -662,4 +719,78 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn test_stop_early() {
+        use crate::assert_diff_eq;
+
+        let from_filename = "foo";
+        let from = ["a", "b", "c", ""].join("\n");
+        let to_filename = "bar";
+        let to = ["a", "d", "c", ""].join("\n");
+
+        let diff_full = diff(
+            from.as_bytes(),
+            to.as_bytes(),
+            &Params {
+                from: from_filename.into(),
+                to: to_filename.into(),
+                ..Default::default()
+            },
+        );
+
+        let expected_full = [
+            "*** foo\tTIMESTAMP",
+            "--- bar\tTIMESTAMP",
+            "***************",
+            "*** 1,3 ****",
+            "  a",
+            "! b",
+            "  c",
+            "--- 1,3 ----",
+            "  a",
+            "! d",
+            "  c",
+            "",
+        ]
+        .join("\n");
+        assert_diff_eq!(diff_full, expected_full);
+
+        let diff_brief = diff(
+            from.as_bytes(),
+            to.as_bytes(),
+            &Params {
+                from: from_filename.into(),
+                to: to_filename.into(),
+                brief: true,
+                ..Default::default()
+            },
+        );
+
+        let expected_brief = ["*** foo\tTIMESTAMP", "--- bar\tTIMESTAMP", ""].join("\n");
+        assert_diff_eq!(diff_brief, expected_brief);
+
+        let nodiff_full = diff(
+            from.as_bytes(),
+            from.as_bytes(),
+            &Params {
+                from: from_filename.into(),
+                to: to_filename.into(),
+                ..Default::default()
+            },
+        );
+        assert!(nodiff_full.is_empty());
+
+        let nodiff_brief = diff(
+            from.as_bytes(),
+            from.as_bytes(),
+            &Params {
+                from: from_filename.into(),
+                to: to_filename.into(),
+                brief: true,
+                ..Default::default()
+            },
+        );
+        assert!(nodiff_brief.is_empty());
+    }
 }

src/ed_diff.rs

@@ -5,6 +5,9 @@
 
 use std::io::Write;
 
+use crate::params::Params;
+use crate::utils::do_write_line;
+
 #[derive(Debug, PartialEq)]
 struct Mismatch {
     pub line_number_expected: usize,
@@ -42,7 +45,7 @@ impl Mismatch {
 }
 
 // Produces a diff between the expected output and actual output.
-fn make_diff(expected: &[u8], actual: &[u8]) -> Result<Vec<Mismatch>, DiffError> {
+fn make_diff(expected: &[u8], actual: &[u8], stop_early: bool) -> Result<Vec<Mismatch>, DiffError> {
     let mut line_number_expected = 1;
     let mut line_number_actual = 1;
     let mut results = Vec::new();
@@ -94,6 +97,10 @@ fn make_diff(expected: &[u8], actual: &[u8]) -> Result<Vec<Mismatch>, DiffError>
                 }
             }
         }
+        if stop_early && !results.is_empty() {
+            // Optimization: stop analyzing the files as soon as there are any differences
+            return Ok(results);
+        }
     }
 
     if !mismatch.actual.is_empty() || !mismatch.expected.is_empty() {
@@ -103,9 +110,13 @@ fn make_diff(expected: &[u8], actual: &[u8]) -> Result<Vec<Mismatch>, DiffError>
     Ok(results)
 }
 
-pub fn diff(expected: &[u8], actual: &[u8]) -> Result<Vec<u8>, DiffError> {
+pub fn diff(expected: &[u8], actual: &[u8], params: &Params) -> Result<Vec<u8>, DiffError> {
     let mut output = Vec::new();
-    let diff_results = make_diff(expected, actual)?;
+    let diff_results = make_diff(expected, actual, params.brief)?;
+    if params.brief && !diff_results.is_empty() {
+        write!(&mut output, "\0").unwrap();
+        return Ok(output);
+    }
     let mut lines_offset = 0;
     for result in diff_results {
         let line_number_expected: isize = result.line_number_expected as isize + lines_offset;
@@ -122,6 +133,7 @@ pub fn diff(expected: &[u8], actual: &[u8]) -> Result<Vec<u8>, DiffError> {
                 expected_count + line_number_expected - 1
             )
             .unwrap(),
+            (1, _) => writeln!(&mut output, "{line_number_expected}c").unwrap(),
             _ => writeln!(
                 &mut output,
                 "{},{}c",
@@ -136,7 +148,7 @@ pub fn diff(expected: &[u8], actual: &[u8]) -> Result<Vec<u8>, DiffError> {
                 if actual == b"." {
                     writeln!(&mut output, "..\n.\ns/.//\na").unwrap();
                 } else {
-                    output.write_all(actual).unwrap();
+                    do_write_line(&mut output, actual, params.expand_tabs, params.tabsize).unwrap();
                     writeln!(&mut output).unwrap();
                 }
             }
@@ -151,11 +163,20 @@ mod tests {
     use super::*;
     use pretty_assertions::assert_eq;
     pub fn diff_w(expected: &[u8], actual: &[u8], filename: &str) -> Result<Vec<u8>, DiffError> {
-        let mut output = diff(expected, actual)?;
+        let mut output = diff(expected, actual, &Params::default())?;
         writeln!(&mut output, "w {filename}").unwrap();
         Ok(output)
     }
 
+    #[test]
+    fn test_basic() {
+        let from = b"a\n";
+        let to = b"b\n";
+        let diff = diff(from, to, &Params::default()).unwrap();
+        let expected = ["1c", "b", ".", ""].join("\n");
+        assert_eq!(diff, expected.as_bytes());
+    }
+
     #[test]
     fn test_permutations() {
         let target = "target/ed-diff/";
@@ -167,9 +188,8 @@ mod tests {
                     for &d in &[0, 1, 2] {
                         for &e in &[0, 1, 2] {
                             for &f in &[0, 1, 2] {
-                                use std::fs::{self, File};
+                                use std::fs::File;
                                 use std::io::Write;
-                                use std::process::Command;
                                 let mut alef = Vec::new();
                                 let mut bet = Vec::new();
                                 alef.write_all(if a == 0 { b"a\n" } else { b"b\n" })
@@ -205,7 +225,7 @@ mod tests {
                                 // This test diff is intentionally reversed.
                                 // We want it to turn the alef into bet.
                                 let diff = diff_w(&alef, &bet, &format!("{target}/alef")).unwrap();
-                                File::create("target/ab.ed")
+                                File::create(&format!("{target}/ab.ed"))
                                     .unwrap()
                                     .write_all(&diff)
                                     .unwrap();
@@ -215,16 +235,20 @@ mod tests {
                                 fb.write_all(&bet[..]).unwrap();
                                 let _ = fa;
                                 let _ = fb;
-                                let output = Command::new("ed")
-                                    .arg(&format!("{target}/alef"))
-                                    .stdin(File::open("target/ab.ed").unwrap())
-                                    .output()
-                                    .unwrap();
-                                assert!(output.status.success(), "{:?}", output);
-                                //println!("{}", String::from_utf8_lossy(&output.stdout));
-                                //println!("{}", String::from_utf8_lossy(&output.stderr));
-                                let alef = fs::read(&format!("{target}/alef")).unwrap();
-                                assert_eq!(alef, bet);
+                                #[cfg(not(windows))] // there's no ed on windows
+                                {
+                                    use std::process::Command;
+                                    let output = Command::new("ed")
+                                        .arg(&format!("{target}/alef"))
+                                        .stdin(File::open(&format!("{target}/ab.ed")).unwrap())
+                                        .output()
+                                        .unwrap();
+                                    assert!(output.status.success(), "{output:?}");
+                                    //println!("{}", String::from_utf8_lossy(&output.stdout));
+                                    //println!("{}", String::from_utf8_lossy(&output.stderr));
+                                    let alef = std::fs::read(&format!("{target}/alef")).unwrap();
+                                    assert_eq!(alef, bet);
+                                }
                             }
                         }
                     }
@@ -244,9 +268,8 @@ mod tests {
                     for &d in &[0, 1, 2] {
                         for &e in &[0, 1, 2] {
                             for &f in &[0, 1, 2] {
-                                use std::fs::{self, File};
+                                use std::fs::File;
                                 use std::io::Write;
-                                use std::process::Command;
                                 let mut alef = Vec::new();
                                 let mut bet = Vec::new();
                                 alef.write_all(if a == 0 { b"\n" } else { b"b\n" }).unwrap();
@@ -275,27 +298,31 @@ mod tests {
                                 }
                                 // This test diff is intentionally reversed.
                                 // We want it to turn the alef into bet.
-                                let diff = diff_w(&alef, &bet, "target/alef_").unwrap();
-                                File::create("target/ab_.ed")
+                                let diff = diff_w(&alef, &bet, &format!("{target}/alef_")).unwrap();
+                                File::create(&format!("{target}/ab_.ed"))
                                     .unwrap()
                                     .write_all(&diff)
                                     .unwrap();
-                                let mut fa = File::create("target/alef_").unwrap();
+                                let mut fa = File::create(&format!("{target}/alef_")).unwrap();
                                 fa.write_all(&alef[..]).unwrap();
                                 let mut fb = File::create(&format!("{target}/bet_")).unwrap();
                                 fb.write_all(&bet[..]).unwrap();
                                 let _ = fa;
                                 let _ = fb;
-                                let output = Command::new("ed")
-                                    .arg("target/alef_")
-                                    .stdin(File::open("target/ab_.ed").unwrap())
-                                    .output()
-                                    .unwrap();
-                                assert!(output.status.success(), "{:?}", output);
-                                //println!("{}", String::from_utf8_lossy(&output.stdout));
-                                //println!("{}", String::from_utf8_lossy(&output.stderr));
-                                let alef = fs::read("target/alef_").unwrap();
-                                assert_eq!(alef, bet);
+                                #[cfg(not(windows))] // there's no ed on windows
+                                {
+                                    use std::process::Command;
+                                    let output = Command::new("ed")
+                                        .arg(&format!("{target}/alef_"))
+                                        .stdin(File::open(&format!("{target}/ab_.ed")).unwrap())
+                                        .output()
+                                        .unwrap();
+                                    assert!(output.status.success(), "{output:?}");
+                                    //println!("{}", String::from_utf8_lossy(&output.stdout));
+                                    //println!("{}", String::from_utf8_lossy(&output.stderr));
+                                    let alef = std::fs::read(&format!("{target}/alef_")).unwrap();
+                                    assert_eq!(alef, bet);
+                                }
                             }
                         }
                     }
@@ -315,9 +342,8 @@ mod tests {
                     for &d in &[0, 1, 2] {
                         for &e in &[0, 1, 2] {
                             for &f in &[0, 1, 2] {
-                                use std::fs::{self, File};
+                                use std::fs::File;
                                 use std::io::Write;
-                                use std::process::Command;
                                 let mut alef = Vec::new();
                                 let mut bet = Vec::new();
                                 alef.write_all(if a == 0 { b"a\n" } else { b"f\n" })
@@ -353,7 +379,7 @@ mod tests {
                                 // This test diff is intentionally reversed.
                                 // We want it to turn the alef into bet.
                                 let diff = diff_w(&alef, &bet, &format!("{target}/alefr")).unwrap();
-                                File::create("target/abr.ed")
+                                File::create(&format!("{target}/abr.ed"))
                                     .unwrap()
                                     .write_all(&diff)
                                     .unwrap();
@@ -363,16 +389,20 @@ mod tests {
                                 fb.write_all(&bet[..]).unwrap();
                                 let _ = fa;
                                 let _ = fb;
-                                let output = Command::new("ed")
-                                    .arg(&format!("{target}/alefr"))
-                                    .stdin(File::open("target/abr.ed").unwrap())
-                                    .output()
-                                    .unwrap();
-                                assert!(output.status.success(), "{:?}", output);
-                                //println!("{}", String::from_utf8_lossy(&output.stdout));
-                                //println!("{}", String::from_utf8_lossy(&output.stderr));
-                                let alef = fs::read(&format!("{target}/alefr")).unwrap();
-                                assert_eq!(alef, bet);
+                                #[cfg(not(windows))] // there's no ed on windows
+                                {
+                                    use std::process::Command;
+                                    let output = Command::new("ed")
+                                        .arg(&format!("{target}/alefr"))
+                                        .stdin(File::open(&format!("{target}/abr.ed")).unwrap())
+                                        .output()
+                                        .unwrap();
+                                    assert!(output.status.success(), "{output:?}");
+                                    //println!("{}", String::from_utf8_lossy(&output.stdout));
+                                    //println!("{}", String::from_utf8_lossy(&output.stderr));
+                                    let alef = std::fs::read(&format!("{target}/alefr")).unwrap();
+                                    assert_eq!(alef, bet);
+                                }
                             }
                         }
                     }
@@ -380,4 +410,40 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn test_stop_early() {
+        let from = ["a", "b", "c", ""].join("\n");
+        let to = ["a", "d", "c", ""].join("\n");
+
+        let diff_full = diff(from.as_bytes(), to.as_bytes(), &Params::default()).unwrap();
+        let expected_full = ["2c", "d", ".", ""].join("\n");
+        assert_eq!(diff_full, expected_full.as_bytes());
+
+        let diff_brief = diff(
+            from.as_bytes(),
+            to.as_bytes(),
+            &Params {
+                brief: true,
+                ..Default::default()
+            },
+        )
+        .unwrap();
+        let expected_brief = "\0".as_bytes();
+        assert_eq!(diff_brief, expected_brief);
+
+        let nodiff_full = diff(from.as_bytes(), from.as_bytes(), &Params::default()).unwrap();
+        assert!(nodiff_full.is_empty());
+
+        let nodiff_brief = diff(
+            from.as_bytes(),
+            from.as_bytes(),
+            &Params {
+                brief: true,
+                ..Default::default()
+            },
+        )
+        .unwrap();
+        assert!(nodiff_brief.is_empty());
+    }
 }

src/lib.rs

@@ -1,7 +1,10 @@
 pub mod context_diff;
 pub mod ed_diff;
+pub mod macros;
 pub mod normal_diff;
+pub mod params;
 pub mod unified_diff;
+pub mod utils;
 
 // Re-export the public functions/types you need
 pub use context_diff::diff as context_diff;

src/macros.rs

@@ -0,0 +1,25 @@
+// asserts equality of the actual diff and expected diff
+// considering datetime varitations
+//
+// It replaces the modification time in the actual diff
+// with placeholder "TIMESTAMP" and then asserts the equality
+//
+// For eg.
+// let brief = "*** fruits_old.txt\t2024-03-24 23:43:05.189597645 +0530\n
+//              --- fruits_new.txt\t2024-03-24 23:35:08.922581904 +0530\n";
+//
+// replaced = "*** fruits_old.txt\tTIMESTAMP\n
+//             --- fruits_new.txt\tTIMESTAMP\n";
+#[macro_export]
+macro_rules! assert_diff_eq {
+    ($actual:expr, $expected:expr) => {{
+        use regex::Regex;
+        use std::str;
+
+        let diff = str::from_utf8(&$actual).unwrap();
+        let re = Regex::new(r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+ [+-]\d{4}").unwrap();
+        let actual = re.replacen(diff, 2, "TIMESTAMP");
+
+        assert_eq!(actual, $expected);
+    }};
+}

src/main.rs

@@ -3,58 +3,94 @@
 // For the full copyright and license information, please view the LICENSE-*
 // files that was distributed with this source code.
 
-use crate::params::{parse_params, Format, Params};
+use crate::params::{parse_params, Format};
 use std::env;
-
+use std::ffi::OsString;
 use std::fs;
-use std::io::{self, Write};
+use std::io::{self, Read, Write};
+use std::process::{exit, ExitCode};
 
 mod context_diff;
 mod ed_diff;
+mod macros;
 mod normal_diff;
 mod params;
 mod unified_diff;
+mod utils;
 
-fn main() -> Result<(), String> {
+// Exit codes are documented at
+// https://www.gnu.org/software/diffutils/manual/html_node/Invoking-diff.html.
+//     An exit status of 0 means no differences were found,
+//     1 means some differences were found,
+//     and 2 means trouble.
+fn main() -> ExitCode {
     let opts = env::args_os();
-    let Params {
-        from,
-        to,
-        context_count,
-        format,
-    } = parse_params(opts)?;
-    // read files
-    let from_content = match fs::read(&from) {
-        Ok(from_content) => from_content,
-        Err(e) => {
-            return Err(format!("Failed to read from-file: {e}"));
+    let params = parse_params(opts).unwrap_or_else(|error| {
+        eprintln!("{error}");
+        exit(2);
+    });
+    // if from and to are the same file, no need to perform any comparison
+    let maybe_report_identical_files = || {
+        if params.report_identical_files {
+            println!(
+                "Files {} and {} are identical",
+                params.from.to_string_lossy(),
+                params.to.to_string_lossy(),
+            );
         }
     };
-    let to_content = match fs::read(&to) {
+    if params.from == "-" && params.to == "-"
+        || same_file::is_same_file(&params.from, &params.to).unwrap_or(false)
+    {
+        maybe_report_identical_files();
+        return ExitCode::SUCCESS;
+    }
+    // read files
+    fn read_file_contents(filepath: &OsString) -> io::Result<Vec<u8>> {
+        if filepath == "-" {
+            let mut content = Vec::new();
+            io::stdin().read_to_end(&mut content).and(Ok(content))
+        } else {
+            fs::read(filepath)
+        }
+    }
+    let from_content = match read_file_contents(&params.from) {
+        Ok(from_content) => from_content,
+        Err(e) => {
+            eprintln!("Failed to read from-file: {e}");
+            return ExitCode::from(2);
+        }
+    };
+    let to_content = match read_file_contents(&params.to) {
         Ok(to_content) => to_content,
         Err(e) => {
-            return Err(format!("Failed to read from-file: {e}"));
+            eprintln!("Failed to read to-file: {e}");
+            return ExitCode::from(2);
         }
     };
     // run diff
-    let result: Vec<u8> = match format {
-        Format::Normal => normal_diff::diff(&from_content, &to_content),
-        Format::Unified => unified_diff::diff(
-            &from_content,
-            &from.to_string_lossy(),
-            &to_content,
-            &to.to_string_lossy(),
-            context_count,
-        ),
-        Format::Context => context_diff::diff(
-            &from_content,
-            &from.to_string_lossy(),
-            &to_content,
-            &to.to_string_lossy(),
-            context_count,
-        ),
-        Format::Ed => ed_diff::diff(&from_content, &to_content)?,
+    let result: Vec<u8> = match params.format {
+        Format::Normal => normal_diff::diff(&from_content, &to_content, &params),
+        Format::Unified => unified_diff::diff(&from_content, &to_content, &params),
+        Format::Context => context_diff::diff(&from_content, &to_content, &params),
+        Format::Ed => ed_diff::diff(&from_content, &to_content, &params).unwrap_or_else(|error| {
+            eprintln!("{error}");
+            exit(2);
+        }),
     };
-    io::stdout().write_all(&result).unwrap();
-    Ok(())
+    if params.brief && !result.is_empty() {
+        println!(
+            "Files {} and {} differ",
+            params.from.to_string_lossy(),
+            params.to.to_string_lossy()
+        );
+    } else {
+        io::stdout().write_all(&result).unwrap();
+    }
+    if result.is_empty() {
+        maybe_report_identical_files();
+        ExitCode::SUCCESS
+    } else {
+        ExitCode::from(1)
+    }
 }

src/normal_diff.rs

@@ -5,6 +5,9 @@
 
 use std::io::Write;
 
+use crate::params::Params;
+use crate::utils::do_write_line;
+
 #[derive(Debug, PartialEq)]
 struct Mismatch {
     pub line_number_expected: usize,
@@ -29,7 +32,7 @@ impl Mismatch {
 }
 
 // Produces a diff between the expected output and actual output.
-fn make_diff(expected: &[u8], actual: &[u8]) -> Vec<Mismatch> {
+fn make_diff(expected: &[u8], actual: &[u8], stop_early: bool) -> Vec<Mismatch> {
     let mut line_number_expected = 1;
     let mut line_number_actual = 1;
     let mut results = Vec::new();
@@ -100,6 +103,10 @@ fn make_diff(expected: &[u8], actual: &[u8]) -> Vec<Mismatch> {
                 }
             }
         }
+        if stop_early && !results.is_empty() {
+            // Optimization: stop analyzing the files as soon as there are any differences
+            return results;
+        }
     }
 
     if !mismatch.actual.is_empty() || !mismatch.expected.is_empty() {
@@ -110,9 +117,15 @@ fn make_diff(expected: &[u8], actual: &[u8]) -> Vec<Mismatch> {
 }
 
 #[must_use]
-pub fn diff(expected: &[u8], actual: &[u8]) -> Vec<u8> {
+pub fn diff(expected: &[u8], actual: &[u8], params: &Params) -> Vec<u8> {
+    // See https://www.gnu.org/software/diffutils/manual/html_node/Detailed-Normal.html
+    // for details on the syntax of the normal format.
     let mut output = Vec::new();
-    let diff_results = make_diff(expected, actual);
+    let diff_results = make_diff(expected, actual, params.brief);
+    if params.brief && !diff_results.is_empty() {
+        write!(&mut output, "\0").unwrap();
+        return output;
+    }
     for result in diff_results {
         let line_number_expected = result.line_number_expected;
         let line_number_actual = result.line_number_actual;
@@ -121,6 +134,7 @@ pub fn diff(expected: &[u8], actual: &[u8]) -> Vec<u8> {
         match (expected_count, actual_count) {
             (0, 0) => unreachable!(),
             (0, _) => writeln!(
+                // 'a' stands for "Add lines"
                 &mut output,
                 "{}a{},{}",
                 line_number_expected - 1,
@@ -129,6 +143,7 @@ pub fn diff(expected: &[u8], actual: &[u8]) -> Vec<u8> {
             )
             .unwrap(),
             (_, 0) => writeln!(
+                // 'd' stands for "Delete lines"
                 &mut output,
                 "{},{}d{}",
                 line_number_expected,
@@ -136,7 +151,33 @@ pub fn diff(expected: &[u8], actual: &[u8]) -> Vec<u8> {
                 line_number_actual - 1
             )
             .unwrap(),
+            (1, 1) => writeln!(
+                // 'c' stands for "Change lines"
+                // exactly one line replaced by one line
+                &mut output,
+                "{line_number_expected}c{line_number_actual}"
+            )
+            .unwrap(),
+            (1, _) => writeln!(
+                // one line replaced by multiple lines
+                &mut output,
+                "{}c{},{}",
+                line_number_expected,
+                line_number_actual,
+                actual_count + line_number_actual - 1
+            )
+            .unwrap(),
+            (_, 1) => writeln!(
+                // multiple lines replaced by one line
+                &mut output,
+                "{},{}c{}",
+                line_number_expected,
+                expected_count + line_number_expected - 1,
+                line_number_actual
+            )
+            .unwrap(),
             _ => writeln!(
+                // general case: multiple lines replaced by multiple lines
                 &mut output,
                 "{},{}c{},{}",
                 line_number_expected,
@@ -148,7 +189,7 @@ pub fn diff(expected: &[u8], actual: &[u8]) -> Vec<u8> {
         }
         for expected in &result.expected {
             write!(&mut output, "< ").unwrap();
-            output.write_all(expected).unwrap();
+            do_write_line(&mut output, expected, params.expand_tabs, params.tabsize).unwrap();
             writeln!(&mut output).unwrap();
         }
         if result.expected_missing_nl {
@@ -159,7 +200,7 @@ pub fn diff(expected: &[u8], actual: &[u8]) -> Vec<u8> {
         }
         for actual in &result.actual {
             write!(&mut output, "> ").unwrap();
-            output.write_all(actual).unwrap();
+            do_write_line(&mut output, actual, params.expand_tabs, params.tabsize).unwrap();
             writeln!(&mut output).unwrap();
         }
         if result.actual_missing_nl {
@@ -173,6 +214,18 @@ pub fn diff(expected: &[u8], actual: &[u8]) -> Vec<u8> {
 mod tests {
     use super::*;
     use pretty_assertions::assert_eq;
+
+    #[test]
+    fn test_basic() {
+        let mut a = Vec::new();
+        a.write_all(b"a\n").unwrap();
+        let mut b = Vec::new();
+        b.write_all(b"b\n").unwrap();
+        let diff = diff(&a, &b, &Params::default());
+        let expected = b"1c1\n< a\n---\n> b\n".to_vec();
+        assert_eq!(diff, expected);
+    }
+
     #[test]
     fn test_permutations() {
         let target = "target/normal-diff/";
@@ -221,7 +274,7 @@ mod tests {
                                 }
                                 // This test diff is intentionally reversed.
                                 // We want it to turn the alef into bet.
-                                let diff = diff(&alef, &bet);
+                                let diff = diff(&alef, &bet, &Params::default());
                                 File::create(&format!("{target}/ab.diff"))
                                     .unwrap()
                                     .write_all(&diff)
@@ -238,7 +291,7 @@ mod tests {
                                     .stdin(File::open(&format!("{target}/ab.diff")).unwrap())
                                     .output()
                                     .unwrap();
-                                assert!(output.status.success(), "{:?}", output);
+                                assert!(output.status.success(), "{output:?}");
                                 //println!("{}", String::from_utf8_lossy(&output.stdout));
                                 //println!("{}", String::from_utf8_lossy(&output.stderr));
                                 let alef = fs::read(&format!("{target}/alef")).unwrap();
@@ -313,7 +366,7 @@ mod tests {
                                     }
                                     // This test diff is intentionally reversed.
                                     // We want it to turn the alef into bet.
-                                    let diff = diff(&alef, &bet);
+                                    let diff = diff(&alef, &bet, &Params::default());
                                     File::create(&format!("{target}/abn.diff"))
                                         .unwrap()
                                         .write_all(&diff)
@@ -331,7 +384,7 @@ mod tests {
                                         .stdin(File::open(&format!("{target}/abn.diff")).unwrap())
                                         .output()
                                         .unwrap();
-                                    assert!(output.status.success(), "{:?}", output);
+                                    assert!(output.status.success(), "{output:?}");
                                     //println!("{}", String::from_utf8_lossy(&output.stdout));
                                     //println!("{}", String::from_utf8_lossy(&output.stderr));
                                     let alef = fs::read(&format!("{target}/alefn")).unwrap();
@@ -387,7 +440,7 @@ mod tests {
                                 }
                                 // This test diff is intentionally reversed.
                                 // We want it to turn the alef into bet.
-                                let diff = diff(&alef, &bet);
+                                let diff = diff(&alef, &bet, &Params::default());
                                 File::create(&format!("{target}/ab_.diff"))
                                     .unwrap()
                                     .write_all(&diff)
@@ -404,7 +457,7 @@ mod tests {
                                     .stdin(File::open(&format!("{target}/ab_.diff")).unwrap())
                                     .output()
                                     .unwrap();
-                                assert!(output.status.success(), "{:?}", output);
+                                assert!(output.status.success(), "{output:?}");
                                 //println!("{}", String::from_utf8_lossy(&output.stdout));
                                 //println!("{}", String::from_utf8_lossy(&output.stderr));
                                 let alef = fs::read(&format!("{target}/alef_")).unwrap();
@@ -465,7 +518,7 @@ mod tests {
                                 }
                                 // This test diff is intentionally reversed.
                                 // We want it to turn the alef into bet.
-                                let diff = diff(&alef, &bet);
+                                let diff = diff(&alef, &bet, &Params::default());
                                 File::create(&format!("{target}/abr.diff"))
                                     .unwrap()
                                     .write_all(&diff)
@@ -482,7 +535,7 @@ mod tests {
                                     .stdin(File::open(&format!("{target}/abr.diff")).unwrap())
                                     .output()
                                     .unwrap();
-                                assert!(output.status.success(), "{:?}", output);
+                                assert!(output.status.success(), "{output:?}");
                                 //println!("{}", String::from_utf8_lossy(&output.stdout));
                                 //println!("{}", String::from_utf8_lossy(&output.stderr));
                                 let alef = fs::read(&format!("{target}/alefr")).unwrap();
@@ -494,4 +547,38 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn test_stop_early() {
+        let from = ["a", "b", "c"].join("\n");
+        let to = ["a", "d", "c"].join("\n");
+
+        let diff_full = diff(from.as_bytes(), to.as_bytes(), &Params::default());
+        let expected_full = ["2c2", "< b", "---", "> d", ""].join("\n");
+        assert_eq!(diff_full, expected_full.as_bytes());
+
+        let diff_brief = diff(
+            from.as_bytes(),
+            to.as_bytes(),
+            &Params {
+                brief: true,
+                ..Default::default()
+            },
+        );
+        let expected_brief = "\0".as_bytes();
+        assert_eq!(diff_brief, expected_brief);
+
+        let nodiff_full = diff(from.as_bytes(), from.as_bytes(), &Params::default());
+        assert!(nodiff_full.is_empty());
+
+        let nodiff_brief = diff(
+            from.as_bytes(),
+            from.as_bytes(),
+            &Params {
+                brief: true,
+                ..Default::default()
+            },
+        );
+        assert!(nodiff_brief.is_empty());
+    }
 }

src/params.rs

@@ -1,7 +1,10 @@
 use std::ffi::{OsStr, OsString};
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+use regex::Regex;
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
 pub enum Format {
+    #[default]
     Normal,
     Unified,
     Context,
@@ -25,6 +28,25 @@ pub struct Params {
     pub to: OsString,
     pub format: Format,
     pub context_count: usize,
+    pub report_identical_files: bool,
+    pub brief: bool,
+    pub expand_tabs: bool,
+    pub tabsize: usize,
+}
+
+impl Default for Params {
+    fn default() -> Self {
+        Self {
+            from: OsString::default(),
+            to: OsString::default(),
+            format: Format::default(),
+            context_count: 3,
+            report_identical_files: false,
+            brief: false,
+            expand_tabs: false,
+            tabsize: 8,
+        }
+    }
 }
 
 pub fn parse_params<I: IntoIterator<Item = OsString>>(opts: I) -> Result<Params, String> {
@@ -34,24 +56,53 @@ pub fn parse_params<I: IntoIterator<Item = OsString>>(opts: I) -> Result<Params,
     let Some(exe) = opts.next() else {
         return Err("Usage: <exe> <from> <to>".to_string());
     };
+    let mut params = Params::default();
     let mut from = None;
     let mut to = None;
     let mut format = None;
-    let mut context_count = 3;
+    let tabsize_re = Regex::new(r"^--tabsize=(?<num>\d+)$").unwrap();
     while let Some(param) = opts.next() {
         if param == "--" {
             break;
         }
         if param == "-" {
             if from.is_none() {
-                from = Some(OsString::from("/dev/stdin"));
+                from = Some(param);
             } else if to.is_none() {
-                to = Some(OsString::from("/dev/stdin"));
+                to = Some(param);
             } else {
                 return Err(format!("Usage: {} <from> <to>", exe.to_string_lossy()));
             }
             continue;
         }
+        if param == "-s" || param == "--report-identical-files" {
+            params.report_identical_files = true;
+            continue;
+        }
+        if param == "-q" || param == "--brief" {
+            params.brief = true;
+            continue;
+        }
+        if param == "-t" || param == "--expand-tabs" {
+            params.expand_tabs = true;
+            continue;
+        }
+        if tabsize_re.is_match(param.to_string_lossy().as_ref()) {
+            // Because param matches the regular expression,
+            // it is safe to assume it is valid UTF-8.
+            let param = param.into_string().unwrap();
+            let tabsize_str = tabsize_re
+                .captures(param.as_str())
+                .unwrap()
+                .name("num")
+                .unwrap()
+                .as_str();
+            params.tabsize = match tabsize_str.parse::<usize>() {
+                Ok(num) => num,
+                Err(_) => return Err(format!("invalid tabsize «{tabsize_str}»")),
+            };
+            continue;
+        }
         let p = osstr_bytes(&param);
         if p.first() == Some(&b'-') && p.get(1) != Some(&b'-') {
             let mut bit = p[1..].iter().copied().peekable();
@@ -60,10 +111,10 @@ pub fn parse_params<I: IntoIterator<Item = OsString>>(opts: I) -> Result<Params,
             while let Some(b) = bit.next() {
                 match b {
                     b'0'..=b'9' => {
-                        context_count = (b - b'0') as usize;
+                        params.context_count = (b - b'0') as usize;
                         while let Some(b'0'..=b'9') = bit.peek() {
-                            context_count *= 10;
-                            context_count += (bit.next().unwrap() - b'0') as usize;
+                            params.context_count *= 10;
+                            params.context_count += (bit.next().unwrap() - b'0') as usize;
                         }
                     }
                     b'c' => {
@@ -97,7 +148,7 @@ pub fn parse_params<I: IntoIterator<Item = OsString>>(opts: I) -> Result<Params,
                         if let Some(context_count_maybe) =
                             context_count_maybe.and_then(|x| x.parse().ok())
                         {
-                            context_count = context_count_maybe;
+                            params.context_count = context_count_maybe;
                             break;
                         }
                         return Err("Invalid context count".to_string());
@@ -113,27 +164,22 @@ pub fn parse_params<I: IntoIterator<Item = OsString>>(opts: I) -> Result<Params,
             return Err(format!("Usage: {} <from> <to>", exe.to_string_lossy()));
         }
     }
-    let from = if let Some(from) = from {
+    params.from = if let Some(from) = from {
         from
     } else if let Some(param) = opts.next() {
         param
     } else {
         return Err(format!("Usage: {} <from> <to>", exe.to_string_lossy()));
     };
-    let to = if let Some(to) = to {
+    params.to = if let Some(to) = to {
         to
     } else if let Some(param) = opts.next() {
         param
     } else {
         return Err(format!("Usage: {} <from> <to>", exe.to_string_lossy()));
     };
-    let format = format.unwrap_or(Format::Normal);
-    Ok(Params {
-        from,
-        to,
-        format,
-        context_count,
-    })
+    params.format = format.unwrap_or(Format::default());
+    Ok(params)
 }
 
 #[cfg(test)]
@@ -148,8 +194,7 @@ mod tests {
             Ok(Params {
                 from: os("foo"),
                 to: os("bar"),
-                format: Format::Normal,
-                context_count: 3,
+                ..Default::default()
             }),
             parse_params([os("diff"), os("foo"), os("bar")].iter().cloned())
         );
@@ -161,7 +206,7 @@ mod tests {
                 from: os("foo"),
                 to: os("bar"),
                 format: Format::Ed,
-                context_count: 3,
+                ..Default::default()
             }),
             parse_params([os("diff"), os("-e"), os("foo"), os("bar")].iter().cloned())
         );
@@ -174,6 +219,7 @@ mod tests {
                 to: os("bar"),
                 format: Format::Unified,
                 context_count: 54,
+                ..Default::default()
             }),
             parse_params(
                 [os("diff"), os("-u54"), os("foo"), os("bar")]
@@ -187,6 +233,7 @@ mod tests {
                 to: os("bar"),
                 format: Format::Unified,
                 context_count: 54,
+                ..Default::default()
             }),
             parse_params(
                 [os("diff"), os("-U54"), os("foo"), os("bar")]
@@ -200,6 +247,7 @@ mod tests {
                 to: os("bar"),
                 format: Format::Unified,
                 context_count: 54,
+                ..Default::default()
             }),
             parse_params(
                 [os("diff"), os("-U"), os("54"), os("foo"), os("bar")]
@@ -213,6 +261,7 @@ mod tests {
                 to: os("bar"),
                 format: Format::Context,
                 context_count: 54,
+                ..Default::default()
             }),
             parse_params(
                 [os("diff"), os("-c54"), os("foo"), os("bar")]
@@ -222,18 +271,226 @@ mod tests {
         );
     }
     #[test]
+    fn report_identical_files() {
+        assert_eq!(
+            Ok(Params {
+                from: os("foo"),
+                to: os("bar"),
+                ..Default::default()
+            }),
+            parse_params([os("diff"), os("foo"), os("bar")].iter().cloned())
+        );
+        assert_eq!(
+            Ok(Params {
+                from: os("foo"),
+                to: os("bar"),
+                report_identical_files: true,
+                ..Default::default()
+            }),
+            parse_params([os("diff"), os("-s"), os("foo"), os("bar")].iter().cloned())
+        );
+        assert_eq!(
+            Ok(Params {
+                from: os("foo"),
+                to: os("bar"),
+                report_identical_files: true,
+                ..Default::default()
+            }),
+            parse_params(
+                [
+                    os("diff"),
+                    os("--report-identical-files"),
+                    os("foo"),
+                    os("bar"),
+                ]
+                .iter()
+                .cloned()
+            )
+        );
+    }
+    #[test]
+    fn brief() {
+        assert_eq!(
+            Ok(Params {
+                from: os("foo"),
+                to: os("bar"),
+                ..Default::default()
+            }),
+            parse_params([os("diff"), os("foo"), os("bar")].iter().cloned())
+        );
+        assert_eq!(
+            Ok(Params {
+                from: os("foo"),
+                to: os("bar"),
+                brief: true,
+                ..Default::default()
+            }),
+            parse_params([os("diff"), os("-q"), os("foo"), os("bar")].iter().cloned())
+        );
+        assert_eq!(
+            Ok(Params {
+                from: os("foo"),
+                to: os("bar"),
+                brief: true,
+                ..Default::default()
+            }),
+            parse_params(
+                [os("diff"), os("--brief"), os("foo"), os("bar"),]
+                    .iter()
+                    .cloned()
+            )
+        );
+    }
+    #[test]
+    fn expand_tabs() {
+        assert_eq!(
+            Ok(Params {
+                from: os("foo"),
+                to: os("bar"),
+                ..Default::default()
+            }),
+            parse_params([os("diff"), os("foo"), os("bar")].iter().cloned())
+        );
+        for option in ["-t", "--expand-tabs"] {
+            assert_eq!(
+                Ok(Params {
+                    from: os("foo"),
+                    to: os("bar"),
+                    expand_tabs: true,
+                    ..Default::default()
+                }),
+                parse_params(
+                    [os("diff"), os(option), os("foo"), os("bar")]
+                        .iter()
+                        .cloned()
+                )
+            );
+        }
+    }
+    #[test]
+    fn tabsize() {
+        assert_eq!(
+            Ok(Params {
+                from: os("foo"),
+                to: os("bar"),
+                ..Default::default()
+            }),
+            parse_params([os("diff"), os("foo"), os("bar")].iter().cloned())
+        );
+        assert_eq!(
+            Ok(Params {
+                from: os("foo"),
+                to: os("bar"),
+                tabsize: 0,
+                ..Default::default()
+            }),
+            parse_params(
+                [os("diff"), os("--tabsize=0"), os("foo"), os("bar")]
+                    .iter()
+                    .cloned()
+            )
+        );
+        assert_eq!(
+            Ok(Params {
+                from: os("foo"),
+                to: os("bar"),
+                tabsize: 42,
+                ..Default::default()
+            }),
+            parse_params(
+                [os("diff"), os("--tabsize=42"), os("foo"), os("bar")]
+                    .iter()
+                    .cloned()
+            )
+        );
+        assert!(parse_params(
+            [os("diff"), os("--tabsize"), os("foo"), os("bar")]
+                .iter()
+                .cloned()
+        )
+        .is_err());
+        assert!(parse_params(
+            [os("diff"), os("--tabsize="), os("foo"), os("bar")]
+                .iter()
+                .cloned()
+        )
+        .is_err());
+        assert!(parse_params(
+            [os("diff"), os("--tabsize=r2"), os("foo"), os("bar")]
+                .iter()
+                .cloned()
+        )
+        .is_err());
+        assert!(parse_params(
+            [os("diff"), os("--tabsize=-1"), os("foo"), os("bar")]
+                .iter()
+                .cloned()
+        )
+        .is_err());
+        assert!(parse_params(
+            [os("diff"), os("--tabsize=r2"), os("foo"), os("bar")]
+                .iter()
+                .cloned()
+        )
+        .is_err());
+        assert!(parse_params(
+            [
+                os("diff"),
+                os("--tabsize=92233720368547758088"),
+                os("foo"),
+                os("bar")
+            ]
+            .iter()
+            .cloned()
+        )
+        .is_err());
+    }
+    #[test]
     fn double_dash() {
         assert_eq!(
             Ok(Params {
                 from: os("-g"),
                 to: os("-h"),
-                format: Format::Normal,
-                context_count: 3,
+                ..Default::default()
             }),
             parse_params([os("diff"), os("--"), os("-g"), os("-h")].iter().cloned())
         );
     }
     #[test]
+    fn default_to_stdin() {
+        assert_eq!(
+            Ok(Params {
+                from: os("foo"),
+                to: os("-"),
+                ..Default::default()
+            }),
+            parse_params([os("diff"), os("foo"), os("-")].iter().cloned())
+        );
+        assert_eq!(
+            Ok(Params {
+                from: os("-"),
+                to: os("bar"),
+                ..Default::default()
+            }),
+            parse_params([os("diff"), os("-"), os("bar")].iter().cloned())
+        );
+        assert_eq!(
+            Ok(Params {
+                from: os("-"),
+                to: os("-"),
+                ..Default::default()
+            }),
+            parse_params([os("diff"), os("-"), os("-")].iter().cloned())
+        );
+        assert!(parse_params([os("diff"), os("foo"), os("bar"), os("-")].iter().cloned()).is_err());
+        assert!(parse_params([os("diff"), os("-"), os("-"), os("-")].iter().cloned()).is_err());
+    }
+    #[test]
+    fn missing_arguments() {
+        assert!(parse_params([os("diff")].iter().cloned()).is_err());
+        assert!(parse_params([os("diff"), os("foo")].iter().cloned()).is_err());
+    }
+    #[test]
     fn unknown_argument() {
         assert!(
             parse_params([os("diff"), os("-g"), os("foo"), os("bar")].iter().cloned()).is_err()
@@ -245,4 +502,15 @@ mod tests {
     fn empty() {
         assert!(parse_params([].iter().cloned()).is_err());
     }
+    #[test]
+    fn conflicting_output_styles() {
+        for (arg1, arg2) in [("-u", "-c"), ("-u", "-e"), ("-c", "-u"), ("-c", "-U42")] {
+            assert!(parse_params(
+                [os("diff"), os(arg1), os(arg2), os("foo"), os("bar")]
+                    .iter()
+                    .cloned()
+            )
+            .is_err());
+        }
+    }
 }

src/unified_diff.rs

@@ -6,6 +6,10 @@
 use std::collections::VecDeque;
 use std::io::Write;
 
+use crate::params::Params;
+use crate::utils::do_write_line;
+use crate::utils::get_modification_time;
+
 #[derive(Debug, PartialEq)]
 pub enum DiffLine {
     Context(Vec<u8>),
@@ -32,7 +36,12 @@ impl Mismatch {
 }
 
 // Produces a diff between the expected output and actual output.
-fn make_diff(expected: &[u8], actual: &[u8], context_size: usize) -> Vec<Mismatch> {
+fn make_diff(
+    expected: &[u8],
+    actual: &[u8],
+    context_size: usize,
+    stop_early: bool,
+) -> Vec<Mismatch> {
     let mut line_number_expected = 1;
     let mut line_number_actual = 1;
     let mut context_queue: VecDeque<&[u8]> = VecDeque::with_capacity(context_size);
@@ -180,6 +189,10 @@ fn make_diff(expected: &[u8], actual: &[u8], context_size: usize) -> Vec<Mismatc
                 line_number_actual += 1;
             }
         }
+        if stop_early && !results.is_empty() {
+            // Optimization: stop analyzing the files as soon as there are any differences
+            return results;
+        }
     }
 
     results.push(mismatch);
@@ -225,18 +238,24 @@ fn make_diff(expected: &[u8], actual: &[u8], context_size: usize) -> Vec<Mismatc
 }
 
 #[must_use]
-pub fn diff(
-    expected: &[u8],
-    expected_filename: &str,
-    actual: &[u8],
-    actual_filename: &str,
-    context_size: usize,
-) -> Vec<u8> {
-    let mut output = format!("--- {expected_filename}\t\n+++ {actual_filename}\t\n").into_bytes();
-    let diff_results = make_diff(expected, actual, context_size);
+pub fn diff(expected: &[u8], actual: &[u8], params: &Params) -> Vec<u8> {
+    let from_modified_time = get_modification_time(&params.from.to_string_lossy());
+    let to_modified_time = get_modification_time(&params.to.to_string_lossy());
+    let mut output = format!(
+        "--- {0}\t{1}\n+++ {2}\t{3}\n",
+        params.from.to_string_lossy(),
+        from_modified_time,
+        params.to.to_string_lossy(),
+        to_modified_time
+    )
+    .into_bytes();
+    let diff_results = make_diff(expected, actual, params.context_count, params.brief);
     if diff_results.is_empty() {
         return Vec::new();
-    };
+    }
+    if params.brief {
+        return output;
+    }
     for result in diff_results {
         let mut line_number_expected = result.line_number_expected;
         let mut line_number_actual = result.line_number_actual;
@@ -358,17 +377,20 @@ pub fn diff(
             match line {
                 DiffLine::Expected(e) => {
                     write!(output, "-").expect("write to Vec is infallible");
-                    output.write_all(&e).expect("write to Vec is infallible");
+                    do_write_line(&mut output, &e, params.expand_tabs, params.tabsize)
+                        .expect("write to Vec is infallible");
                     writeln!(output).unwrap();
                 }
                 DiffLine::Context(c) => {
                     write!(output, " ").expect("write to Vec is infallible");
-                    output.write_all(&c).expect("write to Vec is infallible");
+                    do_write_line(&mut output, &c, params.expand_tabs, params.tabsize)
+                        .expect("write to Vec is infallible");
                     writeln!(output).unwrap();
                 }
                 DiffLine::Actual(r) => {
                     write!(output, "+",).expect("write to Vec is infallible");
-                    output.write_all(&r).expect("write to Vec is infallible");
+                    do_write_line(&mut output, &r, params.expand_tabs, params.tabsize)
+                        .expect("write to Vec is infallible");
                     writeln!(output).unwrap();
                 }
                 DiffLine::MissingNL => {
@@ -434,8 +456,16 @@ mod tests {
                                 }
                                 // This test diff is intentionally reversed.
                                 // We want it to turn the alef into bet.
-                                let diff =
-                                    diff(&alef, "a/alef", &bet, &format!("{target}/alef"), 2);
+                                let diff = diff(
+                                    &alef,
+                                    &bet,
+                                    &Params {
+                                        from: "a/alef".into(),
+                                        to: (&format!("{target}/alef")).into(),
+                                        context_count: 2,
+                                        ..Default::default()
+                                    },
+                                );
                                 File::create(&format!("{target}/ab.diff"))
                                     .unwrap()
                                     .write_all(&diff)
@@ -469,7 +499,7 @@ mod tests {
                                     .unwrap();
                                 println!("{}", String::from_utf8_lossy(&output.stdout));
                                 println!("{}", String::from_utf8_lossy(&output.stderr));
-                                assert!(output.status.success(), "{:?}", output);
+                                assert!(output.status.success(), "{output:?}");
                                 let alef = fs::read(&format!("{target}/alef")).unwrap();
                                 assert_eq!(alef, bet);
                             }
@@ -542,8 +572,16 @@ mod tests {
                                     }
                                     // This test diff is intentionally reversed.
                                     // We want it to turn the alef into bet.
-                                    let diff =
-                                        diff(&alef, "a/alefn", &bet, &format!("{target}/alefn"), 2);
+                                    let diff = diff(
+                                        &alef,
+                                        &bet,
+                                        &Params {
+                                            from: "a/alefn".into(),
+                                            to: (&format!("{target}/alefn")).into(),
+                                            context_count: 2,
+                                            ..Default::default()
+                                        },
+                                    );
                                     File::create(&format!("{target}/abn.diff"))
                                         .unwrap()
                                         .write_all(&diff)
@@ -559,7 +597,7 @@ mod tests {
                                         .stdin(File::open(&format!("{target}/abn.diff")).unwrap())
                                         .output()
                                         .unwrap();
-                                    assert!(output.status.success(), "{:?}", output);
+                                    assert!(output.status.success(), "{output:?}");
                                     //println!("{}", String::from_utf8_lossy(&output.stdout));
                                     //println!("{}", String::from_utf8_lossy(&output.stderr));
                                     let alef = fs::read(&format!("{target}/alefn")).unwrap();
@@ -630,8 +668,16 @@ mod tests {
                                     }
                                     // This test diff is intentionally reversed.
                                     // We want it to turn the alef into bet.
-                                    let diff =
-                                        diff(&alef, "a/alef_", &bet, &format!("{target}/alef_"), 2);
+                                    let diff = diff(
+                                        &alef,
+                                        &bet,
+                                        &Params {
+                                            from: "a/alef_".into(),
+                                            to: (&format!("{target}/alef_")).into(),
+                                            context_count: 2,
+                                            ..Default::default()
+                                        },
+                                    );
                                     File::create(&format!("{target}/ab_.diff"))
                                         .unwrap()
                                         .write_all(&diff)
@@ -647,7 +693,7 @@ mod tests {
                                         .stdin(File::open(&format!("{target}/ab_.diff")).unwrap())
                                         .output()
                                         .unwrap();
-                                    assert!(output.status.success(), "{:?}", output);
+                                    assert!(output.status.success(), "{output:?}");
                                     //println!("{}", String::from_utf8_lossy(&output.stdout));
                                     //println!("{}", String::from_utf8_lossy(&output.stderr));
                                     let alef = fs::read(&format!("{target}/alef_")).unwrap();
@@ -703,8 +749,16 @@ mod tests {
                                 }
                                 // This test diff is intentionally reversed.
                                 // We want it to turn the alef into bet.
-                                let diff =
-                                    diff(&alef, "a/alefx", &bet, &format!("{target}/alefx"), 2);
+                                let diff = diff(
+                                    &alef,
+                                    &bet,
+                                    &Params {
+                                        from: "a/alefx".into(),
+                                        to: (&format!("{target}/alefx")).into(),
+                                        context_count: 2,
+                                        ..Default::default()
+                                    },
+                                );
                                 File::create(&format!("{target}/abx.diff"))
                                     .unwrap()
                                     .write_all(&diff)
@@ -720,7 +774,7 @@ mod tests {
                                     .stdin(File::open(&format!("{target}/abx.diff")).unwrap())
                                     .output()
                                     .unwrap();
-                                assert!(output.status.success(), "{:?}", output);
+                                assert!(output.status.success(), "{output:?}");
                                 //println!("{}", String::from_utf8_lossy(&output.stdout));
                                 //println!("{}", String::from_utf8_lossy(&output.stderr));
                                 let alef = fs::read(&format!("{target}/alefx")).unwrap();
@@ -781,8 +835,16 @@ mod tests {
                                 }
                                 // This test diff is intentionally reversed.
                                 // We want it to turn the alef into bet.
-                                let diff =
-                                    diff(&alef, "a/alefr", &bet, &format!("{target}/alefr"), 2);
+                                let diff = diff(
+                                    &alef,
+                                    &bet,
+                                    &Params {
+                                        from: "a/alefr".into(),
+                                        to: (&format!("{target}/alefr")).into(),
+                                        context_count: 2,
+                                        ..Default::default()
+                                    },
+                                );
                                 File::create(&format!("{target}/abr.diff"))
                                     .unwrap()
                                     .write_all(&diff)
@@ -798,7 +860,7 @@ mod tests {
                                     .stdin(File::open(&format!("{target}/abr.diff")).unwrap())
                                     .output()
                                     .unwrap();
-                                assert!(output.status.success(), "{:?}", output);
+                                assert!(output.status.success(), "{output:?}");
                                 //println!("{}", String::from_utf8_lossy(&output.stdout));
                                 //println!("{}", String::from_utf8_lossy(&output.stderr));
                                 let alef = fs::read(&format!("{target}/alefr")).unwrap();
@@ -810,4 +872,74 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn test_stop_early() {
+        use crate::assert_diff_eq;
+
+        let from_filename = "foo";
+        let from = ["a", "b", "c", ""].join("\n");
+        let to_filename = "bar";
+        let to = ["a", "d", "c", ""].join("\n");
+
+        let diff_full = diff(
+            from.as_bytes(),
+            to.as_bytes(),
+            &Params {
+                from: from_filename.into(),
+                to: to_filename.into(),
+                ..Default::default()
+            },
+        );
+
+        let expected_full = [
+            "--- foo\tTIMESTAMP",
+            "+++ bar\tTIMESTAMP",
+            "@@ -1,3 +1,3 @@",
+            " a",
+            "-b",
+            "+d",
+            " c",
+            "",
+        ]
+        .join("\n");
+        assert_diff_eq!(diff_full, expected_full);
+
+        let diff_brief = diff(
+            from.as_bytes(),
+            to.as_bytes(),
+            &Params {
+                from: from_filename.into(),
+                to: to_filename.into(),
+                brief: true,
+                ..Default::default()
+            },
+        );
+
+        let expected_brief = ["--- foo\tTIMESTAMP", "+++ bar\tTIMESTAMP", ""].join("\n");
+        assert_diff_eq!(diff_brief, expected_brief);
+
+        let nodiff_full = diff(
+            from.as_bytes(),
+            from.as_bytes(),
+            &Params {
+                from: from_filename.into(),
+                to: to_filename.into(),
+                ..Default::default()
+            },
+        );
+        assert!(nodiff_full.is_empty());
+
+        let nodiff_brief = diff(
+            from.as_bytes(),
+            from.as_bytes(),
+            &Params {
+                from: from_filename.into(),
+                to: to_filename.into(),
+                brief: true,
+                ..Default::default()
+            },
+        );
+        assert!(nodiff_brief.is_empty());
+    }
 }

src/utils.rs

@@ -0,0 +1,179 @@
+// 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.
+
+use std::io::Write;
+
+use unicode_width::UnicodeWidthStr;
+
+/// Replace tabs by spaces in the input line.
+/// Correctly handle multi-bytes characters.
+/// This assumes that line does not contain any line breaks (if it does, the result is undefined).
+#[must_use]
+pub fn do_expand_tabs(line: &[u8], tabsize: usize) -> Vec<u8> {
+    let tab = b'\t';
+    let ntabs = line.iter().filter(|c| **c == tab).count();
+    if ntabs == 0 {
+        return line.to_vec();
+    }
+    let mut result = Vec::with_capacity(line.len() + ntabs * (tabsize - 1));
+    let mut offset = 0;
+
+    let mut iter = line.split(|c| *c == tab).peekable();
+    while let Some(chunk) = iter.next() {
+        match String::from_utf8(chunk.to_vec()) {
+            Ok(s) => offset += UnicodeWidthStr::width(s.as_str()),
+            Err(_) => offset += chunk.len(),
+        }
+        result.extend_from_slice(chunk);
+        if iter.peek().is_some() {
+            result.resize(result.len() + tabsize - offset % tabsize, b' ');
+            offset = 0;
+        }
+    }
+
+    result
+}
+
+/// Write a single line to an output stream, expanding tabs to space if necessary.
+/// This assumes that line does not contain any line breaks
+/// (if it does and tabs are to be expanded to spaces, the result is undefined).
+pub fn do_write_line(
+    output: &mut Vec<u8>,
+    line: &[u8],
+    expand_tabs: bool,
+    tabsize: usize,
+) -> std::io::Result<()> {
+    if expand_tabs {
+        output.write_all(do_expand_tabs(line, tabsize).as_slice())
+    } else {
+        output.write_all(line)
+    }
+}
+
+/// Retrieves the modification time of the input file specified by file path
+/// If an error occurs, it returns the current system time
+pub fn get_modification_time(file_path: &str) -> String {
+    use chrono::{DateTime, Local};
+    use std::fs;
+    use std::time::SystemTime;
+
+    let modification_time: SystemTime = fs::metadata(file_path)
+        .and_then(|m| m.modified())
+        .unwrap_or(SystemTime::now());
+
+    let modification_time: DateTime<Local> = modification_time.into();
+    let modification_time: String = modification_time
+        .format("%Y-%m-%d %H:%M:%S%.9f %z")
+        .to_string();
+
+    modification_time
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    mod expand_tabs {
+        use super::*;
+        use pretty_assertions::assert_eq;
+
+        fn assert_tab_expansion(line: &str, tabsize: usize, expected: &str) {
+            assert_eq!(
+                do_expand_tabs(line.as_bytes(), tabsize),
+                expected.as_bytes()
+            );
+        }
+
+        #[test]
+        fn basics() {
+            assert_tab_expansion("foo barr   baz", 8, "foo barr   baz");
+            assert_tab_expansion("foo\tbarr\tbaz", 8, "foo     barr    baz");
+            assert_tab_expansion("foo\tbarr\tbaz", 5, "foo  barr baz");
+            assert_tab_expansion("foo\tbarr\tbaz", 2, "foo barr  baz");
+        }
+
+        #[test]
+        fn multibyte_chars() {
+            assert_tab_expansion("foo\tépée\tbaz", 8, "foo     épée    baz");
+            assert_tab_expansion("foo\t😉\tbaz", 5, "foo  😉   baz");
+
+            // Note: The Woman Scientist emoji (👩‍🔬) is a ZWJ sequence combining
+            // the Woman emoji (👩) and the Microscope emoji (🔬). On supported platforms
+            // it is displayed as a single emoji and should have a print size of 2 columns,
+            // but terminal emulators tend to not support this, and display the two emojis
+            // side by side, thus accounting for a print size of 4 columns.
+            assert_tab_expansion("foo\t👩‍🔬\tbaz", 6, "foo   👩‍🔬  baz");
+        }
+
+        #[test]
+        fn invalid_utf8() {
+            // [240, 240, 152, 137] is an invalid UTF-8 sequence, so it is handled as 4 bytes
+            assert_eq!(
+                do_expand_tabs(&[240, 240, 152, 137, 9, 102, 111, 111], 8),
+                &[240, 240, 152, 137, 32, 32, 32, 32, 102, 111, 111]
+            );
+        }
+    }
+
+    mod write_line {
+        use super::*;
+        use pretty_assertions::assert_eq;
+
+        fn assert_line_written(line: &str, expand_tabs: bool, tabsize: usize, expected: &str) {
+            let mut output: Vec<u8> = Vec::new();
+            assert!(do_write_line(&mut output, line.as_bytes(), expand_tabs, tabsize).is_ok());
+            assert_eq!(output, expected.as_bytes());
+        }
+
+        #[test]
+        fn basics() {
+            assert_line_written("foo bar baz", false, 8, "foo bar baz");
+            assert_line_written("foo bar\tbaz", false, 8, "foo bar\tbaz");
+            assert_line_written("foo bar\tbaz", true, 8, "foo bar baz");
+        }
+    }
+
+    mod modification_time {
+        use super::*;
+
+        #[test]
+        fn set_time() {
+            use chrono::{DateTime, Local};
+            use std::time::SystemTime;
+            use tempfile::NamedTempFile;
+
+            let temp = NamedTempFile::new().unwrap();
+            // set file modification time equal to current time
+            let current = SystemTime::now();
+            let _ = temp.as_file().set_modified(current);
+
+            // format current time
+            let current: DateTime<Local> = current.into();
+            let current: String = current.format("%Y-%m-%d %H:%M:%S%.9f %z").to_string();
+
+            // verify
+            assert_eq!(
+                current,
+                get_modification_time(&temp.path().to_string_lossy())
+            );
+        }
+
+        #[test]
+        fn invalid_file() {
+            use chrono::{DateTime, Local};
+            use std::time::SystemTime;
+
+            let invalid_file = "target/utils/invalid-file";
+
+            // store current time before calling `get_modification_time`
+            // Because the file is invalid, it will return SystemTime::now()
+            // which will be greater than previously saved time
+            let current_time: DateTime<Local> = SystemTime::now().into();
+            let m_time: DateTime<Local> = get_modification_time(invalid_file).parse().unwrap();
+
+            assert!(m_time > current_time);
+        }
+    }
+}