releaser.yaml

name: Release Time

on:
  push:
    # run only against tags
    tags:
      - "*"
  workflow_dispatch:
    inputs:
      debug_enabled:
        type: boolean
        description: "Run the build with tmate debugging enabled (https://github.com/marketplace/actions/debugging-with-tmate)"
        required: false
        default: false

permissions:
  contents: write
  issues: write

jobs:
  check:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Check that the Cargo.yaml has been updated with tag
        if: ${{ !inputs.debug_enabled }}
        run: |
          if ! grep -E "version[ ]*=[ ]*.${GITHUB_REF#refs/tags/}." Cargo.toml; then
            echo "Cargo.toml version does not match tag, version in current Cargo.toml:"
            exit 1
          fi
  crate_metadata:
    name: Extract crate metadata
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Extract crate information
        id: crate_metadata
        run: |
          cargo metadata --no-deps --format-version 1 | jq -r '"name=" + .packages[0].name' | tee -a $GITHUB_OUTPUT
          cargo metadata --no-deps --format-version 1 | jq -r '"version=" + .packages[0].version' | tee -a $GITHUB_OUTPUT
          cargo metadata --no-deps --format-version 1 | jq -r '"maintainer=" + .packages[0].authors[0]' | tee -a $GITHUB_OUTPUT
          cargo metadata --no-deps --format-version 1 | jq -r '"homepage=" + .packages[0].homepage' | tee -a $GITHUB_OUTPUT
          cargo metadata --no-deps --format-version 1 | jq -r '"msrv=" + .packages[0].rust_version' | tee -a $GITHUB_OUTPUT
    outputs:
      name: ${{ steps.crate_metadata.outputs.name }}
      version: ${{ steps.crate_metadata.outputs.version }}
      maintainer: ${{ steps.crate_metadata.outputs.maintainer }}
      homepage: ${{ steps.crate_metadata.outputs.homepage }}
      msrv: ${{ steps.crate_metadata.outputs.msrv }}

  build:
    name: ${{ matrix.job.os }} (${{ matrix.job.target }})
    needs: [check, crate_metadata]
    env:
      BUILD_CMD: cargo
      EXTENSION: ""
    runs-on: ${{ matrix.job.os }}
    strategy:
      fail-fast: false
      matrix:
        job:
          - { os: ubuntu-latest, target: x86_64-unknown-linux-gnu }
          - { os: windows-latest, target: x86_64-pc-windows-msvc }
          - { os: macos-latest, target: x86_64-apple-darwin }
          - {
              target: aarch64-unknown-linux-gnu,
              os: ubuntu-latest,
              use-cross: true,
            }
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Fetch all tags
        run: git fetch --force --tags
      - uses: dtolnay/rust-toolchain@stable
        with:
          targets: ${{ matrix.job.target }}
      - uses: Swatinem/rust-cache@v2
      - name: Install cross
        if: matrix.job.use-cross
        uses: taiki-e/install-action@v2
        with:
          tool: cross
      - name: Overwrite build command env variable
        if: matrix.job.use-cross
        shell: bash
        run: echo "BUILD_CMD=cross" >> $GITHUB_ENV
      - name: Show version information (Rust, cargo, GCC)
        shell: bash
        run: |
          gcc --version || true
          rustup -V
          rustup toolchain list
          rustup default
          cargo -V
          rustc -V
      - name: Add Extension variable on windows
        if: matrix.job.os == 'windows-2019'
        shell: bash
        run: echo "EXTENSION=.exe" >> $GITHUB_ENV
      - name: Build on ${{ matrix.job.target }}
        shell: bash
        run: $BUILD_CMD build --locked --release --target=${{ matrix.job.target }}
      - uses: actions/upload-artifact@v4
        with:
          name: snazy-${{ matrix.job.target }}
          path: target/${{ matrix.job.target }}/release/snazy${{ env.EXTENSION }}

      - name: Set binary name & path
        id: bin
        shell: bash
        run: |
          # Figure out suffix of binary
          EXE_suffix=""
          case ${{ matrix.job.target }} in
            *-pc-windows-*) EXE_suffix=".exe" ;;
          esac;

          # Setup paths
          BIN_NAME="${{ needs.crate_metadata.outputs.name }}${EXE_suffix}"
          BIN_PATH="target/${{ matrix.job.target }}/release/${BIN_NAME}"

          # Let subsequent steps know where to find the binary
          echo "BIN_PATH=${BIN_PATH}" >> $GITHUB_OUTPUT
          echo "BIN_NAME=${BIN_NAME}" >> $GITHUB_OUTPUT

      - name: Create tarball
        id: package
        shell: bash
        run: |
          set -x
          PKG_suffix=".tar.gz" ; 
          DIRNAME="${{ matrix.job.target }}"
          case ${DIRNAME} in
            *-pc-windows-*) PKG_suffix=".zip"; DIRNAME=${DIRNAME/x86_64-pc-windows-msvc/windows} ;;
            *aarch64-unknown-linux-gnu) DIRNAME=${DIRNAME/aarch64-unknown-linux-gnu/linux-arm64} ;;
            *x86_64-unknown-linux-gnu) DIRNAME=${DIRNAME/x86_64-unknown-linux-gnu/linux-amd64} ;;
            *x86_64-apple-darwin) DIRNAME=${DIRNAME/x86_64-apple-darwin/macos} ;;
          esac;
          PKG_BASENAME=${{ needs.crate_metadata.outputs.name }}-v${{ needs.crate_metadata.outputs.version }}-${DIRNAME}
          PKG_NAME=${PKG_BASENAME}${PKG_suffix}
          echo "PKG_NAME=${PKG_NAME}" >> $GITHUB_OUTPUT

          PKG_STAGING="package"
          ARCHIVE_DIR="${PKG_STAGING}/${PKG_BASENAME}/"
          mkdir -p "${ARCHIVE_DIR}"

          # Binary
          cp "${{ steps.bin.outputs.BIN_PATH }}" "$ARCHIVE_DIR"

          # README, LICENSE and CHANGELOG files
          cp "README.md" "LICENSE" "$ARCHIVE_DIR"

          # base compressed package
          pushd "${ARCHIVE_DIR}" >/dev/null
          case "${{ matrix.job.target }}" in
            *-pc-windows-*) 7z -y a "../${PKG_NAME}" * | tail -2 ;;
            *) tar czf "../${PKG_NAME}" * ;;
          esac;
          popd >/dev/null

          # Let subsequent steps know where to find the compressed package
          echo "PKG_PATH=${PKG_STAGING}/${PKG_NAME}" >> $GITHUB_OUTPUT
          if [[ ${{ matrix.job.os }} == 'windows-latest' ]]; then
            certutil -hashfile "${PKG_STAGING}/${PKG_NAME}" sha256 | grep -E [A-Fa-f0-9]{64} > "${PKG_STAGING}/${PKG_NAME}.sha256"
          else
            shasum "${PKG_STAGING}/${PKG_NAME}" > "${PKG_STAGING}/${PKG_NAME}.sha256"
          fi

      - name: "Artifact upload: tarball"
        uses: actions/upload-artifact@master
        with:
          name: ${{ steps.package.outputs.PKG_NAME }}
          path: ${{ steps.package.outputs.PKG_PATH }}

      - name: "Artifact upload: tarball sha256"
        uses: actions/upload-artifact@master
        with:
          name: ${{ steps.package.outputs.PKG_NAME }}.sha256
          path: ${{ steps.package.outputs.PKG_PATH }}.sha256

      - name: Publish archives and packages
        uses: softprops/action-gh-release@v1
        if: startsWith(github.ref, 'refs/tags/')
        with:
          generate_release_notes: true
          files: |
            ${{ steps.package.outputs.PKG_PATH }}
            ${{ steps.package.outputs.PKG_PATH }}.sha256
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

  update_packages:
    if: startsWith(github.ref, 'refs/tags/')
    name: Update Homebrew formula
    needs: build
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 1
      - name: Run update-formula.sh
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          AUR_PRIVATE_KEY: ${{ secrets.AUR_PRIVATE_KEY }}
        run: |
          misc/packages/update.sh