path: root/.cirrus.yml

freebsd_resource_settings: &freebsd_resource_settings
  cpu: 4
  memory: 8GB

task:
    skip: "changesIncludeOnly('contrib/*', 'contrib/**/*', 'doc/*', 'doc/**/*', 'docker/*', 'docker/**/*', 'po/*', 'po/**/*', 'snap/*', 'snap/**/*')"
    matrix:
        - name: FreeBSD 12.3
          freebsd_instance:
            image: freebsd-12-3-release-amd64
            << : *freebsd_resource_settings
        - name: FreeBSD 13.1
          freebsd_instance:
            image: freebsd-13-1-release-amd64
            << : *freebsd_resource_settings

    cargo_cache: &cargo_cache
        # This works in conjunction with after_cache_script and
        # before_cache_script defined below.
        folder: $HOME/cargo-cache
        fingerprint_script:
          # We include the cache name in the fingerprint to avoid re-using old
          # caches that contained ~/.cargo
          - echo cargo-cache
          - cat Cargo.lock

    env:
        HOME: /home/testuser
        RUSTFLAGS: '-D warnings'

    after_cache_script: &after_cache_script
      - mkdir $HOME/.cargo || true
      - mv $HOME/cargo-cache/registry/ $HOME/cargo-cache/git/ $HOME/.cargo/ || true
    install_script:
        # Make sure we use the same package repository for all images. Snapshots
        # (like 11.3-STABLE) default to latest, while releases default to quarterly.
        - sed -i.bak -e 's,pkg+http://pkg.FreeBSD.org/\${ABI}/quarterly,pkg+http://pkg.FreeBSD.org/\${ABI}/latest,' /etc/pkg/FreeBSD.conf
        - pkg update -f
        - pkg upgrade -y
        - pkg install -y rust gmake rubygem-asciidoctor pkgconf stfl curl json-c ncurses openssl sqlite3 gettext-tools libxml2
    setup_script:
        - pw groupadd testgroup
        - pw useradd testuser -g testgroup -w none -m
        - cp -R . $HOME
        - chown -R testuser:testgroup $HOME
    # CI builds take a while to provision, install dependencies and compile our
    # stuff. To maximize the benefits, we ask Make to process as many rules as
    # possible before failing. This enables developers to fix more errors before
    # re-submitting the code to CI, which should increase throughput.
    build_script: su testuser -c 'cd ~ && gmake --jobs=5 --keep-going all test'
    test_script: su testuser -c 'cd ~ && RUST_TEST_THREADS=5 RUST_BACKTRACE=1 gmake -j5 NEWSBOAT_RUN_IGNORED_TESTS=1 ci-check'
    # This installs everything into a "fake filesystem root", then uninstalls
    # everything and checks that there are no files left over. The purpose of
    # this check is to ensure that: 1) `make install` doesn't fail; 2) `make
    # uninstall` cleans up everything that `make install` installed.
    #
    # We run this *before* Clippy because Clippy rebuilds crates in debug mode,
    # which causes some C++ classes to be re-compiled as they depend on cxx
    # bridges.
    fake_install_script: su testuser -c 'cd ~ && mkdir fakeroot && gmake DESTDIR=fakeroot install && gmake DESTDIR=fakeroot uninstall && [ $(find fakeroot -type f -print | wc -l) -eq 0 ]'
    clippy_script: su testuser -c 'cd ~ && cargo clippy --all-targets --all-features -- -D warnings -A unknown-lints'
    before_cache_script: &before_cache_script
        # Cirrus CI sometimes fails to unpack the cache. In that case, it
        # removes the "cache folder" and tries again.
        #
        # We used to use ~/.cargo as a "cache folder", but Cirrus then
        # sometimes removed ~/.cargo/bin and broke the build. To work around
        # that, we're storing the cacheble stuff in a separate directory which
        # we move in/out of ~/.cargo before/after the build.
        - mkdir -p $HOME/cargo-cache/git/
        - mv $HOME/.cargo/registry/ $HOME/cargo-cache/ || true
        - mv $HOME/.cargo/git/db/ $HOME/cargo-cache/git/ || true

task:
    name: Linux i686 (Ubuntu 18.04)
    skip: "changesIncludeOnly('contrib/*', 'contrib/**/*', 'doc/*', 'doc/**/*', 'po/*', 'po/**/*', 'snap/*', 'snap/**/*')"
    container:
        greedy: true
        dockerfile: docker/ubuntu_18.04-i686.dockerfile
    cargo_cache: *cargo_cache
    env:
        RUSTFLAGS: '-D warnings'
        JOBS: 8
    after_cache_script: *after_cache_script
    build_script: &build_script
        - make -j${JOBS} --keep-going all test
    test_script: &test_script
        - RUST_TEST_THREADS=${JOBS} RUST_BACKTRACE=1 make -j${JOBS} NEWSBOAT_RUN_IGNORED_TESTS=1 ci-check
    # For explanation of what this script does, please see the FreeBSD job
    # above.
    fake_install_script: &fake_install_script
        - mkdir fakeroot
        - make DESTDIR=fakeroot install
        - make DESTDIR=fakeroot uninstall
        - test $(find fakeroot -type f -print | wc -l) -eq 0
    clippy_script: &clippy_script
        - cargo clippy --all-targets --all-features -- -D warnings -A unknown-lints
    before_cache_script: *before_cache_script

task:
    skip: "changesIncludeOnly('contrib/*', 'contrib/**/*', 'doc/*', 'doc/**/*', 'docker/*', 'docker/**/*', 'po/*', 'po/**/*', 'snap/*', 'snap/**/*')"
    cargo_cache: *cargo_cache

    after_cache_script: *after_cache_script
    install_script:
        - brew update
        - brew install rustup-init
        - brew install gcc || brew link --overwrite gcc
        - brew install python
        - brew uninstall rbenv ruby-build # ...so that it won't be upgraded when pkg-config is upgraded, because upgrading ruby-build fails; see https://github.com/newsboat/newsboat/issues/866
        - brew outdated "pkg-config" || brew upgrade "pkg-config"
        - brew install "make"
        - brew install "gettext" && brew link --force "gettext"
        - brew outdated "sqlite" || brew upgrade "sqlite"
        - brew outdated "curl" || brew upgrade "curl"
        - brew install "libstfl"
        - brew install "json-c"
        - brew install "asciidoctor"
        - brew install "libxml2"
        - brew install "pyenv" || brew upgrade "pyenv"
        - rustup-init -y --default-toolchain $RUST
        - rustc --version && cargo --version

    env:
        GCOV: /usr/bin/gcov
        PKG_CONFIG_PATH: /usr/local/opt/libxml2/lib/pkgconfig:$PKG_CONFIG_PATH
        PATH: $HOME/.cargo/bin:/usr/local/opt/gettext/bin:/usr/local/opt/python/libexec/bin:/usr/local/opt/make/libexec/gnubin:$PATH
        LDFLAGS: -L/usr/local/opt/gettext/lib
        CFLAGS: -I/usr/local/opt/gettext/include
        CXXFLAGS: -I/usr/local/opt/gettext/include
        GETTEXT_DIR: /usr/local/opt/gettext
        RUSTFLAGS: '-D warnings'
        JOBS: 13

    build_script: *build_script
    test_script: *test_script
    fake_install_script: *fake_install_script
    before_cache_script: *before_cache_script

    matrix:
        - name: macOS Monterey, Clang, Rust stable
          osx_instance:
              image: monterey-base
          env:
              CC: clang
              CXX: clang++
              RUST: stable
        # This job tests our minimum supported Rust version, so only bump on
        # Newsboat release day
        - name: macOS Big Sur, GCC, MSRV
          osx_instance:
              image: big-sur-base
          env:
              CC: gcc
              CXX: g++
              RUST: 1.59.0

task:
    name: Code formatting
    container:
        dockerfile: docker/code-formatting-tools.dockerfile
        cpu: 1
        memory: 512MB
    script:
        - make fmt
          # --exit-code forces git-diff to exit with code 1 if there were
          # changes; that'll fail the build, which is exactly what we need
        - git diff --exit-code

task:
    skip: "changesIncludeOnly('contrib/*', 'contrib/**/*', 'doc/*', 'doc/**/*', 'po/*', 'po/**/*', 'snap/*', 'snap/**/*')"
    env:
        RUSTFLAGS: '-D warnings'
        JOBS: 8

    matrix:
        # These two jobs test our minimum supported Rust version, so only bump on
        # Newsboat release day
        - name: MSRV, GCC 5 (Ubuntu 18.04)
          container:
            greedy: true
            dockerfile: docker/ubuntu_18.04-build-tools.dockerfile
            docker_arguments:
                cxx_package: g++-5
                cc: gcc-5
                cxx: g++-5
                rust_version: 1.59.0
        - name: MSRV, GCC 12 (Ubuntu 22.04)
          container:
            greedy: true
            dockerfile: docker/ubuntu_22.04-build-tools.dockerfile
            docker_arguments:
                cxx_package: g++-12
                cc: gcc-12
                cxx: g++-12
                rust_version: 1.59.0

        - name: GCC 12, more warnings and checks (Ubuntu 22.04)
          container:
            greedy: true
            dockerfile: docker/ubuntu_22.04-build-tools.dockerfile
            docker_arguments:
                cxx_package: g++-12
                cc: gcc-12
                cxx: g++-12
          env: &extra_warnings_and_checks_env
            CXXFLAGS: "-D_GLIBCXX_ASSERTIONS -Wformat -Wformat-security -fstack-protector-all -Wstack-protector -D_FORTIFY_SOURCE=2 -Wnull-dereference -Wdouble-promotion -O3"
        - name: Clang 13, more warnings and checks (Ubuntu 22.04)
          container:
            greedy: true
            dockerfile: docker/ubuntu_22.04-build-tools.dockerfile
            docker_arguments:
                cxx_package: clang-13
                cc: clang-13
                cxx: clang++-13
          env: *extra_warnings_and_checks_env

        - name: Rust stable, GCC 5 (Ubuntu 18.04)
          container:
            greedy: true
            dockerfile: docker/ubuntu_18.04-build-tools.dockerfile
            docker_arguments:
                cxx_package: g++-5
                cc: gcc-5
                cxx: g++-5
        - name: Rust stable, GCC 6 (Ubuntu 18.04)
          container:
            greedy: true
            dockerfile: docker/ubuntu_18.04-build-tools.dockerfile
            docker_arguments:
                cxx_package: g++-6
                cc: gcc-6
                cxx: g++-6
        - name: Rust stable, GCC 7 (Ubuntu 18.04)
          container:
            greedy: true
            dockerfile: docker/ubuntu_18.04-build-tools.dockerfile
            docker_arguments:
                cxx_package: g++-7
                cc: gcc-7
                cxx: g++-7
        - name: Rust stable, GCC 8 (Ubuntu 18.04)
          container:
            greedy: true
            dockerfile: docker/ubuntu_18.04-build-tools.dockerfile
            docker_arguments:
                cxx_package: g++-8
                cc: gcc-8
                cxx: g++-8
        - name: Rust stable, GCC 9 (Ubuntu 20.04)
          container:
            greedy: true
            dockerfile: docker/ubuntu_20.04-build-tools.dockerfile
            docker_arguments:
                cxx_package: g++-9