ci.yaml

name: CI

defaults:
  run:
    shell: bash

on:
  # Build on every pull request (and new PR commit)
  pull_request:
  # Build on new pushes to trunk (E.g. Merge commits)
  # Without the branch filter, each commit on a branch with a PR is triggered twice.
  # See: https://github.community/t/how-to-trigger-an-action-on-push-or-pull-request-but-not-both/16662
  push:
    branches:
      - trunk
    tags:
      - release/*

jobs:

  ormolu:
    runs-on: ubuntu-20.04
    steps:
      - uses: actions/checkout@v2
      - name: Get changed files
        id: changed-files
        uses: tj-actions/changed-files@v37
        with:
          # globs copied from default settings for run-ormolu
          files: |
            **/*.hs
            **/*.hs-boot
          separator: "\n"
      - uses: haskell-actions/run-ormolu@v14
        with:
          version: "0.5.0.1"
          mode: inplace
          pattern: ${{ steps.changed-files.outputs.all_changed_files }}
      - name: apply formatting changes
        uses: stefanzweifel/git-auto-commit-action@v4
        if: ${{ always() }}
        with:
          commit_message: automatically run ormolu

  build:
    name: ${{ matrix.os }}
    runs-on: ${{ matrix.os }}
    needs: ormolu
    defaults:
      run:
        shell: bash
    strategy:
      # Run each build to completion, regardless of if any have failed
      fail-fast: false
      matrix:
        os:
          # While iterating on this file, you can disable one or more of these to speed things up
          - ubuntu-20.04
          - macOS-12
          - windows-2019
    steps:
      - uses: actions/checkout@v2

      # The number towards the beginning of the cache keys allow you to manually avoid using a previous cache.
      # GitHub will automatically delete caches that haven't been accessed in 7 days, but there is no way to
      # purge one manually.


      - id: stackage-resolver
        name: record stackage resolver
        # https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions#environment-files
        # looks for `resolver: nightly-yyyy-mm-dd` or `resolver: lts-xx.yy` in `stack.yaml` and splits it into
        # `nightly` or `lts-xx`.  the whole resolver string is put into resolver_long as a backup cache key
        # ${{ steps.stackage-resolver.outputs.resolver_short }}
        # ${{ steps.stackage-resolver.outputs.resolver_long }}
        run: |
          grep resolver stack.yaml | awk '{ x="resolver_short="; if (split($2,a,"-") > 2) print x a[1]; else {split($2,b,"."); print x b[1]}}' >> "$GITHUB_OUTPUT"
          grep resolver stack.yaml | awk '{print "resolver_long="$2}' >> "$GITHUB_OUTPUT"
      # Cache ~/.stack, keyed by the contents of 'stack.yaml'.
      - uses: actions/cache@v3
        name: cache ~/.stack (unix)
        if: runner.os != 'Windows'
        with:
          path: ~/.stack
          key: stack-1_${{matrix.os}}-${{ steps.stackage-resolver.outputs.resolver_long }}-${{hashFiles('**/stack.yaml')}}-${{github.sha}}
          # Fall-back to use the most recent cache for the stack.yaml, or failing that the OS
          restore-keys: |
            stack-1_${{matrix.os}}-${{ steps.stackage-resolver.outputs.resolver_long }}-${{hashFiles('**/stack.yaml')}}-
            stack-1_${{matrix.os}}-${{ steps.stackage-resolver.outputs.resolver_long }}-
            stack-1_${{matrix.os}}-${{ steps.stackage-resolver.outputs.resolver_short }}-
            stack-1_${{matrix.os}}-${{ steps.stackage-resolver.outputs.resolver_short }}.
            stack-1_${{matrix.os}}-

      # Cache ~/.stack, keyed by the contents of 'stack.yaml'.
      - uses: actions/cache@v3
        name: cache ~/.stack (Windows)
        if: runner.os == 'Windows'
        with:
          path: |
            C:\Users\runneradmin\AppData\Roaming\stack
            C:\Users\runneradmin\AppData\Local\Programs\stack
          key: stack-1_${{matrix.os}}-${{ steps.stackage-resolver.outputs.resolver_long }}-${{hashFiles('**/stack.yaml')}}-${{github.sha}}
          # Fall-back to use the most recent cache for the stack.yaml, or failing that the OS
          restore-keys: |
            stack-1_${{matrix.os}}-${{ steps.stackage-resolver.outputs.resolver_long }}-${{hashFiles('**/stack.yaml')}}-
            stack-1_${{matrix.os}}-${{ steps.stackage-resolver.outputs.resolver_long }}-
            stack-1_${{matrix.os}}-${{ steps.stackage-resolver.outputs.resolver_short }}-
            stack-1_${{matrix.os}}-${{ steps.stackage-resolver.outputs.resolver_short }}.
            stack-1_${{matrix.os}}-

      # Cache each local package's ~/.stack-work for fast incremental builds in CI.
      - uses: actions/cache@v3
        name: cache .stack-work
        with:
          path: |
            **/.stack-work
          # Main cache key: commit hash. This should always result in a cache miss...
          # So when loading a cache we'll always fall back to the restore-keys,
          # which should load the most recent cache via a prefix search on the most
          # recent branch cache.
          # Then it will save a new cache at this commit sha, which should be used by
          # the next build on this branch.
          key: stack-work-4_${{matrix.os}}-${{ steps.stackage-resolver.outputs.resolver_short }}-${{hashFiles('**/stack.yaml')}}-${{github.sha}}
          restore-keys: |
            stack-work-4_${{matrix.os}}-${{ steps.stackage-resolver.outputs.resolver_long }}-${{hashFiles('**/stack.yaml')}}-
            stack-work-4_${{matrix.os}}-${{ steps.stackage-resolver.outputs.resolver_long }}-
            stack-work-4_${{matrix.os}}-${{ steps.stackage-resolver.outputs.resolver_short }}-
            stack-work-4_${{matrix.os}}-${{ steps.stackage-resolver.outputs.resolver_short }}.
            stack-work-4_${{matrix.os}}-

      # Install stack by downloading the binary from GitHub.
      # The installation process differs by OS.
      - name: install stack (Linux)
        if: runner.os == 'Linux'
        working-directory: ${{ runner.temp }}
        run: |
          mkdir stack && cd stack
          curl -L https://github.com/commercialhaskell/stack/releases/download/v2.9.1/stack-2.9.1-linux-x86_64.tar.gz | tar -xz
          echo "$PWD/stack-"* >> $GITHUB_PATH

      - name: install stack (macOS)
        working-directory: ${{ runner.temp }}
        if: runner.os == 'macOS'
        run: |
          mkdir stack && cd stack
          curl -L https://github.com/commercialhaskell/stack/releases/download/v2.9.1/stack-2.9.1-osx-x86_64.tar.gz | tar -xz
          echo "$PWD/stack-"* >> $GITHUB_PATH

      - name: install stack (windows)
        working-directory: ${{ runner.temp }}
        if: runner.os == 'Windows'
        run: |
          mkdir stack && cd stack
          curl -L https://github.com/commercialhaskell/stack/releases/download/v2.9.1/stack-2.9.1-windows-x86_64.tar.gz | tar -xz
          echo "$PWD/stack-"* >> $GITHUB_PATH

      # One of the transcripts fails if the user's git name hasn't been set.
      - name: set git user info
        run: |
          git config --global user.name "GitHub Actions"
          git config --global user.email "actions@github.com"

      - name: remove ~/.stack/setup-exe-cache on macOS
        if: runner.os == 'macOS'
        run: rm -rf ~/.stack/setup-exe-cache

      - name: install stack-clean-old (to scan or clean up old stackage caches)
        run: |
          if ! stack exec -- which stack-clean-old; then
            stack install stack-clean-old
          fi

      - name: check initial stackage cache size
        run: |
          echo global .stack
          stack exec -- stack-clean-old list -G || true
          echo project .stack-work
          stack exec -- stack-clean-old list -P || true

      # Build deps, then build local code. Splitting it into two steps just allows us to see how much time each step
      # takes.
      - name: build dependencies
        # Run up to 5 times in a row before giving up.
        # It's very unlikely that our build-dependencies step will fail on most builds,
        # so if it fails its almost certainly due to a race condition on the Windows
        # file-system API that stack runs into. Since any successful packages are
        # cached within a single build, it should get further along on each re-start
        # and should hopefully finish!
        run: |
          stack --version
          tries=1
          if [[ ${{matrix.os}} = "windows-"* ]]; then
            tries=5
          fi

          for (( i = 0; i < $tries; i++ )); do
              stack --no-terminal build --fast --only-dependencies && break;
          done
      - name: build
        run: stack --no-terminal build --fast --no-run-tests --test

      # Run each test suite (tests and transcripts)
      - name: check disk space before
        if: ${{ always() }}
        run: df -h
      - name: unison-cli test
        run: stack --no-terminal build --fast --test unison-cli
      - name: check disk space after
        if: ${{ always() }}
        run: df -h
      - name: unison-core tests
        run: stack --no-terminal build --fast --test unison-core
      - name: unison-parser-typechecker tests
        run: stack --no-terminal build --fast --test unison-parser-typechecker
      - name: unison-sqlite tests
        run: stack --no-terminal build --fast --test unison-sqlite
      - name: unison-syntax tests
        run: stack --no-terminal build --fast --test unison-syntax
      - name: unison-util-bytes tests
        run: stack --no-terminal build --fast --test unison-util-bytes
      - name: unison-util-cache tests
        run: stack --no-terminal build --fast --test unison-util-cache
      - name: unison-util-relation tests
        run: stack --no-terminal build --fast --test unison-util-relation
      - name: round-trip-tests
        if: runner.os == 'macOS'
        run: |
          mkdir -p /private/tmp
          touch /private/tmp/roundtrip.u
          touch /private/tmp/rewrite-tmp.u
          stack --no-terminal exec unison transcript unison-src/transcripts-round-trip/main.md
          git add unison-src/transcripts-round-trip/main.output.md 
          # Fail if any transcripts cause git diffs.
          git diff --cached --ignore-cr-at-eol --exit-code
          stack --no-terminal exec unison transcript unison-src/transcripts-manual/rewrites.md
          git add unison-src/transcripts-manual/rewrites.output.md 
          # Fail if any transcripts cause git diffs.
          git diff --cached --ignore-cr-at-eol --exit-code
      - name: transcripts
        run: |
          stack --no-terminal exec transcripts
          # Add all changes to the index for when we diff.
          git add --all
          # Fail if any transcripts cause git diffs.
          git diff --cached --ignore-cr-at-eol --exit-code
      - name: cli-integration-tests
        run: stack --no-terminal exec cli-integration-tests
      - name: Cache Racket dependencies
        uses: actions/cache@v2
        if: runner.os == 'Linux'
        with:
          path: |
            ~/.cache/racket
            ~/.local/share/racket
          key: ${{ runner.os }}-racket-8.7

      - uses: Bogdanp/setup-racket@v1.10
        if: runner.os == 'Linux'
        with:
          architecture: 'x64'
          distribution: 'full'
          variant: 'CS'
          version: '8.7' # match with cache key above
      - run: raco pkg install --auto --skip-installed --batch x509-lib
        if: runner.os == 'Linux'
      - uses: awalsh128/cache-apt-pkgs-action@latest
        # read this if a package isn't installing correctly
        # https://github.com/awalsh128/cache-apt-pkgs-action#caveats
        if: runner.os == 'Linux'
        with:
          packages: libb2-dev
          version: 1.0 # cache key version afaik

      - uses: actions/cache@v3
        name: cache base.md codebase (unix)
        if: runner.os == 'Linux'
        with:
          path: ~/.cache/unisonlanguage/base.unison
          key: base.unison_${{hashFiles('**/unison-src/builtin-tests/base.md','**/unison-cli/src/Unison/JitInfo.hs')}}-${{github.sha}}
          restore-keys: base.unison_${{hashFiles('**/unison-src/builtin-tests/base.md','**/unison-cli/src/Unison/JitInfo.hs')}}-

      - name: set up `base` codebase
        if: runner.os == 'Linux'
        run: |
          ./unison-src/builtin-tests/setup-base-codebase.sh

      - name: jit tests
        # if: false # temporarily disabled
        if: runner.os == 'Linux'
        run: |
          ./unison-src/builtin-tests/jit-tests.sh
          cat ./unison-src/builtin-tests/jit-tests.output.md
          CHANGE=$(git diff unison-src/builtin-tests/jit-tests.output.md)
          if [ -n "$CHANGE" ]; then
            echo "The jit-tests output has changed"
            exit 1
          fi

      - name: interpreter tests
        # if: false # temporarily disabled
        if: runner.os == 'Linux'
        run: |
          ./unison-src/builtin-tests/interpreter-tests.sh
          cat ./unison-src/builtin-tests/interpreter-tests.output.md
          CHANGE=$(git diff unison-src/builtin-tests/interpreter-tests.output.md)
          if [ -n "$CHANGE" ]; then
            echo "The interpreter-tests output has changed"
            exit 1
          fi

      - name: check final stackage cache size
        run: |
          echo global .stack
          stack exec -- stack-clean-old list -G || true
          echo project .stack-work
          stack exec -- stack-clean-old list -P || true