ci.yml

name: ci
on:
  pull_request:
  push:
    branches:
    - master
  schedule:
  - cron: '00 01 * * *'

# The section is needed to drop write-all permissions that are granted on
# `schedule` event. By specifying any permission explicitly all others are set
# to none. By using the principle of least privilege the damage a compromised
# workflow can do (because of an injection or compromised third party tool or
# action) is restricted. Currently, the workflow doesn't need any additional
# permission except for pulling the code. Adding labels to issues, commenting
# on pull-requests, etc. may need additional permissions:
#
# Syntax for this section:
# https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#permissions
#
# Reference for how to assign permissions on a job-by-job basis:
# https://docs.github.com/en/actions/using-jobs/assigning-permissions-to-jobs
#
# Reference for available permissions that we can enable if needed:
# https://docs.github.com/en/actions/security-guides/automatic-token-authentication#permissions-for-the-github_token
permissions:
  # to fetch code (actions/checkout)
  contents: read

jobs:
  # This job does our basic build+test for supported platforms.
  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:
        include:
        - build: stable
          os: ubuntu-latest
          rust: stable
        - build: stable-32
          os: ubuntu-latest
          rust: stable
          target: i686-unknown-linux-gnu
        - build: stable-powerpc64
          os: ubuntu-latest
          rust: stable
          target: powerpc64-unknown-linux-gnu
        - build: stable-s390x
          os: ubuntu-latest
          rust: stable
          target: s390x-unknown-linux-gnu
        - build: beta
          os: ubuntu-latest
          rust: beta
        - build: nightly
          os: ubuntu-latest
          rust: nightly
        - build: macos
          os: macos-latest
          rust: stable
        - build: win-msvc
          os: windows-latest
          rust: stable
        - build: win-gnu
          os: windows-latest
          rust: stable-x86_64-gnu
    steps:
    - name: Checkout repository
      uses: actions/checkout@v3
    - name: Install Rust
      uses: dtolnay/rust-toolchain@master
      with:
        toolchain: ${{ matrix.rust }}
    - name: Install and configure Cross
      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
        echo "CARGO=cross" >> $GITHUB_ENV
        echo "TARGET=--target ${{ matrix.target }}" >> $GITHUB_ENV
    - name: Show command used for Cargo
      run: |
        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
    - name: Run subset of tests
      run: ${{ env.CARGO }} test --verbose --test integration $TARGET
    - name: Build regex-syntax docs
      run: ${{ env.CARGO }} doc --verbose --manifest-path regex-syntax/Cargo.toml $TARGET
    - name: Run subset of regex-syntax tests
      run: ${{ env.CARGO }} test --verbose --manifest-path regex-syntax/Cargo.toml $TARGET
    - name: Build regex-automata docs
      run: ${{ env.CARGO }} doc --verbose --manifest-path regex-automata/Cargo.toml $TARGET
    - name: Run subset of regex-automata tests
      if: matrix.build != 'win-gnu'  # Just horrifically slow.
      run: ${{ env.CARGO }} test --verbose --manifest-path regex-automata/Cargo.toml $TARGET
    - name: Run regex-lite tests
      run: ${{ env.CARGO }} test --verbose --manifest-path regex-lite/Cargo.toml $TARGET
    - name: Run regex-cli tests
      run: ${{ env.CARGO }} test --verbose --manifest-path regex-cli/Cargo.toml $TARGET

  # 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@master
      with:
        toolchain: 1.65.0
    # The memchr 2.6 release purportedly bumped its MSRV to Rust 1.60, but it
    # turned out that on aarch64, it was using something that wasn't stabilized
    # until Rust 1.61[1]. (This was an oversight on my part. I had previously
    # thought everything I needed was on Rust 1.60.) To resolve that, I just
    # bumped memchr's MSRV to 1.61. Since it was so soon after the memchr 2.6
    # release, I treated this as a bugfix.
    #
    # But the regex crate's MSRV is at Rust 1.60, and it now depends on at
    # least memchr 2.6 (to make use of its `alloc` feature). So we can't set
    # a lower minimal version. And I can't just bump the MSRV in a patch
    # release as a bug fix because regex 1.9 was released quite some time ago.
    # I could just release regex 1.10 and bump the MSRV there, but eh, I don't
    # want to put out another minor version release just for this.
    #
    # So... pin memchr to 2.6.2, which at least works on x86-64 on Rust 1.60.
    #
    # [1]: https://github.com/BurntSushi/memchr/issues/136
    - name: Pin memchr to 2.6.2
      run: cargo update -p memchr --precise 2.6.2
    - 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@master
      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@master
      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@master
      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@master
      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@master
      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:
    runs-on: ubuntu-latest
    steps:
    - name: Checkout repository
      uses: actions/checkout@v3
    - name: Install Rust
      uses: dtolnay/rust-toolchain@master
      with:
        toolchain: stable
        components: rustfmt
    - name: Check formatting
      run: |
        cargo fmt --all -- --check