Bump to 0.2.2

Emit options and settings before the project()
Bump to 0.2.1
2026-06-08 13:22:55 +00:00 · 2021-12-27 11:49:22 +01:00 · 2021-12-27 11:45:23 +01:00 · 2021-12-27 11:17:20 +01:00 · 2021-12-27 11:12:28 +01:00 · 2021-12-27 11:01:04 +01:00
45 changed files with 1716 additions and 938 deletions
@@ -0,0 +1 @@
+github: [mrexodia]
@@ -5,28 +5,32 @@ on: [push, pull_request]
 jobs:
  build:
    # Skip building pull requests from the same repository
-    if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != '${{ github.repository }}'
+    if: ${{ github.event_name == 'push' || (github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name != github.repository) }}
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
-        os: [windows-2016, windows-2019, macos-10.15, ubuntu-16.04, ubuntu-18.04, ubuntu-20.04]
+        os: [windows-2019, macos-10.15, ubuntu-20.04]
    env:
      BUILD_TYPE: Release
    steps:
    - name: Checkout
      uses: actions/checkout@v2

+    - name: Tag cmkr.cmake
+      if: ${{ startsWith(github.ref, 'refs/tags/') }}
+      run: cmake -P "cmake/replace_tag.cmake"
+
    - name: Build
      run: |
-        cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=${{ env.BUILD_TYPE }}
+        cmake -B build -DCMAKE_BUILD_TYPE=${{ env.BUILD_TYPE }} -DCMAKE_UNITY_BUILD=ON
        cmake --build build --config ${{ env.BUILD_TYPE }} --parallel
        cmake --install build --prefix ./install --config ${{ env.BUILD_TYPE }}

    - name: Check if cmkr was run
      run: |
        ./install/bin/cmkr gen
-        git diff --exit-code
+        git diff --exit-code -- . ":(exclude)cmake/cmkr.cmake"

    - name: Test
      run: |
@@ -53,9 +57,9 @@ jobs:

    - name: Release
      uses: softprops/action-gh-release@v1
-      if: ${{ startsWith(github.ref, 'refs/tags/') && (matrix.os == 'windows-2019' || matrix.os == 'macos-10.15' || matrix.os == 'ubuntu-16.04') }}
+      if: ${{ startsWith(github.ref, 'refs/tags/') }}
      with:
        prerelease: ${{ !startsWith(github.ref, 'refs/tags/v') || contains(github.ref, '-pre') }}
        files: ${{ github.event.repository.name }}-${{ steps.osname.outputs.lowercase }}.zip
      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -3,17 +3,15 @@

 cmake_minimum_required(VERSION 2.8...3.8)

+if(CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR)
+	message(FATAL_ERROR "In-tree builds are not supported. Run CMake from a separate directory: cmake -B build")
+endif()
+
 # Regenerate CMakeLists.txt automatically in the root project
 set(CMKR_ROOT_PROJECT OFF)
 if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
 	set(CMKR_ROOT_PROJECT ON)

-	# Bootstrap cmkr
-	include(cmkr.cmake OPTIONAL RESULT_VARIABLE CMKR_INCLUDE_RESULT)
-	if(CMKR_INCLUDE_RESULT)
-		cmkr()
-	endif()
-
 	# Enable folder support
 	set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 endif()
@@ -27,12 +25,13 @@ project(cmkr
 	LANGUAGES
 		CXX
 	VERSION
-		0.1.4
+		0.2.2
 	DESCRIPTION
 		"CMakeLists generator from TOML"
 )

 include("cmake/generate_documentation.cmake")
+include("cmake/generate_resources.cmake")

 # third_party
 set(CMKR_CMAKE_FOLDER ${CMAKE_FOLDER})
@@ -93,6 +92,8 @@ list(APPEND cmkr_SOURCES
 	"include/help.hpp"
 	"include/literals.hpp"
 	"include/project_parser.hpp"
+	"cmake/cmkr.cmake"
+	"cmake/version.hpp.in"
 )

 list(APPEND cmkr_SOURCES
@@ -129,6 +130,8 @@ target_link_libraries(cmkr PRIVATE
 	nlohmann_json
 )

+generate_resources(${CMKR_TARGET})
+
 unset(CMKR_TARGET)
 unset(CMKR_SOURCES)

@@ -1,35 +1,54 @@
 # cmkr

-`cmkr`, pronounced "cmaker", is a modern build system based on [CMake](https://cmake.org/) and [TOML](https://toml.io). It was originally created by [Mohammed Alyousef](https://github.com/MoAlyousef).
+`cmkr`, pronounced "cmaker", is a modern build system based on [CMake](https://cmake.org/) and [TOML](https://toml.io).

 `cmkr` parses `cmake.toml` files and generates a modern, idiomatic `CMakeLists.txt` for you. A minimal example:

 ```toml
 [project]
 name = "cmkr_for_beginners"
-description = "A minimal cmkr project."

 [target.hello_world]
 type = "executable"
 sources = ["src/main.cpp"]
 ```

-`cmkr` can bootstrap itself from CMake and consumers of your project do not need to install anything to work with it.
+`cmkr` can bootstrap itself from CMake and you only need CMake to use it.

 ## Getting started

-The easiest way to get started is to use the [cmkr_for_beginners](https://github.com/build-cpp/cmkr_for_beginners) template repository. Either open it in [Gitpod](https://gitpod.io/#https://github.com/build-cpp/cmkr_for_beginners), or clone the repository and run:
+To get started run the following commands from your project directory:
+
+```sh
+curl https://raw.githubusercontent.com/build-cpp/cmkr/main/cmake/cmkr.cmake -o cmkr.cmake
+cmake -P cmkr.cmake
+```
+
+After the bootstrapping process finishes, modify [`cmake.toml`](https://build-cpp.github.io/cmkr/cmake-toml) and open the project in your favorite IDE or build with CMake:

 ```sh
 cmake -B build
 cmake --build build
 ```

-Alternatively you can check out the [cmkr topic](https://github.com/topics/cmkr), the [build-cpp organization](https://github.com/build-cpp) or the [tests](https://github.com/build-cpp/cmkr/tree/main/tests) for more examples and templates. You can also check out the [documentation](https://build-cpp.github.io/cmkr).
+Once bootstrapped, `cmkr` does not introduce extra steps to your workflow. After modifying `cmake.toml` you simply build/configure your CMake project and `cmkr` will automatically regenerate `CMakeLists.txt`.
+
+In CI settings the `cmkr` bootstrapping process is skipped so there is no extra configure-time overhead in your pipelines.
+
+## Template repositories
+
+Another way to get started is to use the [cmkr_for_beginners](https://github.com/build-cpp/cmkr_for_beginners) template repository. Either open it in [Gitpod](https://gitpod.io/#https://github.com/build-cpp/cmkr_for_beginners), or clone the repository and run:
+
+```sh
+cmake -B build
+cmake --build build
+```
+
+Check out the [cmkr topic](https://github.com/topics/cmkr), the [build-cpp organization](https://github.com/build-cpp) or the [tests](https://github.com/build-cpp/cmkr/tree/main/tests) for more examples and templates.

 ## Command line

-Optionally you can install `cmkr` in your `PATH` and use it as a utility from the command line:
+Optionally you can put a [`cmkr` release](https://github.com/build-cpp/cmkr/releases) in your `PATH` and use it as a utility from the command line:

 ```
 Usage: cmkr [arguments]
@@ -1,13 +1,17 @@
 [cmake]
 version = "2.8...3.8"
+cmkr-include = false

 [project]
 name = "cmkr"
-version = "0.1.4"
+version = "0.2.2"
 description = "CMakeLists generator from TOML"
 languages = ["CXX"]
 subdirs = ["third_party", "tests"]
-include-after = ["cmake/generate_documentation.cmake"]
+include-after = [
+    "cmake/generate_documentation.cmake",
+    "cmake/generate_resources.cmake"
+]

 [target.cmkr_generate_documentation]
 type = "interface"
@@ -17,10 +21,26 @@ generate_documentation()

 [target.cmkr]
 type = "executable"
-sources = ["src/*.cpp", "include/*.hpp"]
-include-directories = ["include"]
+sources = [
+    "src/*.cpp",
+    "include/*.hpp",
+    "cmake/cmkr.cmake",
+    "cmake/version.hpp.in",
+]
+include-directories = [
+    "include",
+]
 compile-features = ["cxx_std_11"]
-link-libraries = ["toml11", "ghc_filesystem", "mpark_variant", "ordered_map", "nlohmann_json"]
+link-libraries = [
+    "toml11",
+    "ghc_filesystem",
+    "mpark_variant",
+    "ordered_map",
+    "nlohmann_json",
+]
+cmake-after = """
+generate_resources(${CMKR_TARGET})
+"""

 [[install]]
 targets = ["cmkr"]
@@ -1,44 +0,0 @@
-# This file was generated automatically by cmkr.
-
-cmake_minimum_required(VERSION 3.15)
-
-# Regenerate CMakeLists.txt automatically in the root project
-set(CMKR_ROOT_PROJECT OFF)
-if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
-	set(CMKR_ROOT_PROJECT ON)
-
-	# Bootstrap cmkr
-	include(cmkr.cmake OPTIONAL RESULT_VARIABLE CMKR_INCLUDE_RESULT)
-	if(CMKR_INCLUDE_RESULT)
-		cmkr()
-	endif()
-
-	# Enable folder support
-	set_property(GLOBAL PROPERTY USE_FOLDERS ON)
-endif()
-
-# Create a configure-time dependency on cmake.toml to improve IDE support
-if(CMKR_ROOT_PROJECT)
-	configure_file(cmake.toml cmake.toml COPYONLY)
-endif()
-
-project(example
-	VERSION
-		0.1.0
-)
-
-# Target example
-set(example_SOURCES
-	"src/example.cpp"
-	cmake.toml
-)
-
-add_executable(example ${example_SOURCES})
-
-get_directory_property(CMKR_VS_STARTUP_PROJECT DIRECTORY ${PROJECT_SOURCE_DIR} DEFINITION VS_STARTUP_PROJECT)
-if(NOT CMKR_VS_STARTUP_PROJECT)
-	set_property(DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT example)
-endif()
-
-source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${example_SOURCES})
-
@@ -1,12 +0,0 @@
-# This is a minimal example project used for testing the cmkr bootstrapping process
-
-[cmake]
-version = "3.15"
-
-[project]
-name = "example"
-version = "0.1.0"
-
-[target.example]
-type = "executable"
-sources = ["src/example.cpp"]
@@ -1,162 +1,222 @@
-include_guard()
-
-# Change these defaults to point to your infrastructure if desired
-set(CMKR_REPO "https://github.com/build-cpp/cmkr" CACHE STRING "cmkr git repository" FORCE)
-set(CMKR_TAG "archive_3cd84a97" CACHE STRING "cmkr git tag (this needs to be available forever)" FORCE)
-
-# Set these from the command line to customize for development/debugging purposes
-set(CMKR_EXECUTABLE "" CACHE FILEPATH "cmkr executable")
-set(CMKR_SKIP_GENERATION OFF CACHE BOOL "skip automatic cmkr generation")
-
-# Disable cmkr if generation is disabled
-if(DEFINED ENV{CI} OR CMKR_SKIP_GENERATION)
-    message(STATUS "[cmkr] Skipping automatic cmkr generation")
-    macro(cmkr)
-    endmacro()
-    return()
-endif()
-
-# Disable cmkr if no cmake.toml file is found
-if(NOT EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/cmake.toml")
-    message(AUTHOR_WARNING "[cmkr] Not found: ${CMAKE_CURRENT_SOURCE_DIR}/cmake.toml")
-    macro(cmkr)
-    endmacro()
-    return()
-endif()
-
-# Convert a Windows native path to CMake path
-if(CMKR_EXECUTABLE MATCHES "\\\\")
-    string(REPLACE "\\" "/" CMKR_EXECUTABLE_CMAKE "${CMKR_EXECUTABLE}")
-    set(CMKR_EXECUTABLE "${CMKR_EXECUTABLE_CMAKE}" CACHE FILEPATH "" FORCE)
-    unset(CMKR_EXECUTABLE_CMAKE)
-endif()
-
-# Helper macro to execute a process (COMMAND_ERROR_IS_FATAL ANY is 3.19 and higher)
-function(cmkr_exec)
-    execute_process(COMMAND ${ARGV} RESULT_VARIABLE CMKR_EXEC_RESULT)
-    if(NOT CMKR_EXEC_RESULT EQUAL 0)
-        message(FATAL_ERROR "cmkr_exec(${ARGV}) failed (exit code ${CMKR_EXEC_RESULT})")
-    endif()
-endfunction()
-
-# Windows-specific hack (CMAKE_EXECUTABLE_PREFIX is not set at the moment)
-if(WIN32)
-    set(CMKR_EXECUTABLE_NAME "cmkr.exe")
-else()
-    set(CMKR_EXECUTABLE_NAME "cmkr")
-endif()
-
-# Use cached cmkr if found
-set(CMKR_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/_cmkr_${CMKR_TAG}")
-set(CMKR_CACHED_EXECUTABLE "${CMKR_DIRECTORY}/bin/${CMKR_EXECUTABLE_NAME}")
-
-if(NOT CMKR_CACHED_EXECUTABLE STREQUAL CMKR_EXECUTABLE AND CMKR_EXECUTABLE MATCHES "^${CMAKE_CURRENT_BINARY_DIR}/_cmkr")
-    message(AUTHOR_WARNING "[cmkr] Upgrading '${CMKR_EXECUTABLE}' to '${CMKR_CACHED_EXECUTABLE}'")
-    unset(CMKR_EXECUTABLE CACHE)
-endif()
-
-if(CMKR_EXECUTABLE AND EXISTS "${CMKR_EXECUTABLE}")
-    message(VERBOSE "[cmkr] Found cmkr: '${CMKR_EXECUTABLE}'")
-elseif(CMKR_EXECUTABLE AND NOT CMKR_EXECUTABLE STREQUAL CMKR_CACHED_EXECUTABLE)
-    message(FATAL_ERROR "[cmkr] '${CMKR_EXECUTABLE}' not found")
-else()
-    set(CMKR_EXECUTABLE "${CMKR_CACHED_EXECUTABLE}" CACHE FILEPATH "Full path to cmkr executable" FORCE)
-    message(VERBOSE "[cmkr] Bootstrapping '${CMKR_EXECUTABLE}'")
-    
-    message(STATUS "[cmkr] Fetching cmkr...")
-    if(EXISTS "${CMKR_DIRECTORY}")
-        cmkr_exec("${CMAKE_COMMAND}" -E rm -rf "${CMKR_DIRECTORY}")
-    endif()
-    find_package(Git QUIET REQUIRED)
-    cmkr_exec("${GIT_EXECUTABLE}"
-        clone
-        --config advice.detachedHead=false
-        --branch ${CMKR_TAG}
-        --depth 1
-        ${CMKR_REPO}
-        "${CMKR_DIRECTORY}"
-    )
-    message(STATUS "[cmkr] Building cmkr...")
-    cmkr_exec("${CMAKE_COMMAND}"
-        --no-warn-unused-cli
-        "${CMKR_DIRECTORY}"
-        "-B${CMKR_DIRECTORY}/build"
-        "-DCMAKE_BUILD_TYPE=Release"
-        "-DCMAKE_INSTALL_PREFIX=${CMKR_DIRECTORY}"
-        "-DCMKR_GENERATE_DOCUMENTATION=OFF"
-    )
-    cmkr_exec("${CMAKE_COMMAND}"
-        --build "${CMKR_DIRECTORY}/build"
-        --config Release
-        --parallel
-    )
-    cmkr_exec("${CMAKE_COMMAND}"
-        --install "${CMKR_DIRECTORY}/build"
-        --config Release
-        --prefix "${CMKR_DIRECTORY}"
-        --component cmkr
-    )
-    if(NOT EXISTS ${CMKR_EXECUTABLE})
-        message(FATAL_ERROR "[cmkr] Failed to bootstrap '${CMKR_EXECUTABLE}'")
-    endif()
-    cmkr_exec("${CMKR_EXECUTABLE}" version)
-    message(STATUS "[cmkr] Bootstrapped ${CMKR_EXECUTABLE}")
-endif()
-execute_process(COMMAND "${CMKR_EXECUTABLE}" version
-    RESULT_VARIABLE CMKR_EXEC_RESULT
-)
-if(NOT CMKR_EXEC_RESULT EQUAL 0)
-    message(FATAL_ERROR "[cmkr] Failed to get version, try clearing the cache and rebuilding")
-endif()
-
-# This is the macro that contains black magic
-macro(cmkr)
-    # When this macro is called from the generated file, fake some internal CMake variables
-    get_source_file_property(CMKR_CURRENT_LIST_FILE "${CMAKE_CURRENT_LIST_FILE}" CMKR_CURRENT_LIST_FILE)
-    if(CMKR_CURRENT_LIST_FILE)
-        set(CMAKE_CURRENT_LIST_FILE "${CMKR_CURRENT_LIST_FILE}")
-        get_filename_component(CMAKE_CURRENT_LIST_DIR "${CMAKE_CURRENT_LIST_FILE}" DIRECTORY)
-    endif()
-
-    # File-based include guard (include_guard is not documented to work)
-    get_source_file_property(CMKR_INCLUDE_GUARD "${CMAKE_CURRENT_LIST_FILE}" CMKR_INCLUDE_GUARD)
-    if(NOT CMKR_INCLUDE_GUARD)
-        set_source_files_properties("${CMAKE_CURRENT_LIST_FILE}" PROPERTIES CMKR_INCLUDE_GUARD TRUE)
-
-        file(SHA256 "${CMAKE_CURRENT_LIST_FILE}" CMKR_LIST_FILE_SHA256_PRE)
-
-        # Generate CMakeLists.txt
-        cmkr_exec("${CMKR_EXECUTABLE}" gen
-            WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-        )
-
-        file(SHA256 "${CMAKE_CURRENT_LIST_FILE}" CMKR_LIST_FILE_SHA256_POST)
-
-        # Delete the temporary file if it was left for some reason
-        set(CMKR_TEMP_FILE "${CMAKE_CURRENT_SOURCE_DIR}/CMakerLists.txt")
-        if(EXISTS "${CMKR_TEMP_FILE}")
-            file(REMOVE "${CMKR_TEMP_FILE}")
-        endif()
-
-        if(NOT CMKR_LIST_FILE_SHA256_PRE STREQUAL CMKR_LIST_FILE_SHA256_POST)
-            # Copy the now-generated CMakeLists.txt to CMakerLists.txt
-            # This is done because you cannot include() a file you are currently in
-            configure_file(CMakeLists.txt "${CMKR_TEMP_FILE}" COPYONLY)
-            
-            # Add the macro required for the hack at the start of the cmkr macro
-            set_source_files_properties("${CMKR_TEMP_FILE}" PROPERTIES
-                CMKR_CURRENT_LIST_FILE "${CMAKE_CURRENT_LIST_FILE}"
-            )
-            
-            # 'Execute' the newly-generated CMakeLists.txt
-            include("${CMKR_TEMP_FILE}")
-            
-            # Delete the generated file
-            file(REMOVE "${CMKR_TEMP_FILE}")
-            
-            # Do not execute the rest of the original CMakeLists.txt
-            return()
-        endif()
-        # Resume executing the unmodified CMakeLists.txt
-    endif()
-endmacro()
+include_guard()
+
+# Change these defaults to point to your infrastructure if desired
+set(CMKR_REPO "https://github.com/build-cpp/cmkr" CACHE STRING "cmkr git repository" FORCE)
+set(CMKR_TAG "v0.2.2" CACHE STRING "cmkr git tag (this needs to be available forever)" FORCE)
+
+# To bootstrap/generate a cmkr project: cmake -P cmkr.cmake
+if(CMAKE_SCRIPT_MODE_FILE)
+    set(CMAKE_BINARY_DIR "${CMAKE_BINARY_DIR}/build")
+    set(CMAKE_CURRENT_BINARY_DIR "${CMAKE_BINARY_DIR}")
+    file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}")
+endif()
+
+# Set these from the command line to customize for development/debugging purposes
+set(CMKR_EXECUTABLE "" CACHE FILEPATH "cmkr executable")
+set(CMKR_SKIP_GENERATION OFF CACHE BOOL "skip automatic cmkr generation")
+set(CMKR_BUILD_TYPE "Debug" CACHE STRING "cmkr build configuration")
+
+# Disable cmkr if generation is disabled
+if(DEFINED ENV{CI} OR CMKR_SKIP_GENERATION OR CMKR_BUILD_SKIP_GENERATION)
+    message(STATUS "[cmkr] Skipping automatic cmkr generation")
+    unset(CMKR_BUILD_SKIP_GENERATION CACHE)
+    macro(cmkr)
+    endmacro()
+    return()
+endif()
+
+# Disable cmkr if no cmake.toml file is found
+if(NOT CMAKE_SCRIPT_MODE_FILE AND NOT EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/cmake.toml")
+    message(AUTHOR_WARNING "[cmkr] Not found: ${CMAKE_CURRENT_SOURCE_DIR}/cmake.toml")
+    macro(cmkr)
+    endmacro()
+    return()
+endif()
+
+# Convert a Windows native path to CMake path
+if(CMKR_EXECUTABLE MATCHES "\\\\")
+    string(REPLACE "\\" "/" CMKR_EXECUTABLE_CMAKE "${CMKR_EXECUTABLE}")
+    set(CMKR_EXECUTABLE "${CMKR_EXECUTABLE_CMAKE}" CACHE FILEPATH "" FORCE)
+    unset(CMKR_EXECUTABLE_CMAKE)
+endif()
+
+# Helper macro to execute a process (COMMAND_ERROR_IS_FATAL ANY is 3.19 and higher)
+function(cmkr_exec)
+    execute_process(COMMAND ${ARGV} RESULT_VARIABLE CMKR_EXEC_RESULT)
+    if(NOT CMKR_EXEC_RESULT EQUAL 0)
+        message(FATAL_ERROR "cmkr_exec(${ARGV}) failed (exit code ${CMKR_EXEC_RESULT})")
+    endif()
+endfunction()
+
+# Windows-specific hack (CMAKE_EXECUTABLE_PREFIX is not set at the moment)
+if(WIN32)
+    set(CMKR_EXECUTABLE_NAME "cmkr.exe")
+else()
+    set(CMKR_EXECUTABLE_NAME "cmkr")
+endif()
+
+# Use cached cmkr if found
+if(DEFINED ENV{CMKR_CACHE} AND EXISTS "$ENV{CMKR_CACHE}")
+    set(CMKR_DIRECTORY_PREFIX "$ENV{CMKR_CACHE}")
+    string(REPLACE "\\" "/" CMKR_DIRECTORY_PREFIX "${CMKR_DIRECTORY_PREFIX}")
+    if(NOT CMKR_DIRECTORY_PREFIX MATCHES "\\/$")
+        set(CMKR_DIRECTORY_PREFIX "${CMKR_DIRECTORY_PREFIX}/")
+    endif()
+else()
+    set(CMKR_DIRECTORY_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/_cmkr_")
+endif()
+set(CMKR_DIRECTORY "${CMKR_DIRECTORY_PREFIX}${CMKR_TAG}")
+set(CMKR_CACHED_EXECUTABLE "${CMKR_DIRECTORY}/bin/${CMKR_EXECUTABLE_NAME}")
+
+# Handle upgrading logic
+if(CMKR_EXECUTABLE AND NOT CMKR_CACHED_EXECUTABLE STREQUAL CMKR_EXECUTABLE)    
+    if(CMKR_EXECUTABLE MATCHES "^${CMAKE_CURRENT_BINARY_DIR}/_cmkr")
+        if(DEFINED ENV{CMKR_CACHE} AND EXISTS "$ENV{CMKR_CACHE}")
+            message(AUTHOR_WARNING "[cmkr] Switching to cached cmkr: '${CMKR_CACHED_EXECUTABLE}'")
+            if(EXISTS "${CMKR_CACHED_EXECUTABLE}")
+                set(CMKR_EXECUTABLE "${CMKR_CACHED_EXECUTABLE}" CACHE FILEPATH "Full path to cmkr executable" FORCE)
+            else()
+                unset(CMKR_EXECUTABLE CACHE)
+            endif()
+        else()
+            message(AUTHOR_WARNING "[cmkr] Upgrading '${CMKR_EXECUTABLE}' to '${CMKR_CACHED_EXECUTABLE}'")
+            unset(CMKR_EXECUTABLE CACHE)
+        endif()
+    elseif(DEFINED ENV{CMKR_CACHE} AND EXISTS "$ENV{CMKR_CACHE}" AND CMKR_EXECUTABLE MATCHES "^${CMKR_DIRECTORY_PREFIX}")
+        message(AUTHOR_WARNING "[cmkr] Upgrading cached '${CMKR_EXECUTABLE}' to '${CMKR_CACHED_EXECUTABLE}'")
+        unset(CMKR_EXECUTABLE CACHE)
+    endif()
+endif()
+
+if(CMKR_EXECUTABLE AND EXISTS "${CMKR_EXECUTABLE}")
+    message(VERBOSE "[cmkr] Found cmkr: '${CMKR_EXECUTABLE}'")
+elseif(CMKR_EXECUTABLE AND NOT CMKR_EXECUTABLE STREQUAL CMKR_CACHED_EXECUTABLE)
+    message(FATAL_ERROR "[cmkr] '${CMKR_EXECUTABLE}' not found")
+elseif(NOT CMKR_EXECUTABLE AND EXISTS "${CMKR_CACHED_EXECUTABLE}")
+    set(CMKR_EXECUTABLE "${CMKR_CACHED_EXECUTABLE}" CACHE FILEPATH "Full path to cmkr executable" FORCE)
+    message(STATUS "[cmkr] Found cached cmkr: '${CMKR_EXECUTABLE}'")
+else()
+    set(CMKR_EXECUTABLE "${CMKR_CACHED_EXECUTABLE}" CACHE FILEPATH "Full path to cmkr executable" FORCE)
+    message(VERBOSE "[cmkr] Bootstrapping '${CMKR_EXECUTABLE}'")
+    
+    message(STATUS "[cmkr] Fetching cmkr...")
+    if(EXISTS "${CMKR_DIRECTORY}")
+        cmkr_exec("${CMAKE_COMMAND}" -E rm -rf "${CMKR_DIRECTORY}")
+    endif()
+    find_package(Git QUIET REQUIRED)
+    cmkr_exec("${GIT_EXECUTABLE}"
+        clone
+        --config advice.detachedHead=false
+        --branch ${CMKR_TAG}
+        --depth 1
+        ${CMKR_REPO}
+        "${CMKR_DIRECTORY}"
+    )
+    message(STATUS "[cmkr] Building cmkr (using system compiler)...")
+    cmkr_exec("${CMAKE_COMMAND}"
+        --no-warn-unused-cli
+        "${CMKR_DIRECTORY}"
+        "-B${CMKR_DIRECTORY}/build"
+        "-DCMAKE_BUILD_TYPE=${CMKR_BUILD_TYPE}"
+        "-DCMAKE_UNITY_BUILD=ON"
+        "-DCMAKE_INSTALL_PREFIX=${CMKR_DIRECTORY}"
+        "-DCMKR_GENERATE_DOCUMENTATION=OFF"
+    )
+    cmkr_exec("${CMAKE_COMMAND}"
+        --build "${CMKR_DIRECTORY}/build"
+        --config "${CMKR_BUILD_TYPE}"
+        --parallel
+    )
+    cmkr_exec("${CMAKE_COMMAND}"
+        --install "${CMKR_DIRECTORY}/build"
+        --config "${CMKR_BUILD_TYPE}"
+        --prefix "${CMKR_DIRECTORY}"
+        --component cmkr
+    )
+    if(NOT EXISTS ${CMKR_EXECUTABLE})
+        message(FATAL_ERROR "[cmkr] Failed to bootstrap '${CMKR_EXECUTABLE}'")
+    endif()
+    cmkr_exec("${CMKR_EXECUTABLE}" version)
+    message(STATUS "[cmkr] Bootstrapped ${CMKR_EXECUTABLE}")
+endif()
+execute_process(COMMAND "${CMKR_EXECUTABLE}" version
+    RESULT_VARIABLE CMKR_EXEC_RESULT
+)
+if(NOT CMKR_EXEC_RESULT EQUAL 0)
+    message(FATAL_ERROR "[cmkr] Failed to get version, try clearing the cache and rebuilding")
+endif()
+
+# Use cmkr.cmake as a script
+if(CMAKE_SCRIPT_MODE_FILE)
+    if(NOT EXISTS "${CMAKE_SOURCE_DIR}/cmake.toml")
+        execute_process(COMMAND "${CMKR_EXECUTABLE}" init
+            RESULT_VARIABLE CMKR_EXEC_RESULT
+        )
+        if(NOT CMKR_EXEC_RESULT EQUAL 0)
+            message(FATAL_ERROR "[cmkr] Failed to bootstrap cmkr project. Please report an issue: https://github.com/build-cpp/cmkr/issues/new")
+        else()
+            message(STATUS "[cmkr] Modify cmake.toml and then configure using: cmake -B build")
+        endif()
+    else()
+        execute_process(COMMAND "${CMKR_EXECUTABLE}" gen
+            RESULT_VARIABLE CMKR_EXEC_RESULT
+        )
+        if(NOT CMKR_EXEC_RESULT EQUAL 0)
+            message(FATAL_ERROR "[cmkr] Failed to generate project.")
+        else()
+            message(STATUS "[cmkr] Configure using: cmake -B build")
+        endif()
+    endif()
+endif()
+
+# This is the macro that contains black magic
+macro(cmkr)
+    # When this macro is called from the generated file, fake some internal CMake variables
+    get_source_file_property(CMKR_CURRENT_LIST_FILE "${CMAKE_CURRENT_LIST_FILE}" CMKR_CURRENT_LIST_FILE)
+    if(CMKR_CURRENT_LIST_FILE)
+        set(CMAKE_CURRENT_LIST_FILE "${CMKR_CURRENT_LIST_FILE}")
+        get_filename_component(CMAKE_CURRENT_LIST_DIR "${CMAKE_CURRENT_LIST_FILE}" DIRECTORY)
+    endif()
+
+    # File-based include guard (include_guard is not documented to work)
+    get_source_file_property(CMKR_INCLUDE_GUARD "${CMAKE_CURRENT_LIST_FILE}" CMKR_INCLUDE_GUARD)
+    if(NOT CMKR_INCLUDE_GUARD)
+        set_source_files_properties("${CMAKE_CURRENT_LIST_FILE}" PROPERTIES CMKR_INCLUDE_GUARD TRUE)
+
+        file(SHA256 "${CMAKE_CURRENT_LIST_FILE}" CMKR_LIST_FILE_SHA256_PRE)
+
+        # Generate CMakeLists.txt
+        cmkr_exec("${CMKR_EXECUTABLE}" gen
+            WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        )
+
+        file(SHA256 "${CMAKE_CURRENT_LIST_FILE}" CMKR_LIST_FILE_SHA256_POST)
+
+        # Delete the temporary file if it was left for some reason
+        set(CMKR_TEMP_FILE "${CMAKE_CURRENT_SOURCE_DIR}/CMakerLists.txt")
+        if(EXISTS "${CMKR_TEMP_FILE}")
+            file(REMOVE "${CMKR_TEMP_FILE}")
+        endif()
+
+        if(NOT CMKR_LIST_FILE_SHA256_PRE STREQUAL CMKR_LIST_FILE_SHA256_POST)
+            # Copy the now-generated CMakeLists.txt to CMakerLists.txt
+            # This is done because you cannot include() a file you are currently in
+            configure_file(CMakeLists.txt "${CMKR_TEMP_FILE}" COPYONLY)
+            
+            # Add the macro required for the hack at the start of the cmkr macro
+            set_source_files_properties("${CMKR_TEMP_FILE}" PROPERTIES
+                CMKR_CURRENT_LIST_FILE "${CMAKE_CURRENT_LIST_FILE}"
+            )
+            
+            # 'Execute' the newly-generated CMakeLists.txt
+            include("${CMKR_TEMP_FILE}")
+            
+            # Delete the generated file
+            file(REMOVE "${CMKR_TEMP_FILE}")
+            
+            # Do not execute the rest of the original CMakeLists.txt
+            return()
+        endif()
+        # Resume executing the unmodified CMakeLists.txt
+    endif()
+endmacro()
@@ -1,76 +1,76 @@
-option(CMKR_GENERATE_DOCUMENTATION "Generate cmkr documentation" ${CMKR_ROOT_PROJECT})
-set(CMKR_TESTS "" CACHE INTERNAL "List of test directories in the order declared in tests/cmake.toml")
-
-if(CMKR_GENERATE_DOCUMENTATION)
-    # Hook the add_test function to capture the tests in the order declared in tests/cmake.toml
-    function(add_test)
-        cmake_parse_arguments(TEST "" "WORKING_DIRECTORY" "" ${ARGN})
-        get_filename_component(TEST_WORKING_DIRECTORY "${TEST_WORKING_DIRECTORY}" NAME)
-        list(APPEND CMKR_TESTS "${TEST_WORKING_DIRECTORY}")
-        set(CMKR_TESTS "${CMKR_TESTS}" CACHE INTERNAL "")
-        _add_test(${test} ${ARGN})
-    endfunction()
-endif()
-
-function(generate_documentation)
-    if(CMKR_GENERATE_DOCUMENTATION)
-        message(STATUS "[cmkr] Generating documentation...")
-        
-        # Delete previously generated examples
-        set(example_folder "${PROJECT_SOURCE_DIR}/docs/examples")
-        file(GLOB example_files "${example_folder}/*.md")
-        list(REMOVE_ITEM example_files "${example_folder}/index.md")
-        if(example_files)
-            file(REMOVE ${example_files})
-        endif()
-
-        message(DEBUG "[cmkr] Test directories: ${CMKR_TESTS}")
-        set(test_index 0)
-        foreach(test_dir ${CMKR_TESTS})
-            set(test_name "${test_dir}")
-            set(test_dir "${PROJECT_SOURCE_DIR}/tests/${test_dir}")
-            set(test_toml "${test_dir}/cmake.toml")
-            if(IS_DIRECTORY "${test_dir}" AND EXISTS "${test_toml}")
-                message(DEBUG "[cmkr] Generating documentation for: ${test_toml} (index: ${test_index})")
-
-                # Set template variables
-                set(EXAMPLE_PERMALINK "${test_name}")
-                set(EXAMPLE_INDEX ${test_index})
-                math(EXPR test_index "${test_index}+1")
-
-                # Read cmake.toml file
-                file(READ "${test_toml}" test_contents NO_HEX_CONVERSION)
-                string(LENGTH "${test_contents}" toml_length)
-                
-                # Extract header text
-                string(REGEX MATCH "^(\n*(#[^\n]+\n)+\n*)" EXAMPLE_HEADER "${test_contents}")
-                string(LENGTH "${EXAMPLE_HEADER}" header_length)
-                string(STRIP "${EXAMPLE_HEADER}" EXAMPLE_HEADER)
-                string(REGEX REPLACE "\n# ?" "\n" EXAMPLE_HEADER "\n${EXAMPLE_HEADER}")
-                string(STRIP "${EXAMPLE_HEADER}" EXAMPLE_HEADER)
-                
-                # Extract footer text
-                string(REGEX MATCH "(((#[^\n]+)(\n+|$))+)$" EXAMPLE_FOOTER "${test_contents}")
-                string(LENGTH "${EXAMPLE_FOOTER}" footer_length)
-                string(STRIP "${EXAMPLE_FOOTER}" EXAMPLE_FOOTER)
-                string(REGEX REPLACE "\n# ?" "\n" EXAMPLE_FOOTER "\n${EXAMPLE_FOOTER}")
-                string(STRIP "${EXAMPLE_FOOTER}" EXAMPLE_FOOTER)
-                
-                # Extract toml body
-                math(EXPR toml_length "${toml_length}-${header_length}-${footer_length}")
-                string(SUBSTRING "${test_contents}" ${header_length} ${toml_length} EXAMPLE_TOML)
-                string(STRIP "${EXAMPLE_TOML}" EXAMPLE_TOML)
-
-                # Extract title from description
-                if("${EXAMPLE_TOML}" MATCHES "description *= *\"([^\"]+)\"")
-                    set(EXAMPLE_TITLE "${CMAKE_MATCH_1}")
-    
-                    # Generate documentation markdown page
-                    configure_file("${PROJECT_SOURCE_DIR}/cmake/example.md.in" "${example_folder}/${EXAMPLE_PERMALINK}.md" @ONLY NEWLINE_STYLE LF)
-                else()
-                    message(DEBUG "[cmkr] Skipping documentation generation for ${test_name} because description is missing")
-                endif()
-            endif()
-        endforeach()
-    endif()
-endfunction()
+option(CMKR_GENERATE_DOCUMENTATION "Generate cmkr documentation" ${CMKR_ROOT_PROJECT})
+set(CMKR_TESTS "" CACHE INTERNAL "List of test directories in the order declared in tests/cmake.toml")
+
+if(CMKR_GENERATE_DOCUMENTATION)
+    # Hook the add_test function to capture the tests in the order declared in tests/cmake.toml
+    function(add_test)
+        cmake_parse_arguments(TEST "" "WORKING_DIRECTORY" "" ${ARGN})
+        get_filename_component(TEST_WORKING_DIRECTORY "${TEST_WORKING_DIRECTORY}" NAME)
+        list(APPEND CMKR_TESTS "${TEST_WORKING_DIRECTORY}")
+        set(CMKR_TESTS "${CMKR_TESTS}" CACHE INTERNAL "")
+        _add_test(${test} ${ARGN})
+    endfunction()
+endif()
+
+function(generate_documentation)
+    if(CMKR_GENERATE_DOCUMENTATION)
+        message(STATUS "[cmkr] Generating documentation...")
+        
+        # Delete previously generated examples
+        set(example_folder "${PROJECT_SOURCE_DIR}/docs/examples")
+        file(GLOB example_files "${example_folder}/*.md")
+        list(REMOVE_ITEM example_files "${example_folder}/index.md")
+        if(example_files)
+            file(REMOVE ${example_files})
+        endif()
+
+        message(DEBUG "[cmkr] Test directories: ${CMKR_TESTS}")
+        set(test_index 0)
+        foreach(test_dir ${CMKR_TESTS})
+            set(test_name "${test_dir}")
+            set(test_dir "${PROJECT_SOURCE_DIR}/tests/${test_dir}")
+            set(test_toml "${test_dir}/cmake.toml")
+            if(IS_DIRECTORY "${test_dir}" AND EXISTS "${test_toml}")
+                message(DEBUG "[cmkr] Generating documentation for: ${test_toml} (index: ${test_index})")
+
+                # Set template variables
+                set(EXAMPLE_PERMALINK "${test_name}")
+                set(EXAMPLE_INDEX ${test_index})
+                math(EXPR test_index "${test_index}+1")
+
+                # Read cmake.toml file
+                file(READ "${test_toml}" test_contents NO_HEX_CONVERSION)
+                string(LENGTH "${test_contents}" toml_length)
+                
+                # Extract header text
+                string(REGEX MATCH "^(\n*(#[^\n]+\n)+\n*)" EXAMPLE_HEADER "${test_contents}")
+                string(LENGTH "${EXAMPLE_HEADER}" header_length)
+                string(STRIP "${EXAMPLE_HEADER}" EXAMPLE_HEADER)
+                string(REGEX REPLACE "\n# ?" "\n\n" EXAMPLE_HEADER "\n${EXAMPLE_HEADER}")
+                string(STRIP "${EXAMPLE_HEADER}" EXAMPLE_HEADER)
+                
+                # Extract footer text
+                string(REGEX MATCH "(((#[^\n]+)(\n+|$))+)$" EXAMPLE_FOOTER "${test_contents}")
+                string(LENGTH "${EXAMPLE_FOOTER}" footer_length)
+                string(STRIP "${EXAMPLE_FOOTER}" EXAMPLE_FOOTER)
+                string(REGEX REPLACE "\n# ?" "\n\n" EXAMPLE_FOOTER "\n${EXAMPLE_FOOTER}")
+                string(STRIP "${EXAMPLE_FOOTER}" EXAMPLE_FOOTER)
+                
+                # Extract toml body
+                math(EXPR toml_length "${toml_length}-${header_length}-${footer_length}")
+                string(SUBSTRING "${test_contents}" ${header_length} ${toml_length} EXAMPLE_TOML)
+                string(STRIP "${EXAMPLE_TOML}" EXAMPLE_TOML)
+
+                # Extract title from description
+                if("${EXAMPLE_TOML}" MATCHES "description *= *\"([^\"]+)\"")
+                    set(EXAMPLE_TITLE "${CMAKE_MATCH_1}")
+    
+                    # Generate documentation markdown page
+                    configure_file("${PROJECT_SOURCE_DIR}/cmake/example.md.in" "${example_folder}/${EXAMPLE_PERMALINK}.md" @ONLY NEWLINE_STYLE LF)
+                else()
+                    message(DEBUG "[cmkr] Skipping documentation generation for ${test_name} because description is missing")
+                endif()
+            endif()
+        endforeach()
+    endif()
+endfunction()
@@ -0,0 +1,24 @@
+# Enumerates the target sources and automatically generates include/resources/${RESOURCE_NAME}.h from all .cmake files
+function(generate_resources target)
+    get_property(TARGET_SOURCES
+        TARGET ${target}
+        PROPERTY SOURCES
+    )
+    foreach(SOURCE ${TARGET_SOURCES})
+        get_filename_component(RESOURCE_NAME "${SOURCE}" NAME_WE)
+        set(RESOURCE_HEADER "include/resources/${RESOURCE_NAME}.hpp")
+
+        if(SOURCE MATCHES ".cmake$")
+            # Add configure-time dependency on the source file
+            configure_file("${SOURCE}" "${RESOURCE_HEADER}" COPYONLY)
+            # Generate the actual resource into the header
+            file(READ "${SOURCE}" RESOURCE_CONTENTS)
+            configure_file("${PROJECT_SOURCE_DIR}/cmake/resource.hpp.in" "${RESOURCE_HEADER}" @ONLY)
+            message(STATUS "[cmkr] Generated ${RESOURCE_HEADER}")
+        elseif(SOURCE MATCHES ".in$")
+            configure_file("${SOURCE}" "${RESOURCE_HEADER}" @ONLY)
+            message(STATUS "[cmkr] Generated ${RESOURCE_HEADER}")
+        endif()
+    endforeach()
+    target_include_directories(${target} PUBLIC "${CMAKE_CURRENT_BINARY_DIR}/include")
+endfunction()
@@ -0,0 +1,27 @@
+cmake_minimum_required(VERSION 3.20)
+
+find_package(Git REQUIRED)
+
+execute_process(COMMAND
+    "${GIT_EXECUTABLE}" name-rev --tags --name-only HEAD
+    OUTPUT_VARIABLE GIT_TAG
+)
+
+string(FIND "${GIT_TAG}" "\n" NEWLINE_POS)
+string(SUBSTRING "${GIT_TAG}" 0 ${NEWLINE_POS} GIT_TAG)
+string(STRIP "${GIT_TAG}" GIT_TAG)
+
+if("${GIT_TAG}" STREQUAL "")
+    message(FATAL_ERROR "Failed to retrieve git tag!")
+endif()
+
+message(STATUS "CMKR_TAG: '${GIT_TAG}'")
+
+file(READ "cmake/cmkr.cmake" CMKR_CMAKE)
+string(REGEX REPLACE "CMKR_TAG \"[^\"]+\"" "CMKR_TAG \"${GIT_TAG}\"" CMKR_CMAKE "${CMKR_CMAKE}")
+file(CONFIGURE
+    OUTPUT "cmake/cmkr.cmake"
+    CONTENT "${CMKR_CMAKE}"
+    @ONLY
+    NEWLINE_STYLE LF
+)
@@ -0,0 +1,7 @@
+namespace cmkr {
+namespace resources {
+
+static const char* @RESOURCE_NAME@ = R"RESOURCE(@RESOURCE_CONTENTS@)RESOURCE";
+
+}
+}
@@ -1,6 +0,0 @@
-#include <cstdio>
-
-int main()
-{
-    puts("Hello from cmkr!");
-}
@@ -0,0 +1,3 @@
+#pragma once
+
+#define CMKR_VERSION "@PROJECT_VERSION@"
@@ -1,2 +1,3 @@
 _site/
-.jekyll-metadata
+.jekyll-metadata
+assets/
@@ -11,3 +11,5 @@ end

 gem "wdm", "~> 0.1.1", :platforms => [:mingw, :x64_mingw, :mswin]
 gem "just-the-docs"
+
+gem "webrick", "~> 1.7"
@@ -262,6 +262,7 @@ GEM
      unf_ext
    unf_ext (0.0.7.7)
    unicode-display_width (1.7.0)
+    webrick (1.7.0)
    zeitwerk (2.4.2)

 PLATFORMS
@@ -275,6 +276,7 @@ DEPENDENCIES
  tzinfo (~> 1.2)
  tzinfo-data
  wdm (~> 0.1.1)
+  webrick (~> 1.7)

 BUNDLED WITH
-   2.1.2
+   2.2.26
@@ -0,0 +1,197 @@
+---
+layout: page
+title: Reference
+permalink: /cmake-toml/
+nav_order: 1
+---
+
+# Reference
+
+This page is a reference for the options in the `cmake.toml` file. If you think anything is missing or unclear, please [edit this page](https://github.com/build-cpp/cmkr/edit/main/docs/cmake-toml.md) or open an [issue](https://github.com/build-cpp/cmkr/issues).
+
+See the [examples](/examples) section for concrete examples.
+
+## CMake configuration
+
+```toml
+[cmake]
+version = "3.15"
+cmkr-include = "cmkr.cmake"
+```
+
+## Project configuration
+
+```toml
+[project]
+name = "myproject"
+version = "1.0.0"
+description = "Description of the project"
+languages = ["C", "CXX"]
+cmake-before = """
+message(STATUS "CMake injected before the project() call")
+"""
+cmake-after = """
+message(STATUS "CMake injected after the project() call")
+"""
+include-before = ["cmake/before-project.cmake"]
+include-after = ["cmake/after-project.cmake"]
+```
+
+## Conditions
+
+You can specify your own conditions and use them in any `condition` field:
+
+```toml
+[conditions]
+arch64 = "CMAKE_SIZEOF_VOID_P EQUALS 8"
+arch32 = "CMAKE_SIZEOF_VOID_P EQUALS 4"
+```
+
+You can also prefix most keys with `condition.` to represent a conditional:
+
+```toml
+[target]
+type = "executable"
+sources = ["src/main.cpp"]
+windows.sources = ["src/windows_specific.cpp"]
+```
+
+This will make the `arch64` and `arch32` conditions available with their respective CMake expressions. The following conditions are predefined (you can override them if you desire):
+
+```toml
+[conditions]
+windows = "WIN32"
+macos = "CMAKE_SYSTEM_NAME MATCHES \"Darwin\""
+unix = "UNIX"
+bsd = "CMAKE_SYSTEM_NAME MATCHES \"BSD\""
+linux = "CMAKE_SYSTEM_NAME MATCHES \"Linux\""
+gcc = "CMAKE_CXX_COMPILER_ID STREQUAL \"GNU\" OR CMAKE_C_COMPILER_ID STREQUAL \"GNU\""
+clang = "CMAKE_CXX_COMPILER_ID MATCHES \"Clang\" OR CMAKE_C_COMPILER_ID MATCHES \"Clang\""
+msvc = "MSVC"
+```
+
+## Subdirectories
+
+```toml
+[subdir.mysubdir]
+condition = "linux"
+cmake-before = """
+message(STATUS "CMake injected before the add_subdirectory() call"
+"""
+cmake-after = """
+message(STATUS "CMake injected after the add_subdirectory() call")
+"""
+include-before = ["cmake/before-subdir.cmake"]
+include-after = ["cmake/after-subdir.cmake"]
+```
+
+## Vcpkg
+
+```toml
+[vcpkg]
+version = "2021.05.12"
+url = "https://github.com/microsoft/vcpkg/archive/refs/tags/2021.05.12.tar.gz"
+packages = ["fmt", "zlib"]
+```
+
+The vcpkg `version` will automatically generate the `url` from the [official repository](https://github.com/microsoft/vcpkg/releases). For a custom registry you can specify your own `url` (and omit the `version`). You can browse available packages on [vcpkg.io](https://vcpkg.io/en/packages.html).
+
+To specify package features you can use the following syntax: `imgui[docking-experimental,freetype,sdl2-binding,opengl3-binding]`.
+
+## Packages
+
+```toml
+[find-package]
+mypackage = { version = "1.0", required = true, config = true, components = ["mycomponent"] }
+
+# Alternative syntax
+[find-package.mypackage]
+version = "1.0"
+required = true
+config = true
+components = ["mycomponent"]
+```
+
+## FetchContent
+
+**Note**: The `[fetch-content]` feature is unpolished and will likely change in a future release.
+
+```toml
+[fetch-content]
+gitcontent = { git = "https://github.com/myuser/gitcontent", tag = "v0.1" }
+svncontent = { svn = "https://svn-host.com/url", rev = "svn_rev" }
+urlcontent = { url = "https://content-host.com/urlcontent.zip", hash = "123123123123" }
+
+# Alternative syntax
+[fetch-content.gitcontent]
+git = "https://github.com/myuser/gitcontent"
+tag = "v0.1"
+```
+
+## Targets
+
+```toml
+[target.mytarget]
+condition = "linux"
+alias = "mytarget::mytarget"
+type = "static" # executable, shared (DLL), static, interface, object, library, custom
+headers = ["src/mytarget.h"]
+sources = ["src/mytarget.cpp"]
+
+# The keys below match the target_xxx CMake commands
+# Keys prefixed with private- will get PRIVATE visibility
+compile-definitions = [""]
+private-compile-definitions = [""]
+compile-features = [""]
+private-compile-features = [""]
+compile-options = [""]
+private-compile-options = [""]
+include-directories = [""]
+private-include-directories = [""]
+link-directories = [""]
+private-link-directories = [""]
+link-libraries = [""]
+private-link-libraries = [""]
+link-options = [""]
+private-link-options = [""]
+precompile-headers = [""]
+private-precompile-headers = [""]
+
+cmake-before = """
+message(STATUS "CMake injected before the target")
+"""
+cmake-after = """
+message(STATUS "CMake injected after the target")
+"""
+include-before = "cmake/target-before.cmake"
+include-after = "cmake/target-after.cmake"
+
+# See https://cmake.org/cmake/help/latest/manual/cmake-properties.7.html#properties-on-targets for a list of target properties
+[target.mytarget.properties]
+CXX_STANDARD = 17
+CXX_STANDARD_REQUIRED = true
+FOLDER = "MyFolder"
+```
+
+## Tests and installation (unfinished)
+
+**Note**: The `[[test]]` and `[[install]]` are unfinished features and will likely change in a future release.
+
+```toml
+# You can declare as many as you want like this, but the name has to be unique
+[[test]]
+name = "mytest"
+command = "$<TARGET_FILE:mytest>"
+arguments = ["arg1", "arg2"]
+configurations = ["Debug", "Release", "RelWithDebInfo", "MinSizeRelease"]
+working-directory = "mytest-dir"
+```
+
+```toml
+[[install]]
+targets = ["mytarget", "mytest"]
+destination = ["bin"]
+files = ["content/my.png"]
+dirs = [""]
+configs = [""]
+```
@@ -1,22 +0,0 @@
---
-layout: page
-title: Command line
-permalink: /command-line/
-nav_order: 2
---
-
-## Command line
-
-Optionally you can install `cmkr` in your `PATH` and use it as a utility from the command line:
-
-```
-Usage: cmkr [arguments]
-arguments:
-    init    [executable|library|shared|static|interface] Starts a new project in the same directory.
-    gen                                                  Generates CMakeLists.txt file.
-    build   <extra cmake args>                           Run cmake and build.
-    install                                              Run cmake --install. Needs admin privileges.
-    clean                                                Clean the build directory.
-    help                                                 Show help.
-    version                                              Current cmkr version.
-```
@@ -0,0 +1,27 @@
+---
+# Automatically generated from tests/cxx-standard/cmake.toml - DO NOT EDIT
+layout: default
+title: Changing C++ standard
+permalink: /examples/cxx-standard
+parent: Examples
+nav_order: 5
+---
+
+# Changing C++ standard
+
+Require a C++11 compiler for the target `example`.
+
+```toml
+[project]
+name = "cxx-standard"
+description = "Changing C++ standard"
+
+[target.example]
+type = "executable"
+sources = ["src/main.cpp"]
+compile-features = ["cxx_std_11"]
+```
+
+This is equivalent to CMake's [target_compile_features](https://cmake.org/cmake/help/latest/command/target_compile_features.html)`(example PRIVATE cxx_std_11)`. For more information on available C/C++ standards and features see [cmake-compile-features(7)](https://cmake.org/cmake/help/latest/manual/cmake-compile-features.7.html).
+
+<sup><sub>This page was automatically generated from [tests/cxx-standard/cmake.toml](https://github.com/build-cpp/cmkr/tree/main/tests/cxx-standard/cmake.toml).</sub></sup>
@@ -0,0 +1,35 @@
+---
+# Automatically generated from tests/globbing/cmake.toml - DO NOT EDIT
+layout: default
+title: Globbing sources
+permalink: /examples/globbing
+parent: Examples
+nav_order: 6
+---
+
+# Globbing sources
+
+
+
+```toml
+[project]
+name = "globbing"
+description = "Globbing sources"
+
+# Recursively glob in the mylib/ folder
+[target.mylib]
+type = "static"
+alias = "mylib::mylib"
+sources = ["mylib/**.hpp", "mylib/**.cpp"]
+include-directories = ["mylib/include"]
+
+# Single-folder glob in example/src/
+[target.example]
+type = "executable"
+sources = ["example/src/*.cpp"]
+link-libraries = ["mylib::mylib"]
+```
+
+As you can see in the example above you can use `**.ext` to glob recursively and `*.ext` to glob non-recursively. This **does not** generate `file(GLOB ...)` commands, but instead globs when cmkr is run. Files are sorted to give deterministic results regardless of the platform used.
+
+<sup><sub>This page was automatically generated from [tests/globbing/cmake.toml](https://github.com/build-cpp/cmkr/tree/main/tests/globbing/cmake.toml).</sub></sup>
@@ -33,4 +33,6 @@ link-libraries = ["fmt::fmt"]

 The bootstrapping of vcpkg is fully automated and no user interaction is necessary. You can disable vcpkg by setting `CMKR_DISABLE_VCPKG=ON`.

+To specify package features you can use the following syntax: `imgui[docking-experimental,freetype,sdl2-binding,opengl3-binding]`.
+
 <sup><sub>This page was automatically generated from [tests/vcpkg/cmake.toml](https://github.com/build-cpp/cmkr/tree/main/tests/vcpkg/cmake.toml).</sub></sup>
@@ -1,17 +0,0 @@
---
-layout: page
-title: Getting started
-permalink: /getting-started/
-nav_order: 1
---
-
-## Getting started
-
-The easiest way to get started is to use the [cmkr_for_beginners](https://github.com/build-cpp/cmkr_for_beginners) template repository. Either open it in [Gitpod](https://gitpod.io/#https://github.com/build-cpp/cmkr_for_beginners), or clone the repository and run:
-
-```sh
-cmake -B build
-cmake --build build
-```
-
-Alternatively you can check out the [cmkr topic](https://github.com/topics/cmkr) or the [build-cpp organization](https://github.com/build-cpp) for more examples and templates.
@@ -0,0 +1 @@
+google-site-verification: google13f7c659b54c069f.html
@@ -6,18 +6,72 @@ nav_order: 0

 # Index

-`cmkr`, pronounced "cmaker", is a modern build system based on [CMake](https://cmake.org/) and [TOML](https://toml.io). It was originally created by [Mohammed Alyousef](https://github.com/MoAlyousef).
+`cmkr`, pronounced "cmaker", is a modern build system based on [CMake](https://cmake.org/) and [TOML](https://toml.io).

 `cmkr` parses `cmake.toml` files and generates a modern, idiomatic `CMakeLists.txt` for you. A minimal example:

 ```toml
 [project]
 name = "cmkr_for_beginners"
-description = "A minimal cmkr project."

 [target.hello_world]
 type = "executable"
 sources = ["src/main.cpp"]
 ```

-`cmkr` can bootstrap itself from CMake and consumers of your project do not need to install anything to work with it.
+`cmkr` can bootstrap itself from CMake and you only need CMake to use it.
+
+## Getting started
+
+To get started run the following commands from your project directory:
+
+```sh
+curl https://raw.githubusercontent.com/build-cpp/cmkr/main/cmake/cmkr.cmake -o cmkr.cmake
+cmake -P cmkr.cmake
+```
+
+After the bootstrapping process finishes, modify [`cmake.toml`](https://build-cpp.github.io/cmkr/cmake-toml) and open the project in your favorite IDE or build with CMake:
+
+```sh
+cmake -B build
+cmake --build build
+```
+
+Once bootstrapped, `cmkr` does not introduce extra steps to your workflow. After modifying `cmake.toml` you simply build/configure your CMake project and `cmkr` will automatically regenerate `CMakeLists.txt`.
+
+In CI settings the `cmkr` bootstrapping process is skipped so there is no extra configure-time overhead in your pipelines.
+
+## Template repositories
+
+Another way to get started is to use the [cmkr_for_beginners](https://github.com/build-cpp/cmkr_for_beginners) template repository. Either open it in [Gitpod](https://gitpod.io/#https://github.com/build-cpp/cmkr_for_beginners), or clone the repository and run:
+
+```sh
+cmake -B build
+cmake --build build
+```
+
+Check out the [cmkr topic](https://github.com/topics/cmkr), the [build-cpp organization](https://github.com/build-cpp) or the [tests](https://github.com/build-cpp/cmkr/tree/main/tests) for more examples and templates.
+
+## Command line
+
+Optionally you can put a [`cmkr` release](https://github.com/build-cpp/cmkr/releases) in your `PATH` and use it as a utility from the command line:
+
+```
+Usage: cmkr [arguments]
+arguments:
+    init    [executable|library|shared|static|interface] Starts a new project in the same directory.
+    gen                                                  Generates CMakeLists.txt file.
+    build   <extra cmake args>                           Run cmake and build.
+    install                                              Run cmake --install. Needs admin privileges.
+    clean                                                Clean the build directory.
+    help                                                 Show help.
+    version                                              Current cmkr version.
+```
+
+## Credits
+
+- https://github.com/gulrak/filesystem
+- https://github.com/Tessil/ordered-map
+- https://github.com/ToruNiina/toml11
+- https://github.com/mpark/variant
+- https://www.svgrepo.com/svg/192268/hammer
@@ -1,15 +1,13 @@
 #pragma once

+#include "project_parser.hpp"
+
 namespace cmkr {
 namespace gen {

-int generate_project(const char *typ);
+void generate_project(const std::string &type);

-int generate_cmake(const char *path, bool root = true);
+void generate_cmake(const char *path, const parser::Project *parent_project = nullptr);

 } // namespace gen
 } // namespace cmkr
-
-int cmkr_gen_generate_project(const char *typ);
-
-int cmkr_gen_generate_cmake(const char *path);
@@ -1,45 +1,100 @@
 #pragma once

-static const char *hello_world = &R"lit(
+static const char *cpp_executable = &R"lit(
 #include <iostream>
+#include <cstdlib>

-int %s() {
-    std::cout << "Hello World!\n";
-    return 0;
+int main() {
+    std::cout << "Hello from cmkr!\n";
+    return EXIT_SUCCESS;
 }
 )lit"[1]; // skip initial newline

-static const char *cmake_toml = &R"lit(
-[cmake]
-version = "3.15"
-# subdirs = []
-# build-dir = ""
-# cpp-flags = []
-# c-flags = []
-# link-flags = []
-# generator = ""
-# arguments = []
+static const char *cpp_library = &R"lit(
+#include <@name/@name.hpp>

-[project]
-name = "%s"
-version = "0.1.0"
+#include <iostream>

-# [find-package]
+namespace @name {

-# [fetch-content]
+void hello() {
+    std::cout << "Hello from cmkr!\n";
+}

-# [options]
-
-[target.%s]
-type = "%s"
-sources = ["src/*.cpp"]
-include-directories = ["include"]
-# alias = ""
-# compile-features = []
-# compile-definitions = []
-# link-libraries = []
-
-[[install]]
-%s = ["%s"]
-destination = "${CMAKE_INSTALL_PREFIX}/%s"
+} // namespace @name
+)lit"[1]; // skip initial newline
+
+static const char *hpp_library = &R"lit(
+#pragma once
+
+namespace @name {
+
+void hello();
+
+} // namespace @name
+)lit"[1]; // skip initial newline
+
+static const char *hpp_interface = &R"lit(
+#pragma once
+
+#include <iostream>
+
+namespace @name {
+
+inline void hello() {
+    std::cout << "Hello from cmkr!\n";
+}
+
+} // namespace @name
+)lit"[1]; // skip initial newline
+
+static const char *toml_executable = &R"lit(
+# Reference: https://build-cpp.github.io/cmkr/cmake-toml
+[project]
+name = "@name"
+
+[target.@name]
+type = "executable"
+sources = ["src/@name/main.cpp"]
+compile-features = ["cxx_std_11"]
+)lit"[1]; // skip initial newline
+
+static const char *toml_library = &R"lit(
+# Reference: https://build-cpp.github.io/cmkr/cmake-toml
+[project]
+name = "@name"
+
+[target.@name]
+type = "@type"
+sources = [
+    "src/@name/@name.cpp",
+    "include/@name/@name.hpp"
+]
+include-directories = ["include"]
+compile-features = ["cxx_std_11"]
+)lit"[1]; // skip initial newline
+
+static const char *toml_interface = &R"lit(
+# Reference: https://build-cpp.github.io/cmkr/cmake-toml
+[project]
+name = "@name"
+
+[target.@name]
+type = "interface"
+include-directories = ["include"]
+compile-features = ["cxx_std_11"]
+)lit"[1]; // skip initial newline
+
+static const char *toml_migration = &R"lit(
+# Reference: https://build-cpp.github.io/cmkr/cmake-toml
+[project]
+name = "@name"
+
+# TODO: define a target for each of your executables/libraries like this:
+#[target.myexecutable]
+#type = "executable" # static, shared
+#sources = ["src/@name/*.cpp", "include/@name/*.hpp"]
+#include-directories = ["include"]
+#compile-features = ["cxx_std_11"]
+#link-libraries = ["target-or-library"]
 )lit"[1]; // skip initial newline
@@ -1,8 +1,6 @@
 #pragma once

-#include <map>
 #include <mpark/variant.hpp>
-#include <stdexcept>
 #include <string>
 #include <tsl/ordered_map.h>
 #include <vector>
@@ -28,14 +26,20 @@ struct Package {
    std::string name;
    std::string version;
    bool required = true;
-    bool config = true;
+    bool config = false;
    std::vector<std::string> components;
 };

 struct Vcpkg {
    std::string version;
    std::string url;
-    std::vector<std::string> packages;
+
+    struct Package {
+        std::string name;
+        std::vector<std::string> features;
+    };
+
+    std::vector<Package> packages;
 };

 enum TargetType {
@@ -45,6 +49,7 @@ enum TargetType {
    target_static,
    target_interface,
    target_custom,
+    target_object,
 };

 template <typename T>
@@ -119,6 +124,11 @@ struct Subdir {
    ConditionVector include_after;
 };

+struct Content {
+    std::string name;
+    tsl::ordered_map<std::string, std::string> arguments;
+};
+
 struct Project {
    // This is the CMake version required to use all cmkr versions.
    std::string cmake_version = "3.15";
@@ -126,6 +136,7 @@ struct Project {
    std::string build_dir = "build";
    std::string generator;
    std::string config;
+    bool allow_in_tree = false;
    Condition<std::vector<std::string>> project_subdirs;
    std::vector<std::string> cppflags;
    std::vector<std::string> cflags;
@@ -144,14 +155,14 @@ struct Project {
    std::vector<Option> options;
    std::vector<Package> packages;
    Vcpkg vcpkg;
-    tsl::ordered_map<std::string, std::map<std::string, std::string>> contents;
+    std::vector<Content> contents;
    std::vector<Target> targets;
    std::vector<Test> tests;
    std::vector<Install> installs;
    tsl::ordered_map<std::string, std::string> conditions;
    std::vector<Subdir> subdirs;

-    Project(const std::string &path, bool build);
+    Project(const Project *parent, const std::string &path, bool build);
 };

 bool is_root_path(const std::string &path);
@@ -21,9 +21,7 @@ const char *handle_args(int argc, char **argv) {
        throw std::runtime_error(cmkr::help::message());
    std::string main_arg = args[1];
    if (main_arg == "gen") {
-        auto ret = cmkr::gen::generate_cmake(fs::current_path().string().c_str());
-        if (ret)
-            return "CMake generation error!";
+        cmkr::gen::generate_cmake(fs::current_path().string().c_str());
        return "CMake generation successful!";
    } else if (main_arg == "help") {
        return cmkr::help::message();
@@ -33,15 +31,14 @@ const char *handle_args(int argc, char **argv) {
        std::string type = "executable";
        if (args.size() > 2)
            type = args[2];
-        auto ret = cmkr::gen::generate_project(type.c_str());
-        if (ret)
-            return "Initialization failure!";
+        cmkr::gen::generate_project(type.c_str());
+        cmkr::gen::generate_cmake(fs::current_path().string().c_str());
        return "Directory initialized!";
    } else if (main_arg == "build") {
        auto ret = build::run(argc, argv);
        if (ret)
            return "CMake build error!";
-        return "CMake run completed!";
+        return "CMake build completed!";
    } else if (main_arg == "install") {
        auto ret = build::install();
        if (ret)
@@ -1,20 +1,20 @@
 #include "build.hpp"
-#include "project_parser.hpp"
-#include "error.hpp"
 #include "cmake_generator.hpp"
+#include "error.hpp"
+#include "project_parser.hpp"

 #include "fs.hpp"
+#include <cstddef>
+#include <cstdlib>
 #include <sstream>
-#include <stddef.h>
 #include <stdexcept>
-#include <stdlib.h>
 #include <system_error>

 namespace cmkr {
 namespace build {

 int run(int argc, char **argv) {
-    parser::Project project(".", true);
+    parser::Project project(nullptr, ".", true);
    if (argc > 2) {
        for (int i = 2; i < argc; ++i) {
            project.build_args.push_back(argv[i]);
@@ -22,10 +22,9 @@ int run(int argc, char **argv) {
    }
    std::stringstream ss;

-    if (gen::generate_cmake(fs::current_path().string().c_str()))
-        throw std::runtime_error("CMake generation failure!");
+    gen::generate_cmake(fs::current_path().string().c_str());

-    ss << "cmake -S. -B" << project.build_dir << " ";
+    ss << "cmake -DCMKR_BUILD_SKIP_GENERATION=ON -B" << project.build_dir << " ";

    if (!project.generator.empty()) {
        ss << "-G \"" << project.generator << "\" ";
@@ -50,7 +49,7 @@ int run(int argc, char **argv) {

 int clean() {
    bool ret = false;
-    parser::Project project(".", true);
+    parser::Project project(nullptr, ".", true);
    if (fs::exists(project.build_dir)) {
        ret = fs::remove_all(project.build_dir);
        fs::create_directory(project.build_dir);
@@ -59,7 +58,7 @@ int clean() {
 }

 int install() {
-    parser::Project project(".", false);
+    parser::Project project(nullptr, ".", false);
    auto cmd = "cmake --install " + project.build_dir;
    return ::system(cmd.c_str());
 }
@@ -94,4 +93,4 @@ int cmkr_build_install(void) {
    } catch (...) {
        return cmkr::error::Status(cmkr::error::Status::Code::InstallError);
    }
-}
+}
@@ -1,25 +1,18 @@
 #include "cmake_generator.hpp"
 #include "error.hpp"
 #include "literals.hpp"
-#include "project_parser.hpp"
+#include <resources/cmkr.hpp>

 #include "fs.hpp"
-#include <cassert>
 #include <cstdio>
-#include <cstring>
 #include <fstream>
-#include <iomanip>
-#include <new>
-#include <nlohmann/json.hpp>
-#include <regex>
 #include <sstream>
 #include <stdexcept>
-#include <string>

 namespace cmkr {
 namespace gen {

-inline std::string to_upper(const std::string &str) {
+static std::string to_upper(const std::string &str) {
    std::string temp;
    temp.reserve(str.size());
    for (auto c : str) {
@@ -28,16 +21,16 @@ inline std::string to_upper(const std::string &str) {
    return temp;
 }

-template <typename... Args>
-std::string format(const char *fmt, Args... args) {
-    auto sz = snprintf(nullptr, 0, fmt, args...) + 1;
-    char *buf = new char[sz];
-    int ret = snprintf(buf, sz, fmt, args...);
-    if (ret != sz - 1)
-        throw std::runtime_error("Error formatting string!");
-    std::string temp(buf, buf + sz - 1);
-    delete[] buf;
-    return temp;
+static std::string format(const char *format, tsl::ordered_map<std::string, std::string> variables) {
+    std::string s = format;
+    for (const auto &itr : variables) {
+        size_t start_pos = 0;
+        while ((start_pos = s.find(itr.first, start_pos)) != std::string::npos) {
+            s.replace(start_pos, itr.first.length(), itr.second);
+            start_pos += itr.second.length();
+        }
+    }
+    return s;
 }

 static std::vector<std::string> expand_cmake_path(const fs::path &name, const fs::path &toml_dir) {
@@ -89,52 +82,50 @@ static std::vector<std::string> expand_cmake_paths(const std::vector<std::string
    return result;
 }

-int generate_project(const char *str) {
-    fs::create_directory("src");
-    fs::create_directory("include");
-    const auto dir_name = fs::current_path().stem().string();
-    std::string mainbuf;
-    std::string installed;
-    std::string target;
-    std::string dest;
-    if (!strcmp(str, "executable")) {
-        mainbuf = format(hello_world, "main");
-        installed = "targets";
-        target = dir_name;
-        dest = "bin";
-    } else if (!strcmp(str, "static") || !strcmp(str, "shared") || !strcmp(str, "library")) {
-        mainbuf = format(hello_world, "test");
-        installed = "targets";
-        target = dir_name;
-        dest = "lib";
-    } else if (!strcmp(str, "interface")) {
-        installed = "files";
-        target = "include/*.h";
-        dest = "include/" + dir_name;
+static void create_file(const fs::path &path, const std::string &contents) {
+    if (!path.parent_path().empty()) {
+        fs::create_directories(path.parent_path());
+    }
+    std::ofstream ofs(path, std::ios::binary);
+    if (!ofs) {
+        throw std::runtime_error("Failed to create " + path.string());
+    }
+    ofs << contents;
+}
+
+void generate_project(const std::string &type) {
+    const auto name = fs::current_path().stem().string();
+    if (fs::exists(fs::current_path() / "cmake.toml")) {
+        throw std::runtime_error("Cannot initialize a project when cmake.toml already exists!");
+    }
+
+    tsl::ordered_map<std::string, std::string> variables = {
+        {"@name", name},
+        {"@type", type},
+    };
+
+    if (!fs::is_empty(fs::current_path())) {
+        // Make a backup of an existing CMakeLists.txt if it exists
+        std::error_code ec;
+        fs::rename("CMakeLists.txt", "CMakeLists.txt.bak", ec);
+        // Create an empty cmake.toml for migration purporses
+        create_file("cmake.toml", format(toml_migration, variables));
+        return;
+    }
+
+    if (type == "executable") {
+        create_file("cmake.toml", format(toml_executable, variables));
+        create_file("src/" + name + "/main.cpp", format(cpp_executable, variables));
+    } else if (type == "static" || type == "shared" || type == "library") {
+        create_file("cmake.toml", format(toml_library, variables));
+        create_file("src/" + name + "/" + name + ".cpp", format(cpp_library, variables));
+        create_file("include/" + name + "/" + name + ".hpp", format(hpp_library, variables));
+    } else if (type == "interface") {
+        create_file("cmake.toml", format(toml_interface, variables));
+        create_file("include/" + name + "/" + name + ".hpp", format(hpp_interface, variables));
    } else {
-        throw std::runtime_error("Unknown project type " + std::string(str) +
-                                 "! Supported types are: executable, library, shared, static, interface");
+        throw std::runtime_error("Unknown project type " + type + "! Supported types are: executable, library, shared, static, interface");
    }
-
-    const auto tomlbuf = format(cmake_toml, dir_name.c_str(), dir_name.c_str(), str, installed.c_str(), target.c_str(), dest.c_str());
-
-    if (strcmp(str, "interface")) {
-        std::ofstream ofs("src/main.cpp");
-        if (ofs.is_open()) {
-            ofs << mainbuf;
-        }
-        ofs.flush();
-        ofs.close();
-    }
-
-    std::ofstream ofs2("cmake.toml");
-    if (ofs2.is_open()) {
-        ofs2 << tomlbuf;
-    }
-    ofs2.flush();
-    ofs2.close();
-
-    return 0;
 }

 struct CommandEndl {
@@ -163,13 +154,13 @@ struct Command {
    Command(std::stringstream &ss, int depth, std::string command, std::string post_comment)
        : ss(ss), depth(depth), command(std::move(command)), post_comment(std::move(post_comment)) {}

-    ~Command() {
+    ~Command() noexcept(false) {
        if (!generated) {
-            assert(false && "Incorrect usage of cmd(), you probably forgot ()");
+            throw std::runtime_error("Incorrect usage of cmd(), you probably forgot ()");
        }
    }

-    std::string quote(const std::string &str) {
+    static std::string quote(const std::string &str) {
        // Don't quote arguments that don't need quoting
        if (str.find(' ') == std::string::npos && str.find('\"') == std::string::npos && str.find('/') == std::string::npos &&
            str.find(';') == std::string::npos) {
@@ -412,6 +403,31 @@ struct Generator {
    }
 };

+static bool vcpkg_valid_identifier(const std::string &name) {
+    // prn|aux|nul|con|lpt[1-9]|com[1-9]|core|default
+    auto is_reserved = [](const std::string &s) {
+        if (s == "prn" || s == "aux" || s == "nul" || s == "con" || s == "core" || s == "default") {
+            return true;
+        }
+        if (s.length() == 4 && (s.compare(0, 3, "lpt") == 0 || s.compare(0, 3, "com") == 0) && (s[3] >= '1' && s[3] <= '9')) {
+            return true;
+        }
+        return false;
+    };
+    // [a-z0-9]+(-[a-z0-9]+)*
+    auto is_identifier = [](const std::string &s) {
+        for (size_t i = 0; i < s.length(); i++) {
+            auto c = s[i];
+            if ((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || (i > 0 && c == '-')) {
+                continue;
+            }
+            return false;
+        }
+        return true;
+    };
+    return is_identifier(name) && !is_reserved(name);
+}
+
 static std::string vcpkg_escape_identifier(const std::string &name) {
    // Do a reasonable effort to escape the project name for use with vcpkg
    std::string escaped;
@@ -427,22 +443,18 @@ static std::string vcpkg_escape_identifier(const std::string &name) {
        escaped += std::tolower(ch);
    }

-    const std::regex reserved("prn|aux|nul|con|lpt[1-9]|com[1-9]|core|default");
-    const std::regex ok("[a-z0-9]+(-[a-z0-9]+)*");
-    std::cmatch m;
-    if (!std::regex_match(escaped.c_str(), m, reserved) && std::regex_match(escaped.c_str(), m, ok)) {
-        return escaped;
-    } else {
+    if (!vcpkg_valid_identifier(escaped)) {
        throw std::runtime_error("The escaped project name '" + escaped + "' is not usable with [vcpkg]");
    }
+    return escaped;
 }

-int generate_cmake(const char *path, bool root) {
+void generate_cmake(const char *path, const parser::Project *parent_project) {
    if (!fs::exists(fs::path(path) / "cmake.toml")) {
        throw std::runtime_error("No cmake.toml found!");
    }

-    parser::Project project(path, false);
+    parser::Project project(parent_project, path, false);
    Generator gen(project);

    // Helper lambdas for more convenient CMake generation
@@ -458,25 +470,41 @@ int generate_cmake(const char *path, bool root) {
    comment("See " + cmkr_url + " for more information");
    endl();

-    if (root) {
+    // Root project doesn't have a parent
+    if (parent_project == nullptr) {
        cmd("cmake_minimum_required")("VERSION", project.cmake_version).endl();

+        if (!project.allow_in_tree) {
+            // clang-format off
+            cmd("if")("CMAKE_SOURCE_DIR", "STREQUAL", "CMAKE_BINARY_DIR");
+                cmd("message")("FATAL_ERROR", "In-tree builds are not supported. Run CMake from a separate directory: cmake -B build");
+            cmd("endif")().endl();
+            // clang-format on
+        }
+
        comment("Regenerate CMakeLists.txt automatically in the root project");
        cmd("set")("CMKR_ROOT_PROJECT", "OFF");
        // clang-format off
        cmd("if")("CMAKE_CURRENT_SOURCE_DIR", "STREQUAL", "CMAKE_SOURCE_DIR");
            cmd("set")("CMKR_ROOT_PROJECT", "ON").endl();

-            comment("Bootstrap cmkr");
-            cmd("include")(project.cmkr_include, "OPTIONAL", "RESULT_VARIABLE", "CMKR_INCLUDE_RESULT");
-            cmd("if")("CMKR_INCLUDE_RESULT");
-                cmd("cmkr")();
-            cmd("endif")().endl();
+            if (!project.cmkr_include.empty()) {
+                comment("Bootstrap cmkr");
+                cmd("include")(project.cmkr_include, "OPTIONAL", "RESULT_VARIABLE", "CMKR_INCLUDE_RESULT");
+                cmd("if")("CMKR_INCLUDE_RESULT");
+                    cmd("cmkr")();
+                cmd("endif")().endl();
+            }

            comment("Enable folder support");
            cmd("set_property")("GLOBAL", "PROPERTY", "USE_FOLDERS", "ON");
        cmd("endif")().endl();
        // clang-format on
+
+        fs::path cmkr_include(project.cmkr_include);
+        if (!project.cmkr_include.empty() && !fs::exists(cmkr_include) && cmkr_include.is_relative()) {
+            create_file(cmkr_include, resources::cmkr);
+        }
    }

    // clang-format off
@@ -513,103 +541,6 @@ int generate_cmake(const char *path, bool root) {
        ss << "\")\n\n";
    }

-    gen.handle_condition(project.include_before, [&](const std::string &, const std::vector<std::string> &includes) { inject_includes(includes); });
-    gen.handle_condition(project.cmake_before, [&](const std::string &, const std::string &cmake) { inject_cmake(cmake); });
-
-    if (!project.project_name.empty()) {
-        auto languages = std::make_pair("LANGUAGES", project.project_languages);
-        auto version = std::make_pair("VERSION", project.project_version);
-        auto description = std::make_pair("DESCRIPTION", project.project_description);
-        cmd("project")(project.project_name, languages, version, description).endl();
-    }
-
-    gen.handle_condition(project.include_after, [&](const std::string &, const std::vector<std::string> &includes) { inject_includes(includes); });
-    gen.handle_condition(project.cmake_after, [&](const std::string &, const std::string &cmake) { inject_cmake(cmake); });
-
-    if (!project.contents.empty()) {
-        cmd("include")("FetchContent").endl();
-        for (const auto &dep : project.contents) {
-            cmd("message")("STATUS", "Fetching " + dep.first + "...");
-            ss << "FetchContent_Declare(\n\t" << dep.first << "\n";
-            for (const auto &arg : dep.second) {
-                std::string first_arg = arg.first;
-                if (first_arg == "git") {
-                    first_arg = "GIT_REPOSITORY";
-                } else if (first_arg == "tag") {
-                    first_arg = "GIT_TAG";
-                } else if (first_arg == "svn") {
-                    first_arg = "SVN_REPOSITORY";
-                } else if (first_arg == "rev") {
-                    first_arg = "SVN_REVISION";
-                } else if (first_arg == "url") {
-                    first_arg = "URL";
-                } else if (first_arg == "hash") {
-                    first_arg = "URL_HASH";
-                } else {
-                    // don't change arg
-                }
-                ss << "\t" << first_arg << "\n\t\t" << arg.second << "\n";
-            }
-            ss << ")\n";
-            cmd("FetchContent_MakeAvailable")(dep.first).endl();
-        }
-    }
-
-    if (!project.vcpkg.packages.empty()) {
-        // Allow the user to specify a url or derive it from the version
-        auto url = project.vcpkg.url;
-        if (url.empty()) {
-            if (project.vcpkg.version.empty()) {
-                throw std::runtime_error("You need either [vcpkg].version or [vcpkg].url");
-            }
-            url = "https://github.com/microsoft/vcpkg/archive/refs/tags/" + project.vcpkg.version + ".tar.gz";
-        }
-
-        // CMake to bootstrap vcpkg and download the packages
-        // clang-format off
-        cmd("if")("CMKR_ROOT_PROJECT", "AND", "NOT", "CMKR_DISABLE_VCPKG");
-            cmd("include")("FetchContent");
-            cmd("message")("STATUS", "Fetching vcpkg...");
-            cmd("FetchContent_Declare")("vcpkg", "URL", url);
-            cmd("FetchContent_MakeAvailable")("vcpkg");
-            cmd("include")("${vcpkg_SOURCE_DIR}/scripts/buildsystems/vcpkg.cmake");
-        cmd("endif")();
-        endl();
-        // clang-format on
-
-        // Generate vcpkg.json
-        using namespace nlohmann;
-        json j;
-        j["$cmkr"] = "This file is automatically generated from cmake.toml - DO NOT EDIT";
-        j["$cmkr-url"] = cmkr_url;
-        j["$schema"] = "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json";
-        j["name"] = vcpkg_escape_identifier(project.project_name);
-        j["version-string"] = project.project_version;
-        j["dependencies"] = project.vcpkg.packages;
-        if (!project.project_description.empty()) {
-            j["description"] = project.project_description;
-        }
-
-        std::ofstream ofs("vcpkg.json");
-        if (!ofs) {
-            throw std::runtime_error("Failed to create a vcpkg.json manifest file!");
-        }
-        ofs << std::setw(2) << j << std::endl;
-    }
-
-    if (!project.packages.empty()) {
-        comment("Packages");
-        for (const auto &dep : project.packages) {
-            auto version = dep.version;
-            if (version == "*")
-                version.clear();
-            auto required = dep.required ? "REQUIRED" : "";
-            auto config = dep.config ? "CONFIG" : "";
-            auto components = std::make_pair("COMPONENTS", dep.components);
-            cmd("find_package")(dep.name, version, required, config, components).endl();
-        }
-    }
-
    if (!project.options.empty()) {
        comment("Options");
        for (const auto &opt : project.options) {
@@ -639,6 +570,138 @@ int generate_cmake(const char *path, bool root) {
        endl();
    }

+    gen.handle_condition(project.include_before, [&](const std::string &, const std::vector<std::string> &includes) { inject_includes(includes); });
+    gen.handle_condition(project.cmake_before, [&](const std::string &, const std::string &cmake) { inject_cmake(cmake); });
+
+    if (!project.project_name.empty()) {
+        auto languages = std::make_pair("LANGUAGES", project.project_languages);
+        auto version = std::make_pair("VERSION", project.project_version);
+        auto description = std::make_pair("DESCRIPTION", project.project_description);
+        cmd("project")(project.project_name, languages, version, description).endl();
+    }
+
+    gen.handle_condition(project.include_after, [&](const std::string &, const std::vector<std::string> &includes) { inject_includes(includes); });
+    gen.handle_condition(project.cmake_after, [&](const std::string &, const std::string &cmake) { inject_cmake(cmake); });
+
+    if (!project.contents.empty()) {
+        cmd("include")("FetchContent").endl();
+        for (const auto &content : project.contents) {
+            cmd("message")("STATUS", "Fetching " + content.name + "...");
+            ss << "FetchContent_Declare(\n\t" << content.name << "\n";
+            for (const auto &arg : content.arguments) {
+                ss << "\t" << arg.first << "\n\t\t" << arg.second << "\n";
+            }
+            ss << ")\n";
+            cmd("FetchContent_MakeAvailable")(content.name).endl();
+        }
+    }
+
+    if (!project.vcpkg.packages.empty()) {
+        // Allow the user to specify a url or derive it from the version
+        auto url = project.vcpkg.url;
+        if (url.empty()) {
+            if (project.vcpkg.version.empty()) {
+                throw std::runtime_error("You need either [vcpkg].version or [vcpkg].url");
+            }
+            url = "https://github.com/microsoft/vcpkg/archive/refs/tags/" + project.vcpkg.version + ".tar.gz";
+        }
+
+        // Show a nicer error than vcpkg when specifying an invalid package name
+        for (const auto &package : project.vcpkg.packages) {
+            if (!vcpkg_valid_identifier(package.name)) {
+                throw std::runtime_error("Invalid [vcpkg].packages name '" + package.name + "' (needs to be lowercase alphanumeric)");
+            }
+        }
+
+        // CMake to bootstrap vcpkg and download the packages
+        // clang-format off
+        cmd("if")("CMKR_ROOT_PROJECT", "AND", "NOT", "CMKR_DISABLE_VCPKG");
+            cmd("include")("FetchContent");
+            cmd("message")("STATUS", "Fetching vcpkg...");
+            cmd("FetchContent_Declare")("vcpkg", "URL", url);
+            cmd("FetchContent_MakeAvailable")("vcpkg");
+            cmd("include")("${vcpkg_SOURCE_DIR}/scripts/buildsystems/vcpkg.cmake");
+        cmd("endif")();
+        endl();
+        // clang-format on
+
+        // Generate vcpkg.json (sorry for the ugly string handling, nlohmann compiles very slowly)
+        std::ofstream ofs("vcpkg.json", std::ios::binary);
+        if (!ofs) {
+            throw std::runtime_error("Failed to create a vcpkg.json manifest file!");
+        }
+        ofs << R"({
+  "$cmkr": "This file is automatically generated from cmake.toml - DO NOT EDIT",
+  "$cmkr-url": "https://github.com/build-cpp/cmkr",
+  "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json",
+  "dependencies": [
+)";
+
+        const auto &packages = project.vcpkg.packages;
+        for (size_t i = 0; i < packages.size(); i++) {
+            const auto &package = packages[i];
+            const auto &features = package.features;
+            if (!vcpkg_valid_identifier(package.name)) {
+                throw std::runtime_error("Invalid vcpkg package name '" + package.name + "'");
+            }
+            for (const auto &feature : features) {
+                if (!vcpkg_valid_identifier(feature)) {
+                    throw std::runtime_error("Invalid vcpkg package feature '" + feature + "'");
+                }
+            }
+            if (features.empty()) {
+                ofs << "    \"" << package.name << '\"';
+            } else {
+                ofs << "    {\n";
+                ofs << "      \"name\": \"" << package.name << "\",\n";
+                ofs << "      \"features\": [";
+                for (size_t j = 0; j < features.size(); j++) {
+                    const auto &feature = features[j];
+                    ofs << '\"' << feature << '\"';
+                    if (j + 1 < features.size()) {
+                        ofs << ',';
+                    }
+                }
+                ofs << "]\n";
+                ofs << "    }";
+            }
+            if (i + 1 < packages.size()) {
+                ofs << ',';
+            }
+            ofs << '\n';
+        }
+
+        auto escape = [](const std::string &str) {
+            std::string result;
+            for (auto ch : str) {
+                if (ch == '\\' || ch == '\"') {
+                    result += '\\';
+                }
+                result += ch;
+            }
+            return result;
+        };
+
+        ofs << "  ],\n";
+        ofs << "  \"description\": \"" << escape(project.project_description) << "\",\n";
+        ofs << "  \"name\": \"" << escape(project.project_name) << "\",\n";
+        ofs << R"(  "version-string": "")" << '\n';
+        ofs << "}\n";
+    }
+
+    if (!project.packages.empty()) {
+        comment("Packages");
+        for (const auto &dep : project.packages) {
+            auto version = dep.version;
+            if (version == "*")
+                version.clear();
+            auto required = dep.required ? "REQUIRED" : "";
+            auto config = dep.config ? "CONFIG" : "";
+            auto components = std::make_pair("COMPONENTS", dep.components);
+            cmd("find_package")(dep.name, version, required, config, components).endl();
+        }
+    }
+
    auto add_subdir = [&](const std::string &dir) {
        // clang-format off
        comment(dir);
@@ -761,8 +824,14 @@ int generate_cmake(const char *path, bool root) {
                target_type = "SOURCES";
                target_scope = "PUBLIC";
                break;
+            case parser::target_object:
+                // NOTE: This is properly supported since 3.12
+                add_command = "add_library";
+                target_type = "OBJECT";
+                target_scope = "PUBLIC";
+                break;
            default:
-                assert("Unimplemented enum value" && false);
+                throw std::runtime_error("Unimplemented enum value");
            }

            cmd(add_command)(target.name, target_type).endl();
@@ -883,7 +952,7 @@ int generate_cmake(const char *path, bool root) {
        if (!fs::exists(list_path))
            return true;

-        std::ifstream ifs(list_path, std::ios_base::binary);
+        std::ifstream ifs(list_path, std::ios::binary);
        if (!ifs.is_open()) {
            throw std::runtime_error("Failed to read " + list_path.string());
        }
@@ -893,15 +962,10 @@ int generate_cmake(const char *path, bool root) {
    }();

    if (should_regenerate) {
-        std::ofstream ofs(list_path, std::ios_base::binary);
-        if (ofs.is_open()) {
-            ofs << ss.str();
-        } else {
-            throw std::runtime_error("Failed to write " + list_path.string());
-        }
+        create_file(list_path, ss.str());
    }

-    auto generate_subdir = [path](const fs::path &sub) {
+    auto generate_subdir = [path, &project](const fs::path &sub) {
        // Skip generating for subdirectories that have a cmake.toml with a [project] in it
        fs::path subpath;
        for (const auto &p : sub) {
@@ -913,7 +977,7 @@ int generate_cmake(const char *path, bool root) {

        subpath = path / sub;
        if (fs::exists(subpath / "cmake.toml")) {
-            generate_cmake(subpath.string().c_str(), false);
+            generate_cmake(subpath.string().c_str(), &project);
        }
    };
    for (const auto &itr : project.project_subdirs) {
@@ -924,28 +988,6 @@ int generate_cmake(const char *path, bool root) {
    for (const auto &subdir : project.subdirs) {
        generate_subdir(subdir.name);
    }
-
-    return 0;
 }
 } // namespace gen
 } // namespace cmkr
-
-int cmkr_gen_generate_project(const char *typ) {
-    try {
-        return cmkr::gen::generate_project(typ);
-    } catch (const std::system_error &e) {
-        return e.code().value();
-    } catch (...) {
-        return cmkr::error::Status(cmkr::error::Status::Code::InitError);
-    }
-}
-
-int cmkr_gen_generate_cmake(const char *path) {
-    try {
-        return cmkr::gen::generate_cmake(path);
-    } catch (const std::system_error &e) {
-        return e.code().value();
-    } catch (...) {
-        return cmkr::error::Status(cmkr::error::Status::Code::GenerationError);
-    }
-}
@@ -1,6 +1,6 @@
 #include "error.hpp"

-#include <assert.h>
+#include <cassert>

 namespace cmkr {
 namespace error {
@@ -14,11 +14,12 @@ Status::Code Status::code() const noexcept { return ec_; }
 } // namespace error
 } // namespace cmkr

-const char *err_string[] = {
-    "Success", "Runtime error", "Initialization error", "CMake generation error", "Build error",
+// strings for cmkr::error::Status::Code
+static const char *err_string[] = {
+    "Success", "Runtime error", "Initialization error", "CMake generation error", "Build error", "Clean error", "Install error",
 };

 const char *cmkr_error_status(int i) {
-    assert(i >= 0 && i < 5);
+    assert(i >= 0 && i < (sizeof(err_string) / sizeof(*(err_string))));
    return err_string[i];
-}
+}
@@ -1,9 +1,10 @@
 #include "help.hpp"
+#include <resources/version.hpp>

 namespace cmkr {
 namespace help {

-const char *version() noexcept { return "cmkr version 0.1.3"; }
+const char *version() noexcept { return "cmkr version " CMKR_VERSION; }

 const char *message() noexcept {
    return R"lit(
@@ -2,17 +2,18 @@

 #include "enum_helper.hpp"
 #include "fs.hpp"
+#include <deque>
 #include <stdexcept>
 #include <toml.hpp>
 #include <tsl/ordered_map.h>

 template <>
-const char *enumStrings<cmkr::parser::TargetType>::data[] = {"executable", "library", "shared", "static", "interface", "custom"};
+const char *enumStrings<cmkr::parser::TargetType>::data[] = {"executable", "library", "shared", "static", "interface", "custom", "object"};

 namespace cmkr {
 namespace parser {

-using TomlBasicValue = toml::basic_value<toml::preserve_comments, tsl::ordered_map, std::vector>;
+using TomlBasicValue = toml::basic_value<toml::discard_comments, tsl::ordered_map, std::vector>;

 template <typename EnumType>
 static EnumType to_enum(const std::string &str, const std::string &help_name) {
@@ -33,298 +34,490 @@ static EnumType to_enum(const std::string &str, const std::string &help_name) {
    return value;
 }

-template <typename T>
-static void get_optional(const TomlBasicValue &v, const toml::key &ky, T &destination);
+static std::string format_key_error(const std::string &error, const toml::key &ky, const TomlBasicValue &value) {
+    auto loc = value.location();
+    auto line_number_str = std::to_string(loc.line());
+    auto line_width = line_number_str.length();
+    auto line_str = loc.line_str();

-template <typename T>
-static void get_optional(const TomlBasicValue &v, const toml::key &ky, Condition<T> &destination) {
-    // TODO: this algorithm in O(n) over the amount of keys, kinda bad
-    const auto &table = v.as_table();
-    for (const auto &itr : table) {
-        const auto &key = itr.first;
-        const auto &value = itr.second;
-        if (value.is_table()) {
-            if (value.contains(ky)) {
-                destination[key] = toml::find<T>(value, ky);
+    std::ostringstream oss;
+    oss << "[error] " << error << '\n';
+    oss << " --> " << loc.file_name() << '\n';
+
+    oss << std::string(line_width + 2, ' ') << "|\n";
+    oss << ' ' << line_number_str << " | " << line_str << '\n';
+
+    oss << std::string(line_width + 2, ' ') << '|';
+    auto key_start = line_str.substr(0, loc.column() - 1).rfind(ky);
+    if (key_start == std::string::npos) {
+        key_start = line_str.find(ky);
+    }
+    if (key_start != std::string::npos) {
+        oss << std::string(key_start + 1, ' ') << std::string(ky.length(), '~');
+    }
+    oss << '\n';
+
+    return oss.str();
+}
+
+class TomlChecker {
+    const TomlBasicValue &m_v;
+    tsl::ordered_map<toml::key, bool> m_visited;
+    tsl::ordered_map<toml::key, bool> m_conditionVisited;
+
+  public:
+    TomlChecker(const TomlBasicValue &v, const toml::key &ky) : m_v(toml::find(v, ky)) {}
+    TomlChecker(const TomlBasicValue &v) : m_v(v) {}
+    TomlChecker(const TomlChecker &) = delete;
+    TomlChecker(TomlChecker &&) = delete;
+
+    template <typename T>
+    void optional(const toml::key &ky, Condition<T> &destination) {
+        // TODO: this algorithm in O(n) over the amount of keys, kinda bad
+        const auto &table = m_v.as_table();
+        for (const auto &itr : table) {
+            const auto &key = itr.first;
+            const auto &value = itr.second;
+            if (value.is_table()) {
+                if (value.contains(ky)) {
+                    destination[key] = toml::find<T>(value, ky);
+                }
+            } else if (key == ky) {
+                destination[""] = toml::find<T>(m_v, ky);
+            }
+        }
+
+        // Handle visiting logic
+        for (const auto &itr : destination) {
+            if (!itr.first.empty()) {
+                m_conditionVisited.emplace(itr.first, true);
+            }
+        }
+        visit(ky);
+    }
+
+    template <typename T>
+    void optional(const toml::key &ky, T &destination) {
+        // TODO: this currently doesn't allow you to get an optional map<string, X>
+        if (m_v.contains(ky)) {
+            destination = toml::find<T>(m_v, ky);
+        }
+        visit(ky);
+    }
+
+    template <typename T>
+    void required(const toml::key &ky, T &destination) {
+        destination = toml::find<T>(m_v, ky);
+        visit(ky);
+    }
+
+    bool contains(const toml::key &ky) {
+        visit(ky);
+        return m_v.contains(ky);
+    }
+
+    const TomlBasicValue &find(const toml::key &ky) {
+        visit(ky);
+        return toml::find(m_v, ky);
+    }
+
+    void visit(const toml::key &ky) { m_visited.emplace(ky, true); }
+
+    void check(const tsl::ordered_map<std::string, std::string> &conditions) const {
+        for (const auto &itr : m_v.as_table()) {
+            const auto &ky = itr.first;
+            if (m_conditionVisited.contains(ky)) {
+                if (!conditions.contains(ky)) {
+                    throw std::runtime_error(format_key_error("Unknown condition '" + ky + "'", ky, itr.second));
+                }
+
+                for (const auto &jtr : itr.second.as_table()) {
+                    if (!m_visited.contains(jtr.first)) {
+                        throw std::runtime_error(format_key_error("Unknown key '" + jtr.first + "'", jtr.first, jtr.second));
+                    }
+                }
+            } else if (!m_visited.contains(ky)) {
+                if (itr.second.is_table()) {
+                    for (const auto &jtr : itr.second.as_table()) {
+                        if (!m_visited.contains(jtr.first)) {
+                            throw std::runtime_error(format_key_error("Unknown key '" + jtr.first + "'", jtr.first, jtr.second));
+                        }
+                    }
+                }
+                throw std::runtime_error(format_key_error("Unknown key '" + ky + "'", ky, itr.second));
            }
-        } else if (key == ky) {
-            destination[""] = toml::find<T>(v, ky);
        }
    }
-}
+};

-template <typename T>
-static void get_optional(const TomlBasicValue &v, const toml::key &ky, T &destination) {
-    // TODO: this currently doesn't allow you to get an optional map<string, X>
-    if (v.contains(ky)) {
-        destination = toml::find<T>(v, ky);
+class TomlCheckerRoot {
+    std::deque<TomlChecker> m_checkers;
+    bool m_checked = false;
+
+  public:
+    TomlCheckerRoot() = default;
+    TomlCheckerRoot(const TomlCheckerRoot &) = delete;
+    TomlCheckerRoot(TomlCheckerRoot &&) = delete;
+
+    TomlChecker &create(const TomlBasicValue &v) {
+        m_checkers.emplace_back(v);
+        return m_checkers.back();
    }
-}

-Project::Project(const std::string &path, bool build) {
+    TomlChecker &create(const TomlBasicValue &v, const toml::key &ky) {
+        m_checkers.emplace_back(v, ky);
+        return m_checkers.back();
+    }
+
+    void check(const tsl::ordered_map<std::string, std::string> &conditions) {
+        for (const auto &checker : m_checkers) {
+            checker.check(conditions);
+        }
+    }
+};
+
+Project::Project(const Project *parent, const std::string &path, bool build) {
    const auto toml_path = fs::path(path) / "cmake.toml";
    if (!fs::exists(toml_path)) {
        throw std::runtime_error("No cmake.toml was found!");
    }
-    const auto toml = toml::parse<toml::preserve_comments, tsl::ordered_map, std::vector>(toml_path.string());
+    const auto toml = toml::parse<toml::discard_comments, tsl::ordered_map, std::vector>(toml_path.string());
+
+    TomlCheckerRoot checker;
+
+    if (toml.contains("cmake")) {
+        auto &cmake = checker.create(toml, "cmake");
+
+        cmake.required("version", cmake_version);
+
+        if (cmake.contains("bin-dir")) {
+            throw std::runtime_error("bin-dir has been renamed to build-dir");
+        }
+
+        cmake.optional("build-dir", build_dir);
+        cmake.optional("generator", generator);
+        cmake.optional("config", config);
+        cmake.optional("arguments", gen_args);
+        cmake.optional("allow-in-tree", allow_in_tree);
+
+        if (cmake.contains("cmkr-include")) {
+            const auto &cmkr_include_kv = cmake.find("cmkr-include");
+            if (cmkr_include_kv.is_string()) {
+                cmkr_include = cmkr_include_kv.as_string();
+            } else {
+                // Allow disabling this feature with cmkr-include = false
+                cmkr_include = "";
+            }
+        }
+
+        cmake.optional("cpp-flags", cppflags);
+        cmake.optional("c-flags", cflags);
+        cmake.optional("link-flags", linkflags);
+    }
+
+    // Skip the rest of the parsing when building
    if (build) {
-        if (toml.contains("cmake")) {
-            const auto &cmake = toml::find(toml, "cmake");
+        checker.check(conditions);
+        return;
+    }

-            if (cmake.contains("bin-dir")) {
-                throw std::runtime_error("bin-dir has been renamed to build-dir");
-            }
-
-            get_optional(cmake, "build-dir", build_dir);
-            get_optional(cmake, "generator", generator);
-            get_optional(cmake, "config", config);
-            get_optional(cmake, "arguments", gen_args);
-        }
-    } else {
-        if (toml.contains("cmake")) {
-            const auto &cmake = toml::find(toml, "cmake");
-            cmake_version = toml::find(cmake, "version").as_string();
-            get_optional(cmake, "cmkr-include", cmkr_include);
-            get_optional(cmake, "cpp-flags", cppflags);
-            get_optional(cmake, "c-flags", cflags);
-            get_optional(cmake, "link-flags", linkflags);
-        }
-
-        if (toml.contains("project")) {
-            const auto &project = toml::find(toml, "project");
-            project_name = toml::find(project, "name").as_string();
-            get_optional(project, "version", project_version);
-            get_optional(project, "description", project_description);
-            get_optional(project, "languages", project_languages);
-            get_optional(project, "cmake-before", cmake_before);
-            get_optional(project, "cmake-after", cmake_after);
-            get_optional(project, "include-before", include_before);
-            get_optional(project, "include-after", include_after);
-            get_optional(project, "subdirs", project_subdirs);
-        }
-
-        if (toml.contains("subdir")) {
-            const auto &subs = toml::find(toml, "subdir").as_table();
-            for (const auto &sub : subs) {
-                Subdir subdir;
-                subdir.name = sub.first;
-                get_optional(sub.second, "condition", subdir.condition);
-                get_optional(sub.second, "cmake-before", subdir.cmake_before);
-                get_optional(sub.second, "cmake-after", subdir.cmake_after);
-                get_optional(sub.second, "include-before", subdir.include_before);
-                get_optional(sub.second, "include-after", subdir.include_after);
-                subdirs.push_back(subdir);
-            }
-        }
-
-        if (toml.contains("settings")) {
-            using set_map = std::map<std::string, TomlBasicValue>;
-            const auto &sets = toml::find<set_map>(toml, "settings");
-            for (const auto &set : sets) {
-                Setting s;
-                s.name = set.first;
-                if (set.second.is_boolean()) {
-                    s.val = set.second.as_boolean();
-                } else if (set.second.is_string()) {
-                    s.val = set.second.as_string();
-                } else {
-                    get_optional(set.second, "comment", s.comment);
-                    if (set.second.contains("value")) {
-                        auto v = toml::find(set.second, "value");
-                        if (v.is_boolean()) {
-                            s.val = v.as_boolean();
-                        } else {
-                            s.val = v.as_string();
-                        }
-                    }
-                    get_optional(set.second, "cache", s.cache);
-                    get_optional(set.second, "force", s.force);
-                }
-                settings.push_back(s);
-            }
-        }
-
-        if (toml.contains("options")) {
-            using opts_map = tsl::ordered_map<std::string, TomlBasicValue>;
-            const auto &opts = toml::find<opts_map>(toml, "options");
-            for (const auto &opt : opts) {
-                Option o;
-                o.name = opt.first;
-                if (opt.second.is_boolean()) {
-                    o.val = opt.second.as_boolean();
-                } else {
-                    get_optional(opt.second, "comment", o.comment);
-                    get_optional(opt.second, "value", o.val);
-                }
-                options.push_back(o);
-            }
-        }
-
-        if (toml.contains("find-package")) {
-            using pkg_map = tsl::ordered_map<std::string, TomlBasicValue>;
-            const auto &pkgs = toml::find<pkg_map>(toml, "find-package");
-            for (const auto &pkg : pkgs) {
-                Package p;
-                p.name = pkg.first;
-                if (pkg.second.is_string()) {
-                    p.version = pkg.second.as_string();
-                } else {
-                    get_optional(pkg.second, "version", p.version);
-                    get_optional(pkg.second, "required", p.required);
-                    get_optional(pkg.second, "config", p.config);
-                    get_optional(pkg.second, "components", p.components);
-                }
-                packages.push_back(p);
-            }
-        }
-
-        // TODO: refactor to std::vector<Content> instead of this hacky thing?
-        if (toml.contains("fetch-content")) {
-            contents = toml::find<decltype(contents)>(toml, "fetch-content");
-        }
-
-        if (toml.contains("bin")) {
-            throw std::runtime_error("[[bin]] has been renamed to [[target]]");
-        }
-
-        if (toml.contains("target")) {
-            const auto &ts = toml::find(toml, "target").as_table();
-
-            for (const auto &itr : ts) {
-                const auto &t = itr.second;
-                Target target;
-                target.name = itr.first;
-                target.type = to_enum<TargetType>(toml::find(t, "type").as_string(), "target type");
-
-                get_optional(t, "headers", target.headers);
-                get_optional(t, "sources", target.sources);
-
-                get_optional(t, "compile-definitions", target.compile_definitions);
-                get_optional(t, "private-compile-definitions", target.private_compile_definitions);
-
-                get_optional(t, "compile-features", target.compile_features);
-                get_optional(t, "private-compile-features", target.private_compile_features);
-
-                get_optional(t, "compile-options", target.compile_options);
-                get_optional(t, "private-compile-options", target.private_compile_options);
-
-                get_optional(t, "include-directories", target.include_directories);
-                get_optional(t, "private-include-directories", target.private_include_directories);
-
-                get_optional(t, "link-directories", target.link_directories);
-                get_optional(t, "private-link-directories", target.private_link_directories);
-
-                get_optional(t, "link-libraries", target.link_libraries);
-                get_optional(t, "private-link-libraries", target.private_link_libraries);
-
-                get_optional(t, "link-options", target.link_options);
-                get_optional(t, "private-link-options", target.private_link_options);
-
-                get_optional(t, "precompile-headers", target.precompile_headers);
-                get_optional(t, "private-precompile-headers", target.private_precompile_headers);
-
-                if (!target.headers.empty()) {
-                    auto &sources = target.sources.nth(0).value();
-                    const auto &headers = target.headers.nth(0)->second;
-                    sources.insert(sources.end(), headers.begin(), headers.end());
-                }
-
-                if (t.contains("condition")) {
-                    target.condition = toml::find(t, "condition").as_string();
-                }
-
-                if (t.contains("alias")) {
-                    target.alias = toml::find(t, "alias").as_string();
-                }
-
-                if (t.contains("properties")) {
-                    auto store_property = [&target](const toml::key &k, const TomlBasicValue &v, const std::string &condition) {
-                        if (v.is_array()) {
-                            std::string property_list;
-                            for (const auto &list_val : v.as_array()) {
-                                if (!property_list.empty()) {
-                                    property_list += ';';
-                                }
-                                property_list += list_val.as_string();
-                            }
-                            target.properties[condition][k] = property_list;
-                        } else if (v.is_boolean()) {
-                            target.properties[condition][k] = v.as_boolean() ? "ON" : "OFF";
-                        } else {
-                            target.properties[condition][k] = v.as_string();
-                        }
-                    };
-
-                    const auto &props = toml::find(t, "properties").as_table();
-                    for (const auto &propKv : props) {
-                        const auto &k = propKv.first;
-                        const auto &v = propKv.second;
-                        if (v.is_table()) {
-                            for (const auto &condKv : v.as_table()) {
-                                store_property(condKv.first, condKv.second, k);
-                            }
-                        } else {
-                            store_property(k, v, "");
-                        }
-                    }
-                }
-
-                get_optional(t, "cmake-before", target.cmake_before);
-                get_optional(t, "cmake-after", target.cmake_after);
-                get_optional(t, "include-before", target.include_before);
-                get_optional(t, "include-after", target.include_after);
-
-                targets.push_back(target);
-            }
-        }
-
-        if (toml.contains("test")) {
-            const auto &ts = toml::find(toml, "test").as_array();
-            for (const auto &t : ts) {
-                Test test;
-                test.name = toml::find(t, "name").as_string();
-                get_optional(t, "configurations", test.configurations);
-                get_optional(t, "working-directory", test.working_directory);
-                test.command = toml::find(t, "command").as_string();
-                get_optional(t, "arguments", test.arguments);
-                tests.push_back(test);
-            }
-        }
-
-        if (toml.contains("install")) {
-            const auto &ts = toml::find(toml, "install").as_array();
-            for (const auto &t : ts) {
-                Install inst;
-                get_optional(t, "targets", inst.targets);
-                get_optional(t, "files", inst.files);
-                get_optional(t, "dirs", inst.dirs);
-                get_optional(t, "configs", inst.configs);
-                inst.destination = toml::find(t, "destination").as_string();
-                installs.push_back(inst);
-            }
-        }
-
-        if (toml.contains("vcpkg")) {
-            const auto &v = toml::find(toml, "vcpkg");
-            get_optional(v, "url", vcpkg.url);
-            get_optional(v, "version", vcpkg.version);
-            vcpkg.packages = toml::find<decltype(vcpkg.packages)>(v, "packages");
-        }
-
-        // Reasonable default conditions (you can override these if you desire)
+    // Reasonable default conditions (you can override these if you desire)
+    if (parent == nullptr) {
        conditions["windows"] = R"cmake(WIN32)cmake";
-        conditions["macos"] = R"cmake("${CMAKE_SYSTEM_NAME}" MATCHES "Darwin")cmake";
+        conditions["macos"] = R"cmake(CMAKE_SYSTEM_NAME MATCHES "Darwin")cmake";
        conditions["unix"] = R"cmake(UNIX)cmake";
-        conditions["bsd"] = R"cmake("${CMAKE_SYSTEM_NAME}" MATCHES "BSD")cmake";
-        conditions["linux"] = conditions["lunix"] = R"cmake("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")cmake";
+        conditions["bsd"] = R"cmake(CMAKE_SYSTEM_NAME MATCHES "BSD")cmake";
+        conditions["linux"] = conditions["lunix"] = R"cmake(CMAKE_SYSTEM_NAME MATCHES "Linux")cmake";
+        conditions["gcc"] = R"cmake(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID STREQUAL "GNU")cmake";
+        conditions["clang"] = R"cmake(CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_C_COMPILER_ID MATCHES "Clang")cmake";
+        conditions["msvc"] = R"cmake(MSVC)cmake";
+    } else {
+        conditions = parent->conditions;
+    }

-        if (toml.contains("conditions")) {
-            auto conds = toml::find<decltype(conditions)>(toml, "conditions");
-            for (const auto &cond : conds) {
-                conditions[cond.first] = cond.second;
-            }
+    if (toml.contains("conditions")) {
+        auto conds = toml::find<decltype(conditions)>(toml, "conditions");
+        for (const auto &cond : conds) {
+            conditions[cond.first] = cond.second;
        }
    }
+
+    if (toml.contains("project")) {
+        auto &project = checker.create(toml, "project");
+        project.required("name", project_name);
+        project.optional("version", project_version);
+        project.optional("description", project_description);
+        project.optional("languages", project_languages);
+        project.optional("cmake-before", cmake_before);
+        project.optional("cmake-after", cmake_after);
+        project.optional("include-before", include_before);
+        project.optional("include-after", include_after);
+        project.optional("subdirs", project_subdirs);
+    }
+
+    if (toml.contains("subdir")) {
+        const auto &subs = toml::find(toml, "subdir").as_table();
+        for (const auto &itr : subs) {
+            Subdir subdir;
+            subdir.name = itr.first;
+
+            auto &sub = checker.create(itr.second);
+            sub.optional("condition", subdir.condition);
+            sub.optional("cmake-before", subdir.cmake_before);
+            sub.optional("cmake-after", subdir.cmake_after);
+            sub.optional("include-before", subdir.include_before);
+            sub.optional("include-after", subdir.include_after);
+
+            subdirs.push_back(subdir);
+        }
+    }
+
+    if (toml.contains("settings")) {
+        using set_map = tsl::ordered_map<std::string, TomlBasicValue>;
+        const auto &sets = toml::find<set_map>(toml, "settings");
+        for (const auto &itr : sets) {
+            Setting s;
+            s.name = itr.first;
+            const auto &value = itr.second;
+            if (value.is_boolean()) {
+                s.val = value.as_boolean();
+            } else if (value.is_string()) {
+                s.val = value.as_string();
+            } else {
+                auto &setting = checker.create(value);
+                setting.optional("comment", s.comment);
+                if (setting.contains("value")) {
+                    const auto &v = setting.find("value");
+                    if (v.is_boolean()) {
+                        s.val = v.as_boolean();
+                    } else {
+                        s.val = v.as_string();
+                    }
+                }
+                setting.optional("cache", s.cache);
+                setting.optional("force", s.force);
+            }
+            settings.push_back(s);
+        }
+    }
+
+    if (toml.contains("options")) {
+        using opts_map = tsl::ordered_map<std::string, TomlBasicValue>;
+        const auto &opts = toml::find<opts_map>(toml, "options");
+        for (const auto &itr : opts) {
+            Option o;
+            o.name = itr.first;
+            const auto &value = itr.second;
+            if (value.is_boolean()) {
+                o.val = value.as_boolean();
+            } else {
+                auto &option = checker.create(value);
+                option.optional("comment", o.comment);
+                option.optional("value", o.val);
+            }
+            options.push_back(o);
+        }
+    }
+
+    if (toml.contains("find-package")) {
+        using pkg_map = tsl::ordered_map<std::string, TomlBasicValue>;
+        const auto &pkgs = toml::find<pkg_map>(toml, "find-package");
+        for (const auto &itr : pkgs) {
+            Package p;
+            p.name = itr.first;
+            const auto &value = itr.second;
+            if (itr.second.is_string()) {
+                p.version = itr.second.as_string();
+            } else {
+                auto &pkg = checker.create(value);
+                pkg.optional("version", p.version);
+                pkg.optional("required", p.required);
+                pkg.optional("config", p.config);
+                pkg.optional("components", p.components);
+            }
+            packages.push_back(p);
+        }
+    }
+
+    // TODO: perform checking here
+    if (toml.contains("fetch-content")) {
+        const auto &fc = toml::find(toml, "fetch-content").as_table();
+        for (const auto &itr : fc) {
+            Content content;
+            content.name = itr.first;
+            for (const auto &argItr : itr.second.as_table()) {
+                auto key = argItr.first;
+                if (key == "git") {
+                    key = "GIT_REPOSITORY";
+                } else if (key == "tag") {
+                    key = "GIT_TAG";
+                } else if (key == "svn") {
+                    key = "SVN_REPOSITORY";
+                } else if (key == "rev") {
+                    key = "SVN_REVISION";
+                } else if (key == "url") {
+                    key = "URL";
+                } else if (key == "hash") {
+                    key = "URL_HASH";
+                } else {
+                    // don't change arg
+                }
+                content.arguments.emplace(key, argItr.second.as_string());
+            }
+            contents.emplace_back(std::move(content));
+        }
+    }
+
+    if (toml.contains("bin")) {
+        throw std::runtime_error("[[bin]] has been renamed to [[target]]");
+    }
+
+    if (toml.contains("target")) {
+        const auto &ts = toml::find(toml, "target").as_table();
+
+        for (const auto &itr : ts) {
+            const auto &value = itr.second;
+
+            Target target;
+            target.name = itr.first;
+
+            auto &t = checker.create(value);
+            std::string type;
+            t.required("type", type);
+            target.type = to_enum<TargetType>(type, "target type");
+
+            t.optional("headers", target.headers);
+            t.optional("sources", target.sources);
+
+            t.optional("compile-definitions", target.compile_definitions);
+            t.optional("private-compile-definitions", target.private_compile_definitions);
+
+            t.optional("compile-features", target.compile_features);
+            t.optional("private-compile-features", target.private_compile_features);
+
+            t.optional("compile-options", target.compile_options);
+            t.optional("private-compile-options", target.private_compile_options);
+
+            t.optional("include-directories", target.include_directories);
+            t.optional("private-include-directories", target.private_include_directories);
+
+            t.optional("link-directories", target.link_directories);
+            t.optional("private-link-directories", target.private_link_directories);
+
+            t.optional("link-libraries", target.link_libraries);
+            t.optional("private-link-libraries", target.private_link_libraries);
+
+            t.optional("link-options", target.link_options);
+            t.optional("private-link-options", target.private_link_options);
+
+            t.optional("precompile-headers", target.precompile_headers);
+            t.optional("private-precompile-headers", target.private_precompile_headers);
+
+            if (!target.headers.empty()) {
+                auto &sources = target.sources.nth(0).value();
+                const auto &headers = target.headers.nth(0)->second;
+                sources.insert(sources.end(), headers.begin(), headers.end());
+            }
+
+            t.optional("condition", target.condition);
+            t.optional("alias", target.alias);
+
+            if (t.contains("properties")) {
+                auto store_property = [&target](const toml::key &k, const TomlBasicValue &v, const std::string &condition) {
+                    if (v.is_array()) {
+                        std::string property_list;
+                        for (const auto &list_val : v.as_array()) {
+                            if (!property_list.empty()) {
+                                property_list += ';';
+                            }
+                            property_list += list_val.as_string();
+                        }
+                        target.properties[condition][k] = property_list;
+                    } else if (v.is_boolean()) {
+                        target.properties[condition][k] = v.as_boolean() ? "ON" : "OFF";
+                    } else {
+                        target.properties[condition][k] = v.as_string();
+                    }
+                };
+
+                const auto &props = t.find("properties").as_table();
+                for (const auto &propKv : props) {
+                    const auto &k = propKv.first;
+                    const auto &v = propKv.second;
+                    if (v.is_table()) {
+                        for (const auto &condKv : v.as_table()) {
+                            store_property(condKv.first, condKv.second, k);
+                        }
+                    } else {
+                        store_property(k, v, "");
+                    }
+                }
+            }
+
+            t.optional("cmake-before", target.cmake_before);
+            t.optional("cmake-after", target.cmake_after);
+            t.optional("include-before", target.include_before);
+            t.optional("include-after", target.include_after);
+
+            targets.push_back(target);
+        }
+    }
+
+    if (toml.contains("test")) {
+        const auto &ts = toml::find(toml, "test").as_array();
+        for (const auto &value : ts) {
+            auto &t = checker.create(value);
+            Test test;
+            t.required("name", test.name);
+            t.optional("configurations", test.configurations);
+            t.optional("working-directory", test.working_directory);
+            t.required("command", test.command);
+            t.optional("arguments", test.arguments);
+            tests.push_back(test);
+        }
+    }
+
+    if (toml.contains("install")) {
+        const auto &is = toml::find(toml, "install").as_array();
+        for (const auto &value : is) {
+            auto &i = checker.create(value);
+            Install inst;
+            i.optional("targets", inst.targets);
+            i.optional("files", inst.files);
+            i.optional("dirs", inst.dirs);
+            i.optional("configs", inst.configs);
+            i.required("destination", inst.destination);
+            installs.push_back(inst);
+        }
+    }
+
+    if (toml.contains("vcpkg")) {
+        auto &v = checker.create(toml, "vcpkg");
+        v.optional("url", vcpkg.url);
+        v.optional("version", vcpkg.version);
+        for (const auto &p : v.find("packages").as_array()) {
+            Vcpkg::Package package;
+            const auto &package_str = p.as_string().str;
+            const auto open_bracket = package_str.find('[');
+            const auto close_bracket = package_str.find(']', open_bracket);
+            if (open_bracket == std::string::npos && close_bracket == std::string::npos) {
+                package.name = package_str;
+            } else if (close_bracket != std::string::npos) {
+                package.name = package_str.substr(0, open_bracket);
+                const auto features = package_str.substr(open_bracket + 1, close_bracket - open_bracket - 1);
+                std::istringstream feature_stream{features};
+                std::string feature;
+                while (std::getline(feature_stream, feature, ',')) {
+                    package.features.emplace_back(feature);
+                }
+            } else {
+                throw std::runtime_error("Invalid vcpkg package '" + package_str + "'");
+            }
+            vcpkg.packages.emplace_back(std::move(package));
+        }
+    }
+
+    checker.check(conditions);
 }

 bool is_root_path(const std::string &path) {
@@ -332,7 +525,7 @@ bool is_root_path(const std::string &path) {
    if (!fs::exists(toml_path)) {
        return false;
    }
-    const auto toml = toml::parse<toml::preserve_comments, tsl::ordered_map, std::vector>(toml_path.string());
+    const auto toml = toml::parse<toml::discard_comments, tsl::ordered_map, std::vector>(toml_path.string());
    return toml.contains("project");
 }

@@ -1,2 +1,3 @@
-# These will be generated by cmkr, so no point in tracking them
-**/CMakeLists.txt
+# These will be generated by cmkr, so no point in tracking them
+**/CMakeLists.txt
+**/cmkr.cmake
@@ -58,3 +58,23 @@ add_test(
 		build
 )

+add_test(
+	NAME
+		cxx-standard
+	WORKING_DIRECTORY
+		"${CMAKE_CURRENT_LIST_DIR}/cxx-standard"
+	COMMAND
+		$<TARGET_FILE:cmkr>
+		build
+)
+
+add_test(
+	NAME
+		globbing
+	WORKING_DIRECTORY
+		"${CMAKE_CURRENT_LIST_DIR}/globbing"
+	COMMAND
+		$<TARGET_FILE:cmkr>
+		build
+)
+
@@ -26,4 +26,16 @@ arguments = ["build"]
 name = "vcpkg"
 command = "$<TARGET_FILE:cmkr>"
 working-directory = "vcpkg"
-arguments = ["build"]
+arguments = ["build"]
+
+[[test]]
+name = "cxx-standard"
+command = "$<TARGET_FILE:cmkr>"
+working-directory = "cxx-standard"
+arguments = ["build"]
+
+[[test]]
+name = "globbing"
+command = "$<TARGET_FILE:cmkr>"
+working-directory = "globbing"
+arguments = ["build"]
@@ -0,0 +1,12 @@
+# Require a C++11 compiler for the target `example`.
+
+[project]
+name = "cxx-standard"
+description = "Changing C++ standard"
+
+[target.example]
+type = "executable"
+sources = ["src/main.cpp"]
+compile-features = ["cxx_std_11"]
+
+# This is equivalent to CMake's [target_compile_features](https://cmake.org/cmake/help/latest/command/target_compile_features.html)`(example PRIVATE cxx_std_11)`. For more information on available C/C++ standards and features see [cmake-compile-features(7)](https://cmake.org/cmake/help/latest/manual/cmake-compile-features.7.html).
@@ -0,0 +1,8 @@
+#include <cstdio>
+#include <tuple>
+
+int main()
+{
+    auto tpl = std::make_tuple(1, 2);
+    printf("Hello from C++11 %d\n", std::get<0>(tpl));
+}
@@ -0,0 +1,18 @@
+[project]
+name = "globbing"
+description = "Globbing sources"
+
+# Recursively glob in the mylib/ folder
+[target.mylib]
+type = "static"
+alias = "mylib::mylib"
+sources = ["mylib/**.hpp", "mylib/**.cpp"]
+include-directories = ["mylib/include"]
+
+# Single-folder glob in example/src/
+[target.example]
+type = "executable"
+sources = ["example/src/*.cpp"]
+link-libraries = ["mylib::mylib"]
+
+# As you can see in the example above you can use `**.ext` to glob recursively and `*.ext` to glob non-recursively. This **does not** generate `file(GLOB ...)` commands, but instead globs when cmkr is run. Files are sorted to give deterministic results regardless of the platform used.
@@ -0,0 +1,7 @@
+#include <iostream>
+#include <mylib/mylib.hpp>
+
+int main() {
+    std::cout << mylib::message() << std::endl;
+    return 0;
+}
@@ -0,0 +1,8 @@
+#pragma once
+
+#include <string>
+
+namespace mylib
+{
+std::string message();
+}
@@ -0,0 +1,6 @@
+#include <mylib/mylib.hpp>
+
+std::string mylib::message()
+{
+    return "cmkr is awesome!";
+}
@@ -18,4 +18,5 @@ type = "executable"
 sources = ["src/main.cpp"]
 link-libraries = ["fmt::fmt"]

-# The bootstrapping of vcpkg is fully automated and no user interaction is necessary. You can disable vcpkg by setting `CMKR_DISABLE_VCPKG=ON`.
+# The bootstrapping of vcpkg is fully automated and no user interaction is necessary. You can disable vcpkg by setting `CMKR_DISABLE_VCPKG=ON`.
+# To specify package features you can use the following syntax: `imgui[docking-experimental,freetype,sdl2-binding,opengl3-binding]`.
@@ -1,11 +1,11 @@
-{
-  "$cmkr": "This file is automatically generated from cmake.toml - DO NOT EDIT",
-  "$cmkr-url": "https://github.com/build-cpp/cmkr",
-  "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json",
-  "dependencies": [
-    "fmt"
-  ],
-  "description": "Example of using vcpkg",
-  "name": "vcpkg",
-  "version-string": ""
-}
+{
+  "$cmkr": "This file is automatically generated from cmake.toml - DO NOT EDIT",
+  "$cmkr-url": "https://github.com/build-cpp/cmkr",
+  "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json",
+  "dependencies": [
+    "fmt"
+  ],
+  "description": "Dependencies from vcpkg",
+  "name": "vcpkg",
+  "version-string": ""
+}
Author	SHA1	Message	Date
Duncan Ogilvie	bdaf5c94e6	Bump to 0.2.2	2021-12-27 11:49:22 +01:00
Duncan Ogilvie	fa3b7a346c	Emit options and settings before the project()	2021-12-27 11:45:23 +01:00
Duncan Ogilvie	df1dbf7953	Bump to 0.2.1	2021-12-27 11:17:20 +01:00
Duncan Ogilvie	5951f6930e	Update documentation for vcpkg features	2021-12-27 11:12:28 +01:00
Duncan Ogilvie	a6d5f1c99b	Merge pull request #41 from cursey/vcpkg-package-features Add support for vcpkg package features	2021-12-27 11:01:04 +01:00
Duncan Ogilvie	dc852b9a2f	Run clang-format	2021-12-27 10:54:46 +01:00
cursey	66621a9818	Fix spacing	2021-12-27 01:50:25 -08:00
cursey	2cd8ad0f18	Add missing const	2021-12-27 01:13:16 -08:00
cursey	084cbd6159	Cleanup vcpkg.json generation a little	2021-12-27 01:08:56 -08:00
cursey	b4b0f533a9	Validate vcpkg features	2021-12-27 01:02:05 -08:00
cursey	0acc9b4e5a	Report the badly formed package name to the user	2021-12-27 00:57:48 -08:00
cursey	61dfb0eb60	Fix tabbing in vcpkg.json for packages that have features	2021-12-26 16:32:38 -08:00
cursey	3201fd052e	Add support for vcpkg package features	2021-12-26 15:40:45 -08:00
Duncan Ogilvie	83087ff06e	Release v0.2.0 (finally)	2021-12-23 20:13:12 +01:00
Duncan Ogilvie	88e9241e9f	Improve onboarding experience Thanks Matthaus :give:	2021-12-23 18:04:54 +01:00
Duncan Ogilvie	eff967277d	Update README with a migration guide	2021-12-23 13:32:46 +01:00
Duncan Ogilvie	ea01497246	Bump CMKR_TAG	2021-12-23 04:01:18 +01:00
Duncan Ogilvie	04bf40a5a6	Generate resources/version.hpp with the project version	2021-12-23 03:53:07 +01:00
Duncan Ogilvie	4d14395994	Implement support a CMKR_CACHE environment variable Closes #17	2021-12-23 03:52:20 +01:00
Duncan Ogilvie	3dd3368e4e	Build in Debug with CMAKE_UNITY_BUILD This gives the fastest bootstrapping times and cmkr isn't noticeably slower during generation.	2021-12-23 01:56:11 +01:00
Duncan Ogilvie	bb7874a6df	Improve compilation times Compilation with make went from 13 -> 10 seconds. CMAKE_UNITY_BUILD went even lower to 6 seconds. Closes #11	2021-12-23 01:54:57 +01:00
Duncan Ogilvie	91dbf2986e	Remove dependency on nlohmann json	2021-12-23 00:55:20 +01:00
Duncan Ogilvie	2bcf15c4ed	Add support for object libraries Closes #34	2021-12-23 00:01:18 +01:00
Duncan Ogilvie	6a825e15a0	Slightly improve cmkr init #24	2021-12-22 18:29:13 +01:00
Duncan Ogilvie	cc2b984aa5	Update documentation for conditions	2021-12-22 18:28:38 +01:00
Duncan Ogilvie	56a88c41e2	Merge pull request #35 from build-cpp/toml-checker Proper error messages for invalid keys/conditions	2021-12-22 17:14:05 +01:00
Duncan Ogilvie	6809e8da41	Refactor and add checking for conditions	2021-12-22 16:51:55 +01:00
Duncan Ogilvie	9f9934e9a5	Implemented checking of keys in conditions	2021-12-22 13:31:52 +01:00
Duncan Ogilvie	77f4bf7da0	Some minor fixes related to newlines and formatting	2021-12-22 13:30:59 +01:00
Duncan Ogilvie	09c9c28934	Initial implementation of TomlChecker This is to error when the user specifies an invalid key. Closes #31	2021-12-19 02:34:48 +01:00
Duncan Ogilvie	f02ccc2309	Refactor fetch-content to vector<Content>	2021-12-12 20:11:20 +01:00
Duncan Ogilvie	37e9a1f1a0	Merge pull request #33 from pmeerw/fix-linux Ceating a directory with no name apparently fails on Linux, but silen…	2021-12-10 18:59:23 +01:00
Duncan Ogilvie	a28e63fddc	Merge pull request #32 from pmeerw/cleanup Some cleanup	2021-12-10 18:59:09 +01:00
Peter Meerwald-Stadler	156fc961ec	Ceating a directory with no name apparently fails on Linux, but silently succeeds on Windows	2021-12-10 17:39:36 +01:00
Peter Meerwald-Stadler	31cc1c9481	Avoid explicit number of error strings in cmkr_error_status()	2021-12-10 17:10:06 +01:00
Peter Meerwald-Stadler	19101cd726	Reduce scope of err_string; add missing error codes	2021-12-10 17:10:06 +01:00
Peter Meerwald-Stadler	8ebf69da7e	Use C++ includes	2021-12-10 17:10:06 +01:00
Duncan Ogilvie	1c23469c8c	Bump CMKR_TAG	2021-12-08 14:40:41 +01:00
Duncan Ogilvie	52671dcf5b	Improve documentation for conditions	2021-12-08 14:39:48 +01:00
Duncan Ogilvie	094bab1b81	Add clarification that the system compiler is used when building cmkr	2021-12-08 14:39:35 +01:00
Duncan Ogilvie	0f559bc803	Do not make Package.config default to true	2021-12-08 14:39:18 +01:00
Duncan Ogilvie	491486075d	Error when running cmkr.cmake as a script	2021-11-28 22:18:14 +01:00
Duncan Ogilvie	ed84fc0251	Merge pull request #29 from build-cpp/fix-actions-pr Fix a bug in the logic to skip building pull requests from the same repo	2021-10-27 18:11:24 +02:00
Duncan Ogilvie	8b6780fe1a	Fix a bug in the logic to skip building pull requests from the same repository	2021-10-27 18:03:17 +02:00
Duncan Ogilvie	9ebcb1fb06	Bump CMKR_TAG	2021-10-24 16:19:50 +02:00
Duncan Ogilvie	7c7144b183	Also generate CMakeLists.txt when calling cmkr init	2021-10-24 16:19:08 +02:00
Duncan Ogilvie	07797988b5	Fix a critical bug in generate_resources.cmake	2021-10-24 16:19:03 +02:00
Duncan Ogilvie	285614e4c2	Automatically generate cmkr.cmake when missing	2021-09-13 17:01:46 +02:00
Mohammed Alyousef	e725b10a9f	Just removing my name from the Readme	2021-09-01 22:55:51 +03:00
Duncan Ogilvie	aafaf58c70	Reduce GitHub Actions OS matrix	2021-08-28 13:50:24 +02:00
Duncan Ogilvie	87db22f134	Add documentation for the cmake.toml format	2021-08-28 13:41:51 +02:00
Duncan Ogilvie	416a8365f9	Bump CMKR_TAG	2021-07-04 13:27:01 +02:00
Duncan Ogilvie	a718dfd675	Inherit conditions from the parent project	2021-07-03 16:27:01 +02:00
Duncan Ogilvie	25da3171f0	Add default conditions for gcc/clang/msvc	2021-07-03 16:03:22 +02:00
Duncan Ogilvie	95907602b4	Do not allow in-tree builds per default	2021-07-03 15:56:51 +02:00
Duncan Ogilvie	4b300df8d5	Add some more tests for the documentation	2021-06-27 21:36:01 +02:00
Duncan Ogilvie	760b2a8511	Show a nice error when specifying an invalid vcpkg package name	2021-06-27 00:21:22 +02:00
Duncan Ogilvie	fb9af0213b	Bump CMKR_TAG	2021-06-26 17:16:25 +02:00
				`@@ -0,0 +1 @@`
				`google-site-verification: google13f7c659b54c069f.html`