cd.yml

name: Continuous Deployment

on:
  workflow_dispatch:
  pull_request:
  push:
    branches:
      - main
    tags:
      - "*"

env:
  CICD_INTERMEDIATES_DIR: "_cd-intermediates"

jobs:
  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 '
            .packages[0] |
            [
              "version=" + .version,
              "maintainer=" + (.authors[0] // ""),
              "homepage=" + (.homepage // ""),
              "msrv=" + (.rust_version // "")
            ] |
            join("\n")
          ' | tee -a $GITHUB_OUTPUT
    outputs:
      name: "mago"
      bin-name: "mago"
      version: ${{ steps.crate_metadata.outputs.version }}
      maintainer: ${{ steps.crate_metadata.outputs.maintainer }}
      homepage: ${{ steps.crate_metadata.outputs.homepage }}
      msrv: ${{ steps.crate_metadata.outputs.msrv }}

  ensure_cargo_fmt:
    name: Ensure 'cargo fmt' has been run
    runs-on: ubuntu-20.04
    steps:
      - uses: dtolnay/rust-toolchain@stable
        with:
          components: rustfmt
      - uses: actions/checkout@v4
      - run: cargo fmt -- --check

  min_version:
    name: Minimum supported rust version
    runs-on: ubuntu-20.04
    needs: crate_metadata
    steps:
      - name: Checkout source code
        uses: actions/checkout@v4

      - name: Install rust toolchain (v${{ needs.crate_metadata.outputs.msrv }})
        uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{ needs.crate_metadata.outputs.msrv }}
          components: clippy
      - name: Run clippy (on minimum supported rust version to prevent warnings we can't fix)
        run: cargo clippy --locked --all-targets ${{ env.MSRV_FEATURES }}
      - name: Run tests
        run: cargo test --locked ${{ env.MSRV_FEATURES }}

  build:
    name: ${{ matrix.job.target }} (${{ matrix.job.os }})
    runs-on: ${{ matrix.job.os }}
    needs: crate_metadata
    strategy:
      fail-fast: false
      matrix:
        job:
          - {
              target: aarch64-unknown-linux-gnu,
              os: ubuntu-20.04,
              use-cross: true,
            }
          - { target: aarch64-apple-darwin, os: macos-14 }
          - {
              target: arm-unknown-linux-gnueabihf,
              os: ubuntu-20.04,
              use-cross: true,
            }
          - {
              target: arm-unknown-linux-musleabihf,
              os: ubuntu-20.04,
              use-cross: true,
            }
          - { target: i686-pc-windows-msvc, os: windows-2019 }
          - {
              target: i686-unknown-linux-gnu,
              os: ubuntu-20.04,
              use-cross: true,
            }
          - {
              target: i686-unknown-linux-musl,
              os: ubuntu-20.04,
              use-cross: true,
            }
          - { target: x86_64-apple-darwin, os: macos-12 }
          # - { target: x86_64-pc-windows-gnu       , os: windows-2019                  }
          - { target: x86_64-pc-windows-msvc, os: windows-2019 }
          - {
              target: x86_64-unknown-linux-gnu,
              os: ubuntu-20.04,
              use-cross: true,
            }
          - {
              target: x86_64-unknown-linux-musl,
              os: ubuntu-20.04,
              use-cross: true,
            }

    env:
      BUILD_CMD: cargo

    steps:
      - name: checkout source code
        uses: actions/checkout@v4

      - name: install prerequisites
        shell: bash
        run: |
          case ${{ matrix.job.target }} in
            arm-unknown-linux-*) sudo apt-get -y update ; sudo apt-get -y install gcc-arm-linux-gnueabihf ;;
            aarch64-unknown-linux-gnu) sudo apt-get -y update ; sudo apt-get -y install gcc-aarch64-linux-gnu ;;
          esac

      - name: install Rust toolchain
        uses: dtolnay/rust-toolchain@stable
        with:
          targets: ${{ matrix.job.target }}

      - 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: |
          set -x
          gcc --version || true
          rustup -V
          rustup toolchain list
          rustup default
          cargo -V
          rustc -V

      - name: build
        shell: bash
        run: $BUILD_CMD build --locked --release --target=${{ matrix.job.target }}

      - name: set binary name
        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.bin-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: set testing options
        id: test-options
        shell: bash
        run: |
          # test only library unit tests and binary for arm-type targets
          unset CARGO_TEST_OPTIONS
          unset CARGO_TEST_OPTIONS ; case ${{ matrix.job.target }} in arm-* | aarch64-*) CARGO_TEST_OPTIONS="--bin ${{ steps.bin.outputs.BIN_NAME }}" ;; esac;
          echo "CARGO_TEST_OPTIONS=${CARGO_TEST_OPTIONS}" >> $GITHUB_OUTPUT

      - name: run tests
        shell: bash
        run: $BUILD_CMD test --locked --target=${{ matrix.job.target }} ${{ steps.test-options.outputs.CARGO_TEST_OPTIONS}}

      - name: create tarball
        id: package
        shell: bash
        run: |
          PKG_suffix=".tar.gz" ; case ${{ matrix.job.target }} in *-pc-windows-*) PKG_suffix=".zip" ;; esac;
          PKG_BASENAME=${{ needs.crate_metadata.outputs.name }}-v${{ needs.crate_metadata.outputs.version }}-${{ matrix.job.target }}
          PKG_NAME=${PKG_BASENAME}${PKG_suffix}
          echo "PKG_NAME=${PKG_NAME}" >> $GITHUB_OUTPUT

          PKG_STAGING="${{ env.CICD_INTERMEDIATES_DIR }}/package"
          ARCHIVE_DIR="${PKG_STAGING}/${PKG_BASENAME}/"
          mkdir -p "${ARCHIVE_DIR}"
          mkdir -p "${ARCHIVE_DIR}/autocomplete"

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

          # README, and LICENSE files
          cp "README.md" "LICENSE-MIT" "LICENSE-APACHE" "$ARCHIVE_DIR"

          # Man page
          cp 'doc/${{ needs.crate_metadata.outputs.name }}.1' "$ARCHIVE_DIR"

          # Autocompletion files
          cp 'target/${{ matrix.job.target }}/release/build/${{ needs.crate_metadata.outputs.name }}'*/out/'${{ needs.crate_metadata.outputs.name }}.bash' "$ARCHIVE_DIR/autocomplete/"
          cp 'target/${{ matrix.job.target }}/release/build/${{ needs.crate_metadata.outputs.name }}'*/out/'${{ needs.crate_metadata.outputs.name }}.fish' "$ARCHIVE_DIR/autocomplete/"
          cp 'target/${{ matrix.job.target }}/release/build/${{ needs.crate_metadata.outputs.name }}'*/out/'_${{ needs.crate_metadata.outputs.name }}.ps1' "$ARCHIVE_DIR/autocomplete/"
          cp 'target/${{ matrix.job.target }}/release/build/${{ needs.crate_metadata.outputs.name }}'*/out/'_${{ needs.crate_metadata.outputs.name }}' "$ARCHIVE_DIR/autocomplete/"

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

          # Let subsequent steps know where to find the compressed package
          echo "PKG_PATH=${PKG_STAGING}/${PKG_NAME}" >> $GITHUB_OUTPUT

      - name: create Debian package
        id: debian-package
        shell: bash
        if: startsWith(matrix.job.os, 'ubuntu')
        run: |
          COPYRIGHT_YEARS="2018 - "$(date "+%Y")
          DPKG_STAGING="${{ env.CICD_INTERMEDIATES_DIR }}/debian-package"
          DPKG_DIR="${DPKG_STAGING}/dpkg"
          mkdir -p "${DPKG_DIR}"

          DPKG_BASENAME=${{ needs.crate_metadata.outputs.name }}
          DPKG_CONFLICTS=${{ needs.crate_metadata.outputs.name }}-musl
          case ${{ matrix.job.target }} in *-musl*) DPKG_BASENAME=${{ needs.crate_metadata.outputs.name }}-musl ; DPKG_CONFLICTS=${{ needs.crate_metadata.outputs.name }} ;; esac;
          DPKG_VERSION=${{ needs.crate_metadata.outputs.version }}

          unset DPKG_ARCH
          case ${{ matrix.job.target }} in
            aarch64-*-linux-*) DPKG_ARCH=arm64 ;;
            arm-*-linux-*hf) DPKG_ARCH=armhf ;;
            i686-*-linux-*) DPKG_ARCH=i686 ;;
            x86_64-*-linux-*) DPKG_ARCH=amd64 ;;
            *) DPKG_ARCH=notset ;;
          esac;

          DPKG_NAME="${DPKG_BASENAME}_${DPKG_VERSION}_${DPKG_ARCH}.deb"
          echo "DPKG_NAME=${DPKG_NAME}" >> $GITHUB_OUTPUT

          # Binary
          install -Dm755 "${{ steps.bin.outputs.BIN_PATH }}" "${DPKG_DIR}/usr/bin/${{ steps.bin.outputs.BIN_NAME }}"

          # Man page
          install -Dm644 'doc/${{ needs.crate_metadata.outputs.name }}.1' "${DPKG_DIR}/usr/share/man/man1/${{ needs.crate_metadata.outputs.name }}.1"
          gzip -n --best "${DPKG_DIR}/usr/share/man/man1/${{ needs.crate_metadata.outputs.name }}.1"

          # Autocompletion files
          install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ needs.crate_metadata.outputs.name }}'*/out/'${{ needs.crate_metadata.outputs.name }}.bash' "${DPKG_DIR}/usr/share/bash-completion/completions/${{ needs.crate_metadata.outputs.name }}"
          install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ needs.crate_metadata.outputs.name }}'*/out/'${{ needs.crate_metadata.outputs.name }}.fish' "${DPKG_DIR}/usr/share/fish/vendor_completions.d/${{ needs.crate_metadata.outputs.name }}.fish"
          install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ needs.crate_metadata.outputs.name }}'*/out/'_${{ needs.crate_metadata.outputs.name }}' "${DPKG_DIR}/usr/share/zsh/vendor-completions/_${{ needs.crate_metadata.outputs.name }}"

          # README and LICENSE
          install -Dm644 "README.md" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/README.md"
          install -Dm644 "LICENSE-MIT" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/LICENSE-MIT"
          install -Dm644 "LICENSE-APACHE" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/LICENSE-APACHE"

          cat > "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/copyright" <<EOF
          Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
          Upstream-Name: ${{ needs.crate_metadata.outputs.name }}
          Source: ${{ needs.crate_metadata.outputs.homepage }}

          Files: *
          Copyright: ${{ needs.crate_metadata.outputs.maintainer }}
          Copyright: $COPYRIGHT_YEARS ${{ needs.crate_metadata.outputs.maintainer }}
          License: Apache-2.0 or MIT

          License: Apache-2.0
            On Debian systems, the complete text of the Apache-2.0 can be found in the
            file /usr/share/common-licenses/Apache-2.0.

          License: MIT
            Permission is hereby granted, free of charge, to any person obtaining a copy
            of this software and associated documentation files (the "Software"), to deal
            in the Software without restriction, including without limitation the rights
            to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
            copies of the Software, and to permit persons to whom the Software is
            furnished to do so, subject to the following conditions:

            The above copyright notice and this permission notice shall be included in all
            copies or substantial portions of the Software.

            THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
            IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
            FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
            AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
            LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
            OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
            SOFTWARE.
          EOF
            chmod 644 "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/copyright"

            # control file
            mkdir -p "${DPKG_DIR}/DEBIAN"
            cat > "${DPKG_DIR}/DEBIAN/control" <<EOF
          Package: ${DPKG_BASENAME}
          Version: ${DPKG_VERSION}
          Section: utils
          Priority: optional
          Maintainer: ${{ needs.crate_metadata.outputs.maintainer }}
          Homepage: ${{ needs.crate_metadata.outputs.homepage }}
          Architecture: ${DPKG_ARCH}
          Provides: ${{ needs.crate_metadata.outputs.name }}
          Conflicts: ${DPKG_CONFLICTS}
          Description: A command-line benchmarking tool
          EOF

          DPKG_PATH="${DPKG_STAGING}/${DPKG_NAME}"
          echo "DPKG_PATH=${DPKG_PATH}" >> $GITHUB_OUTPUT

          # build dpkg
          fakeroot dpkg-deb --build "${DPKG_DIR}" "${DPKG_PATH}"

      - 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: Debian package"
        uses: actions/upload-artifact@master
        if: steps.debian-package.outputs.DPKG_NAME
        with:
          name: ${{ steps.debian-package.outputs.DPKG_NAME }}
          path: ${{ steps.debian-package.outputs.DPKG_PATH }}

      - name: check for release
        id: is-release
        shell: bash
        run: |
          unset IS_RELEASE ; if [[ $GITHUB_REF =~ ^refs/tags/[0-9].* ]]; then IS_RELEASE='true' ; fi
          echo "IS_RELEASE=${IS_RELEASE}" >> $GITHUB_OUTPUT

      - name: publish archives and packages
        uses: softprops/action-gh-release@v2
        if: steps.is-release.outputs.IS_RELEASE
        with:
          files: |
            ${{ steps.package.outputs.PKG_PATH }}
            ${{ steps.debian-package.outputs.DPKG_PATH }}
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}