cmake.yml

name: CMake Build Matrix

on: [ push, pull_request ]

env:
  CMAKE_VERSION: 3.26.0
  NINJA_VERSION: 1.10.1
  BUILD_TYPE: Release
  CCACHE_VERSION: 3.7.7
  CI_RUNNING: 1

jobs:
  build:
    name: ${{ matrix.config.name }}
    runs-on: ${{ matrix.config.os }}
    strategy:
      fail-fast: true
      matrix:
        config:
#          - {
#            name: "Windows Latest MSVC", artifact: "Windows-MSVC.7z",
#            os: windows-latest,
#            cc: "cl", cxx: "cl",
#            environment_script: "C:/Program Files (x86)/Microsoft Visual Studio/2019/Enterprise/VC/Auxiliary/Build/vcvars64.bat",
#            tcf: "-D CMAKE_TOOLCHAIN_FILE=c:/vcpkg/scripts/buildsystems/vcpkg.cmake"
#          }
          #- {
          #  name: "Windows Latest MinGW", artifact: "Windows-MinGW.7z",
          #  os: windows-latest,
          #  cc: "gcc", cxx: "g++"
          #}
          - {
            name: "Ubuntu Latest GCC", artifact: "Linux.7z",
            os: ubuntu-latest,
            cc: "gcc-10", cxx: "g++-10"
          }
#          - {
#            name: "macOS Latest Clang", artifact: "macOS.7z",
#            os: macos-latest,
#            cc: "clang", cxx: "clang++"
#          }

    steps:
      - uses: actions/checkout@v1

      - name: Install gcc 10+ for Ubuntu-18
        #if: matrix.os == 'ubuntu-latest'
        if: runner.os == 'Linux'
        run: |
          # if [[ "$OSTYPE" == "linux-gnu"* ]]; then
          if [[ "$(gcc --version|head -1)" != *10.* ]]; then
            sudo add-apt-repository ppa:ubuntu-toolchain-r/test
            sudo apt update
            sudo apt install -y gcc-10 g++-10
          fi
          # fi

#      - name: Install yaml-cpp
#        run:   |
#          if [ "$RUNNER_OS" == "Linux" ]; then
#               sudo apt install -y libyaml-cpp-dev
#          elif [ "$RUNNER_OS" == "Windows" ]; then
#               # choco install yaml-cpp
#               vcpkg install yaml-cpp:x64-windows
#          elif [ "$RUNNER_OS" == "Darwin" ]; then
#               brew install yaml-cpp
#          elif [ "$RUNNER_OS" == "macOS" ]; then
#               brew install yaml-cpp
#          else
#               echo "$RUNNER_OS not supported"
#               exit 1
#          fi
#        shell: bash

      - name: Download Ninja and CMake
        shell: cmake -P {0}
        run: |
          set(cmake_version $ENV{CMAKE_VERSION})
          set(ninja_version $ENV{NINJA_VERSION})
          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)
          # Add to PATH environment variable
          file(TO_CMAKE_PATH "$ENV{GITHUB_WORKSPACE}/${cmake_dir}" cmake_dir)
          set(path_separator ":")
          if ("${{ runner.os }}" STREQUAL "Windows")
            set(path_separator ";")
          endif()
          file(APPEND "$ENV{GITHUB_PATH}" "$ENV{GITHUB_WORKSPACE}${path_separator}${cmake_dir}")
          if (NOT "${{ runner.os }}" STREQUAL "Windows")
            execute_process(
              COMMAND chmod +x ninja
              COMMAND chmod +x ${cmake_dir}/cmake
            )
          endif()
      - name: Download ccache
        id: ccache
        shell: cmake -P {0}
        run: |
          set(ccache_url "https://github.com/cristianadam/ccache/releases/download/v$ENV{CCACHE_VERSION}/${{ runner.os }}.tar.xz")
          file(DOWNLOAD "${ccache_url}" ./ccache.tar.xz SHOW_PROGRESS)
          execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf ./ccache.tar.xz)
      - name: Prepare ccache timestamp
        id: ccache_cache_timestamp
        shell: cmake -P {0}
        run: |
          string(TIMESTAMP current_date "%Y-%m-%d-%H;%M;%S" UTC)
          message("::set-output name=timestamp::${current_date}")
      - name: ccache cache files
        uses: actions/cache@v1.1.0
        with:
          path: .ccache
          key: ${{ matrix.config.name }}-ccache-${{ steps.ccache_cache_timestamp.outputs.timestamp }}
          restore-keys: |
            ${{ matrix.config.name }}-ccache-1-
      # - name: prepare tools (doxygen, ...)
      #   id: building_tools
      #   run: |
      #     sudo apt-get install doxygen
      - name: Configure
        shell: cmake -P {0}
        run: |
          set(ENV{CC} ${{ matrix.config.cc }})
          set(ENV{CXX} ${{ matrix.config.cxx }})
          message(STATUS "### TCF: '${{ matrix.config.tcf }}'")
          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()
          set(path_separator ":")
          if ("${{ runner.os }}" STREQUAL "Windows")
            set(path_separator ";")
          endif()
          set(ENV{PATH} "$ENV{GITHUB_WORKSPACE}${path_separator}$ENV{PATH}")
          execute_process(
            COMMAND cmake
              -S .
              -B build
              -D CMAKE_BUILD_TYPE=$ENV{BUILD_TYPE}
              -G Ninja
              -D CMAKE_MAKE_PROGRAM=ninja
              -D CMAKE_C_COMPILER_LAUNCHER=ccache
              -D CMAKE_CXX_COMPILER_LAUNCHER=ccache
              ${{ matrix.config.tcf }}
            RESULT_VARIABLE result
          )
          if (NOT result EQUAL 0)
            message(FATAL_ERROR "Bad exit status")
          endif()
      - name: Build
        shell: cmake -P {0}
        run: |
          set(ENV{CC} ${{ matrix.config.cc }})
          set(ENV{CXX} ${{ matrix.config.cxx }})
          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()
          file(TO_CMAKE_PATH "$ENV{GITHUB_WORKSPACE}" ccache_basedir)
          set(ENV{CCACHE_BASEDIR} "${ccache_basedir}")
          set(ENV{CCACHE_DIR} "${ccache_basedir}/.ccache")
          set(ENV{CCACHE_COMPRESS} "true")
          set(ENV{CCACHE_COMPRESSLEVEL} "6")
          set(ENV{CCACHE_MAXSIZE} "400M")
          if ("${{ matrix.config.cxx }}" STREQUAL "cl")
            set(ENV{CCACHE_MAXSIZE} "600M")
          endif()
          execute_process(COMMAND ccache -p)
          execute_process(COMMAND ccache -z)
          execute_process(
            COMMAND cmake --build build
            RESULT_VARIABLE result
            OUTPUT_VARIABLE output
            ERROR_VARIABLE output
            ECHO_OUTPUT_VARIABLE ECHO_ERROR_VARIABLE
          )
          if (NOT result EQUAL 0)
            string(REGEX MATCH "FAILED:.*$" error_message "${output}")
            string(REPLACE "\n" "%0A" error_message "${error_message}")
            message("::error::${error_message}")
            message(FATAL_ERROR "Build failed")
          endif()
          execute_process(COMMAND ccache -s)
      - name: Run tests
        shell: cmake -P {0}
        run: |
          include(ProcessorCount)
          ProcessorCount(N)
          set(ENV{CTEST_OUTPUT_ON_FAILURE} "ON")
          execute_process(
            COMMAND ctest -j ${N}
            WORKING_DIRECTORY build
            RESULT_VARIABLE result
            OUTPUT_VARIABLE output
            ERROR_VARIABLE output
            ECHO_OUTPUT_VARIABLE ECHO_ERROR_VARIABLE
          )
          if (NOT result EQUAL 0)
            string(REGEX MATCH "[0-9]+% tests.*[0-9.]+ sec.*$" test_results "${output}")
            string(REPLACE "\n" "%0A" test_results "${test_results}")
            message("::error::${test_results}")
            message(FATAL_ERROR "Running tests failed!")
          endif()
      - name: Install Strip
        run: cmake --install build --prefix instdir --strip


      - name: Pack
        working-directory: instdir
        run: cmake -E tar cfv ../${{ matrix.config.artifact }} --format=7zip .


      - name: Upload
        uses: actions/upload-artifact@v1
        with:
          path: ./${{ matrix.config.artifact }}
          name: ${{ matrix.config.artifact }}

  release:
    if: contains(github.ref, 'tags/v')
    runs-on: ubuntu-latest
    needs: build

    steps:
      - name: Create Release
        id: create_release
        uses: actions/create-release@v1.0.0
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          tag_name: ${{ github.ref }}
          release_name: Release ${{ github.ref }}
          draft: false
          prerelease: false

      - name: Store Release url
        run: |
          echo "${{ steps.create_release.outputs.upload_url }}" > ./upload_url
      - uses: actions/upload-artifact@v1
        with:
          path: ./upload_url
          name: upload_url

  publish:
    if: contains(github.ref, 'tags/v')
    name: ${{ matrix.config.name }}
    runs-on: ${{ matrix.config.os }}
    strategy:
      fail-fast: false
      matrix:
        config:
#          - {
#            name: "Windows Latest MSVC", artifact: "Windows-MSVC.7z",
#            os: windows-latest
#          }
#          - {
#            name: "Windows Latest MinGW", artifact: "Windows-MinGW.7z",
#            os: ubuntu-latest
#          }
          - {
            name: "Ubuntu Latest GCC", artifact: "Linux.7z",
            os: ubuntu-latest
          }
#          - {
#            name: "macOS Latest Clang", artifact: "macOS.7z",
#            os: ubuntu-latest
#          }
    needs: release

    steps:
      - name: Download artifact
        uses: actions/download-artifact@v1
        with:
          name: ${{ matrix.config.artifact }}
          path: ./

      - name: Download URL
        uses: actions/download-artifact@v1
        with:
          name: upload_url
          path: ./
      - uses: pCYSl5EDgo/cat@master
        id: set_upload_url
        with:
          path: ./upload_url
      # - name: set_upload_url
      #   if: matrix.os != 'windows-latest'
      #   run: |
      #     upload_url=`cat ./upload_url`
      #     echo ::set-output name=upload_url::$upload_url
      - name: Upload to Release
        id: upload_to_release
        uses: actions/upload-release-asset@v1.0.1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          upload_url: ${{ steps.set_upload_url.outputs.text }}
          asset_path: ./${{ matrix.config.artifact }}
          asset_name: ${{ matrix.config.artifact }}
          asset_content_type: application/x-gtar