impl: cut over to regex-automata

.github/workflows/ci.yml

@@ -28,31 +28,25 @@ permissions:
   contents: read
 
 jobs:
+  # This job does our basic build+test for supported platforms.
   test:
-    name: test
     env:
       # For some builds, we use cross to test on 32-bit and big-endian
       # systems.
       CARGO: cargo
       # When CARGO is set to CROSS, TARGET is set to `--target matrix.target`.
+      # Note that we only use cross on Linux, so setting a target on a
+      # different OS will just use normal cargo.
       TARGET:
+      # Bump this as appropriate. We pin to a version to make sure CI
+      # continues to work as cross releases in the past have broken things
+      # in subtle ways.
+      CROSS_VERSION: v0.2.5
     runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: false
       matrix:
-        build:
-        - pinned
-        - stable
-        - stable-32
-        - stable-mips
-        - beta
-        - nightly
-        - macos
-        - win-msvc
-        - win-gnu
         include:
-        - build: pinned
-          os: ubuntu-latest
-          rust: 1.60.0
         - build: stable
           os: ubuntu-latest
           rust: stable
@@ -80,107 +74,161 @@ jobs:
           os: windows-latest
           rust: stable-x86_64-gnu
     steps:
-
     - name: Checkout repository
       uses: actions/checkout@v3
-
     - name: Install Rust
       uses: dtolnay/rust-toolchain@v1
       with:
         toolchain: ${{ matrix.rust }}
-
     - name: Install and configure Cross
-      if: matrix.target != ''
+      if: matrix.os == 'ubuntu-latest' && matrix.target != ''
       run: |
+        # In the past, new releases of 'cross' have broken CI. So for now, we
+        # pin it. We also use their pre-compiled binary releases because cross
+        # has over 100 dependencies and takes a bit to compile.
+        dir="$RUNNER_TEMP/cross-download"
+        mkdir "$dir"
+        echo "$dir" >> $GITHUB_PATH
+        cd "$dir"
+        curl -LO "https://github.com/cross-rs/cross/releases/download/$CROSS_VERSION/cross-x86_64-unknown-linux-musl.tar.gz"
+        tar xf cross-x86_64-unknown-linux-musl.tar.gz
+
         # We used to install 'cross' from master, but it kept failing. So now
         # we build from a known-good version until 'cross' becomes more stable
         # or we find an alternative. Notably, between v0.2.1 and current
         # master (2022-06-14), the number of Cross's dependencies has doubled.
-        cargo install --bins --git https://github.com/rust-embedded/cross --tag v0.2.1
+        # cargo install --bins --git https://github.com/rust-embedded/cross --tag v0.2.1
         echo "CARGO=cross" >> $GITHUB_ENV
         echo "TARGET=--target ${{ matrix.target }}" >> $GITHUB_ENV
-
     - name: Show command used for Cargo
       run: |
-        echo "cargo command is: ${{ env.CARGO }}"
-        echo "target flag is: ${{ env.TARGET }}"
-
+        echo "cargo command is: $CARGO"
+        echo "target flag is: $TARGET"
     - name: Show CPU info for debugging
       if: matrix.os == 'ubuntu-latest'
       run: lscpu
-
     - name: Basic build
       run: ${{ env.CARGO }} build --verbose $TARGET
-
     - name: Build docs
       run: ${{ env.CARGO }} doc --verbose $TARGET
-
-    # Our dev dependencies evolve more rapidly than we'd like, so only run
-    # tests when we aren't pinning the Rust version.
-    #
-    # Also, our "full" test suite does quite a lot of work, so we only run it
-    # on one build. Otherwise, we just run the "default" set of tests.
     - name: Run subset of tests
-      if: matrix.build != 'pinned' && matrix.build != 'stable'
       run: ${{ env.CARGO }} test --verbose --test default $TARGET
-
-    - name: Run full test suite
-      if: matrix.build == 'stable'
-      # 'stable' is Linux only, so we have bash.
-      run: ./test
-
-    - name: Run randomized tests against regexes from the wild
-      if: matrix.build == 'stable'
-      run: |
-        # We run the tests in release mode since it winds up being faster.
-        RUST_REGEX_RANDOM_TEST=1 ${{ env.CARGO }} test --release --verbose --test crates-regex $TARGET
-
     - name: Build regex-syntax docs
-      if: matrix.build != 'pinned'
-      run: |
-        ${{ env.CARGO }} doc --verbose --manifest-path regex-syntax/Cargo.toml $TARGET
-
+      run: ${{ env.CARGO }} doc --verbose --manifest-path regex-syntax/Cargo.toml $TARGET
     - name: Run subset of regex-syntax tests
-      if: matrix.build != 'pinned' && matrix.build != 'stable'
-      run: |
-        ${{ env.CARGO }} test --verbose --manifest-path regex-syntax/Cargo.toml $TARGET
-
-    - name: Run full regex-syntax test suite
-      if: matrix.build == 'stable'
-      run: |
-        # 'stable' is Linux only, so we have bash.
-        ./regex-syntax/test
-
+      run: ${{ env.CARGO }} test --verbose --manifest-path regex-syntax/Cargo.toml $TARGET
     - name: Build regex-automata docs
-      if: matrix.build != 'pinned'
-      run: |
-        ${{ env.CARGO }} doc --verbose --manifest-path regex-automata/Cargo.toml $TARGET
-
+      run: ${{ env.CARGO }} doc --verbose --manifest-path regex-automata/Cargo.toml $TARGET
     - name: Run subset of regex-automata tests
-      if: matrix.build != 'pinned' && matrix.build != 'stable'
-      run: |
-        ${{ env.CARGO }} test --verbose --manifest-path regex-automata/Cargo.toml $TARGET
-
-    - name: Run full regex-automata test suite
-      if: matrix.build == 'stable'
-      run: |
-        # 'stable' is Linux only, so we have bash.
-        ./regex-automata/test
-
-    - name: Run regex-capi tests
-      if: matrix.build == 'stable'
-      run: |
-        # 'stable' is Linux only, so we have bash.
-        ./regex-capi/test
-
+      if: matrix.build != 'win-gnu'  # Just horrifically slow.
+      run: ${{ env.CARGO }} test --verbose --manifest-path regex-automata/Cargo.toml $TARGET
     - if: matrix.build == 'nightly'
       name: Run benchmarks as tests
       run: |
         cd bench
         ./run rust --no-run --verbose
 
+  # This job runs a stripped down version of CI to test the MSRV. The specific
+  # reason for doing this is that the regex crate's dev-dependencies tend to
+  # evolve more quickly. There isn't as tight of a control on them because,
+  # well, they're only used in tests and their MSRV doesn't matter as much.
+  #
+  # It is a bit unfortunate that our MSRV test is basically just "build it"
+  # and pass if that works. But usually MSRV is broken by compilation problems
+  # and not runtime behavior. So this is in practice good enough.
+  msrv:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+    - name: Install Rust
+      uses: dtolnay/rust-toolchain@v1
+      with:
+        toolchain: 1.60.0
+    - name: Basic build
+      run: cargo build --verbose
+    - name: Build docs
+      run: cargo doc --verbose
+
+  # This job runs many more tests for the regex crate proper. Basically,
+  # it repeats the same test suite for a bunch of different crate feature
+  # combinations. There are so many features that exhaustive testing isn't
+  # really possible, but we cover as much as is feasible.
+  #
+  # If there is a feature combo that should be tested but isn't, you'll want to
+  # add it to the appropriate 'test' script in this repo.
+  testfull-regex:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+    - name: Install Rust
+      uses: dtolnay/rust-toolchain@v1
+      with:
+        toolchain: stable
+    - name: Run full test suite
+      run: ./test
+
+  # Same as above, but for regex-automata, which has even more crate features!
+  testfull-regex-automata:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+    - name: Install Rust
+      uses: dtolnay/rust-toolchain@v1
+      with:
+        toolchain: stable
+    - name: Run full test suite
+      run: ./regex-automata/test
+
+  # Same as above, but for regex-syntax.
+  testfull-regex-syntax:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+    - name: Install Rust
+      uses: dtolnay/rust-toolchain@v1
+      with:
+        toolchain: stable
+    - name: Run full test suite
+      run: ./regex-syntax/test
+
+  # Same as above, but for regex-capi.
+  testfull-regex-capi:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+    - name: Install Rust
+      uses: dtolnay/rust-toolchain@v1
+      with:
+        toolchain: stable
+    - name: Run full test suite
+      run: ./regex-capi/test
+
+  # Runs miri on regex-automata's test suite. This doesn't quite cover
+  # everything. Many tests are disabled when building with miri because of
+  # how slow miri runs. But it still gives us decent coverage.
+  miri-regex-automata:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+    - name: Install Rust
+      uses: dtolnay/rust-toolchain@v1
+      with:
+        # We use nightly here so that we can use miri I guess?
+        # It caught me by surprise that miri seems to only be
+        # available on nightly.
+        toolchain: nightly
+        components: miri
+    - name: Run full test suite
+      run: cargo miri test --manifest-path regex-automata/Cargo.toml
+
+  # Tests that everything is formatted correctly.
   rustfmt:
-    name: rustfmt
     runs-on: ubuntu-latest
     steps:
     - name: Checkout repository

Cargo.toml

@@ -238,43 +238,6 @@ name = "default"
 path = "tests/test_default_bytes.rs"
 name = "default-bytes"
 
-# Run the test suite on the NFA algorithm over Unicode codepoints.
-[[test]]
-path = "tests/test_nfa.rs"
-name = "nfa"
-
-# Run the test suite on the NFA algorithm over bytes that match UTF-8 only.
-[[test]]
-path = "tests/test_nfa_utf8bytes.rs"
-name = "nfa-utf8bytes"
-
-# Run the test suite on the NFA algorithm over arbitrary bytes.
-[[test]]
-path = "tests/test_nfa_bytes.rs"
-name = "nfa-bytes"
-
-# Run the test suite on the backtracking engine over Unicode codepoints.
-[[test]]
-path = "tests/test_backtrack.rs"
-name = "backtrack"
-
-# Run the test suite on the backtracking engine over bytes that match UTF-8
-# only.
-[[test]]
-path = "tests/test_backtrack_utf8bytes.rs"
-name = "backtrack-utf8bytes"
-
-# Run the test suite on the backtracking engine over arbitrary bytes.
-[[test]]
-path = "tests/test_backtrack_bytes.rs"
-name = "backtrack-bytes"
-
-# Run all backends against each regex found on crates.io and make sure
-# that they all do the same thing.
-[[test]]
-path = "tests/test_crates_regex.rs"
-name = "crates-regex"
-
 [package.metadata.docs.rs]
 # We want to document all features.
 all-features = true

Cross.toml

@@ -0,0 +1,7 @@
+[build.env]
+passthrough = [
+    "RUST_BACKTRACE",
+    "RUST_LOG",
+    "REGEX_TEST",
+    "REGEX_TEST_VERBOSE",
+]

bench/src/bench.rs

@@ -304,6 +304,3 @@ cfg_if! {
         mod sherlock;
     }
 }
-
-#[cfg(any(feature = "re-rust", feature = "re-rust-bytes"))]
-mod rust_compile;