haskell.yml

name: Haskell CI

defaults:
  run:
    shell: bash

on:
  push:
    branches:
      - main
  pull_request:

jobs:
  build:
    runs-on: ${{ matrix.os }}

    strategy:
      fail-fast: false
      matrix:
        cabal: ["3.12"]
        ghc: ["9.8.1", "9.6.3", "9.4.8"]
        os: [ubuntu-latest, windows-latest]

        include:
          # Using include, to make sure there will only be one macOS job, even if the matrix gets expanded later on.
          # We want a single job, because macOS runners are scarce.
          - ghc: "9.6.3"
            cabal: "3.12"
            os: macos-latest

    env:
      # Modify this value to "invalidate" the cabal cache.
      CABAL_CACHE_VERSION: "2024-08-05"

    steps:

    - name: Install Haskell
      uses: input-output-hk/actions/haskell@latest
      id: setup-haskell
      with:
        ghc-version: ${{ matrix.ghc }}
        cabal-version: ${{ matrix.cabal }}

    # - name: Install system dependencies
    #   uses: input-output-hk/actions/base@latest
    #   with:
    #     use-sodium-vrf: true # default is true

    - uses: actions/checkout@v4

    - name: Cabal update
      run: cabal update

    - name: Configure build
      run: |
        cabal configure --enable-tests --enable-benchmarks
        cabal build all --enable-tests --enable-benchmarks --dry-run

    - name: Record dependencies
      run: |
        cat dist-newstyle/cache/plan.json | jq -r '."install-plan"[].id' | sort | uniq > dependencies.txt
        date +"%Y-%m-%d" > date.txt

    - name: View dependencies
      run: |
        echo "date                  = $(cat date.txt)"
        echo "md5(dependencies.txt) = $(md5sum dependencies.txt)"
        echo "md5(date.txt)         = $(md5sum date.txt)"

    - name: Upload dependencies.txt
      uses: actions/upload-artifact@v2
      with:
        name: dependencies
        path: dependencies.txt

    - uses: actions/cache@v4
      name: Cache cabal store
      with:
        path: ${{ steps.setup-haskell.outputs.cabal-store }}
        key: cache-${{ env.CACHE_VERSION }}-${{ runner.os }}-${{ matrix.ghc }}-${{ hashFiles('dependencies.txt') }}-${{ hashFiles('date.txt') }}
        restore-keys: |
          cache-${{ env.CACHE_VERSION }}-${{ runner.os }}-${{ matrix.ghc }}-${{ hashFiles('dependencies.txt') }}-${{ hashFiles('date.txt') }}
          cache-${{ env.CACHE_VERSION }}-${{ runner.os }}-${{ matrix.ghc }}-${{ hashFiles('dependencies.txt') }}
          cache-${{ env.CACHE_VERSION }}-${{ runner.os }}-${{ matrix.ghc }}

    # Now we install the dependencies. If the cache was found and restored in the previous step,
    # this should be a no-op, but if the cache key was not found we need to build stuff so we can
    # cache it for the next step.
    - name: Install dependencies
      run: cabal build all --enable-tests --only-dependencies -j --ghc-option=-j4

    # Now we build.
    - name: Build all
      run: cabal build all --enable-tests

    - name: Run tests
      env:
        TMPDIR: ${{ runner.temp }}
        TMP: ${{ runner.temp }}
        KEEP_WORKSPACE: 1
      run: cabal test all --enable-tests --enable-benchmarks

  check:
    needs: build
    runs-on: ubuntu-latest
    outputs:
      tag: ${{ steps.tag.outputs.tag }}

    steps:
      - uses: actions/checkout@v2

      - name: Check if cabal project is sane
        run: |
          PROJECT_DIR=$PWD
          mkdir -p $PROJECT_DIR/build/sdist
          for i in $(git ls-files | grep '\.cabal'); do
            cd $PROJECT_DIR && cd `dirname $i`
            cabal check
          done

      - name: Tag new version
        id: tag
        if: ${{ github.ref == 'refs/heads/main' }}
        env:
          server: http://hackage.haskell.org
          username: ${{ secrets.HACKAGE_USER }}
          password: ${{ secrets.HACKAGE_PASS }}
        run: |
          package_version="$(cat *.cabal | grep '^version:' | cut -d : -f 2 | xargs)"

          echo "Package version is v$package_version"

          git fetch --unshallow origin

          if git tag "v$package_version"; then
            echo "Tagging with new version "v$package_version""

            if git push origin "v$package_version"; then
              echo "Tagged with new version "v$package_version""

              echo "::set-output name=tag::v$package_version"
            fi
          fi

  release:
    needs: [build, check]
    runs-on: ubuntu-latest
    if: ${{ needs.check.outputs.tag != '' }}
    outputs:
      upload_url: ${{ steps.create_release.outputs.upload_url }}

    steps:
      - uses: actions/checkout@v2

      - name: Create source distribution
        run: |
          PROJECT_DIR=$PWD
          mkdir -p $PROJECT_DIR/build/sdist
          for i in $(git ls-files | grep '\.cabal'); do
            cd $PROJECT_DIR && cd `dirname $i`
            cabal v2-sdist -o $PROJECT_DIR/build/sdist
          done;

      - name: Publish to hackage
        env:
          server: http://hackage.haskell.org
          username: ${{ secrets.HACKAGE_USER }}
          password: ${{ secrets.HACKAGE_PASS }}
          candidate: false
        run: |
          package_version="$(cat *.cabal | grep '^version:' | cut -d : -f 2 | xargs)"

          for PACKAGE_TARBALL in $(find ./build/sdist/ -name "*.tar.gz"); do
            PACKAGE_NAME=$(basename ${PACKAGE_TARBALL%.*.*})

            if ${{ env.candidate }}; then
              TARGET_URL="${{ env.server }}/packages/candidates";
              DOCS_URL="${{ env.server }}/package/$PACKAGE_NAME/candidate/docs"
            else
              TARGET_URL="${{ env.server }}/packages/upload";
              DOCS_URL="${{ env.server }}/package/$PACKAGE_NAME/docs"
            fi

            HACKAGE_STATUS=$(curl --silent --head -w %{http_code} -XGET --anyauth --user "${{ env.username }}:${{ env.password }}" ${{ env.server }}/package/$PACKAGE_NAME -o /dev/null)

            if [ "$HACKAGE_STATUS" = "404" ]; then
              echo "Uploading $PACKAGE_NAME to $TARGET_URL"

              curl -X POST -f --user "${{ env.username }}:${{ env.password }}" $TARGET_URL -F "package=@$PACKAGE_TARBALL"
              echo "Uploaded $PACKAGE_NAME"
            else
              echo "Package $PACKAGE_NAME" already exists on Hackage.
            fi
          done

      - name: Create Release
        id: create_release
        uses: actions/create-release@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token
        with:
          tag_name: ${{ github.ref }}
          release_name: Release ${{ github.ref }}
          body: Undocumented
          draft: true
          prerelease: false