build_cmake.yml

name: CMake Build Matrix

on: [push]

jobs:
  build:
    name: ${{ matrix.config.name }}
    runs-on: ${{ matrix.config.os }}
    strategy:
      fail-fast: false
      matrix:
        config:
        - {
            name: "Windows Latest MinGW", artifact_suffix: "Win64",
            os: windows-latest,
            build_type: "Release", cc: "gcc", cxx: "g++"
          }
        - {
            name: "Ubuntu Latest GCC", artifact_suffix: "Linux",
            os: ubuntu-latest,
            build_type: "Release", cc: "gcc", cxx: "g++"
          }
        - {
            name: "macOS Latest Clang", artifact_suffix: "macOS",
            os: macos-latest,
            build_type: "Release", cc: "clang", cxx: "clang++"
          }

    steps:
    - uses: actions/checkout@v3

    - name: Install dependencies
      run: |
        if [ "$RUNNER_OS" == "Linux" ]; then
          sudo apt update
          sudo apt install libasound2-dev mesa-common-dev libx11-dev libxrandr-dev libxi-dev xorg-dev libgl1-mesa-dev libglu1-mesa-dev
        elif [ "$RUNNER_OS" == "Windows" ]; then
          echo 'C:/ProgramData/chocolatey/lib/mingw/tools/install/mingw64/bin' >> $GITHUB_PATH
        fi
      shell: bash
        

    - name: Download Ninja and CMake
      id: cmake_and_ninja
      shell: cmake -P {0}
      run: |
        set(ninja_version "1.9.0")
        set(cmake_version "3.16.2")
        
        message(STATUS "Using host CMake version: ${CMAKE_VERSION}")

        if ("${{ runner.os }}" STREQUAL "Windows")
          set(ninja_suffix "win.zip")
          set(cmake_suffix "win64-x64.zip")
          set(cmake_dir "cmake-${cmake_version}-win64-x64/bin")
        elseif ("${{ runner.os }}" STREQUAL "Linux")
          set(ninja_suffix "linux.zip")
          set(cmake_suffix "Linux-x86_64.tar.gz")
          set(cmake_dir "cmake-${cmake_version}-Linux-x86_64/bin")
        elseif ("${{ runner.os }}" STREQUAL "macOS")
          set(ninja_suffix "mac.zip")
          set(cmake_suffix "Darwin-x86_64.tar.gz")
          set(cmake_dir "cmake-${cmake_version}-Darwin-x86_64/CMake.app/Contents/bin")
        endif()

        set(ninja_url "https://github.com/ninja-build/ninja/releases/download/v${ninja_version}/ninja-${ninja_suffix}")
        file(DOWNLOAD "${ninja_url}" ./ninja.zip SHOW_PROGRESS)
        execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf ./ninja.zip)

        set(cmake_url "https://github.com/Kitware/CMake/releases/download/v${cmake_version}/cmake-${cmake_version}-${cmake_suffix}")
        file(DOWNLOAD "${cmake_url}" ./cmake.zip SHOW_PROGRESS)
        execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf ./cmake.zip)

        # Save the path for other steps
        file(TO_CMAKE_PATH "$ENV{GITHUB_WORKSPACE}/${cmake_dir}" cmake_dir)
        file(APPEND $ENV{GITHUB_OUTPUT} "cmake_dir=${cmake_dir}")
        #message("::set-output name=cmake_dir::${cmake_dir}")

        if (NOT "${{ runner.os }}" STREQUAL "Windows")
          execute_process(
            COMMAND chmod +x ninja
            COMMAND chmod +x ${cmake_dir}/cmake
          )
        endif()

    - name: Configure
      shell: cmake -P {0}
      run: |
        set(ENV{CC} ${{ matrix.config.cc }})
        set(ENV{CXX} ${{ matrix.config.cxx }})

        if ("${{ runner.os }}" STREQUAL "Windows" AND NOT "x${{ matrix.config.environment_script }}" STREQUAL "x")
          execute_process(
            COMMAND "${{ matrix.config.environment_script }}" && set
            OUTPUT_FILE environment_script_output.txt
          )
          file(STRINGS environment_script_output.txt output_lines)
          foreach(line IN LISTS output_lines)
            if (line MATCHES "^([a-zA-Z0-9_-]+)=(.*)$")
              set(ENV{${CMAKE_MATCH_1}} "${CMAKE_MATCH_2}")
            endif()
          endforeach()
        endif()

        file(TO_CMAKE_PATH "$ENV{GITHUB_WORKSPACE}/ninja" ninja_program)

        execute_process(
          COMMAND ${{ steps.cmake_and_ninja.outputs.cmake_dir }}/cmake
            -S .
            -B build
            -D CMAKE_BUILD_TYPE=${{ matrix.config.build_type }}
            -G Ninja
            -D CMAKE_MAKE_PROGRAM=${ninja_program}
          RESULT_VARIABLE result
        )
        if (NOT result EQUAL 0)
          message(FATAL_ERROR "Bad exit status")
        endif()


    - name: Build
      shell: cmake -P {0}
      run: |
        set(ENV{NINJA_STATUS} "[%f/%t %o/sec] ")

        if ("${{ runner.os }}" STREQUAL "Windows" AND NOT "x${{ matrix.config.environment_script }}" STREQUAL "x")
          file(STRINGS environment_script_output.txt output_lines)
          foreach(line IN LISTS output_lines)
            if (line MATCHES "^([a-zA-Z0-9_-]+)=(.*)$")
              set(ENV{${CMAKE_MATCH_1}} "${CMAKE_MATCH_2}")
            endif()
          endforeach()
        endif()

        execute_process(
          COMMAND ${{ steps.cmake_and_ninja.outputs.cmake_dir }}/cmake --build build
          RESULT_VARIABLE result
        )
        if (NOT result EQUAL 0)
          message(FATAL_ERROR "Bad exit status")
        endif()


    - name: Run tests
      shell: cmake -P {0}
      run: |
        include(ProcessorCount)
        ProcessorCount(N)

        execute_process(
          COMMAND ${{ steps.cmake_and_ninja.outputs.cmake_dir }}/ctest -j ${N}
          WORKING_DIRECTORY build
          RESULT_VARIABLE result
        )
        if (NOT result EQUAL 0)
          message(FATAL_ERROR "Running tests failed!")
        endif()

    - name: Pack Linux
      if: ${{ runner.os == 'Linux' }}
      run: cd build && ${{ steps.cmake_and_ninja.outputs.cmake_dir }}/cpack -G TGZ

    - name: Pack Others
      if: ${{ runner.os != 'Linux' }}
      run: cd build && ${{ steps.cmake_and_ninja.outputs.cmake_dir }}/cpack -G ZIP

    - name: Get package name (win)
      if: ${{ runner.os == 'Windows' }}
      shell: python
      run: |
        import os
        import re
        p = re.compile(r"project\(cadmium VERSION (\d+.\d+.\d+) LANGUAGES C CXX\)")
        env_file = os.getenv('GITHUB_ENV')
        entry = "VERSION={}"
        with open(env_file, "a") as env:
            with open('CMakeLists.txt') as f:
                for line in f:
                    m = p.match(line)
                    if m:
                      print(entry.format(m.group(1)), file=env)

    - name: Get package name (non-win)
      if: ${{ runner.os != 'Windows' }}
      run: |
        version=$(grep "project("  CMakeLists.txt | cut -d ' ' -f3)
        echo "VERSION=$version" >> "$GITHUB_ENV"

    - name: Upload
      uses: actions/upload-artifact@v3
      with:
        path: build/cadmium-*
        name: cadmium-${{env.VERSION}}-${{matrix.config.artifact_suffix}}

  create_release:
    name: Create release
    if: startsWith( github.ref, 'refs/tags/v')
    runs-on: ubuntu-latest
    needs: [build]
    steps:
      - uses: actions/checkout@v3
      - name: Extract release notes
        id: extract-release-notes
        uses: ffurrer2/extract-release-notes@v1
        with:
          changelog_file: CHANGELOG.md
      - name: Get release name
        run: |
          version=$(grep "project("  CMakeLists.txt | cut -d ' ' -f3)
          echo "VERSION=$version" >> "$GITHUB_ENV"
      - uses: actions/download-artifact@v3
        with:
          path: artifacts
      - name: Create release
        id: create_release
        uses: thomaseizinger/create-release@1.0.0
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          name: ${{ github.ref_name }}
          body: ${{ steps.extract-release-notes.outputs.release_notes }}
          prerelease: false
          draft: false
      - name: Upload release artifacts
        uses: pyTooling/Actions/releaser@r0
        with:
          tag: ${{ github.ref }}
          rm: true
          token: ${{ secrets.GITHUB_TOKEN }}
          files: |
            ./artifacts/cadmium-${{env.VERSION}}/cadmium-*.zip