CMake & Makefile —
Build Sistemleri.

# target: prerequisites
# [TAB]recipe

target: prerequisite1 prerequisite2
	recipe_komutu arg1 arg2

# Örnek: main.c ve utils.c varsa → myapp oluştur
myapp: main.o utils.o
	gcc -o myapp main.o utils.o

main.o: main.c main.h
	gcc -c main.c

utils.o: utils.c utils.h
	gcc -c utils.c

.PHONY: all clean help install

all: myapp
	@echo "Build tamamlandı."

clean:
	rm -f myapp *.o *.d

help:
	@echo "Hedefler: all  clean  install  help"

install: myapp
	install -m 755 myapp /usr/local/bin/

CC      := gcc
CFLAGS  := -Wall -Wextra -std=c11 -O2
TARGET  := myapp
SRCS    := main.c utils.c
OBJS    := $(SRCS:.c=.o)

.PHONY: all clean

all: $(TARGET)

# Link: .o dosyalarından binary oluştur
$(TARGET): $(OBJS)
	$(CC) $(CFLAGS) -o $@ $^

# Compile: her .c → .o
%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

clean:
	rm -f $(TARGET) $(OBJS)

CC      := gcc
CFLAGS  := -Wall -Wextra -std=c11 -O2
TARGET  := myapp
SRCS    := main.c utils.c
OBJS    := $(SRCS:.c=.o)
DEPS    := $(SRCS:.c=.d)   # her .c için bir .d dependency dosyası

.PHONY: all clean

all: $(TARGET)

$(TARGET): $(OBJS)
	$(CC) -o $@ $^

# -MMD: .d dosyası üret; -MP: sahte hedef ekle (eksik header için hata verme)
%.o: %.c
	$(CC) $(CFLAGS) -MMD -MP -c $< -o $@

# Üretilen .d dosyalarını dahil et
-include $(DEPS)

clean:
	rm -f $(TARGET) $(OBJS) $(DEPS)

# Recursive: CFLAGS her kullanımda $(EXTRA) ile genişler
CFLAGS  = -Wall $(EXTRA)

# Simple: OBJS anında hesaplanır, sonraki SRCS değişikliği etkilemez
OBJS    := $(SRCS:.c=.o)

# Append: mevcut değere ekle
CFLAGS  += -O2

# Conditional: komut satırından make CC=clang ile override edilebilir
CC      ?= gcc

# wildcard: glob ile dosya listesi
SRCS    := $(wildcard src/*.c)

# patsubst: pattern substitution — .c → .o
OBJS    := $(patsubst %.c,%.o,$(SRCS))

# notdir: path'den dosya adını çıkar
FILENAMES := $(notdir $(SRCS))   # src/main.c → main.c

# addprefix: her öğeye prefix ekle
OBJS    := $(addprefix build/,$(notdir $(SRCS:.c=.o)))

# dir: path kısmı
DIRS    := $(dir $(SRCS))   # src/main.c → src/

# shell: shell komutu çalıştır, çıktısını al
GIT_HASH := $(shell git rev-parse --short HEAD)

# subst: literal string ikamesi
REL_SRCS := $(subst src/,,$(SRCS))   # src/ prefix'ini kaldır

# filter / filter-out: listeyi filtrele
C_SRCS  := $(filter %.c,$(ALL_SRCS))
NO_TEST := $(filter-out %_test.c,$(SRCS))

CC      := gcc
CFLAGS  := -Wall -Wextra -std=c11 -Iinclude
LDFLAGS :=
LDLIBS  := -lm
TARGET  := build/myapp

# src/ ve src/platform/ altındaki tüm .c dosyaları
SRCS    := $(wildcard src/*.c) $(wildcard src/platform/*.c)

# src/foo.c → build/foo.o
OBJS    := $(patsubst src/%.c,build/%.o,$(SRCS))
DEPS    := $(OBJS:.o=.d)

.PHONY: all clean dirs

all: dirs $(TARGET)

dirs:
	@mkdir -p build/platform

$(TARGET): $(OBJS)
	$(CC) $(LDFLAGS) -o $@ $^ $(LDLIBS)

build/%.o: src/%.c
	$(CC) $(CFLAGS) -MMD -MP -c $< -o $@

-include $(DEPS)

clean:
	rm -rf build/

# CMake minimum versiyonu — kullanılan özelliklere göre belirle
cmake_minimum_required(VERSION 3.21)

# Proje adı, versiyonu ve kullanılan diller
project(MyProject
  VERSION 1.0.0
  LANGUAGES C CXX
)

# Executable tanımla
add_executable(myapp
  src/main.c
  src/utils.c
)

# build/ dizini oluştur ve içine gir
mkdir build && cd build

# CMake ile configure: üst dizindeki CMakeLists.txt'i işle
cmake ..

# Derleme — platform-native aracı çağırır (make veya ninja)
cmake --build .

# Temizle
cmake --build . --target clean

# Paralel build (tüm CPU çekirdeklerini kullan)
cmake --build . --parallel $(nproc)

# Alternatif: build/ dizininden çıkmadan configure + build
cmake -S . -B build
cmake --build build

# Ninja'yı yükle (Ubuntu/Debian)
sudo apt install ninja-build

# Ninja generator ile configure
cmake -G "Ninja" -S . -B build-ninja

# Build — cmake --build ninja'yı otomatik çağırır
cmake --build build-ninja

# Mevcut generator'ları listele
cmake --help | grep "Generators" -A 30

# -D ile cache değişkeni set et
cmake -DCMAKE_BUILD_TYPE=Release ..
cmake -DCMAKE_INSTALL_PREFIX=/opt/myapp ..
cmake -DMYAPP_ENABLE_TESTS=ON ..

# Birden fazla -D bir arada
cmake \
  -DCMAKE_BUILD_TYPE=Release \
  -DCMAKE_INSTALL_PREFIX=/opt/myapp \
  -DBUILD_SHARED_LIBS=OFF \
  ..

# Cache'i sil ve yeniden configure (clean configure)
rm -rf build/ && cmake -S . -B build

# ── Executable ──────────────────────────────────────────────
add_executable(myapp
  src/main.c
  src/app.c
)

# ── Static library (.a) ─────────────────────────────────────
# Derleme zamanında binary'e gömülür. Runtime'da bağımlılık yok.
add_library(mylib_static STATIC
  src/utils.c
  src/parser.c
)

# ── Shared library (.so / .dll) ─────────────────────────────
# Runtime'da dinamik yüklenir. ABI uyumluluğu önemli.
add_library(mylib_shared SHARED
  src/utils.c
  src/parser.c
)

# ── Object library (.o dosya koleksiyonu) ───────────────────
# Static ve shared arasında derlenmeden paylaşılır.
add_library(mylib_obj OBJECT
  src/utils.c
  src/parser.c
)

# ── Interface library (header-only) ─────────────────────────
# Compile edilecek kaynak yok; sadece usage requirements taşır.
add_library(mylib_iface INTERFACE)
target_include_directories(mylib_iface INTERFACE include/)

# mylib: libssl'i kullanır ama dışarı aktarmaz (PRIVATE)
add_library(mylib STATIC src/crypto.c)
target_link_libraries(mylib
  PRIVATE  OpenSSL::SSL      # sadece mylib'in implementation'ı kullanır
  PUBLIC   mylib_headers     # mylib de kullanır, mylib'e bağlananlar da
)

# myapp: mylib'e bağlanır → OpenSSL transitif DEĞİL gelir (PRIVATE)
add_executable(myapp src/main.c)
target_link_libraries(myapp
  PRIVATE  mylib
)

# REQUIRED: bulunamazsa hata ver ve dur
find_package(OpenSSL REQUIRED)
find_package(Threads REQUIRED)
find_package(ZLIB REQUIRED)

# OPTIONAL: bulunamazsa devam et, sonraki if ile kontrol et
find_package(OpenMP)
if(OpenMP_FOUND)
  target_link_libraries(myapp PRIVATE OpenMP::OpenMP_C)
endif()

# Versiyon gereksinimi
find_package(Boost 1.75 REQUIRED COMPONENTS filesystem system)

# Imported target ile kullan
target_link_libraries(myapp
  PRIVATE
    OpenSSL::SSL
    OpenSSL::Crypto
    Threads::Threads
    ZLIB::ZLIB
)

find_package(PkgConfig REQUIRED)

# pkg_check_modules: pkg-config ile kütüphane bul
pkg_check_modules(LIBCURL REQUIRED libcurl)
pkg_check_modules(GLIB2 REQUIRED glib-2.0>=2.50)

target_include_directories(myapp PRIVATE ${LIBCURL_INCLUDE_DIRS})
target_link_libraries(myapp PRIVATE ${LIBCURL_LIBRARIES})
target_compile_options(myapp PRIVATE ${LIBCURL_CFLAGS_OTHER})

include(FetchContent)

# nlohmann/json — header-only JSON kütüphanesi
FetchContent_Declare(
  json
  URL https://github.com/nlohmann/json/releases/download/v3.11.3/json.tar.xz
  URL_HASH SHA256=d6c65aca6b1ed68e7a182f4757257b107ae403032760ed6ef121c9d55e81757d
)

# GoogleTest
FetchContent_Declare(
  googletest
  GIT_REPOSITORY https://github.com/google/googletest.git
  GIT_TAG        v1.14.0
)

# İndir + configure + kaynak ağacına ekle
FetchContent_MakeAvailable(json googletest)

# Artık imported target olarak kullanılabilir
target_link_libraries(myapp PRIVATE nlohmann_json::nlohmann_json)
target_link_libraries(mytest PRIVATE GTest::gtest_main)

# include/ klasörünü bu target için arama yoluna ekle
target_include_directories(myapp
  PRIVATE   include/                  # sadece myapp kullanır
  PUBLIC    ${CMAKE_CURRENT_SOURCE_DIR}/include  # myapp + bağlananlar
  INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/api      # sadece bağlananlar
)

# Generator expression ile kaynak vs install ayrımı
target_include_directories(mylib
  PUBLIC
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
    $<INSTALL_INTERFACE:include>
)

target_compile_options(myapp
  PRIVATE
    -Wall
    -Wextra
    -Wpedantic
    -Werror             # uyarıları hata yap
    -fstack-protector-strong
    $<$<CONFIG:Debug>:-g -O0>
    $<$<CONFIG:Release>:-O3 -DNDEBUG>
)

# Derleyici bazlı koşullu flag (Clang vs GCC)
target_compile_options(myapp PRIVATE
  $<$<C_COMPILER_ID:Clang>:-Weverything>
  $<$<C_COMPILER_ID:GNU>:-Wformat=2>
)

target_compile_definitions(myapp
  PRIVATE
    DEBUG=1
    VERSION="${PROJECT_VERSION}"
    PLATFORM_LINUX
    $<$<CONFIG:Debug>:ENABLE_LOGGING>    # sadece Debug'da
)

# Makefile'daki -DFOO=1 eşdeğeri
# target_compile_definitions, -D prefix'ini kendisi ekler

add_executable(myapp src/main.c)

# Sonradan kaynak ekle (koşullu platform dosyaları için ideal)
target_sources(myapp PRIVATE
  src/utils.c
  src/parser.c
)

if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
  target_sources(myapp PRIVATE src/platform/linux.c)
elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
  target_sources(myapp PRIVATE src/platform/macos.c)
endif()

# C/C++ standart versiyonunu zorla
set_target_properties(myapp PROPERTIES
  C_STANDARD          11
  C_STANDARD_REQUIRED ON
  C_EXTENSIONS        OFF
  CXX_STANDARD        17
  CXX_STANDARD_REQUIRED ON
  OUTPUT_NAME         "myapp-v${PROJECT_VERSION}"  # binary adını değiştir
  RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
)

# Property oku
get_target_property(MY_SOURCES myapp SOURCES)
message(STATUS "Sources: ${MY_SOURCES}")

# Shared library versiyonlama
set_target_properties(mylib PROPERTIES
  VERSION   ${PROJECT_VERSION}
  SOVERSION ${PROJECT_VERSION_MAJOR}
)

# Hedef sistem bilgisi
set(CMAKE_SYSTEM_NAME    Linux)
set(CMAKE_SYSTEM_PROCESSOR arm)

# Cross compiler — PATH'te olmalı
set(CMAKE_C_COMPILER   arm-linux-gnueabihf-gcc)
set(CMAKE_CXX_COMPILER arm-linux-gnueabihf-g++)
set(CMAKE_ASM_COMPILER arm-linux-gnueabihf-as)

# Sysroot: hedef sistemin rootfs kopyası
set(CMAKE_SYSROOT /opt/sysroot/arm-linux-gnueabihf)

# find_* komutlarının arama davranışı
set(CMAKE_FIND_ROOT_PATH  /opt/sysroot/arm-linux-gnueabihf)

# HOST araçları (cmake, python) host'ta ara
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)

# Kütüphaneleri ve header'ları sadece sysroot'ta ara
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

# ARM Cortex-A için optimize flag'ler (opsiyonel)
set(CMAKE_C_FLAGS_INIT   "-march=armv7-a -mfpu=neon-vfpv4 -mfloat-abi=hard")
set(CMAKE_CXX_FLAGS_INIT "-march=armv7-a -mfpu=neon-vfpv4 -mfloat-abi=hard")

# Toolchain yükle (Debian/Ubuntu)
sudo apt install gcc-arm-linux-gnueabihf g++-arm-linux-gnueabihf

# Ayrı bir build dizini kullan — host build'dan ayrı tut
cmake \
  -S . \
  -B build-arm \
  -DCMAKE_TOOLCHAIN_FILE=cmake/arm-linux-gnueabihf.cmake \
  -DCMAKE_BUILD_TYPE=Release

cmake --build build-arm --parallel $(nproc)

# Çıktıyı doğrula
file build-arm/myapp
# → build-arm/myapp: ELF 32-bit LSB executable, ARM, EABI5 version 1

# QEMU ile test (opsiyonel)
qemu-arm -L /opt/sysroot/arm-linux-gnueabihf build-arm/myapp

set(CMAKE_SYSTEM_NAME    Linux)
set(CMAKE_SYSTEM_PROCESSOR aarch64)

set(CMAKE_C_COMPILER   aarch64-linux-gnu-gcc)
set(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++)

# Raspberry Pi OS sysroot (rsync ile RPi'den alınmış)
set(CMAKE_SYSROOT /opt/rpi4-sysroot)
set(CMAKE_FIND_ROOT_PATH /opt/rpi4-sysroot)

set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

# Cortex-A72 (RPi4) optimizasyonu
set(CMAKE_C_FLAGS_INIT "-mcpu=cortex-a72 -mtune=cortex-a72")

# SDK'yı yükle (Yocto'dan üretilen installer)
./poky-glibc-x86_64-core-image-minimal-aarch64-qemuarm64-toolchain-4.3.sh

# SDK ortamını aktif et
source /opt/poky/4.3/environment-setup-aarch64-poky-linux

# SDK'nın sağladığı toolchain file ile CMake çalıştır
cmake \
  -DCMAKE_TOOLCHAIN_FILE=$OECORE_NATIVE_SYSROOT/usr/share/cmake/OEToolchainConfig.cmake \
  -S . -B build-yocto

cmake --build build-yocto

# $<condition>  →  1 veya 0
$<BOOL:val>           # val boş veya 0 değilse 1
$<CONFIG:Debug>       # build tipi Debug ise 1
$<PLATFORM_ID:Linux>  # platform Linux ise 1
$<C_COMPILER_ID:GNU>  # C derleyicisi GCC ise 1

# $<IF:condition,then,else>
$<IF:$<CONFIG:Debug>,-g,-O3>

# $<condition:value>  →  condition=1 ise value, 0 ise boş string
$<$<CONFIG:Debug>:-fsanitize=address>

target_compile_options(myapp PRIVATE
  # Debug: adres sanitizer + debug semboller, optimizasyon yok
  $<$<CONFIG:Debug>:
    -g
    -O0
    -fsanitize=address
    -fsanitize=undefined
    -fno-omit-frame-pointer
  >

  # Release: maksimum optimizasyon
  $<$<CONFIG:Release>:
    -O3
    -DNDEBUG
    -ffunction-sections
    -fdata-sections
  >

  # RelWithDebInfo: release + debug semboller
  $<$<CONFIG:RelWithDebInfo>:
    -O2
    -g
    -DNDEBUG
  >
)

# Linker flag: ASan için link etmek gerekiyor
target_link_options(myapp PRIVATE
  $<$<CONFIG:Debug>:-fsanitize=address -fsanitize=undefined>
)

# Kullanım: cmake -DCMAKE_BUILD_TYPE=Debug -S . -B build-debug

# Karma C/C++ projesinde dile özgü standart flag'ler
target_compile_options(myapp PRIVATE
  $<$<COMPILE_LANGUAGE:C>:   -std=c11   -Wstrict-prototypes>
  $<$<COMPILE_LANGUAGE:CXX>: -std=c++17 -Wno-deprecated>
)

# TARGET_FILE: test komutunda binary path'i dinamik al
add_test(NAME mytest
  COMMAND $<TARGET_FILE:myapp> --test
)

# Yükle
sudo apt install ccache

# Versiyon ve yol
ccache --version
which ccache   # → /usr/bin/ccache

# İstatistikler
ccache -s

# Cache'i temizle
ccache -C

# Cache boyutunu ayarla (default 5GB)
ccache -M 10G

# Yöntem 1: CMAKE_*_COMPILER_LAUNCHER (önerilen, CMake 3.4+)
find_program(CCACHE_PROGRAM ccache)
if(CCACHE_PROGRAM)
  set(CMAKE_C_COMPILER_LAUNCHER   ${CCACHE_PROGRAM})
  set(CMAKE_CXX_COMPILER_LAUNCHER ${CCACHE_PROGRAM})
  message(STATUS "ccache found: ${CCACHE_PROGRAM}")
endif()

# Yöntem 2: global set (CMakeLists.txt'e sabit yaz)
set(CMAKE_C_COMPILER_LAUNCHER   ccache)
set(CMAKE_CXX_COMPILER_LAUNCHER ccache)

# Yöntem 3: komut satırından
# cmake -DCMAKE_C_COMPILER_LAUNCHER=ccache ...

ccache -s
# Çıktı örneği:
# Summary:
#   Hits:            892 / 1024 (87.1%)
#     Direct:        712
#     Preprocessed:  180
#   Misses:          132
#     Direct:        105
#     Preprocessed:   27
# Primary storage:
#   Cache size (GiB):  2.14 / 10.00
#   Files:           4816

# CMake 3.16+: target_precompile_headers
target_precompile_headers(myapp PRIVATE
  include/pch.h           # sık değişmeyen, büyük header'lar buraya
  <vector>
  <string>
  <unordered_map>
)

# Birden fazla target arasında PCH paylaş
target_precompile_headers(mylib2 REUSE_FROM mylib)

# CMake 3.16+: UNITY_BUILD — tüm .c dosyalarını tek bir compilation unit'e toplar
set_target_properties(myapp PROPERTIES
  UNITY_BUILD ON
)

# Batch boyutu: kaç dosyayı tek compilation unit'e koy
set_target_properties(myapp PROPERTIES
  UNITY_BUILD_BATCH_SIZE 8
)

myproject/
├── CMakeLists.txt          # Ana CMake dosyası
├── cmake/
│   ├── arm-linux-gnueabihf.cmake
│   └── myproject-config.cmake.in
├── include/
│   └── myproject/
│       └── core.h          # Public API header'ları
├── src/
│   ├── core.c              # Library kaynak kodu
│   └── main.c              # Executable entry point
└── tests/
    ├── CMakeLists.txt
    └── test_core.c

cmake_minimum_required(VERSION 3.21)

project(myproject
  VERSION     1.2.0
  DESCRIPTION "Embedded Linux utility library"
  LANGUAGES   C
)

# ── ccache ──────────────────────────────────────────────────
find_program(CCACHE ccache)
if(CCACHE)
  set(CMAKE_C_COMPILER_LAUNCHER ${CCACHE})
endif()

# ── Build type varsayılanı ───────────────────────────────────
if(NOT CMAKE_BUILD_TYPE)
  set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
endif()

# ── Options ─────────────────────────────────────────────────
option(MYPROJECT_BUILD_TESTS   "Build unit tests"   ON)
option(MYPROJECT_BUILD_SHARED  "Build shared lib"  OFF)

# ── Library ─────────────────────────────────────────────────
set(LIB_TYPE STATIC)
if(MYPROJECT_BUILD_SHARED)
  set(LIB_TYPE SHARED)
endif()

add_library(myproject_core ${LIB_TYPE}
  src/core.c
)

target_include_directories(myproject_core
  PUBLIC
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
    $<INSTALL_INTERFACE:include>
)

target_compile_options(myproject_core PRIVATE
  -Wall -Wextra -Wpedantic
  $<$<CONFIG:Debug>:-g -O0 -fsanitize=address>
  $<$<CONFIG:Release>:-O2>
)

set_target_properties(myproject_core PROPERTIES
  C_STANDARD          11
  C_STANDARD_REQUIRED ON
  VERSION             ${PROJECT_VERSION}
  SOVERSION           ${PROJECT_VERSION_MAJOR}
)

# ── Executable ──────────────────────────────────────────────
add_executable(myapp src/main.c)
target_link_libraries(myapp PRIVATE myproject_core)

# ── Tests ───────────────────────────────────────────────────
if(MYPROJECT_BUILD_TESTS)
  enable_testing()
  add_subdirectory(tests)
endif()

# ── Install ─────────────────────────────────────────────────
include(GNUInstallDirs)

install(TARGETS myproject_core myapp
  EXPORT  myproject-targets
  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

install(DIRECTORY include/myproject
  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
)

install(EXPORT myproject-targets
  FILE        myproject-targets.cmake
  NAMESPACE   myproject::
  DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/myproject
)

add_executable(test_core test_core.c)
target_link_libraries(test_core PRIVATE myproject_core)

# CTest'e test ekle
add_test(
  NAME    core_unit_test
  COMMAND $<TARGET_FILE:test_core>
)

# Test ortam değişkenleri
set_tests_properties(core_unit_test PROPERTIES
  ENVIRONMENT "MYAPP_LOG_LEVEL=debug"
  TIMEOUT     30
)

# Configure
cmake \
  -S . -B build \
  -DCMAKE_BUILD_TYPE=Debug \
  -DMYPROJECT_BUILD_TESTS=ON

# Build
cmake --build build --parallel $(nproc)

# Test — tüm testleri çalıştır
ctest --test-dir build --output-on-failure

# Install (custom prefix)
cmake --install build --prefix /opt/myproject

# Sonuç dizin yapısı:
# /opt/myproject/
# ├── bin/myapp
# ├── include/myproject/core.h
# └── lib/libmyproject_core.a

# Ana CMakeLists.txt'e ekle (install direktiflerinden sonra)
set(CPACK_PACKAGE_NAME           "myproject")
set(CPACK_PACKAGE_VERSION        ${PROJECT_VERSION})
set(CPACK_PACKAGE_CONTACT        "dev@example.com")
set(CPACK_GENERATOR              "DEB;TGZ")
set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6 (>= 2.17)")
include(CPack)

# Paket oluştur
# cmake --build build
# cpack --config build/CPackConfig.cmake
# → myproject-1.2.0-Linux.tar.gz
# → myproject_1.2.0_amd64.deb

name: CI

on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-22.04
    strategy:
      matrix:
        build_type: [Debug, Release]

    steps:
      - uses: actions/checkout@v4

      - name: Install dependencies
        run: sudo apt-get install -y ccache ninja-build

      - name: Configure
        run: |
          cmake \
            -S . -B build \
            -G Ninja \
            -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} \
            -DCMAKE_C_COMPILER_LAUNCHER=ccache \
            -DMYPROJECT_BUILD_TESTS=ON

      - name: Build
        run: cmake --build build --parallel

      - name: Test
        run: ctest --test-dir build --output-on-failure