Also generate CMakeLists.txt when calling cmkr init

Fix a critical bug in generate_resources.cmake
Automatically generate cmkr.cmake when missing
2026-06-08 13:22:55 +00:00 · 2021-10-24 16:19:08 +02:00 · 2021-10-24 16:19:03 +02:00 · 2021-09-13 17:01:46 +02:00 · 2021-09-01 22:55:51 +03:00 · 2021-08-28 13:50:24 +02:00
61 changed files with 26952 additions and 510 deletions
@@ -10,25 +10,56 @@ jobs:
    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 }} "-DCMAKE_INSTALL_PREFIX=${{ github.workspace }}/install"
+        cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=${{ env.BUILD_TYPE }}
        cmake --build build --config ${{ env.BUILD_TYPE }} --parallel
-        cmake --install build --config ${{ env.BUILD_TYPE }}
+        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: |
        cd build/tests
        ctest -C ${{ env.BUILD_TYPE }}
+
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v2
+      with:
+        name: ${{ github.event.repository.name }}-${{ matrix.os }}
+        path: install/bin/*
+
+    - name: Get lowercase OS name
+      id: osname
+      uses: ASzc/change-string-case-action@v1
+      with:
+        string: ${{ runner.os }}
+
+    - name: Compress artifacts
+      uses: papeloto/action-zip@v1
+      with:
+        files: install/bin/
+        dest: ${{ github.event.repository.name }}-${{ steps.osname.outputs.lowercase }}.zip
+
+    - name: Release
+      uses: softprops/action-gh-release@v1
+      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 }}
@@ -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()
@@ -32,6 +30,9 @@ project(cmkr
 		"CMakeLists generator from TOML"
 )

+include("cmake/generate_documentation.cmake")
+include("cmake/generate_resources.cmake")
+
 # third_party
 set(CMKR_CMAKE_FOLDER ${CMAKE_FOLDER})
 if(CMAKE_FOLDER)
@@ -54,27 +55,44 @@ set(CMAKE_FOLDER ${CMKR_CMAKE_FOLDER})



+# Target cmkr_generate_documentation
+set(CMKR_TARGET cmkr_generate_documentation)
+set(cmkr_generate_documentation_SOURCES "")
+
+set(CMKR_SOURCES ${cmkr_generate_documentation_SOURCES})
+add_library(cmkr_generate_documentation INTERFACE)
+
+if(cmkr_generate_documentation_SOURCES)
+	target_sources(cmkr_generate_documentation INTERFACE ${cmkr_generate_documentation_SOURCES})
+endif()
+
+generate_documentation()
+
+unset(CMKR_TARGET)
+unset(CMKR_SOURCES)
+
 # Target cmkr
 set(CMKR_TARGET cmkr)
 set(cmkr_SOURCES "")

 list(APPEND cmkr_SOURCES
-	"src/args.cpp"
+	"src/arguments.cpp"
 	"src/build.cpp"
-	"src/cmake.cpp"
+	"src/cmake_generator.cpp"
 	"src/error.cpp"
-	"src/gen.cpp"
 	"src/help.cpp"
 	"src/main.cpp"
-	"include/args.hpp"
+	"src/project_parser.cpp"
+	"include/arguments.hpp"
 	"include/build.hpp"
-	"include/cmake.hpp"
+	"include/cmake_generator.hpp"
 	"include/enum_helper.hpp"
 	"include/error.hpp"
 	"include/fs.hpp"
-	"include/gen.hpp"
 	"include/help.hpp"
 	"include/literals.hpp"
+	"include/project_parser.hpp"
+	"cmake/cmkr.cmake"
 )

 list(APPEND cmkr_SOURCES
@@ -108,10 +126,14 @@ target_link_libraries(cmkr PRIVATE
 	ghc_filesystem
 	mpark_variant
 	ordered_map
+	nlohmann_json
 )

+generate_resources(${CMKR_TARGET})
+
 unset(CMKR_TARGET)
 unset(CMKR_SOURCES)
+
 install(
 	TARGETS
 		cmkr
@@ -1,8 +1,6 @@
 # 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).
-
-**NOTE**: The documentation is currently a work-in-progress due to breaking changes since `0.1.4`. For examples you can check the [cmkr GitHub topic](https://github.com/topics/cmkr) and the [tests](https://github.com/build-cpp/cmkr/tree/main/tests).
+`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:

@@ -27,7 +25,7 @@ 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.
+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).

 ## Command line

@@ -51,3 +49,4 @@ arguments:
 - https://github.com/Tessil/ordered-map
 - https://github.com/ToruNiina/toml11
 - https://github.com/mpark/variant
+- https://www.svgrepo.com/svg/192268/hammer
@@ -1,5 +1,6 @@
 [cmake]
 version = "2.8...3.8"
+cmkr-include = false

 [project]
 name = "cmkr"
@@ -7,13 +8,38 @@ version = "0.1.4"
 description = "CMakeLists generator from TOML"
 languages = ["CXX"]
 subdirs = ["third_party", "tests"]
+include-after = [
+    "cmake/generate_documentation.cmake",
+    "cmake/generate_resources.cmake"
+]
+
+[target.cmkr_generate_documentation]
+type = "interface"
+cmake-after = """
+generate_documentation()
+"""

 [target.cmkr]
 type = "executable"
-sources = ["src/*.cpp", "include/*.hpp"]
-include-directories = ["include"]
+sources = [
+    "src/*.cpp",
+    "include/*.hpp",
+    "cmake/cmkr.cmake",
+]
+include-directories = [
+    "include",
+]
 compile-features = ["cxx_std_11"]
-link-libraries = ["toml11", "ghc_filesystem", "mpark_variant", "ordered_map"]
+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,156 +1,163 @@
-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_7cdf36f3" 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(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}"
-    )
-    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)
-
-        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
-            set(CMKR_TEMP_FILE "${CMAKE_CURRENT_SOURCE_DIR}/CMakerLists.txt")
-            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 "archive_a718dfd6" 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 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 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()
@@ -0,0 +1,20 @@
+---
+# Automatically generated from tests/@EXAMPLE_PERMALINK@/cmake.toml - DO NOT EDIT
+layout: default
+title: @EXAMPLE_TITLE@
+permalink: /examples/@EXAMPLE_PERMALINK@
+parent: Examples
+nav_order: @EXAMPLE_INDEX@
+---
+
+# @EXAMPLE_TITLE@
+
+@EXAMPLE_HEADER@
+
+```toml
+@EXAMPLE_TOML@
+```
+
+@EXAMPLE_FOOTER@
+
+<sup><sub>This page was automatically generated from [tests/@EXAMPLE_PERMALINK@/cmake.toml](https://github.com/build-cpp/cmkr/tree/main/tests/@EXAMPLE_PERMALINK@/cmake.toml).</sub></sup>
@@ -0,0 +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()
@@ -0,0 +1,20 @@
+# 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})
+        if(SOURCE MATCHES ".cmake$")
+            get_filename_component(RESOURCE_NAME "${SOURCE}" NAME_WE)
+            set(RESOURCE_HEADER "include/resources/${RESOURCE_NAME}.hpp")
+            # 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}")
+        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!");
-}
@@ -1 +1,2 @@
-_site
+_site/
+.jekyll-metadata
@@ -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
@@ -3,7 +3,19 @@ title: cmkr
 plugins:
  - jekyll-remote-theme

-# Build settings
-# theme: just-the-docs
-remote_theme: pmarsceill/just-the-docs
+# Automatically deduce dark theme preference https://github.com/pmarsceill/just-the-docs/pull/464
+remote_theme: build-cpp/just-the-docs@light-switch
 search_enabled: true
+color_scheme: light-or-dark
+heading_anchors: true
+aux_links:
+  "cmkr":
+    - "https://github.com/build-cpp/cmkr"
+aux_links_new_tab: true
+
+gh_edit_link: true
+gh_edit_link_text: "Edit this page on GitHub."
+gh_edit_repository: "https://github.com/build-cpp/cmkr"
+gh_edit_branch: "main"
+gh_edit_view_mode: "edit"
+gh_edit_source: docs
@@ -0,0 +1,170 @@
+---
+layout: page
+title: cmake.toml
+permalink: /cmake-toml/
+nav_order: 3
+---
+
+# cmake.toml
+
+This page is supposed to be 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 more real-world 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
+
+```toml
+[conditions]
+arch64 = "CMAKE_SIZEOF_VOID_P EQUALS 8"
+arch32 = "CMAKE_SIZEOF_VOID_P EQUALS 4"
+```
+
+## 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. For a custom registry you can specify your own `url` (and omit the `version`).
+
+## 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, library, shared, static, interface, 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 = [""]
+```
@@ -5,7 +5,7 @@ permalink: /command-line/
 nav_order: 2
 ---

-## Command line
+# Command line

 Optionally you can install `cmkr` in your `PATH` and use it as a utility from the command line:

@@ -0,0 +1,26 @@
+---
+# Automatically generated from tests/basic/cmake.toml - DO NOT EDIT
+layout: default
+title: Minimal example
+permalink: /examples/basic
+parent: Examples
+nav_order: 0
+---
+
+# Minimal example
+
+A minimal `cmake.toml` project:
+
+```toml
+[project]
+name = "basic"
+description = "Minimal example"
+
+[target.basic]
+type = "executable"
+sources = ["src/basic.cpp"]
+```
+
+Declares an executable target called `basic` with `src/basic.cpp` as a source file. Equivalent to CMake's [add_executable](https://cmake.org/cmake/help/latest/command/add_executable.html)`(basic src/basic.cpp)`.
+
+<sup><sub>This page was automatically generated from [tests/basic/cmake.toml](https://github.com/build-cpp/cmkr/tree/main/tests/basic/cmake.toml).</sub></sup>
@@ -1,17 +0,0 @@
---
-layout: default
-title: Changing C/C++ version
-permalink: /examples/cpp-version-change
-parent: Examples
-nav_order: 3
---
-
-# Changing C/C++ version
-
-Simple example changing C++ to version 20 and C standard to the version 11
-
-```toml
-[target.example]
-type = "executable"
-compile-features = [ "cxx_std_20", "c_std_11" ]
-```
@@ -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,30 @@
+---
+# Automatically generated from tests/fetch-content/cmake.toml - DO NOT EDIT
+layout: default
+title: Fetching from git
+permalink: /examples/fetch-content
+parent: Examples
+nav_order: 2
+---
+
+# Fetching from git
+
+Downloads [fmt v7.1.3](https://fmt.dev/7.1.3/) from [GitHub](https://github.com) and links an `example` target to it:
+
+```toml
+[project]
+name = "fetch-content"
+description = "Fetching from git"
+
+[fetch-content]
+fmt = { git = "https://github.com/fmtlib/fmt", tag = "7.1.3" }
+
+[target.example]
+type = "executable"
+sources = ["src/main.cpp"]
+link-libraries = ["fmt::fmt"]
+```
+
+This is equivalent to calling CMake's [FetchContent](https://cmake.org/cmake/help/latest/module/FetchContent.html).
+
+<sup><sub>This page was automatically generated from [tests/fetch-content/cmake.toml](https://github.com/build-cpp/cmkr/tree/main/tests/fetch-content/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>
@@ -1,22 +0,0 @@
---
-layout: default
-title: Import content from Github
-permalink: /examples/import-from-git
-parent: Examples
-nav_order: 2
---
-
-# Import content from Github
-
-Importing an existing project called Zydis to my project
-
-tag is optional but you can target any branch with it
-
-```toml
-[fetch-content]
-zydis = { git = "https://github.com/zyantific/zydis.git", tag = "v3.1.0" }
-
-[target.example]
-type = "executable"
-link-libraries = ["zydis"]
-```
@@ -1,10 +0,0 @@
---
-layout: default
-title: Examples
-permalink: /examples/
-nav_order: 4
-has_children: true
---
-
-# Examples
-
@@ -0,0 +1,11 @@
+---
+layout: default
+title: Examples
+permalink: /examples/
+nav_order: 100
+has_children: true
+---
+
+# Examples
+
+The examples in this section are automatically generated from the [tests](https://github.com/build-cpp/cmkr/blob/main/tests/cmake.toml).
@@ -0,0 +1,31 @@
+---
+# Automatically generated from tests/interface/cmake.toml - DO NOT EDIT
+layout: default
+title: Header-only library
+permalink: /examples/interface
+parent: Examples
+nav_order: 1
+---
+
+# Header-only library
+
+
+
+```toml
+[project]
+name = "interface"
+description = "Header-only library"
+
+[target.mylib]
+type = "interface"
+include-directories = ["include"]
+
+[target.example]
+type = "executable"
+sources = ["src/main.cpp"]
+link-libraries = ["mylib"]
+```
+
+
+
+<sup><sub>This page was automatically generated from [tests/interface/cmake.toml](https://github.com/build-cpp/cmkr/tree/main/tests/interface/cmake.toml).</sub></sup>
@@ -1,23 +0,0 @@
---
-layout: default
-title: Quickstart
-permalink: /examples/quickstart
-parent: Examples
-nav_order: 1
---
-
-# Quickstart
-
-Smallest possible start point you can have using cmkr
-
-```toml
-[cmake]
-version = "3.15"
-
-[project]
-name = "hello-world"
-
-[target.hello-world]
-type = "executable"
-sources = [ "src/*.cpp" ]
-```
@@ -0,0 +1,36 @@
+---
+# Automatically generated from tests/vcpkg/cmake.toml - DO NOT EDIT
+layout: default
+title: Dependencies from vcpkg
+permalink: /examples/vcpkg
+parent: Examples
+nav_order: 4
+---
+
+# Dependencies from vcpkg
+
+Downloads [fmt v7.1.3](https://fmt.dev/7.1.3/) using [vcpkg](https://vcpkg.io/) and links an `example` target to it:
+
+```toml
+[project]
+name = "vcpkg"
+description = "Dependencies from vcpkg"
+
+# See https://github.com/microsoft/vcpkg/releases for vcpkg versions
+# See https://vcpkg.io/en/packages.html for available packages
+[vcpkg]
+version = "2021.05.12"
+packages = ["fmt"]
+
+[find-package]
+fmt = {}
+
+[target.example]
+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`.
+
+<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>
@@ -5,7 +5,7 @@ permalink: /getting-started/
 nav_order: 1
 ---

-## Getting started
+# 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:

@@ -6,7 +6,7 @@ nav_order: 0

 # Index

-[cmkr](https://github.com/build-cpp/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). It was originally created by [Mohammed Alyousef](https://github.com/MoAlyousef).

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

@@ -0,0 +1,2 @@
+bundle install
+bundle exec jekyll serve --force_polling --livereload --incremental
@@ -1,11 +1,13 @@
 #pragma once

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

 int generate_project(const char *typ);

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

 } // namespace gen
 } // namespace cmkr
@@ -8,7 +8,7 @@
 #include <vector>

 namespace cmkr {
-namespace cmake {
+namespace parser {

 struct Setting {
    std::string name;
@@ -34,6 +34,7 @@ struct Package {

 struct Vcpkg {
    std::string version;
+    std::string url;
    std::vector<std::string> packages;
 };

@@ -55,19 +56,37 @@ struct Target {
    std::string name;
    TargetType type = {};

-    // https://cmake.org/cmake/help/latest/manual/cmake-commands.7.html#project-commands
-    ConditionVector compile_definitions;
-    ConditionVector compile_features;
-    ConditionVector compile_options;
-    ConditionVector include_directories;
-    ConditionVector link_directories;
-    ConditionVector link_libraries;
-    ConditionVector link_options;
-    ConditionVector precompile_headers;
+    ConditionVector headers;
    ConditionVector sources;

+    // https://cmake.org/cmake/help/latest/manual/cmake-commands.7.html#project-commands
+    ConditionVector compile_definitions;
+    ConditionVector private_compile_definitions;
+
+    ConditionVector compile_features;
+    ConditionVector private_compile_features;
+
+    ConditionVector compile_options;
+    ConditionVector private_compile_options;
+
+    ConditionVector include_directories;
+    ConditionVector private_include_directories;
+
+    ConditionVector link_directories;
+    ConditionVector private_link_directories;
+
+    ConditionVector link_libraries;
+    ConditionVector private_link_libraries;
+
+    ConditionVector link_options;
+    ConditionVector private_link_options;
+
+    ConditionVector precompile_headers;
+    ConditionVector private_precompile_headers;
+
+    std::string condition;
    std::string alias;
-    tsl::ordered_map<std::string, std::string> properties;
+    Condition<tsl::ordered_map<std::string, std::string>> properties;

    Condition<std::string> cmake_before;
    Condition<std::string> cmake_after;
@@ -91,14 +110,24 @@ struct Install {
    std::string destination;
 };

-struct CMake {
+struct Subdir {
+    std::string name;
+    std::string condition;
+    Condition<std::string> cmake_before;
+    Condition<std::string> cmake_after;
+    ConditionVector include_before;
+    ConditionVector include_after;
+};
+
+struct Project {
    // This is the CMake version required to use all cmkr versions.
    std::string cmake_version = "3.15";
    std::string cmkr_include = "cmkr.cmake";
    std::string build_dir = "build";
    std::string generator;
    std::string config;
-    Condition<std::vector<std::string>> subdirs;
+    bool allow_in_tree = false;
+    Condition<std::vector<std::string>> project_subdirs;
    std::vector<std::string> cppflags;
    std::vector<std::string> cflags;
    std::vector<std::string> linkflags;
@@ -121,9 +150,12 @@ struct CMake {
    std::vector<Test> tests;
    std::vector<Install> installs;
    tsl::ordered_map<std::string, std::string> conditions;
+    std::vector<Subdir> subdirs;

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

-} // namespace cmake
+bool is_root_path(const std::string &path);
+
+} // namespace parser
 } // namespace cmkr
@@ -1,6 +1,6 @@
-#include "args.hpp"
+#include "arguments.hpp"
 #include "build.hpp"
-#include "gen.hpp"
+#include "cmake_generator.hpp"
 #include "help.hpp"

 #include "fs.hpp"
@@ -36,6 +36,9 @@ const char *handle_args(int argc, char **argv) {
        auto ret = cmkr::gen::generate_project(type.c_str());
        if (ret)
            return "Initialization failure!";
+        ret = cmkr::gen::generate_cmake(fs::current_path().string().c_str());
+        if (ret)
+            return "CMake generation error!";
        return "Directory initialized!";
    } else if (main_arg == "build") {
        auto ret = build::run(argc, argv);
@@ -1,7 +1,7 @@
 #include "build.hpp"
-#include "cmake.hpp"
+#include "cmake_generator.hpp"
 #include "error.hpp"
-#include "gen.hpp"
+#include "project_parser.hpp"

 #include "fs.hpp"
 #include <sstream>
@@ -14,10 +14,10 @@ namespace cmkr {
 namespace build {

 int run(int argc, char **argv) {
-    cmake::CMake cmake(".", true);
+    parser::Project project(nullptr, ".", true);
    if (argc > 2) {
        for (int i = 2; i < argc; ++i) {
-            cmake.build_args.push_back(argv[i]);
+            project.build_args.push_back(argv[i]);
        }
    }
    std::stringstream ss;
@@ -25,22 +25,22 @@ int run(int argc, char **argv) {
    if (gen::generate_cmake(fs::current_path().string().c_str()))
        throw std::runtime_error("CMake generation failure!");

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

-    if (!cmake.generator.empty()) {
-        ss << "-G \"" << cmake.generator << "\" ";
+    if (!project.generator.empty()) {
+        ss << "-G \"" << project.generator << "\" ";
    }
-    if (!cmake.config.empty()) {
-        ss << "-DCMAKE_BUILD_TYPE=" << cmake.config << " ";
+    if (!project.config.empty()) {
+        ss << "-DCMAKE_BUILD_TYPE=" << project.config << " ";
    }
-    if (!cmake.gen_args.empty()) {
-        for (const auto &arg : cmake.gen_args) {
+    if (!project.gen_args.empty()) {
+        for (const auto &arg : project.gen_args) {
            ss << "-D" << arg << " ";
        }
    }
-    ss << "&& cmake --build " << cmake.build_dir << " --parallel";
+    ss << "&& cmake --build " << project.build_dir << " --parallel";
    if (argc > 2) {
-        for (const auto &arg : cmake.build_args) {
+        for (const auto &arg : project.build_args) {
            ss << " " << arg;
        }
    }
@@ -50,17 +50,17 @@ int run(int argc, char **argv) {

 int clean() {
    bool ret = false;
-    cmake::CMake cmake(".", true);
-    if (fs::exists(cmake.build_dir)) {
-        ret = fs::remove_all(cmake.build_dir);
-        fs::create_directory(cmake.build_dir);
+    parser::Project project(nullptr, ".", true);
+    if (fs::exists(project.build_dir)) {
+        ret = fs::remove_all(project.build_dir);
+        fs::create_directory(project.build_dir);
    }
    return !ret;
 }

 int install() {
-    cmake::CMake cmake(".", false);
-    auto cmd = "cmake --install " + cmake.build_dir;
+    parser::Project project(nullptr, ".", false);
+    auto cmd = "cmake --install " + project.build_dir;
    return ::system(cmd.c_str());
 }
 } // namespace build
@@ -1,14 +1,17 @@
-#include "gen.hpp"
-#include "cmake.hpp"
+#include "cmake_generator.hpp"
 #include "error.hpp"
 #include "literals.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>
@@ -155,12 +158,14 @@ struct Command {
    bool first_arg = true;
    bool had_newline = false;
    bool generated = false;
+    std::string post_comment;

-    Command(std::stringstream &ss, int depth, const std::string &command) : ss(ss), depth(depth), command(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() {
        if (!generated) {
-            assert(false && "Incorrect usage of cmd()");
+            assert(false && "Incorrect usage of cmd(), you probably forgot ()");
        }
    }

@@ -300,7 +305,11 @@ struct Command {
        (void)std::initializer_list<bool>{print_arg(values)...};
        if (had_newline)
            ss << '\n' << indent(depth);
-        ss << ")\n";
+        ss << ")";
+        if (!post_comment.empty()) {
+            ss << " # " << post_comment;
+        }
+        ss << "\n";
        return CommandEndl(ss);
    }
 };
@@ -316,25 +325,25 @@ static std::string tolf(const std::string &str) {
 };

 struct Generator {
-    Generator(cmake::CMake &cmake) : cmake(cmake) {}
+    Generator(parser::Project &project) : project(project) {}
    Generator(const Generator &) = delete;

-    cmake::CMake &cmake;
+    parser::Project &project;
    std::stringstream ss;
    int indent = 0;

-    Command cmd(const std::string &command) {
+    Command cmd(const std::string &command, const std::string &post_comment = "") {
        if (command.empty())
            throw std::invalid_argument("command cannot be empty");
        if (command == "if") {
            indent++;
-            return Command(ss, indent - 1, command);
+            return Command(ss, indent - 1, command, post_comment);
        } else if (command == "else" || command == "elseif") {
-            return Command(ss, indent - 1, command);
+            return Command(ss, indent - 1, command, post_comment);
        } else if (command == "endif") {
            indent--;
        }
-        return Command(ss, indent, command);
+        return Command(ss, indent, command, post_comment);
    }

    CommandEndl comment(const std::string &comment) {
@@ -378,16 +387,16 @@ struct Generator {
    }

    template <typename T, typename Lambda>
-    void handle_condition(const cmake::Condition<T> &value, const Lambda &fn) {
+    void handle_condition(const parser::Condition<T> &value, const Lambda &fn) {
        if (!value.empty()) {
            for (const auto &itr : value) {
                const auto &condition = itr.first;
                if (!condition.empty()) {
-                    if (cmake.conditions.count(condition) == 0) {
+                    if (project.conditions.count(condition) == 0) {
                        // TODO: somehow print line number information here?
                        throw std::runtime_error("Unknown condition '" + condition + "'");
                    }
-                    cmd("if")(RawArg(cmake.conditions[condition]));
+                    cmd("if", condition)(RawArg(project.conditions[condition]));
                }

                if (!itr.second.empty()) {
@@ -403,28 +412,66 @@ struct Generator {
    }
 };

-int generate_cmake(const char *path, bool root) {
+static bool vcpkg_valid_identifier(const std::string &name) {
+    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;
+    return !std::regex_match(name.c_str(), m, reserved) && std::regex_match(name.c_str(), m, ok);
+}
+
+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;
+    for (char ch : name) {
+        if ((ch & 0x80) != 0) {
+            throw std::runtime_error("Non-ASCII characters are not allowed in [project].name when using [vcpkg]");
+        }
+
+        if (ch == '_' || ch == ' ') {
+            ch = '-';
+        }
+
+        escaped += std::tolower(ch);
+    }
+
+    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, const parser::Project *parent_project) {
    if (!fs::exists(fs::path(path) / "cmake.toml")) {
        throw std::runtime_error("No cmake.toml found!");
    }

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

    // Helper lambdas for more convenient CMake generation
    auto &ss = gen.ss;
-    auto cmd = [&gen](const std::string &comment) { return gen.cmd(comment); };
+    auto cmd = [&gen](const std::string &command) { return gen.cmd(command); };
    auto comment = [&gen](const std::string &comment) { return gen.comment(comment); };
    auto endl = [&gen]() { gen.endl(); };
    auto inject_includes = [&gen](const std::vector<std::string> &includes) { gen.inject_includes(includes); };
    auto inject_cmake = [&gen](const std::string &cmake) { gen.inject_cmake(cmake); };

+    std::string cmkr_url = "https://github.com/build-cpp/cmkr";
    comment("This file is automatically generated from cmake.toml - DO NOT EDIT");
-    comment("See https://github.com/build-cpp/cmkr for more information");
+    comment("See " + cmkr_url + " for more information");
    endl();

-    if (root) {
-        cmd("cmake_minimum_required")("VERSION", cmake.cmake_version).endl();
+    // 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");
@@ -432,16 +479,28 @@ int generate_cmake(const char *path, bool root) {
        cmd("if")("CMAKE_CURRENT_SOURCE_DIR", "STREQUAL", "CMAKE_SOURCE_DIR");
            cmd("set")("CMKR_ROOT_PROJECT", "ON").endl();

-            comment("Bootstrap cmkr");
-            cmd("include")(cmake.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()) {
+            fs::create_directories(cmkr_include.parent_path());
+            std::ofstream ofs(cmkr_include.string(), std::ios::binary);
+            if (!ofs) {
+                throw std::runtime_error("Failed to create " + project.cmkr_include);
+            }
+            ofs.write(resources::cmkr, strlen(resources::cmkr));
+        }
    }

    // clang-format off
@@ -452,48 +511,48 @@ int generate_cmake(const char *path, bool root) {
    // clang-format on

    // TODO: remove support and replace with global compile-features
-    if (!cmake.cppflags.empty()) {
+    if (!project.cppflags.empty()) {
        ss << "set(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} \"";
-        for (const auto &flag : cmake.cppflags) {
+        for (const auto &flag : project.cppflags) {
            ss << flag << " ";
        }
        ss << "\")\n\n";
    }

    // TODO: remove support and replace with global compile-features
-    if (!cmake.cflags.empty()) {
+    if (!project.cflags.empty()) {
        ss << "set(CMAKE_C_FLAGS ${CMAKE_C_FLAGS} \"";
-        for (const auto &flag : cmake.cflags) {
+        for (const auto &flag : project.cflags) {
            ss << flag << " ";
        }
        ss << "\")\n\n";
    }

    // TODO: remove support and replace with global linker-flags
-    if (!cmake.linkflags.empty()) {
+    if (!project.linkflags.empty()) {
        ss << "set(CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS} \"";
-        for (const auto &flag : cmake.linkflags) {
+        for (const auto &flag : project.linkflags) {
            ss << flag << " ";
        }
        ss << "\")\n\n";
    }

-    gen.handle_condition(cmake.include_before, [&](const std::string &, const std::vector<std::string> &includes) { inject_includes(includes); });
-    gen.handle_condition(cmake.cmake_before, [&](const std::string &, const std::string &cmake) { inject_cmake(cmake); });
+    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 (!cmake.project_name.empty()) {
-        auto languages = std::make_pair("LANGUAGES", cmake.project_languages);
-        auto version = std::make_pair("VERSION", cmake.project_version);
-        auto description = std::make_pair("DESCRIPTION", cmake.project_description);
-        cmd("project")(cmake.project_name, languages, version, description).endl();
+    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(cmake.include_after, [&](const std::string &, const std::vector<std::string> &includes) { inject_includes(includes); });
-    gen.handle_condition(cmake.cmake_after, [&](const std::string &, const std::string &cmake) { inject_cmake(cmake); });
+    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 (!cmake.contents.empty()) {
+    if (!project.contents.empty()) {
        cmd("include")("FetchContent").endl();
-        for (const auto &dep : cmake.contents) {
+        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) {
@@ -520,20 +579,58 @@ int generate_cmake(const char *path, bool root) {
        }
    }

-    if (!cmake.vcpkg.version.empty()) {
-        assert("pmm is required in fetch-content for vcpkg to work" && cmake.contents.count("pmm") != 0);
-        comment("Bootstrap vcpkg");
-        cmd("include")("${pmm_SOURCE_DIR}/pmm.cmake");
-        tsl::ordered_map<std::string, std::vector<std::string>> vcpkg_args;
-        vcpkg_args["REVISION"] = {cmake.vcpkg.version};
-        vcpkg_args["REQUIRES"] = cmake.vcpkg.packages;
-        auto vcpkg = std::make_pair("VCPKG", vcpkg_args);
-        cmd("pmm")(vcpkg).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)) {
+                throw std::runtime_error("Invalid [vcpkg].packages name '" + package + "' (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
+        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 (!cmake.packages.empty()) {
+    if (!project.packages.empty()) {
        comment("Packages");
-        for (const auto &dep : cmake.packages) {
+        for (const auto &dep : project.packages) {
            auto version = dep.version;
            if (version == "*")
                version.clear();
@@ -544,17 +641,17 @@ int generate_cmake(const char *path, bool root) {
        }
    }

-    if (!cmake.options.empty()) {
+    if (!project.options.empty()) {
        comment("Options");
-        for (const auto &opt : cmake.options) {
+        for (const auto &opt : project.options) {
            cmd("option")(opt.name, opt.comment, opt.val ? "ON" : "OFF");
        }
        endl();
    }

-    if (!cmake.settings.empty()) {
+    if (!project.settings.empty()) {
        comment("Settings");
-        for (const auto &set : cmake.settings) {
+        for (const auto &set : project.settings) {
            std::string set_val;
            if (set.val.index() == 1) {
                set_val = mpark::get<1>(set.val);
@@ -573,30 +670,65 @@ int generate_cmake(const char *path, bool root) {
        endl();
    }

-    // generate_cmake is called on the subdirectories recursively later
-    if (!cmake.subdirs.empty()) {
-        gen.handle_condition(cmake.subdirs, [&](const std::string &, const std::vector<std::string> &subdirs) {
-            for (const auto &dir : subdirs) {
-                // clang-format off
-                comment(dir);
-                cmd("set")("CMKR_CMAKE_FOLDER", "${CMAKE_FOLDER}");
-                cmd("if")("CMAKE_FOLDER");
-                    cmd("set")("CMAKE_FOLDER", "${CMAKE_FOLDER}/" + dir);
-                cmd("else")();
-                    cmd("set")("CMAKE_FOLDER", dir);
-                cmd("endif")();
-                // clang-format on
+    auto add_subdir = [&](const std::string &dir) {
+        // clang-format off
+        comment(dir);
+        cmd("set")("CMKR_CMAKE_FOLDER", "${CMAKE_FOLDER}");
+        cmd("if")("CMAKE_FOLDER");
+            cmd("set")("CMAKE_FOLDER", "${CMAKE_FOLDER}/" + dir);
+        cmd("else")();
+            cmd("set")("CMAKE_FOLDER", dir);
+        cmd("endif")();
+        // clang-format on

-                cmd("add_subdirectory")(dir);
-                cmd("set")("CMAKE_FOLDER", "${CMKR_CMAKE_FOLDER}").endl();
+        cmd("add_subdirectory")(dir);
+        cmd("set")("CMAKE_FOLDER", "${CMKR_CMAKE_FOLDER}").endl();
+    };
+
+    // generate_cmake is called on the subdirectories recursively later
+    if (!project.project_subdirs.empty()) {
+        gen.handle_condition(project.project_subdirs, [&](const std::string &, const std::vector<std::string> &subdirs) {
+            for (const auto &dir : subdirs) {
+                add_subdir(dir);
            }
        });
        endl();
    }
+    for (const auto &subdir : project.subdirs) {
+        if (!subdir.condition.empty()) {
+            const auto &condition = subdir.condition;
+            if (project.conditions.count(condition) == 0) {
+                throw std::runtime_error("Unknown condition '" + condition + "' for [subdir." + subdir.name + "]");
+            }
+            gen.cmd("if", condition)(RawArg(project.conditions[condition]));
+        }

-    if (!cmake.targets.empty()) {
-        for (const auto &target : cmake.targets) {
+        gen.handle_condition(subdir.include_before,
+                             [&](const std::string &, const std::vector<std::string> &includes) { inject_includes(includes); });
+        gen.handle_condition(subdir.cmake_before, [&](const std::string &, const std::string &cmake) { inject_cmake(cmake); });
+
+        add_subdir(subdir.name);
+
+        gen.handle_condition(subdir.include_after, [&](const std::string &, const std::vector<std::string> &includes) { inject_includes(includes); });
+        gen.handle_condition(subdir.cmake_after, [&](const std::string &, const std::string &cmake) { inject_cmake(cmake); });
+
+        if (!subdir.condition.empty()) {
+            cmd("endif")();
+        }
+    }
+
+    if (!project.targets.empty()) {
+        for (const auto &target : project.targets) {
            comment("Target " + target.name);
+
+            if (!target.condition.empty()) {
+                const auto &condition = target.condition;
+                if (project.conditions.count(condition) == 0) {
+                    throw std::runtime_error("Unknown condition '" + condition + "' for [target." + target.name + "]");
+                }
+                gen.cmd("if", condition)(RawArg(project.conditions[condition]));
+            }
+
            cmd("set")("CMKR_TARGET", target.name);

            gen.handle_condition(target.include_before,
@@ -620,7 +752,7 @@ int generate_cmake(const char *path, bool root) {
                cmd("list")("APPEND", sources_var, sources);
            });

-            if (!added_toml && target.type != cmake::target_interface) {
+            if (!added_toml && target.type != parser::target_interface) {
                cmd("list")("APPEND", sources_var, std::vector<std::string>{"cmake.toml"}).endl();
            }
            cmd("set")("CMKR_SOURCES", "${" + sources_var + "}");
@@ -629,32 +761,32 @@ int generate_cmake(const char *path, bool root) {
            std::string target_type;
            std::string target_scope;
            switch (target.type) {
-            case cmake::target_executable:
+            case parser::target_executable:
                add_command = "add_executable";
                target_type = "";
                target_scope = "PRIVATE";
                break;
-            case cmake::target_library:
+            case parser::target_library:
                add_command = "add_library";
                target_type = "";
                target_scope = "PUBLIC";
                break;
-            case cmake::target_shared:
+            case parser::target_shared:
                add_command = "add_library";
                target_type = "SHARED";
                target_scope = "PUBLIC";
                break;
-            case cmake::target_static:
+            case parser::target_static:
                add_command = "add_library";
                target_type = "STATIC";
                target_scope = "PUBLIC";
                break;
-            case cmake::target_interface:
+            case parser::target_interface:
                add_command = "add_library";
                target_type = "INTERFACE";
                target_scope = "INTERFACE";
                break;
-            case cmake::target_custom:
+            case parser::target_custom:
                // TODO: add proper support, this is hacky
                add_command = "add_custom_target";
                target_type = "SOURCES";
@@ -668,12 +800,12 @@ int generate_cmake(const char *path, bool root) {

            // clang-format off
            cmd("if")(sources_var);
-                cmd("target_sources")(target.name, target.type == cmake::target_interface ? "INTERFACE" : "PRIVATE", "${" + sources_var + "}");
+                cmd("target_sources")(target.name, target.type == parser::target_interface ? "INTERFACE" : "PRIVATE", "${" + sources_var + "}");
            cmd("endif")().endl();
            // clang-format on

            // The first executable target will become the Visual Studio startup project
-            if (target.type == cmake::target_executable) {
+            if (target.type == parser::target_executable) {
                cmd("get_directory_property")("CMKR_VS_STARTUP_PROJECT", "DIRECTORY", "${PROJECT_SOURCE_DIR}", "DEFINITION", "VS_STARTUP_PROJECT");
                // clang-format off
                cmd("if")("NOT", "CMKR_VS_STARTUP_PROJECT");
@@ -683,28 +815,46 @@ int generate_cmake(const char *path, bool root) {
            }

            if (!target.sources.empty()) {
-                cmd("source_group")("TREE", "${CMAKE_CURRENT_SOURCE_DIR}", "FILES", "${" + target.name + "_SOURCES}").endl();
+                cmd("source_group")("TREE", "${CMAKE_CURRENT_SOURCE_DIR}", "FILES", "${" + sources_var + "}").endl();
            }

            if (!target.alias.empty()) {
                cmd("add_library")(target.alias, "ALIAS", target.name);
            }

-            auto target_cmd = [&](const char *command, const cmake::ConditionVector &cargs) {
-                gen.handle_condition(
-                    cargs, [&](const std::string &, const std::vector<std::string> &args) { cmd(command)(target.name, target_scope, args); });
+            auto target_cmd = [&](const char *command, const parser::ConditionVector &cargs, const std::string &scope) {
+                gen.handle_condition(cargs,
+                                     [&](const std::string &, const std::vector<std::string> &args) { cmd(command)(target.name, scope, args); });
            };

-            target_cmd("target_compile_definitions", target.compile_definitions);
-            target_cmd("target_compile_features", target.compile_features);
-            target_cmd("target_compile_options", target.compile_options);
-            target_cmd("target_include_directories", target.include_directories);
-            target_cmd("target_link_directories", target.link_directories);
-            target_cmd("target_link_libraries", target.link_libraries);
-            target_cmd("target_precompile_headers", target.precompile_headers);
+            target_cmd("target_compile_definitions", target.compile_definitions, target_scope);
+            target_cmd("target_compile_definitions", target.private_compile_definitions, "PRIVATE");
+
+            target_cmd("target_compile_features", target.compile_features, target_scope);
+            target_cmd("target_compile_features", target.private_compile_features, "PRIVATE");
+
+            target_cmd("target_compile_options", target.compile_options, target_scope);
+            target_cmd("target_compile_options", target.private_compile_options, "PRIVATE");
+
+            target_cmd("target_include_directories", target.include_directories, target_scope);
+            target_cmd("target_include_directories", target.private_include_directories, "PRIVATE");
+
+            target_cmd("target_link_directories", target.link_directories, target_scope);
+            target_cmd("target_link_directories", target.private_link_directories, "PRIVATE");
+
+            target_cmd("target_link_libraries", target.link_libraries, target_scope);
+            target_cmd("target_link_libraries", target.private_link_libraries, "PRIVATE");
+
+            target_cmd("target_link_options", target.link_options, target_scope);
+            target_cmd("target_link_options", target.private_link_options, "PRIVATE");
+
+            target_cmd("target_precompile_headers", target.precompile_headers, target_scope);
+            target_cmd("target_precompile_headers", target.private_precompile_headers, "PRIVATE");

            if (!target.properties.empty()) {
-                cmd("set_target_properties")(target.name, "PROPERTIES", target.properties).endl();
+                gen.handle_condition(target.properties, [&](const std::string &, const tsl::ordered_map<std::string, std::string> &properties) {
+                    cmd("set_target_properties")(target.name, "PROPERTIES", properties);
+                });
            }

            gen.handle_condition(target.include_after,
@@ -713,23 +863,33 @@ int generate_cmake(const char *path, bool root) {

            cmd("unset")("CMKR_TARGET");
            cmd("unset")("CMKR_SOURCES");
+
+            if (!target.condition.empty()) {
+                cmd("endif")();
+            }
+
+            endl();
        }
    }

-    if (!cmake.tests.empty()) {
+    if (!project.tests.empty()) {
        cmd("enable_testing")().endl();
-        for (const auto &test : cmake.tests) {
+        for (const auto &test : project.tests) {
            auto name = std::make_pair("NAME", test.name);
            auto configurations = std::make_pair("CONFIGURATIONS", test.configurations);
-            auto working_directory = std::make_pair("WORKING_DIRECTORY", test.working_directory);
+            auto dir = test.working_directory;
+            if (fs::is_directory(fs::path(path) / dir)) {
+                dir = "${CMAKE_CURRENT_LIST_DIR}/" + dir;
+            }
+            auto working_directory = std::make_pair("WORKING_DIRECTORY", dir);
            auto command = std::make_pair("COMMAND", test.command);
            auto arguments = std::make_pair("", test.arguments);
            cmd("add_test")(name, configurations, working_directory, command, arguments).endl();
        }
    }

-    if (!cmake.installs.empty()) {
-        for (const auto &inst : cmake.installs) {
+    if (!project.installs.empty()) {
+        for (const auto &inst : project.installs) {
            auto targets = std::make_pair("TARGETS", inst.targets);
            auto dirs = std::make_pair("DIRS", inst.dirs);
            std::vector<std::string> files_data;
@@ -772,12 +932,28 @@ int generate_cmake(const char *path, bool root) {
        }
    }

-    for (const auto &itr : cmake.subdirs) {
-        for (const auto &sub : itr.second) {
-            auto subpath = fs::path(path) / fs::path(sub);
-            if (fs::exists(subpath / "cmake.toml"))
-                generate_cmake(subpath.string().c_str(), false);
+    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) {
+            subpath /= p;
+            if (parser::is_root_path((path / subpath).string())) {
+                return;
+            }
        }
+
+        subpath = path / sub;
+        if (fs::exists(subpath / "cmake.toml")) {
+            generate_cmake(subpath.string().c_str(), &project);
+        }
+    };
+    for (const auto &itr : project.project_subdirs) {
+        for (const auto &sub : itr.second) {
+            generate_subdir(sub);
+        }
+    }
+    for (const auto &subdir : project.subdirs) {
+        generate_subdir(subdir.name);
    }

    return 0;
@@ -1,4 +1,4 @@
-#include "args.hpp"
+#include "arguments.hpp"

 #include <cstdio>
 #include <cstdlib>
@@ -1,4 +1,4 @@
-#include "cmake.hpp"
+#include "project_parser.hpp"

 #include "enum_helper.hpp"
 #include "fs.hpp"
@@ -7,10 +7,10 @@
 #include <tsl/ordered_map.h>

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

 namespace cmkr {
-namespace cmake {
+namespace parser {

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

@@ -55,16 +55,18 @@ static void get_optional(const TomlBasicValue &v, const toml::key &ky, Condition

 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);
    }
 }

-CMake::CMake(const std::string &path, bool build) {
-    if (!fs::exists(fs::path(path) / "cmake.toml")) {
+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>((fs::path(path) / "cmake.toml").string());
+    const auto toml = toml::parse<toml::preserve_comments, tsl::ordered_map, std::vector>(toml_path.string());
    if (build) {
        if (toml.contains("cmake")) {
            const auto &cmake = toml::find(toml, "cmake");
@@ -77,12 +79,21 @@ CMake::CMake(const std::string &path, bool build) {
            get_optional(cmake, "generator", generator);
            get_optional(cmake, "config", config);
            get_optional(cmake, "arguments", gen_args);
+            get_optional(cmake, "allow-in-tree", allow_in_tree);
        }
    } 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);
+            if (cmake.contains("cmkr-include")) {
+                const auto &cmkr_include_kv = toml::find(cmake, "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 = "";
+                }
+            }
            get_optional(cmake, "cpp-flags", cppflags);
            get_optional(cmake, "c-flags", cflags);
            get_optional(cmake, "link-flags", linkflags);
@@ -98,7 +109,21 @@ CMake::CMake(const std::string &path, bool build) {
            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", subdirs);
+            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")) {
@@ -163,7 +188,9 @@ CMake::CMake(const std::string &path, bool build) {
        }

        // TODO: refactor to std::vector<Content> instead of this hacky thing?
-        get_optional(toml, "fetch-content", contents);
+        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]]");
@@ -178,34 +205,75 @@ CMake::CMake(const std::string &path, bool build) {
                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")) {
-                    const auto &props = toml::find(t, "properties").as_table();
-                    for (const auto &propKv : props) {
-                        if (propKv.second.is_array()) {
+                    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 : propKv.second.as_array()) {
+                            for (const auto &list_val : v.as_array()) {
                                if (!property_list.empty()) {
                                    property_list += ';';
                                }
                                property_list += list_val.as_string();
                            }
-                            target.properties[propKv.first] = property_list;
+                            target.properties[condition][k] = property_list;
+                        } else if (v.is_boolean()) {
+                            target.properties[condition][k] = v.as_boolean() ? "ON" : "OFF";
                        } else {
-                            target.properties[propKv.first] = propKv.second.as_string();
+                            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, "");
                        }
                    }
                }
@@ -247,23 +315,24 @@ CMake::CMake(const std::string &path, bool build) {

        if (toml.contains("vcpkg")) {
            const auto &v = toml::find(toml, "vcpkg");
-            vcpkg.version = toml::find(v, "version").as_string();
+            get_optional(v, "url", vcpkg.url);
+            get_optional(v, "version", vcpkg.version);
            vcpkg.packages = toml::find<decltype(vcpkg.packages)>(v, "packages");
-
-            // This allows the user to use a custom pmm version if desired
-            if (contents.count("pmm") == 0) {
-                contents["pmm"]["url"] = "https://github.com/vector-of-bool/pmm/archive/refs/tags/1.5.1.tar.gz";
-                // Hack to not execute pmm's example CMakeLists.txt
-                contents["pmm"]["SOURCE_SUBDIR"] = "pmm";
-            }
        }

        // Reasonable default conditions (you can override these if you desire)
-        conditions["windows"] = R"cmake(WIN32)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";
+        if (parent == nullptr) {
+            conditions["windows"] = R"cmake(WIN32)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["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");
@@ -273,5 +342,15 @@ CMake::CMake(const std::string &path, bool build) {
        }
    }
 }
-} // namespace cmake
+
+bool is_root_path(const std::string &path) {
+    const auto toml_path = fs::path(path) / "cmake.toml";
+    if (!fs::exists(toml_path)) {
+        return false;
+    }
+    const auto toml = toml::parse<toml::preserve_comments, tsl::ordered_map, std::vector>(toml_path.string());
+    return toml.contains("project");
+}
+
+} // namespace parser
 } // namespace cmkr
@@ -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
@@ -18,6 +18,26 @@ add_test(
 		build
 )

+add_test(
+	NAME
+		interface
+	WORKING_DIRECTORY
+		"${CMAKE_CURRENT_LIST_DIR}/interface"
+	COMMAND
+		$<TARGET_FILE:cmkr>
+		build
+)
+
+add_test(
+	NAME
+		fetch-content
+	WORKING_DIRECTORY
+		"${CMAKE_CURRENT_LIST_DIR}/fetch-content"
+	COMMAND
+		$<TARGET_FILE:cmkr>
+		build
+)
+
 add_test(
 	NAME
 		conditions
@@ -30,9 +50,29 @@ add_test(

 add_test(
 	NAME
-		interface
+		vcpkg
 	WORKING_DIRECTORY
-		"${CMAKE_CURRENT_LIST_DIR}/interface"
+		"${CMAKE_CURRENT_LIST_DIR}/vcpkg"
+	COMMAND
+		$<TARGET_FILE:cmkr>
+		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
@@ -1,9 +1,11 @@
-[cmake]
-version = "3.5"
+# A minimal `cmake.toml` project:

 [project]
 name = "basic"
+description = "Minimal example"

 [target.basic]
 type = "executable"
 sources = ["src/basic.cpp"]
+
+# Declares an executable target called `basic` with `src/basic.cpp` as a source file. Equivalent to CMake's [add_executable](https://cmake.org/cmake/help/latest/command/add_executable.html)`(basic src/basic.cpp)`.
@@ -1,17 +1,41 @@
 [[test]]
 name = "basic"
 command = "$<TARGET_FILE:cmkr>"
-working-directory = "${CMAKE_CURRENT_LIST_DIR}/basic"
-arguments = ["build"]
-
-[[test]]
-name = "conditions"
-command = "$<TARGET_FILE:cmkr>"
-working-directory = "${CMAKE_CURRENT_LIST_DIR}/conditions"
+working-directory = "basic"
 arguments = ["build"]

 [[test]]
 name = "interface"
 command = "$<TARGET_FILE:cmkr>"
-working-directory = "${CMAKE_CURRENT_LIST_DIR}/interface"
-arguments = ["build"]
+working-directory = "interface"
+arguments = ["build"]
+
+[[test]]
+name = "fetch-content"
+command = "$<TARGET_FILE:cmkr>"
+working-directory = "fetch-content"
+arguments = ["build"]
+
+[[test]]
+name = "conditions"
+command = "$<TARGET_FILE:cmkr>"
+working-directory = "conditions"
+arguments = ["build"]
+
+[[test]]
+name = "vcpkg"
+command = "$<TARGET_FILE:cmkr>"
+working-directory = "vcpkg"
+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"]
@@ -14,4 +14,10 @@ windows.cmake-after = "message(STATUS win32-after)"
 macos.cmake-after = "message(STATUS macos-after)"
 linux.cmake-after = "message(STATUS linux-after)"
 unix.cmake-after = "message(STATUS unix-after)"
-custom.cmake-after = "message(STATUS custom-after)"
+custom.cmake-after = "message(STATUS custom-after)"
+
+[target.example.properties]
+AUTOMOC = false
+custom.OUTPUT_NAME = "example2"
+custom.AUTORCC = true
+AUTOGEN = "ON"
@@ -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,15 @@
+# Downloads [fmt v7.1.3](https://fmt.dev/7.1.3/) from [GitHub](https://github.com) and links an `example` target to it:
+
+[project]
+name = "fetch-content"
+description = "Fetching from git"
+
+[fetch-content]
+fmt = { git = "https://github.com/fmtlib/fmt", tag = "7.1.3" }
+
+[target.example]
+type = "executable"
+sources = ["src/main.cpp"]
+link-libraries = ["fmt::fmt"]
+
+# This is equivalent to calling CMake's [FetchContent](https://cmake.org/cmake/help/latest/module/FetchContent.html).
@@ -0,0 +1,6 @@
+#include <fmt/core.h>
+
+int main()
+{
+    fmt::print("Hello, world!\n");
+}
@@ -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!";
+}
@@ -1,5 +1,6 @@
 [project]
 name = "interface"
+description = "Header-only library"

 [target.mylib]
 type = "interface"
@@ -0,0 +1,21 @@
+# Downloads [fmt v7.1.3](https://fmt.dev/7.1.3/) using [vcpkg](https://vcpkg.io/) and links an `example` target to it:
+
+[project]
+name = "vcpkg"
+description = "Dependencies from vcpkg"
+
+# See https://github.com/microsoft/vcpkg/releases for vcpkg versions
+# See https://vcpkg.io/en/packages.html for available packages
+[vcpkg]
+version = "2021.05.12"
+packages = ["fmt"]
+
+[find-package]
+fmt = {}
+
+[target.example]
+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`.
@@ -0,0 +1,6 @@
+#include <fmt/core.h>
+
+int main()
+{
+    fmt::print("Hello, world!\n");
+}
@@ -0,0 +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": "Dependencies from vcpkg",
+  "name": "vcpkg",
+  "version-string": ""
+}
@@ -16,3 +16,7 @@ target_include_directories(toml11 INTERFACE toml11-3.6.0)
 # https://github.com/mpark/variant (BSL-1.0)
 add_library(mpark_variant INTERFACE)
 target_include_directories(mpark_variant INTERFACE variant-1.4.0/include)
+
+# https://github.com/nlohmann/json (MIT)
+add_library(nlohmann_json INTERFACE)
+target_include_directories(nlohmann_json INTERFACE nlohmann-3.9.1/include)
@@ -0,0 +1,21 @@
+MIT License 
+
+Copyright (c) 2013-2021 Niels Lohmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
Author	SHA1	Message	Date
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
Duncan Ogilvie	264e4ace18	Fix bug checking the root path of subdirectories	2021-06-26 17:15:56 +02:00
Duncan Ogilvie	b6ab584a1a	Bump CMKR_TAG	2021-06-26 16:28:12 +02:00
Duncan Ogilvie	3cd84a9708	Add basic support for [subdir.mydir]	2021-06-26 16:22:26 +02:00
Duncan Ogilvie	9932e501ce	Rename files to make the project easier to navigate	2021-06-25 12:38:48 +02:00
Duncan Ogilvie	1b37dd76a5	Rename things to try to make the code more readable	2021-06-25 12:25:58 +02:00
Duncan Ogilvie	82f2a11311	Bump CMKR_TAG	2021-06-23 22:36:29 +02:00
Duncan Ogilvie	eaf03eb785	Add support for target condition	2021-06-15 02:15:06 +02:00
Duncan Ogilvie	8ea5b77ba5	Merge pull request #28 from build-cpp/conditional-properties Implement conditional properties	2021-06-14 23:38:47 +02:00
Duncan Ogilvie	a12b3ae021	Bump CMKR_TAG	2021-06-14 23:36:39 +02:00
Duncan Ogilvie	2450cfb2c9	Implement conditional properties Closes #8	2021-06-14 23:29:51 +02:00
Duncan Ogilvie	8d024556e3	Fix CI	2021-06-14 04:34:44 +02:00
Duncan Ogilvie	af3807ca2b	Add support for private- target options	2021-06-14 04:01:02 +02:00
Duncan Ogilvie	17f085c66d	Minor improvements to cmkr.cmake	2021-06-01 17:14:08 +02:00
Duncan Ogilvie	5ad6134e07	Merge pull request #27 from build-cpp/manifest Add support for headers and vcpkg manifest mode	2021-05-31 15:30:34 +02:00
Duncan Ogilvie	7b20d8c54c	Restore [vcpkg].version functionality and add a test + documentation	2021-05-31 14:02:13 +02:00
MoAlyousef	ffdedbdace	fixes	2021-05-29 17:40:44 +03:00
MoAlyousef	bb7a0bc0ed	signal failure to write a vcpkg.json file	2021-05-28 05:48:23 +03:00
MoAlyousef	dd0003f8fe	add nlohmann_json to cmake toml	2021-05-28 05:39:00 +03:00
MoAlyousef	a32caca8f0	fix fetching vcpkg	2021-05-28 05:08:45 +03:00
MoAlyousef	f565ad2af0	fix formatting, add check for project version in manifest mode	2021-05-28 05:03:00 +03:00
MoAlyousef	dc4b59f05d	prelim vcpkg manifest support	2021-05-28 04:54:04 +03:00
Duncan Ogilvie	4988f141e4	Bump version in cmkr.cmake bootstrapper	2021-05-18 13:14:43 +02:00
Duncan Ogilvie	64b58425e6	Add missing code generation for link-options	2021-05-18 13:13:48 +02:00
Duncan Ogilvie	d4f0cdf152	Allow test working directories with a relative path	2021-05-16 23:07:22 +02:00
Duncan Ogilvie	306bb3d4fc	Automatically generate documentation from tests	2021-05-16 22:55:55 +02:00
Duncan Ogilvie	acd3688d16	Fix [fetch-content]	2021-05-16 22:51:42 +02:00
Duncan Ogilvie	23c5713c6b	Fix pipeline typos	2021-05-13 21:48:21 +02:00
Duncan Ogilvie	cebe73c8e5	Improved dark theme	2021-05-13 21:43:34 +02:00
Duncan Ogilvie	779d4ae96a	Update README.md	2021-05-13 15:32:07 +02:00
Duncan Ogilvie	7eed60bc7d	Use dark theme when the system uses dark theme in the documentation	2021-05-13 06:16:36 +02:00
Duncan Ogilvie	aa468dcf9c	Only upload artifacts for certain operating systems in the matrix	2021-05-13 05:53:46 +02:00
Duncan Ogilvie	1bd9d2228e	Logic for prereleases in github actions	2021-05-13 05:47:37 +02:00
Duncan Ogilvie	5364b5ea72	Add credits for documentation favicon	2021-05-13 05:30:56 +02:00
Duncan Ogilvie	7a5d3b0491	Github actions artifacts and release binaries	2021-05-13 05:29:21 +02:00