New release (0.4.2)

CI: test all features

.appveyor.yml

@@ -1,23 +0,0 @@
-os: Visual Studio 2015
-
-version: "{build}"
-
-environment:
-  matrix:
-    - channel: stable
-      target: x86_64-pc-windows-msvc
-    - channel: nightly
-      target: x86_64-pc-windows-msvc
-
-install:
-  - appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
-  - rustup-init -yv --default-toolchain %channel% --default-host %target%
-  - set PATH=%PATH%;%USERPROFILE%\.cargo\bin
-  - rustc -vV && cargo -vV
-
-build_script:
-  - cargo build --verbose
-
-test_script:
-  - cargo test --verbose
-

.github/dependabot.yml

@@ -0,0 +1,12 @@
+version: 2
+updates:
+  - package-ecosystem: "cargo"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    open-pull-requests-limit: 5
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: daily
+    open-pull-requests-limit: 5

.github/workflows/ci.yml

@@ -10,15 +10,25 @@ jobs:
       matrix:
         os: [ubuntu-latest, macOS-latest, windows-latest]
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@v3
+      - name: Install `rust` toolchain
+        run: |
+          ## Install `rust` toolchain
+          rustup toolchain install stable --no-self-update -c rustfmt --profile minimal
+          rustup default stable
+
+      # For bindgen: https://github.com/rust-lang/rust-bindgen/issues/1797
+      - uses: KyleMayes/install-llvm-action@v1
+        if: matrix.os == 'windows-latest'
         with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - uses: actions-rs/cargo@v1
-        with:
-          command: check
+          version: "11.0"
+          directory: ${{ runner.temp }}/llvm
+      - run: echo "LIBCLANG_PATH=$((gcm clang).source -replace "clang.exe")" >> $env:GITHUB_ENV
+        if: matrix.os == 'windows-latest'
+
+      - name: Check
+        run: |
+          cargo check --all --all-features
 
   test:
     name: cargo test
@@ -27,44 +37,116 @@ jobs:
       matrix:
         os: [ubuntu-latest, macOS-latest, windows-latest]
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@v3
+      - name: Install `rust` toolchain
+        run: |
+          ## Install `rust` toolchain
+          rustup toolchain install stable --no-self-update -c rustfmt --profile minimal
+          rustup default stable
+
+      # For bindgen: https://github.com/rust-lang/rust-bindgen/issues/1797
+      - uses: KyleMayes/install-llvm-action@v1
+        if: matrix.os == 'windows-latest'
         with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - uses: actions-rs/cargo@v1
-        with:
-          command: test
+          version: "11.0"
+          directory: ${{ runner.temp }}/llvm
+      - run: echo "LIBCLANG_PATH=$((gcm clang).source -replace "clang.exe")" >> $env:GITHUB_ENV
+        if: matrix.os == 'windows-latest'
+
+      - name: Check
+        run: |
+          cargo check
 
   fmt:
     name: cargo fmt --all -- --check
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
+      - uses: actions/checkout@v3
+      - name: Install `rust` toolchain
+        run: |
+          ## Install `rust` toolchain
+          rustup toolchain install stable --no-self-update -c rustfmt --profile minimal
+          rustup default stable
+
       - run: rustup component add rustfmt
-      - uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
+      - name: cargo fmt
+        run: |
+          cargo fmt --all -- --check
 
   clippy:
     name: cargo clippy -- -D warnings
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
+      - uses: actions/checkout@v3
+      - name: Install `rust` toolchain
+        run: |
+          ## Install `rust` toolchain
+          rustup toolchain install stable --no-self-update -c rustfmt --profile minimal
+          rustup default stable
       - run: rustup component add clippy
-      - uses: actions-rs/cargo@v1
+      - name: cargo clippy
+        run: |
+          cargo clippy -- -D warnings
+
+  grcov:
+    name: Code coverage
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os:
+          - ubuntu-latest
+        toolchain:
+          - nightly
+        cargo_flags:
+          - "--all-features"
+    steps:
+      - name: Checkout source code
+        uses: actions/checkout@v3
+
+      - name: Install `rust` toolchain
+        run: |
+          ## Install `rust` toolchain
+          rustup toolchain install nightly --no-self-update -c rustfmt --profile minimal
+          rustup default nightly
+
+      - name: "`grcov` ~ install"
+        run: cargo install grcov
+
+      - name: cargo test
+        run: |
+          cargo test --all --no-fail-fast ${{ matrix.cargo_flags }}
+        env:
+          CARGO_INCREMENTAL: "0"
+          RUSTFLAGS: '-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort -Cdebug-assertions=off'
+          RUSTDOCFLAGS: '-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort -Cdebug-assertions=off'
+
+      - name: Generate coverage data
+        id: grcov
+        run: |
+          grcov target/debug/ \
+              --branch \
+              --llvm \
+              --source-dir . \
+              --output-path lcov.info \
+              --ignore-not-existing \
+              --excl-line "#\\[derive\\(" \
+              --excl-br-line "#\\[derive\\(" \
+              --excl-start "#\\[cfg\\(test\\)\\]" \
+              --excl-br-start "#\\[cfg\\(test\\)\\]" \
+              --commit-sha ${{ github.sha }} \
+              --service-job-id ${{ github.job }} \
+              --service-name "GitHub Actions" \
+              --service-number ${{ github.run_id }}
+      - name: Upload coverage as artifact
+        uses: actions/upload-artifact@v3
         with:
-          command: clippy
-          args: -- -D warnings
+          name: lcov.info
+          # path: ${{ steps.grcov.outputs.report }}
+          path: lcov.info
+
+      - name: Upload coverage to codecov.io
+        uses: codecov/codecov-action@v3
+        with:
+          # file: ${{ steps.grcov.outputs.report }}
+          file: lcov.info
+          fail_ci_if_error: true

.github/workflows/compat.yml

@@ -0,0 +1,145 @@
+on: [push, pull_request]
+
+name: External testsuites
+
+jobs:
+  gnu-tests:
+    name: Run GNU findutils tests
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout findutils
+      uses: actions/checkout@v3
+      with:
+        path: findutils
+    - name: Checkout GNU findutils
+      uses: actions/checkout@v3
+      with:
+        repository: gnu-mirror-unofficial/findutils
+        path: findutils.gnu
+        ref: 5768a03ddfb5e18b1682e339d6cdd24ff721c510
+        submodules: true
+    - name: Install `rust` toolchain
+      run: |
+        ## Install `rust` toolchain
+        rustup toolchain install stable --no-self-update -c rustfmt --profile minimal
+        rustup default stable
+    - name: Install dependencies
+      shell: bash
+      run: |
+        # Enable sources & install dependencies
+        sudo find /etc/apt/sources.list* -type f -exec sed -i 'p; s/^deb /deb-src /' '{}' +
+        sudo apt-get update
+        sudo apt-get build-dep findutils
+    - name: Run GNU tests
+      shell: bash
+      run: |
+        cd findutils
+        bash util/build-gnu.sh ||:
+    - name: Extract testing info
+      shell: bash
+      run: |
+    - uses: actions/upload-artifact@v3
+      with:
+        name: gnu-test-report
+        path: |
+          findutils.gnu/find/testsuite/*.log
+          findutils.gnu/xargs/testsuite/*.log
+          findutils.gnu/tests/**/*.log
+    - uses: actions/upload-artifact@v3
+      with:
+        name: gnu-result
+        path: gnu-result.json
+    - name: Download the result
+      uses: dawidd6/action-download-artifact@v2
+      with:
+        workflow: compat.yml
+        workflow_conclusion: completed
+        name: gnu-result
+        repo: uutils/findutils
+        branch: main
+        path: dl
+    - name: Download the log
+      uses: dawidd6/action-download-artifact@v2
+      with:
+        workflow: compat.yml
+        workflow_conclusion: completed
+        name: gnu-test-report
+        repo: uutils/findutils
+        branch: main
+        path: dl
+    - name: Compare failing tests against master
+      shell: bash
+      run: |
+        ./findutils/util/diff-gnu.sh ./dl ./findutils.gnu
+    - name: Compare against main results
+      shell: bash
+      run: |
+        mv dl/gnu-result.json latest-gnu-result.json
+        python findutils/util/compare_gnu_result.py
+
+  bfs-tests:
+    name: Run BFS tests
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout findutils
+      uses: actions/checkout@v3
+      with:
+        path: findutils
+    - name: Checkout BFS
+      uses: actions/checkout@v3
+      with:
+        repository: tavianator/bfs
+        path: bfs
+        ref: '2.6.2'
+    - name: Install `rust` toolchain
+      run: |
+        ## Install `rust` toolchain
+        rustup toolchain install stable --no-self-update -c rustfmt --profile minimal
+        rustup default stable
+    - name: Install dependencies
+      shell: bash
+      run: |
+        # Enable sources & install dependencies
+        sudo find /etc/apt/sources.list* -type f -exec sed -i 'p; s/^deb /deb-src /' '{}' +
+        sudo apt-get update
+        sudo apt-get build-dep bfs
+    - name: Run BFS tests
+      shell: bash
+      run: |
+        cd findutils
+        bash util/build-bfs.sh ||:
+    - uses: actions/upload-artifact@v3
+      with:
+        name: bfs-test-report
+        path: bfs/tests.log
+    - uses: actions/upload-artifact@v3
+      with:
+        name: bfs-result
+        path: bfs-result.json
+    - name: Download the result
+      uses: dawidd6/action-download-artifact@v2
+      with:
+        workflow: compat.yml
+        workflow_conclusion: completed
+        name: bfs-result
+        repo: uutils/findutils
+        branch: main
+        path: dl
+    - name: Download the log
+      uses: dawidd6/action-download-artifact@v2
+      with:
+        workflow: compat.yml
+        workflow_conclusion: completed
+        name: bfs-test-report
+        repo: uutils/findutils
+        branch: main
+        path: dl
+    - name: Compare failing tests against main
+      shell: bash
+      run: |
+        ./findutils/util/diff-bfs.sh dl/tests.log bfs/tests.log
+    - name: Compare against main results
+      shell: bash
+      run: |
+        mv dl/bfs-result.json latest-bfs-result.json
+        python findutils/util/compare_bfs_result.py

.gitignore

@@ -3,5 +3,4 @@ target
 .project
 .cargo
 .settings
-test_data/links/link-f
-test_data/links/link-d
+test_data/links/link-*

.pre-commit-config.yaml

@@ -0,0 +1,17 @@
+repos:
+-   repo: local
+    hooks:
+    -   id: rust-linting
+        name: Rust linting
+        description: Run cargo fmt on files included in the commit.
+        entry: cargo +nightly fmt --
+        pass_filenames: true
+        types: [file, rust]
+        language: system
+    -   id: rust-clippy
+        name: Rust clippy
+        description: Run cargo clippy on files included in the commit.
+        entry: cargo +nightly clippy --workspace --all-targets --all-features --
+        pass_filenames: false
+        types: [file, rust]
+        language: system

.travis.yml

@@ -1,33 +0,0 @@
-language: rust
-
-sudo: false
-os:
-  - linux
-  - osx
-rust:
-  - stable
-  - nightly
-
-matrix:
-  fast_finish: true
-
-branches:
-  only:
-    - master
-
-cache: cargo
-
-before_cache: |
-  if [[ "$TRAVIS_RUST_VERSION" = nightly ]]; then
-    RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install cargo-tarpaulin -f
-  fi
-
-script:
-  - cargo build --verbose
-  - cargo test --verbose
-
-after_script: |
-  if [[ "$TRAVIS_OS_NAME" = linux && "$TRAVIS_RUST_VERSION" = nightly ]]; then
-    cargo tarpaulin --out Xml
-    bash <(curl -s https://codecov.io/bash)
-  fi

AUTHORS

@@ -1,4 +0,0 @@
-# Names should be added to this file like so:
-# # Name or Organization <email address>
-#
-# Google Inc. <opensource@google.com>

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "findutils"
-version = "0.1.0"
+version = "0.4.2"
 homepage = "https://github.com/uutils/findutils"
 repository = "https://github.com/uutils/findutils"
 edition = "2018"
@@ -10,20 +10,31 @@ description = "Rust implementation of GNU findutils"
 authors = ["uutils developers"]
 
 [dependencies]
-glob = "0.3"
+chrono = "0.4"
+clap = "2.34"
+faccess = "0.2.4"
 walkdir = "2.3"
-tempdir = "0.3"
-regex = "1.4"
+regex = "1.7"
+once_cell = "1.18"
+onig = "6.4"
+uucore = { version = "0.0.20", features = ["entries", "fs", "fsext", "mode"] }
 
 [dev-dependencies]
-assert_cmd = "1"
-predicates = "1"
-serial_test = "0.5"
+assert_cmd = "2"
+filetime = "0.2"
+nix = "0.26"
+predicates = "3"
+serial_test = "2.0"
+tempfile = "3"
 
 [[bin]]
 name = "find"
 path = "src/find/main.rs"
 
+[[bin]]
+name = "xargs"
+path = "src/xargs/main.rs"
+
 [[bin]]
 name = "testing-commandline"
 path = "src/testing/commandline/main.rs"

README.md

@@ -1,7 +1,23 @@
 # findutils
 
-[![Build Status](https://travis-ci.org/uutils/findutils.svg?branch=master)](https://travis-ci.org/uutils/findutils)
-[![Build status](https://ci.appveyor.com/api/projects/status/wrmbs03dn6sb721e/branch/master?svg=true)](https://ci.appveyor.com/project/Arcterus/findutils/branch/master)
+[![Crates.io](https://img.shields.io/crates/v/findutils.svg)](https://crates.io/crates/findutils)
+[![dependency status](https://deps.rs/repo/github/uutils/findutils/status.svg)](https://deps.rs/repo/github/uutils/findutils)
 [![codecov](https://codecov.io/gh/uutils/findutils/branch/master/graph/badge.svg)](https://codecov.io/gh/uutils/findutils)
 
 Rust implementation of [GNU findutils](https://www.gnu.org/software/findutils/).
+
+## Run the GNU testsuite on rust/findutils:
+
+```
+bash util/build-gnu.sh
+
+# To run a specific test:
+bash util/build-gnu.sh tests/misc/help-version.sh
+```
+
+## Comparing with GNU
+
+![Evolution over time - GNU testsuite](https://github.com/uutils/findutils-tracking/blob/main/gnu-results.png?raw=true)
+![Evolution over time - BFS testsuite](https://github.com/uutils/findutils-tracking/blob/main/bfs-results.png?raw=true)
+
+For more details, see https://github.com/uutils/findutils-tracking/

src/find/main.rs

@@ -4,12 +4,9 @@
 // license that can be found in the LICENSE file or at
 // https://opensource.org/licenses/MIT.
 
-extern crate findutils;
-extern crate glob;
-
 fn main() {
     let args = std::env::args().collect::<Vec<String>>();
-    let strs: Vec<&str> = args.iter().map(|s| s.as_ref()).collect();
+    let strs: Vec<&str> = args.iter().map(std::convert::AsRef::as_ref).collect();
     let deps = findutils::find::StandardDependencies::new();
     std::process::exit(findutils::find::find_main(&strs, &deps));
 }

src/find/matchers/access.rs

@@ -0,0 +1,60 @@
+// Copyright 2022 Tavian Barnes
+//
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+use faccess::PathExt;
+use walkdir::DirEntry;
+
+use super::{Matcher, MatcherIO};
+
+/// Matcher for -{read,writ,execut}able.
+pub enum AccessMatcher {
+    Readable,
+    Writable,
+    Executable,
+}
+
+impl Matcher for AccessMatcher {
+    fn matches(&self, file_info: &DirEntry, _: &mut MatcherIO) -> bool {
+        let path = file_info.path();
+
+        match self {
+            Self::Readable => path.readable(),
+            Self::Writable => path.writable(),
+            Self::Executable => path.executable(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::find::matchers::tests::get_dir_entry_for;
+    use crate::find::matchers::Matcher;
+    use crate::find::tests::FakeDependencies;
+
+    #[test]
+    fn access_matcher() {
+        let file_info = get_dir_entry_for("test_data/simple", "abbbc");
+        let deps = FakeDependencies::new();
+
+        assert!(
+            AccessMatcher::Readable.matches(&file_info, &mut deps.new_matcher_io()),
+            "file should be readable"
+        );
+
+        assert!(
+            AccessMatcher::Writable.matches(&file_info, &mut deps.new_matcher_io()),
+            "file should be writable"
+        );
+
+        #[cfg(unix)]
+        assert!(
+            !AccessMatcher::Executable.matches(&file_info, &mut deps.new_matcher_io()),
+            "file should not be executable"
+        );
+    }
+}

src/find/matchers/delete.rs

@@ -18,14 +18,10 @@ use super::{Matcher, MatcherIO};
 pub struct DeleteMatcher;
 
 impl DeleteMatcher {
-    pub fn new() -> DeleteMatcher {
+    pub fn new() -> Self {
         DeleteMatcher
     }
 
-    pub fn new_box() -> io::Result<Box<dyn Matcher>> {
-        Ok(Box::new(DeleteMatcher::new()))
-    }
-
     fn delete(&self, file_path: &Path, file_type: FileType) -> io::Result<()> {
         if file_type.is_dir() {
             fs::remove_dir(file_path)
@@ -63,8 +59,8 @@ impl Matcher for DeleteMatcher {
 
 #[cfg(test)]
 mod tests {
-    use std::fs::File;
-    use tempdir::TempDir;
+    use std::fs::{create_dir, File};
+    use tempfile::Builder;
 
     use super::*;
     use crate::find::matchers::tests::get_dir_entry_for;
@@ -75,9 +71,11 @@ mod tests {
         let matcher = DeleteMatcher::new();
         let deps = FakeDependencies::new();
 
-        let temp_dir = TempDir::new_in("test_data", "delete_matcher").expect("made temp dir");
+        let temp_dir = Builder::new().prefix("test_data").tempdir().unwrap();
+
         let temp_dir_path = temp_dir.path().to_string_lossy();
         File::create(temp_dir.path().join("test")).expect("created test file");
+        create_dir(temp_dir.path().join("test_dir")).expect("created test directory");
         let test_entry = get_dir_entry_for(&temp_dir_path, "test");
         assert!(
             matcher.matches(&test_entry, &mut deps.new_matcher_io()),
@@ -88,14 +86,13 @@ mod tests {
             "DeleteMatcher should actually delete files it matches",
         );
 
-        let temp_dir_name = temp_dir.path().file_name().unwrap().to_string_lossy();
-        let temp_dir_entry = get_dir_entry_for("test_data", &temp_dir_name);
+        let temp_dir_entry = get_dir_entry_for(&temp_dir_path, "test_dir");
         assert!(
             matcher.matches(&temp_dir_entry, &mut deps.new_matcher_io()),
             "DeleteMatcher should match directories",
         );
         assert!(
-            !temp_dir.path().exists(),
+            !temp_dir.path().join("test_dir").exists(),
             "DeleteMatcher should actually delete (empty) directories it matches",
         );
     }

src/find/matchers/empty.rs

@@ -0,0 +1,100 @@
+// Copyright 2021 Collabora, Ltd.
+//
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+use std::{
+    fs::read_dir,
+    io::{stderr, Write},
+};
+
+use super::Matcher;
+
+pub struct EmptyMatcher;
+
+impl EmptyMatcher {
+    pub fn new() -> EmptyMatcher {
+        EmptyMatcher
+    }
+}
+
+impl Matcher for EmptyMatcher {
+    fn matches(&self, file_info: &walkdir::DirEntry, _: &mut super::MatcherIO) -> bool {
+        if file_info.file_type().is_file() {
+            match file_info.metadata() {
+                Ok(meta) => meta.len() == 0,
+                Err(err) => {
+                    writeln!(
+                        &mut stderr(),
+                        "Error getting size for {}: {}",
+                        file_info.path().display(),
+                        err
+                    )
+                    .unwrap();
+                    false
+                }
+            }
+        } else if file_info.file_type().is_dir() {
+            match read_dir(file_info.path()) {
+                Ok(mut it) => it.next().is_none(),
+                Err(err) => {
+                    writeln!(
+                        &mut stderr(),
+                        "Error getting contents of {}: {}",
+                        file_info.path().display(),
+                        err
+                    )
+                    .unwrap();
+                    false
+                }
+            }
+        } else {
+            false
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use tempfile::Builder;
+
+    use super::*;
+    use crate::find::matchers::tests::get_dir_entry_for;
+    use crate::find::matchers::Matcher;
+    use crate::find::tests::FakeDependencies;
+
+    #[test]
+    fn empty_files() {
+        let empty_file_info = get_dir_entry_for("test_data/simple", "abbbc");
+        let nonempty_file_info = get_dir_entry_for("test_data/size", "512bytes");
+
+        let matcher = EmptyMatcher::new();
+        let deps = FakeDependencies::new();
+
+        assert!(matcher.matches(&empty_file_info, &mut deps.new_matcher_io()));
+        assert!(!matcher.matches(&nonempty_file_info, &mut deps.new_matcher_io()));
+    }
+
+    #[test]
+    fn empty_directories() {
+        let temp_dir = Builder::new()
+            .prefix("empty_directories")
+            .tempdir()
+            .unwrap();
+        let temp_dir_path = temp_dir.path().to_string_lossy();
+        let subdir_name = "subdir";
+        std::fs::create_dir(temp_dir.path().join(subdir_name)).unwrap();
+
+        let matcher = EmptyMatcher::new();
+        let deps = FakeDependencies::new();
+
+        let file_info = get_dir_entry_for(&temp_dir_path, subdir_name);
+        assert!(matcher.matches(&file_info, &mut deps.new_matcher_io()));
+
+        std::fs::File::create(temp_dir.path().join(subdir_name).join("a")).unwrap();
+
+        let file_info = get_dir_entry_for(&temp_dir_path, subdir_name);
+        assert!(!matcher.matches(&file_info, &mut deps.new_matcher_io()));
+    }
+}

src/find/matchers/exec.rs

@@ -14,7 +14,7 @@ use walkdir::DirEntry;
 use super::{Matcher, MatcherIO};
 
 enum Arg {
-    Filename,
+    FileArg(Vec<OsString>),
     LiteralArg(OsString),
 }
 
@@ -29,33 +29,26 @@ impl SingleExecMatcher {
         executable: &str,
         args: &[&str],
         exec_in_parent_dir: bool,
-    ) -> Result<SingleExecMatcher, Box<dyn Error>> {
+    ) -> Result<Self, Box<dyn Error>> {
         let transformed_args = args
             .iter()
-            .map(|&a| match a {
-                "{}" => Arg::Filename,
-                _ => Arg::LiteralArg(OsString::from(a)),
+            .map(|&a| {
+                let parts = a.split("{}").collect::<Vec<_>>();
+                if parts.len() == 1 {
+                    // No {} present
+                    Arg::LiteralArg(OsString::from(a))
+                } else {
+                    Arg::FileArg(parts.iter().map(OsString::from).collect())
+                }
             })
             .collect();
 
-        Ok(SingleExecMatcher {
+        Ok(Self {
             executable: executable.to_string(),
             args: transformed_args,
             exec_in_parent_dir,
         })
     }
-
-    pub fn new_box(
-        executable: &str,
-        args: &[&str],
-        exec_in_parent_dir: bool,
-    ) -> Result<Box<dyn Matcher>, Box<dyn Error>> {
-        Ok(Box::new(SingleExecMatcher::new(
-            executable,
-            args,
-            exec_in_parent_dir,
-        )?))
-    }
 }
 
 impl Matcher for SingleExecMatcher {
@@ -72,16 +65,23 @@ impl Matcher for SingleExecMatcher {
         };
 
         for arg in &self.args {
-            command.arg(match *arg {
-                Arg::LiteralArg(ref a) => a.as_os_str(),
-                Arg::Filename => path_to_file.as_os_str(),
-            });
+            match *arg {
+                Arg::LiteralArg(ref a) => command.arg(a.as_os_str()),
+                Arg::FileArg(ref parts) => command.arg(&parts.join(path_to_file.as_os_str())),
+            };
         }
         if self.exec_in_parent_dir {
-            if file_info.path() == Path::new(".") {
-                command.current_dir(file_info.path());
-            } else if let Some(parent) = file_info.path().parent() {
-                command.current_dir(parent);
+            match file_info.path().parent() {
+                None => {
+                    // Root paths like "/" have no parent.  Run them from the root to match GNU find.
+                    command.current_dir(file_info.path());
+                }
+                Some(parent) if parent == Path::new("") => {
+                    // Paths like "foo" have a parent of "".  Avoid chdir("").
+                }
+                Some(parent) => {
+                    command.current_dir(parent);
+                }
             }
         }
         match command.status() {

src/find/matchers/glob.rs

@@ -0,0 +1,238 @@
+// Copyright 2022 Tavian Barnes
+//
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+use onig::{self, Regex, RegexOptions, Syntax};
+
+/// Parse a string as a POSIX Basic Regular Expression.
+fn parse_bre(expr: &str, options: RegexOptions) -> Result<Regex, onig::Error> {
+    let bre = Syntax::posix_basic();
+    Regex::with_options(expr, bre.options() | options, bre)
+}
+
+/// Push a literal character onto a regex, escaping it if necessary.
+fn regex_push_literal(regex: &mut String, ch: char) {
+    // https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html#tag_09_03_03
+    if matches!(ch, '.' | '[' | '\\' | '*' | '^' | '$') {
+        regex.push('\\');
+    }
+    regex.push(ch);
+}
+
+/// Extracts a bracket expression from a glob.
+fn extract_bracket_expr(pattern: &str) -> Option<(String, &str)> {
+    // https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_13_01
+    //
+    //     If an open bracket introduces a bracket expression as in XBD RE Bracket Expression,
+    //     except that the <exclamation-mark> character ( '!' ) shall replace the <circumflex>
+    //     character ( '^' ) in its role in a non-matching list in the regular expression notation,
+    //     it shall introduce a pattern bracket expression. A bracket expression starting with an
+    //     unquoted <circumflex> character produces unspecified results. Otherwise, '[' shall match
+    //     the character itself.
+    //
+    // To check for valid bracket expressions, we scan for the closing bracket and
+    // attempt to parse that segment as a regex.  If that fails, we treat the '['
+    // literally.
+
+    let mut expr = "[".to_string();
+
+    let mut chars = pattern.chars();
+    let mut next = chars.next();
+
+    // https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html#tag_09_03_05
+    //
+    //     3. A non-matching list expression begins with a <circumflex> ( '^' ) ...
+    //
+    // (but in a glob, '!' is used instead of '^')
+    if next == Some('!') {
+        expr.push('^');
+        next = chars.next();
+    }
+
+    // https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html#tag_09_03_05
+    //
+    //     1. ... The <right-square-bracket> ( ']' ) shall lose its special meaning and represent
+    //        itself in a bracket expression if it occurs first in the list (after an initial
+    //        <circumflex> ( '^' ), if any).
+    if next == Some(']') {
+        expr.push(']');
+        next = chars.next();
+    }
+
+    while let Some(ch) = next {
+        expr.push(ch);
+
+        match ch {
+            '[' => {
+                // https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html#tag_09_03_05
+                //
+                //     4. A collating symbol is a collating element enclosed within bracket-period
+                //        ( "[." and ".]" ) delimiters. ...
+                //
+                //     5. An equivalence class expression shall ... be expressed by enclosing any
+                //        one of the collating elements in the equivalence class within bracket-
+                //        equal ( "[=" and "=]" ) delimiters.
+                //
+                //     6. ...  A character class expression is expressed as a character class name
+                //        enclosed within bracket- <colon> ( "[:" and ":]" ) delimiters.
+                next = chars.next();
+                if let Some(delim) = next {
+                    expr.push(delim);
+
+                    if matches!(delim, '.' | '=' | ':') {
+                        let rest = chars.as_str();
+                        let end = rest.find([delim, ']'])? + 2;
+                        expr.push_str(&rest[..end]);
+                        chars = rest[end..].chars();
+                    }
+                }
+            }
+            ']' => {
+                // https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html#tag_09_03_05
+                //
+                //     1. ... The <right-square-bracket> ( ']' ) shall ... terminate the bracket
+                //        expression, unless it appears in a collating symbol (such as "[.].]" ) or is
+                //        the ending <right-square-bracket> for a collating symbol, equivalence class,
+                //        or character class.
+                break;
+            }
+            _ => {}
+        }
+
+        next = chars.next();
+    }
+
+    if parse_bre(&expr, RegexOptions::REGEX_OPTION_NONE).is_ok() {
+        Some((expr, chars.as_str()))
+    } else {
+        None
+    }
+}
+
+/// Converts a POSIX glob into a POSIX Basic Regular Expression
+fn glob_to_regex(pattern: &str) -> String {
+    let mut regex = String::new();
+
+    let mut chars = pattern.chars();
+    while let Some(ch) = chars.next() {
+        // https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_13
+        match ch {
+            '?' => regex.push('.'),
+            '*' => regex.push_str(".*"),
+            '\\' => {
+                if let Some(ch) = chars.next() {
+                    regex_push_literal(&mut regex, ch);
+                } else {
+                    // https://pubs.opengroup.org/onlinepubs/9699919799/functions/fnmatch.html
+                    //
+                    //     If pattern ends with an unescaped <backslash>, fnmatch() shall return a
+                    //     non-zero value (indicating either no match or an error).
+                    //
+                    // Most implementations return FNM_NOMATCH in this case, so return a regex that
+                    // never matches.
+                    return "$.".to_string();
+                }
+            }
+            '[' => {
+                if let Some((expr, rest)) = extract_bracket_expr(chars.as_str()) {
+                    regex.push_str(&expr);
+                    chars = rest.chars();
+                } else {
+                    regex_push_literal(&mut regex, ch);
+                }
+            }
+            _ => regex_push_literal(&mut regex, ch),
+        }
+    }
+
+    regex
+}
+
+/// An fnmatch()-style glob matcher.
+pub struct Pattern {
+    regex: Regex,
+}
+
+impl Pattern {
+    /// Parse an fnmatch()-style glob.
+    pub fn new(pattern: &str, caseless: bool) -> Self {
+        let options = if caseless {
+            RegexOptions::REGEX_OPTION_IGNORECASE
+        } else {
+            RegexOptions::REGEX_OPTION_NONE
+        };
+
+        // As long as glob_to_regex() is correct, this should never fail
+        let regex = parse_bre(&glob_to_regex(pattern), options).unwrap();
+        Self { regex }
+    }
+
+    /// Test if this pattern matches a string.
+    pub fn matches(&self, string: &str) -> bool {
+        self.regex.is_match(string)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn literals() {
+        assert_eq!(glob_to_regex(r"foo.bar"), r"foo\.bar");
+    }
+
+    #[test]
+    fn regex_special() {
+        assert_eq!(glob_to_regex(r"^foo.bar$"), r"\^foo\.bar\$");
+    }
+
+    #[test]
+    fn wildcards() {
+        assert_eq!(glob_to_regex(r"foo?bar*baz"), r"foo.bar.*baz");
+    }
+
+    #[test]
+    fn escapes() {
+        assert_eq!(glob_to_regex(r"fo\o\?bar\*baz\\"), r"foo?bar\*baz\\");
+    }
+
+    #[test]
+    fn incomplete_escape() {
+        assert_eq!(glob_to_regex(r"foo\"), r"$.")
+    }
+
+    #[test]
+    fn valid_brackets() {
+        assert_eq!(glob_to_regex(r"foo[bar][!baz]"), r"foo[bar][^baz]");
+    }
+
+    #[test]
+    fn complex_brackets() {
+        assert_eq!(
+            glob_to_regex(r"[!]!.*[\[.].][=]=][:space:]-]"),
+            r"[^]!.*[\[.].][=]=][:space:]-]"
+        );
+    }
+
+    #[test]
+    fn invalid_brackets() {
+        assert_eq!(glob_to_regex(r"foo[bar[!baz"), r"foo\[bar\[!baz");
+    }
+
+    #[test]
+    fn pattern_matches() {
+        assert!(Pattern::new(r"foo*bar", false).matches("foo--bar"));
+
+        assert!(!Pattern::new(r"foo*bar", false).matches("bar--foo"));
+    }
+
+    #[test]
+    fn caseless_matches() {
+        assert!(Pattern::new(r"foo*BAR", true).matches("FOO--bar"));
+
+        assert!(!Pattern::new(r"foo*BAR", true).matches("BAR--foo"));
+    }
+}

src/find/matchers/lname.rs

@@ -0,0 +1,111 @@
+// Copyright 2017 Google Inc.
+//
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+use std::io::{stderr, Write};
+use std::path::PathBuf;
+
+use walkdir::DirEntry;
+
+use super::glob::Pattern;
+use super::{Matcher, MatcherIO};
+
+fn read_link_target(file_info: &DirEntry) -> Option<PathBuf> {
+    match file_info.path().read_link() {
+        Ok(target) => Some(target),
+        Err(err) => {
+            // If it's not a symlink, then it's not an error that should be
+            // shown.
+            if err.kind() != std::io::ErrorKind::InvalidInput {
+                writeln!(
+                    &mut stderr(),
+                    "Error reading target of {}: {}",
+                    file_info.path().display(),
+                    err
+                )
+                .unwrap();
+            }
+
+            None
+        }
+    }
+}
+
+/// This matcher makes a comparison of the link target against a shell wildcard
+/// pattern. See `glob::Pattern` for details on the exact syntax.
+pub struct LinkNameMatcher {
+    pattern: Pattern,
+}
+
+impl LinkNameMatcher {
+    pub fn new(pattern_string: &str, caseless: bool) -> LinkNameMatcher {
+        let pattern = Pattern::new(pattern_string, caseless);
+        Self { pattern }
+    }
+}
+
+impl Matcher for LinkNameMatcher {
+    fn matches(&self, file_info: &DirEntry, _: &mut MatcherIO) -> bool {
+        if let Some(target) = read_link_target(file_info) {
+            self.pattern.matches(&target.to_string_lossy())
+        } else {
+            false
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::find::matchers::tests::get_dir_entry_for;
+    use crate::find::matchers::Matcher;
+    use crate::find::tests::FakeDependencies;
+
+    use std::io::ErrorKind;
+
+    #[cfg(unix)]
+    use std::os::unix::fs::symlink;
+    #[cfg(windows)]
+    use std::os::windows::fs::symlink_file;
+
+    fn create_file_link() {
+        #[cfg(unix)]
+        if let Err(e) = symlink("abbbc", "test_data/links/link-f") {
+            assert!(
+                e.kind() == ErrorKind::AlreadyExists,
+                "Failed to create sym link: {:?}",
+                e
+            );
+        }
+        #[cfg(windows)]
+        if let Err(e) = symlink_file("abbbc", "test_data/links/link-f") {
+            assert!(
+                e.kind() == ErrorKind::AlreadyExists,
+                "Failed to create sym link: {:?}",
+                e
+            );
+        }
+    }
+
+    #[test]
+    fn matches_against_link_target() {
+        create_file_link();
+
+        let link_f = get_dir_entry_for("test_data/links", "link-f");
+        let matcher = LinkNameMatcher::new("ab?bc", false);
+        let deps = FakeDependencies::new();
+        assert!(matcher.matches(&link_f, &mut deps.new_matcher_io()));
+    }
+
+    #[test]
+    fn caseless_matches_against_link_target() {
+        create_file_link();
+
+        let link_f = get_dir_entry_for("test_data/links", "link-f");
+        let matcher = LinkNameMatcher::new("AbB?c", true);
+        let deps = FakeDependencies::new();
+        assert!(matcher.matches(&link_f, &mut deps.new_matcher_io()));
+    }
+}

src/find/matchers/logical_matchers.rs

@@ -11,7 +11,7 @@
 //! to "-foo -o ( -bar -baz )", not "( -foo -o -bar ) -baz").
 use std::error::Error;
 use std::iter::Iterator;
-use std::path::PathBuf;
+use std::path::Path;
 use walkdir::DirEntry;
 
 use super::{Matcher, MatcherIO};
@@ -25,8 +25,8 @@ pub struct AndMatcher {
 }
 
 impl AndMatcher {
-    pub fn new(submatchers: Vec<Box<dyn Matcher>>) -> AndMatcher {
-        AndMatcher { submatchers }
+    pub fn new(submatchers: Vec<Box<dyn Matcher>>) -> Self {
+        Self { submatchers }
     }
 }
 
@@ -35,16 +35,23 @@ impl Matcher for AndMatcher {
     /// place. If the nth sub-matcher returns false, then we immediately return
     /// and don't make any further calls.
     fn matches(&self, dir_entry: &DirEntry, matcher_io: &mut MatcherIO) -> bool {
-        self.submatchers
-            .iter()
-            .all(|x| x.matches(dir_entry, matcher_io))
+        for matcher in &self.submatchers {
+            if !matcher.matches(dir_entry, matcher_io) {
+                return false;
+            }
+            if matcher_io.should_quit() {
+                break;
+            }
+        }
+
+        true
     }
 
     fn has_side_effects(&self) -> bool {
         self.submatchers.iter().any(|x| x.has_side_effects())
     }
 
-    fn finished_dir(&self, dir: &PathBuf) {
+    fn finished_dir(&self, dir: &Path) {
         for m in &self.submatchers {
             m.finished_dir(dir);
         }
@@ -62,14 +69,14 @@ pub struct AndMatcherBuilder {
 }
 
 impl AndMatcherBuilder {
-    pub fn new() -> AndMatcherBuilder {
-        AndMatcherBuilder {
+    pub fn new() -> Self {
+        Self {
             submatchers: Vec::new(),
         }
     }
 
-    pub fn new_and_condition(&mut self, matcher: Box<dyn Matcher>) {
-        self.submatchers.push(matcher);
+    pub fn new_and_condition(&mut self, matcher: impl Matcher) {
+        self.submatchers.push(matcher.into_box());
     }
 
     /// Builds a Matcher: consuming the builder in the process.
@@ -79,9 +86,7 @@ impl AndMatcherBuilder {
             // safe to unwrap: we've just checked the size
             return self.submatchers.pop().unwrap();
         }
-        let matcher = Box::new(AndMatcher::new(self.submatchers));
-        self.submatchers = Vec::new();
-        matcher
+        AndMatcher::new(self.submatchers).into_box()
     }
 }
 
@@ -94,8 +99,8 @@ pub struct OrMatcher {
 }
 
 impl OrMatcher {
-    pub fn new(submatchers: Vec<Box<dyn Matcher>>) -> OrMatcher {
-        OrMatcher { submatchers }
+    pub fn new(submatchers: Vec<Box<dyn Matcher>>) -> Self {
+        Self { submatchers }
     }
 }
 
@@ -104,16 +109,23 @@ impl Matcher for OrMatcher {
     /// place. If the nth sub-matcher returns true, then we immediately return
     /// and don't make any further calls.
     fn matches(&self, dir_entry: &DirEntry, matcher_io: &mut MatcherIO) -> bool {
-        self.submatchers
-            .iter()
-            .any(|x| x.matches(dir_entry, matcher_io))
+        for matcher in &self.submatchers {
+            if matcher.matches(dir_entry, matcher_io) {
+                return true;
+            }
+            if matcher_io.should_quit() {
+                break;
+            }
+        }
+
+        false
     }
 
     fn has_side_effects(&self) -> bool {
         self.submatchers.iter().any(|x| x.has_side_effects())
     }
 
-    fn finished_dir(&self, dir: &PathBuf) {
+    fn finished_dir(&self, dir: &Path) {
         for m in &self.submatchers {
             m.finished_dir(dir);
         }
@@ -131,7 +143,7 @@ pub struct OrMatcherBuilder {
 }
 
 impl OrMatcherBuilder {
-    pub fn new_and_condition(&mut self, matcher: Box<dyn Matcher>) {
+    pub fn new_and_condition(&mut self, matcher: impl Matcher) {
         // safe to unwrap. submatchers always has at least one member
         self.submatchers
             .last_mut()
@@ -151,8 +163,8 @@ impl OrMatcherBuilder {
         Ok(())
     }
 
-    pub fn new() -> OrMatcherBuilder {
-        let mut o = OrMatcherBuilder {
+    pub fn new() -> Self {
+        let mut o = Self {
             submatchers: Vec::new(),
         };
         o.submatchers.push(AndMatcherBuilder::new());
@@ -170,7 +182,7 @@ impl OrMatcherBuilder {
         for x in self.submatchers {
             submatchers.push(x.build());
         }
-        Box::new(OrMatcher::new(submatchers))
+        OrMatcher::new(submatchers).into_box()
     }
 }
 
@@ -184,8 +196,8 @@ pub struct ListMatcher {
 }
 
 impl ListMatcher {
-    pub fn new(submatchers: Vec<Box<dyn Matcher>>) -> ListMatcher {
-        ListMatcher { submatchers }
+    pub fn new(submatchers: Vec<Box<dyn Matcher>>) -> Self {
+        Self { submatchers }
     }
 }
 
@@ -196,6 +208,9 @@ impl Matcher for ListMatcher {
         let mut rc = false;
         for matcher in &self.submatchers {
             rc = matcher.matches(dir_entry, matcher_io);
+            if matcher_io.should_quit() {
+                break;
+            }
         }
         rc
     }
@@ -204,7 +219,7 @@ impl Matcher for ListMatcher {
         self.submatchers.iter().any(|x| x.has_side_effects())
     }
 
-    fn finished_dir(&self, dir: &PathBuf) {
+    fn finished_dir(&self, dir: &Path) {
         for m in &self.submatchers {
             m.finished_dir(dir);
         }
@@ -222,7 +237,7 @@ pub struct ListMatcherBuilder {
 }
 
 impl ListMatcherBuilder {
-    pub fn new_and_condition(&mut self, matcher: Box<dyn Matcher>) {
+    pub fn new_and_condition(&mut self, matcher: impl Matcher) {
         // safe to unwrap. submatchers always has at least one member
         self.submatchers
             .last_mut()
@@ -265,8 +280,8 @@ impl ListMatcherBuilder {
         Ok(())
     }
 
-    pub fn new() -> ListMatcherBuilder {
-        let mut o = ListMatcherBuilder {
+    pub fn new() -> Self {
+        let mut o = Self {
             submatchers: Vec::new(),
         };
         o.submatchers.push(OrMatcherBuilder::new());
@@ -291,12 +306,6 @@ impl ListMatcherBuilder {
 /// A simple matcher that always matches.
 pub struct TrueMatcher;
 
-impl TrueMatcher {
-    pub fn new_box() -> Box<dyn Matcher> {
-        Box::new(TrueMatcher {})
-    }
-}
-
 impl Matcher for TrueMatcher {
     fn matches(&self, _dir_entry: &DirEntry, _: &mut MatcherIO) -> bool {
         true
@@ -312,24 +321,16 @@ impl Matcher for FalseMatcher {
     }
 }
 
-impl FalseMatcher {
-    pub fn new_box() -> Box<dyn Matcher> {
-        Box::new(FalseMatcher {})
-    }
-}
-
 /// Matcher that wraps another matcher and inverts matching criteria.
 pub struct NotMatcher {
     submatcher: Box<dyn Matcher>,
 }
 
 impl NotMatcher {
-    pub fn new(submatcher: Box<dyn Matcher>) -> NotMatcher {
-        NotMatcher { submatcher }
-    }
-
-    pub fn new_box(submatcher: Box<dyn Matcher>) -> Box<NotMatcher> {
-        Box::new(NotMatcher::new(submatcher))
+    pub fn new(submatcher: impl Matcher) -> Self {
+        Self {
+            submatcher: submatcher.into_box(),
+        }
     }
 }
 
@@ -342,7 +343,7 @@ impl Matcher for NotMatcher {
         self.submatcher.has_side_effects()
     }
 
-    fn finished_dir(&self, dir: &PathBuf) {
+    fn finished_dir(&self, dir: &Path) {
         self.submatcher.finished_dir(dir);
     }
 
@@ -355,13 +356,16 @@ impl Matcher for NotMatcher {
 
 mod tests {
     use super::*;
+    use crate::find::matchers::quit::QuitMatcher;
     use crate::find::matchers::tests::get_dir_entry_for;
     use crate::find::matchers::{Matcher, MatcherIO};
     use crate::find::tests::FakeDependencies;
+    use std::cell::RefCell;
+    use std::rc::Rc;
     use walkdir::DirEntry;
 
     /// Simple Matcher impl that has side effects
-    pub struct HasSideEffects {}
+    pub struct HasSideEffects;
 
     impl Matcher for HasSideEffects {
         fn matches(&self, _: &DirEntry, _: &mut MatcherIO) -> bool {
@@ -373,9 +377,13 @@ mod tests {
         }
     }
 
-    impl HasSideEffects {
-        pub fn new_box() -> Box<dyn Matcher> {
-            Box::new(HasSideEffects {})
+    /// Matcher that counts its invocations
+    struct Counter(Rc<RefCell<u32>>);
+
+    impl Matcher for Counter {
+        fn matches(&self, _: &DirEntry, _: &mut MatcherIO) -> bool {
+            *self.0.borrow_mut() += 1;
+            true
         }
     }
 
@@ -386,12 +394,12 @@ mod tests {
         let deps = FakeDependencies::new();
 
         // start with one matcher returning true
-        builder.new_and_condition(TrueMatcher::new_box());
+        builder.new_and_condition(TrueMatcher);
         assert!(builder.build().matches(&abbbc, &mut deps.new_matcher_io()));
 
         builder = AndMatcherBuilder::new();
-        builder.new_and_condition(TrueMatcher::new_box());
-        builder.new_and_condition(FalseMatcher::new_box());
+        builder.new_and_condition(TrueMatcher);
+        builder.new_and_condition(FalseMatcher);
         assert!(!builder.build().matches(&abbbc, &mut deps.new_matcher_io()));
     }
 
@@ -402,13 +410,13 @@ mod tests {
         let deps = FakeDependencies::new();
 
         // start with one matcher returning false
-        builder.new_and_condition(FalseMatcher::new_box());
+        builder.new_and_condition(FalseMatcher);
         assert!(!builder.build().matches(&abbbc, &mut deps.new_matcher_io()));
 
         let mut builder = OrMatcherBuilder::new();
-        builder.new_and_condition(FalseMatcher::new_box());
+        builder.new_and_condition(FalseMatcher);
         builder.new_or_condition("-o").unwrap();
-        builder.new_and_condition(TrueMatcher::new_box());
+        builder.new_and_condition(TrueMatcher);
         assert!(builder.build().matches(&abbbc, &mut deps.new_matcher_io()));
     }
 
@@ -419,21 +427,21 @@ mod tests {
         let deps = FakeDependencies::new();
 
         // result should always match that of the last pushed submatcher
-        builder.new_and_condition(FalseMatcher::new_box());
+        builder.new_and_condition(FalseMatcher);
         assert!(!builder.build().matches(&abbbc, &mut deps.new_matcher_io()));
 
         builder = ListMatcherBuilder::new();
-        builder.new_and_condition(FalseMatcher::new_box());
+        builder.new_and_condition(FalseMatcher);
         builder.new_list_condition().unwrap();
-        builder.new_and_condition(TrueMatcher::new_box());
+        builder.new_and_condition(TrueMatcher);
         assert!(builder.build().matches(&abbbc, &mut deps.new_matcher_io()));
 
         builder = ListMatcherBuilder::new();
-        builder.new_and_condition(FalseMatcher::new_box());
+        builder.new_and_condition(FalseMatcher);
         builder.new_list_condition().unwrap();
-        builder.new_and_condition(TrueMatcher::new_box());
+        builder.new_and_condition(TrueMatcher);
         builder.new_list_condition().unwrap();
-        builder.new_and_condition(FalseMatcher::new_box());
+        builder.new_and_condition(FalseMatcher);
         assert!(!builder.build().matches(&abbbc, &mut deps.new_matcher_io()));
     }
 
@@ -460,12 +468,12 @@ mod tests {
         let mut builder = AndMatcherBuilder::new();
 
         // start with one matcher with no side effects false
-        builder.new_and_condition(TrueMatcher::new_box());
+        builder.new_and_condition(TrueMatcher);
         assert!(!builder.build().has_side_effects());
 
         builder = AndMatcherBuilder::new();
-        builder.new_and_condition(TrueMatcher::new_box());
-        builder.new_and_condition(HasSideEffects::new_box());
+        builder.new_and_condition(TrueMatcher);
+        builder.new_and_condition(HasSideEffects);
         assert!(builder.build().has_side_effects());
     }
 
@@ -474,12 +482,12 @@ mod tests {
         let mut builder = OrMatcherBuilder::new();
 
         // start with one matcher with no side effects false
-        builder.new_and_condition(TrueMatcher::new_box());
+        builder.new_and_condition(TrueMatcher);
         assert!(!builder.build().has_side_effects());
 
         builder = OrMatcherBuilder::new();
-        builder.new_and_condition(TrueMatcher::new_box());
-        builder.new_and_condition(HasSideEffects::new_box());
+        builder.new_and_condition(TrueMatcher);
+        builder.new_and_condition(HasSideEffects);
         assert!(builder.build().has_side_effects());
     }
 
@@ -488,12 +496,12 @@ mod tests {
         let mut builder = ListMatcherBuilder::new();
 
         // start with one matcher with no side effects false
-        builder.new_and_condition(TrueMatcher::new_box());
+        builder.new_and_condition(TrueMatcher);
         assert!(!builder.build().has_side_effects());
 
         builder = ListMatcherBuilder::new();
-        builder.new_and_condition(TrueMatcher::new_box());
-        builder.new_and_condition(HasSideEffects::new_box());
+        builder.new_and_condition(TrueMatcher);
+        builder.new_and_condition(HasSideEffects);
         assert!(builder.build().has_side_effects());
     }
 
@@ -512,8 +520,8 @@ mod tests {
     #[test]
     fn not_matches_works() {
         let abbbc = get_dir_entry_for("test_data/simple", "abbbc");
-        let not_true = NotMatcher::new(TrueMatcher::new_box());
-        let not_false = NotMatcher::new(FalseMatcher::new_box());
+        let not_true = NotMatcher::new(TrueMatcher);
+        let not_false = NotMatcher::new(FalseMatcher);
         let deps = FakeDependencies::new();
         assert!(!not_true.matches(&abbbc, &mut deps.new_matcher_io()));
         assert!(not_false.matches(&abbbc, &mut deps.new_matcher_io()));
@@ -521,9 +529,64 @@ mod tests {
 
     #[test]
     fn not_has_side_effects_works() {
-        let has_fx = NotMatcher::new(HasSideEffects::new_box());
-        let hasnt_fx = NotMatcher::new(FalseMatcher::new_box());
+        let has_fx = NotMatcher::new(HasSideEffects);
+        let has_no_fx = NotMatcher::new(FalseMatcher);
         assert!(has_fx.has_side_effects());
-        assert!(!hasnt_fx.has_side_effects());
+        assert!(!has_no_fx.has_side_effects());
+    }
+
+    #[test]
+    fn and_quit_works() {
+        let abbbc = get_dir_entry_for("test_data/simple", "abbbc");
+        let mut builder = AndMatcherBuilder::new();
+        let deps = FakeDependencies::new();
+
+        let before = Rc::new(RefCell::new(0));
+        let after = Rc::new(RefCell::new(0));
+        builder.new_and_condition(Counter(before.clone()));
+        builder.new_and_condition(QuitMatcher);
+        builder.new_and_condition(Counter(after.clone()));
+        builder.build().matches(&abbbc, &mut deps.new_matcher_io());
+
+        assert_eq!(*before.borrow(), 1);
+        assert_eq!(*after.borrow(), 0);
+    }
+
+    #[test]
+    fn or_quit_works() {
+        let abbbc = get_dir_entry_for("test_data/simple", "abbbc");
+        let mut builder = OrMatcherBuilder::new();
+        let deps = FakeDependencies::new();
+
+        let before = Rc::new(RefCell::new(0));
+        let after = Rc::new(RefCell::new(0));
+        builder.new_and_condition(Counter(before.clone()));
+        builder.new_or_condition("-o").unwrap();
+        builder.new_and_condition(QuitMatcher);
+        builder.new_or_condition("-o").unwrap();
+        builder.new_and_condition(Counter(after.clone()));
+        builder.build().matches(&abbbc, &mut deps.new_matcher_io());
+
+        assert_eq!(*before.borrow(), 1);
+        assert_eq!(*after.borrow(), 0);
+    }
+
+    #[test]
+    fn list_quit_works() {
+        let abbbc = get_dir_entry_for("test_data/simple", "abbbc");
+        let mut builder = ListMatcherBuilder::new();
+        let deps = FakeDependencies::new();
+
+        let before = Rc::new(RefCell::new(0));
+        let after = Rc::new(RefCell::new(0));
+        builder.new_and_condition(Counter(before.clone()));
+        builder.new_list_condition().unwrap();
+        builder.new_and_condition(QuitMatcher);
+        builder.new_list_condition().unwrap();
+        builder.new_and_condition(Counter(after.clone()));
+        builder.build().matches(&abbbc, &mut deps.new_matcher_io());
+
+        assert_eq!(*before.borrow(), 1);
+        assert_eq!(*after.borrow(), 0);
     }
 }

src/find/matchers/mod.rs

@@ -4,29 +4,60 @@
 // license that can be found in the LICENSE file or at
 // https://opensource.org/licenses/MIT.
 
+mod access;
 mod delete;
+mod empty;
 pub mod exec;
+mod glob;
+mod lname;
 mod logical_matchers;
 mod name;
+mod path;
 mod perm;
 mod printer;
+mod printf;
 mod prune;
+mod quit;
+mod regex;
 mod size;
+mod stat;
 mod time;
 mod type_matcher;
 
-use regex::Regex;
-use std::error::Error;
-use std::path::PathBuf;
+use ::regex::Regex;
+use std::path::Path;
 use std::time::SystemTime;
+use std::{error::Error, str::FromStr};
 use walkdir::DirEntry;
 
+use self::access::AccessMatcher;
+use self::delete::DeleteMatcher;
+use self::empty::EmptyMatcher;
+use self::exec::SingleExecMatcher;
+use self::lname::LinkNameMatcher;
+use self::logical_matchers::{
+    AndMatcherBuilder, FalseMatcher, ListMatcherBuilder, NotMatcher, TrueMatcher,
+};
+use self::name::NameMatcher;
+use self::path::PathMatcher;
+use self::perm::PermMatcher;
+use self::printer::{PrintDelimiter, Printer};
+use self::printf::Printf;
+use self::prune::PruneMatcher;
+use self::quit::QuitMatcher;
+use self::regex::RegexMatcher;
+use self::size::SizeMatcher;
+use self::stat::{InodeMatcher, LinksMatcher};
+use self::time::{FileTimeMatcher, FileTimeType, NewerMatcher};
+use self::type_matcher::TypeMatcher;
+
 use super::{Config, Dependencies};
 
 /// Struct holding references to outputs and any inputs that can't be derived
 /// from the file/directory info.
 pub struct MatcherIO<'a> {
     should_skip_dir: bool,
+    quit: bool,
     deps: &'a dyn Dependencies<'a>,
 }
 
@@ -35,6 +66,7 @@ impl<'a> MatcherIO<'a> {
         MatcherIO {
             deps,
             should_skip_dir: false,
+            quit: false,
         }
     }
 
@@ -46,6 +78,14 @@ impl<'a> MatcherIO<'a> {
         self.should_skip_dir
     }
 
+    pub fn quit(&mut self) {
+        self.quit = true;
+    }
+
+    pub fn should_quit(&self) -> bool {
+        self.quit
+    }
+
     pub fn now(&self) -> SystemTime {
         self.deps.now()
     }
@@ -55,7 +95,15 @@ impl<'a> MatcherIO<'a> {
 /// is what's being searched for. To a first order approximation, find consists
 /// of building a chain of Matcher objects, and then walking a directory tree,
 /// passing each entry to the chain of Matchers.
-pub trait Matcher {
+pub trait Matcher: 'static {
+    /// Boxes this matcher as a trait object.
+    fn into_box(self) -> Box<dyn Matcher>
+    where
+        Self: Sized,
+    {
+        Box::new(self)
+    }
+
     /// Returns whether the given file matches the object's predicate.
     fn matches(&self, file_info: &DirEntry, matcher_io: &mut MatcherIO) -> bool;
 
@@ -70,7 +118,7 @@ pub trait Matcher {
     }
 
     /// Notification that find has finished processing a given directory.
-    fn finished_dir(&self, _finished_directory: &PathBuf) {}
+    fn finished_dir(&self, _finished_directory: &Path) {}
 
     /// Notification that find has finished processing all directories -
     /// allowing for any cleanup that isn't suitable for destructors (e.g.
@@ -78,6 +126,28 @@ pub trait Matcher {
     fn finished(&self) {}
 }
 
+impl Matcher for Box<dyn Matcher> {
+    fn into_box(self) -> Box<dyn Matcher> {
+        self
+    }
+
+    fn matches(&self, file_info: &DirEntry, matcher_io: &mut MatcherIO) -> bool {
+        (**self).matches(file_info, matcher_io)
+    }
+
+    fn has_side_effects(&self) -> bool {
+        (**self).has_side_effects()
+    }
+
+    fn finished_dir(&self, finished_directory: &Path) {
+        (**self).finished_dir(finished_directory)
+    }
+
+    fn finished(&self) {
+        (**self).finished()
+    }
+}
+
 pub enum ComparableValue {
     MoreThan(u64),
     EqualTo(u64),
@@ -113,9 +183,9 @@ pub fn build_top_level_matcher(
 
     // if the matcher doesn't have any side-effects, then we default to printing
     if !top_level_matcher.has_side_effects() {
-        let mut new_and_matcher = logical_matchers::AndMatcherBuilder::new();
+        let mut new_and_matcher = AndMatcherBuilder::new();
         new_and_matcher.new_and_condition(top_level_matcher);
-        new_and_matcher.new_and_condition(printer::Printer::new_box());
+        new_and_matcher.new_and_condition(Printer::new(PrintDelimiter::Newline));
         return Ok(new_and_matcher.build());
     }
     Ok(top_level_matcher)
@@ -195,7 +265,9 @@ fn build_matcher_tree(
     arg_index: usize,
     expecting_bracket: bool,
 ) -> Result<(usize, Box<dyn Matcher>), Box<dyn Error>> {
-    let mut top_level_matcher = logical_matchers::ListMatcherBuilder::new();
+    let mut top_level_matcher = ListMatcherBuilder::new();
+
+    let mut regex_type = regex::RegexType::default();
 
     // can't use getopts for a variety or reasons:
     // order of arguments is important
@@ -205,57 +277,95 @@ fn build_matcher_tree(
     let mut invert_next_matcher = false;
     while i < args.len() {
         let possible_submatcher = match args[i] {
-            "-print" => Some(printer::Printer::new_box()),
-            "-true" => Some(logical_matchers::TrueMatcher::new_box()),
-            "-false" => Some(logical_matchers::FalseMatcher::new_box()),
-            "-name" => {
+            "-print" => Some(Printer::new(PrintDelimiter::Newline).into_box()),
+            "-print0" => Some(Printer::new(PrintDelimiter::Null).into_box()),
+            "-printf" => {
                 if i >= args.len() - 1 {
                     return Err(From::from(format!("missing argument to {}", args[i])));
                 }
                 i += 1;
-                Some(name::NameMatcher::new_box(args[i])?)
+                Some(Printf::new(args[i])?.into_box())
             }
-            "-iname" => {
+            "-true" => Some(TrueMatcher.into_box()),
+            "-false" => Some(FalseMatcher.into_box()),
+            "-lname" | "-ilname" => {
                 if i >= args.len() - 1 {
                     return Err(From::from(format!("missing argument to {}", args[i])));
                 }
                 i += 1;
-                Some(name::CaselessNameMatcher::new_box(args[i])?)
+                Some(LinkNameMatcher::new(args[i], args[i - 1].starts_with("-i")).into_box())
+            }
+            "-name" | "-iname" => {
+                if i >= args.len() - 1 {
+                    return Err(From::from(format!("missing argument to {}", args[i])));
+                }
+                i += 1;
+                Some(NameMatcher::new(args[i], args[i - 1].starts_with("-i")).into_box())
+            }
+            "-path" | "-ipath" | "-wholename" | "-iwholename" => {
+                if i >= args.len() - 1 {
+                    return Err(From::from(format!("missing argument to {}", args[i])));
+                }
+                i += 1;
+                Some(PathMatcher::new(args[i], args[i - 1].starts_with("-i")).into_box())
+            }
+            "-readable" => Some(AccessMatcher::Readable.into_box()),
+            "-regextype" => {
+                if i >= args.len() - 1 {
+                    return Err(From::from(format!("missing argument to {}", args[i])));
+                }
+                i += 1;
+                regex_type = regex::RegexType::from_str(args[i])?;
+                None
+            }
+            "-regex" => {
+                if i >= args.len() - 1 {
+                    return Err(From::from(format!("missing argument to {}", args[i])));
+                }
+                i += 1;
+                Some(RegexMatcher::new(regex_type, args[i], false)?.into_box())
+            }
+            "-iregex" => {
+                if i >= args.len() - 1 {
+                    return Err(From::from(format!("missing argument to {}", args[i])));
+                }
+                i += 1;
+                Some(RegexMatcher::new(regex_type, args[i], true)?.into_box())
             }
             "-type" => {
                 if i >= args.len() - 1 {
                     return Err(From::from(format!("missing argument to {}", args[i])));
                 }
                 i += 1;
-                Some(type_matcher::TypeMatcher::new_box(args[i])?)
+                Some(TypeMatcher::new(args[i])?.into_box())
             }
             "-delete" => {
                 // -delete implicitly requires -depth
                 config.depth_first = true;
-                Some(delete::DeleteMatcher::new_box()?)
+                Some(DeleteMatcher::new().into_box())
             }
             "-newer" => {
                 if i >= args.len() - 1 {
                     return Err(From::from(format!("missing argument to {}", args[i])));
                 }
                 i += 1;
-                Some(time::NewerMatcher::new_box(args[i])?)
+                Some(NewerMatcher::new(args[i])?.into_box())
             }
             "-mtime" | "-atime" | "-ctime" => {
                 if i >= args.len() - 1 {
                     return Err(From::from(format!("missing argument to {}", args[i])));
                 }
                 let file_time_type = match args[i] {
-                    "-atime" => time::FileTimeType::Accessed,
-                    "-ctime" => time::FileTimeType::Created,
-                    "-mtime" => time::FileTimeType::Modified,
+                    "-atime" => FileTimeType::Accessed,
+                    "-ctime" => FileTimeType::Created,
+                    "-mtime" => FileTimeType::Modified,
                     // This shouldn't be possible. We've already checked the value
                     // is one of those three values.
                     _ => unreachable!("Encountered unexpected value {}", args[i]),
                 };
                 let days = convert_arg_to_comparable_value(args[i], args[i + 1])?;
                 i += 1;
-                Some(time::FileTimeMatcher::new_box(file_time_type, days))
+                Some(FileTimeMatcher::new(file_time_type, days).into_box())
             }
             "-size" => {
                 if i >= args.len() - 1 {
@@ -264,12 +374,13 @@ fn build_matcher_tree(
                 let (size, unit) =
                     convert_arg_to_comparable_value_and_suffix(args[i], args[i + 1])?;
                 i += 1;
-                Some(size::SizeMatcher::new_box(size, &unit)?)
+                Some(SizeMatcher::new(size, &unit)?.into_box())
             }
+            "-empty" => Some(EmptyMatcher::new().into_box()),
             "-exec" | "-execdir" => {
                 let mut arg_index = i + 1;
                 while arg_index < args.len() && args[arg_index] != ";" {
-                    if args[arg_index] == "+" {
+                    if args[arg_index - 1] == "{}" && args[arg_index] == "+" {
                         // MultiExecMatcher isn't written yet
                         return Err(From::from(format!(
                             "{} [args...] + isn't supported yet. \
@@ -287,20 +398,38 @@ fn build_matcher_tree(
                 let executable = args[i + 1];
                 let exec_args = &args[i + 2..arg_index];
                 i = arg_index;
-                Some(exec::SingleExecMatcher::new_box(
-                    executable,
-                    exec_args,
-                    expression == "-execdir",
-                )?)
+                Some(
+                    SingleExecMatcher::new(executable, exec_args, expression == "-execdir")?
+                        .into_box(),
+                )
             }
+            "-inum" => {
+                if i >= args.len() - 1 {
+                    return Err(From::from(format!("missing argument to {}", args[i])));
+                }
+                let inum = convert_arg_to_comparable_value(args[i], args[i + 1])?;
+                i += 1;
+                Some(InodeMatcher::new(inum)?.into_box())
+            }
+            "-links" => {
+                if i >= args.len() - 1 {
+                    return Err(From::from(format!("missing argument to {}", args[i])));
+                }
+                let inum = convert_arg_to_comparable_value(args[i], args[i + 1])?;
+                i += 1;
+                Some(LinksMatcher::new(inum)?.into_box())
+            }
+            "-executable" => Some(AccessMatcher::Executable.into_box()),
             "-perm" => {
                 if i >= args.len() - 1 {
                     return Err(From::from(format!("missing argument to {}", args[i])));
                 }
                 i += 1;
-                Some(perm::PermMatcher::new_box(args[i])?)
+                Some(PermMatcher::new(args[i])?.into_box())
             }
-            "-prune" => Some(prune::PruneMatcher::new_box()),
+            "-prune" => Some(PruneMatcher::new().into_box()),
+            "-quit" => Some(QuitMatcher.into_box()),
+            "-writable" => Some(AccessMatcher::Writable.into_box()),
             "-not" | "!" => {
                 if !are_more_expressions(args, i) {
                     return Err(From::from(format!(
@@ -311,7 +440,7 @@ fn build_matcher_tree(
                 invert_next_matcher = !invert_next_matcher;
                 None
             }
-            "-a" => {
+            "-and" | "-a" => {
                 if !are_more_expressions(args, i) {
                     return Err(From::from(format!(
                         "expected an expression after {}",
@@ -357,6 +486,11 @@ fn build_matcher_tree(
                 config.depth_first = true;
                 None
             }
+            "-mount" | "-xdev" => {
+                // TODO add warning if it appears after actual testing criterion
+                config.same_file_system = true;
+                None
+            }
             "-sorted" => {
                 // TODO add warning if it appears after actual testing criterion
                 config.sorted_output = true;
@@ -382,13 +516,16 @@ fn build_matcher_tree(
                 config.help_requested = true;
                 None
             }
+            "-version" | "--version" => {
+                config.version_requested = true;
+                None
+            }
 
             _ => return Err(From::from(format!("Unrecognized flag: '{}'", args[i]))),
         };
         if let Some(submatcher) = possible_submatcher {
             if invert_next_matcher {
-                top_level_matcher
-                    .new_and_condition(logical_matchers::NotMatcher::new_box(submatcher));
+                top_level_matcher.new_and_condition(NotMatcher::new(submatcher));
                 invert_next_matcher = false;
             } else {
                 top_level_matcher.new_and_condition(submatcher);
@@ -419,7 +556,13 @@ mod tests {
     pub fn get_dir_entry_for(directory: &str, filename: &str) -> DirEntry {
         for wrapped_dir_entry in WalkDir::new(fix_up_slashes(directory)) {
             let dir_entry = wrapped_dir_entry.unwrap();
-            if dir_entry.file_name().to_string_lossy() == filename {
+            if dir_entry
+                .path()
+                .strip_prefix(directory)
+                .unwrap()
+                .to_string_lossy()
+                == fix_up_slashes(filename)
+            {
                 return dir_entry;
             }
         }
@@ -468,7 +611,7 @@ mod tests {
             let deps = FakeDependencies::new();
 
             let matcher =
-                build_top_level_matcher(&[arg, "-name", "doesntexist"], &mut config).unwrap();
+                build_top_level_matcher(&[arg, "-name", "does_not_exist"], &mut config).unwrap();
 
             assert!(matcher.matches(&abbbc_lower, &mut deps.new_matcher_io()));
             assert_eq!(
@@ -509,7 +652,8 @@ mod tests {
 
             config = Config::default();
             let matcher =
-                build_top_level_matcher(&[arg, arg, "-name", "doesntexist"], &mut config).unwrap();
+                build_top_level_matcher(&[arg, arg, "-name", "does_not_exist"], &mut config)
+                    .unwrap();
 
             assert!(!matcher.matches(&abbbc_lower, &mut deps.new_matcher_io()));
         }
@@ -579,17 +723,19 @@ mod tests {
 
     #[test]
     fn build_top_level_matcher_dash_a_works() {
-        let abbbc = get_dir_entry_for("./test_data/simple", "abbbc");
-        let mut config = Config::default();
-        let deps = FakeDependencies::new();
+        for arg in &["-a", "-and"] {
+            let abbbc = get_dir_entry_for("./test_data/simple", "abbbc");
+            let mut config = Config::default();
+            let deps = FakeDependencies::new();
 
-        // build a matcher using an explicit -a argument
-        let matcher = build_top_level_matcher(&["-true", "-a", "-true"], &mut config).unwrap();
-        assert!(matcher.matches(&abbbc, &mut deps.new_matcher_io()));
-        assert_eq!(
-            deps.get_output_as_string(),
-            fix_up_slashes("./test_data/simple/abbbc\n")
-        );
+            // build a matcher using an explicit -a argument
+            let matcher = build_top_level_matcher(&["-true", arg, "-true"], &mut config).unwrap();
+            assert!(matcher.matches(&abbbc, &mut deps.new_matcher_io()));
+            assert_eq!(
+                deps.get_output_as_string(),
+                fix_up_slashes("./test_data/simple/abbbc\n")
+            );
+        }
     }
 
     #[test]
@@ -948,6 +1094,13 @@ mod tests {
             .expect("parsing argument list with exec that takes brackets and -os should work");
     }
 
+    #[test]
+    fn build_top_level_exec_plus_semicolon() {
+        let mut config = Config::default();
+        build_top_level_matcher(&["-exec", "foo", "{}", "foo", "+", ";"], &mut config)
+            .expect("only {} + should be considered a multi-exec");
+    }
+
     #[test]
     #[cfg(unix)]
     fn build_top_level_matcher_perm() {
@@ -973,7 +1126,7 @@ mod tests {
     fn build_top_level_matcher_perm_bad() {
         let mut config = Config::default();
         if let Err(e) = build_top_level_matcher(&["-perm", "foo"], &mut config) {
-            assert!(e.to_string().contains("invalid mode"));
+            assert!(e.to_string().contains("invalid operator"));
         } else {
             panic!("-perm with bad mode pattern should fail");
         }