Bump to 0.2.19

Improve and document the `[options]` feature

.github/workflows/build.yml

@@ -15,7 +15,7 @@ jobs:
       BUILD_TYPE: Release
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
 
     - name: Tag cmkr.cmake
       if: ${{ startsWith(github.ref, 'refs/tags/') }}
@@ -38,28 +38,31 @@ jobs:
         ctest -C ${{ env.BUILD_TYPE }} --verbose
 
     - name: Upload artifacts
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v3
       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
+      uses: ASzc/change-string-case-action@07c1e24a97f0951e13f88870b99c058fcf0b14cf # v5
+      if: ${{ startsWith(github.ref, 'refs/tags/') }}
       with:
         string: ${{ runner.os }}
 
     - name: Compress artifacts
-      uses: vimtor/action-zip@v1
+      uses: vimtor/action-zip@26a249fb00d43ca98dad77a4b3838025fc226aa1 # v1.1
+      if: ${{ startsWith(github.ref, 'refs/tags/') }}
       with:
         files: install/bin/
         dest: ${{ github.event.repository.name }}-${{ steps.osname.outputs.lowercase }}.zip
 
     - name: Release
-      uses: softprops/action-gh-release@v1
+      uses: softprops/action-gh-release@de2c0eb89ae2a093876385947365aca7b0e5f844 # v0.1.15
       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
+        generate_release_notes: true
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -9,3 +9,4 @@ build*/
 .idea/
 cmake-build*/
 CMakeLists.txt.user
+.vscode/

CMakeLists.txt

@@ -7,17 +7,14 @@ 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)
 
 	# 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)
+	# Create a configure-time dependency on cmake.toml to improve IDE support
 	configure_file(cmake.toml cmake.toml COPYONLY)
 endif()
 
@@ -25,7 +22,7 @@ project(cmkr
 	LANGUAGES
 		CXX
 	VERSION
-		0.2.15
+		0.2.19
 	DESCRIPTION
 		"CMakeLists generator from TOML"
 )
@@ -33,7 +30,7 @@ project(cmkr
 include("cmake/generate_documentation.cmake")
 include("cmake/generate_resources.cmake")
 
-# third_party
+# Subdirectory: third_party
 set(CMKR_CMAKE_FOLDER ${CMAKE_FOLDER})
 if(CMAKE_FOLDER)
 	set(CMAKE_FOLDER "${CMAKE_FOLDER}/third_party")
@@ -43,7 +40,7 @@ endif()
 add_subdirectory(third_party)
 set(CMAKE_FOLDER ${CMKR_CMAKE_FOLDER})
 
-# tests
+# Subdirectory: tests
 set(CMKR_CMAKE_FOLDER ${CMAKE_FOLDER})
 if(CMAKE_FOLDER)
 	set(CMAKE_FOLDER "${CMAKE_FOLDER}/tests")
@@ -53,29 +50,14 @@ endif()
 add_subdirectory(tests)
 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})
+# Target: cmkr_generate_documentation
 add_library(cmkr_generate_documentation INTERFACE)
 
-if(cmkr_generate_documentation_SOURCES)
-	target_sources(cmkr_generate_documentation INTERFACE ${cmkr_generate_documentation_SOURCES})
-endif()
-
+set(CMKR_TARGET cmkr_generate_documentation)
 generate_documentation()
 
-unset(CMKR_TARGET)
-unset(CMKR_SOURCES)
-
-# Target cmkr
-set(CMKR_TARGET cmkr)
-set(cmkr_SOURCES "")
-
-list(APPEND cmkr_SOURCES
+# Target: cmkr
+set(cmkr_SOURCES
 	"src/arguments.cpp"
 	"src/build.cpp"
 	"src/cmake_generator.cpp"
@@ -93,24 +75,12 @@ list(APPEND cmkr_SOURCES
 	"include/project_parser.hpp"
 	"cmake/cmkr.cmake"
 	"cmake/version.hpp.in"
-)
-
-list(APPEND cmkr_SOURCES
 	cmake.toml
 )
 
-set(CMKR_SOURCES ${cmkr_SOURCES})
 add_executable(cmkr)
 
-if(cmkr_SOURCES)
-	target_sources(cmkr PRIVATE ${cmkr_SOURCES})
-endif()
-
-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 cmkr)
-endif()
-
+target_sources(cmkr PRIVATE ${cmkr_SOURCES})
 source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${cmkr_SOURCES})
 
 target_compile_features(cmkr PRIVATE
@@ -129,10 +99,13 @@ target_link_libraries(cmkr PRIVATE
 	nlohmann_json
 )
 
-generate_resources(${CMKR_TARGET})
+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 cmkr)
+endif()
 
-unset(CMKR_TARGET)
-unset(CMKR_SOURCES)
+set(CMKR_TARGET cmkr)
+generate_resources(${CMKR_TARGET})
 
 install(
 	TARGETS

README.md

@@ -13,27 +13,29 @@ type = "executable"
 sources = ["src/main.cpp"]
 ```
 
-`cmkr` can bootstrap itself from CMake and you only need CMake to use it.
+`cmkr` can bootstrap itself and you only need CMake and a C++ compiler to use it.
 
 ## Getting started
 
-To get started run the following commands from your project directory:
+To get started, run the following commands from your project directory:
 
 ```sh
 curl https://raw.githubusercontent.com/build-cpp/cmkr/main/cmake/cmkr.cmake -o cmkr.cmake
 cmake -P cmkr.cmake
 ```
 
-After the bootstrapping process finishes, modify [`cmake.toml`](https://build-cpp.github.io/cmkr/cmake-toml) and open the project in your favorite IDE or build with CMake:
+After the bootstrapping process finishes, customize [`cmake.toml`](https://build-cpp.github.io/cmkr/cmake-toml) for your project and run CMake:
 
 ```sh
 cmake -B build
 cmake --build build
 ```
 
-Once bootstrapped, `cmkr` does not introduce extra steps to your workflow. After modifying `cmake.toml` you simply build/configure your CMake project and `cmkr` will automatically regenerate `CMakeLists.txt`.
+Once bootstrapped, `cmkr` does not introduce extra steps to your workflow. After modifying `cmake.toml` you simply build/configure your CMake project and `cmkr` will automatically regenerate `CMakeLists.txt` when necessary.
 
-In CI settings the `cmkr` bootstrapping process is skipped so there is no extra configure-time overhead in your pipelines.
+<sub>**Note**: The `cmake.toml` project file, generated `CMakeLists.txt` and `cmkr.cmake` bootstrapping script are all intended to be added to source control.</sub>
+
+In CI environments the `cmkr` bootstrapping process is skipped, so there is no additional overhead in your pipelines.
 
 ## Template repositories
 
@@ -53,10 +55,10 @@ Optionally you can put a [`cmkr` release](https://github.com/build-cpp/cmkr/rele
 ```
 Usage: cmkr [arguments]
 arguments:
-    init    [executable|library|shared|static|interface] Starts a new project in the same directory.
+    init    [executable|library|shared|static|interface] Create a project.
     gen                                                  Generates CMakeLists.txt file.
     build   <extra cmake args>                           Run cmake and build.
-    install                                              Run cmake --install. Needs admin privileges.
+    install                                              Run cmake --install.
     clean                                                Clean the build directory.
     help                                                 Show help.
     version                                              Current cmkr version.
@@ -64,10 +66,10 @@ arguments:
 
 ## Credits
 
-- https://github.com/gulrak/filesystem
-- https://github.com/Tessil/ordered-map
-- https://github.com/ToruNiina/toml11
-- https://github.com/mpark/variant
-- https://www.svgrepo.com/svg/192268/hammer
-- https://github.com/can1357 for buying `cmkr.build` ❤️
-- https://github.com/JustasMasiulis for fixing the dark theme ❤️
+- [gulrak/filesystem](https://github.com/gulrak/filesystem)
+- [Tessil/ordered-map](https://github.com/Tessil/ordered-map)
+- [ToruNiina/toml11](https://github.com/ToruNiina/toml11)
+- [mpark/variant](https://github.com/mpark/variant)
+- [SVG Repo Hammer](https://www.svgrepo.com/svg/192268/hammer)
+- [can1357](https://github.com/can1357) for buying `cmkr.build` ❤️
+- [JustasMasiulis](https://github.com/JustasMasiulis) for fixing the dark theme ❤️

cmake.toml

@@ -4,14 +4,14 @@ cmkr-include = false
 
 [project]
 name = "cmkr"
-version = "0.2.15"
+version = "0.2.19"
 description = "CMakeLists generator from TOML"
 languages = ["CXX"]
-subdirs = ["third_party", "tests"]
 include-after = [
     "cmake/generate_documentation.cmake",
     "cmake/generate_resources.cmake"
 ]
+subdirs = ["third_party", "tests"]
 
 [target.cmkr_generate_documentation]
 type = "interface"

cmake/cmkr.cmake

@@ -2,7 +2,7 @@ include_guard()
 
 # Change these defaults to point to your infrastructure if desired
 set(CMKR_REPO "https://github.com/build-cpp/cmkr" CACHE STRING "cmkr git repository" FORCE)
-set(CMKR_TAG "v0.2.15" CACHE STRING "cmkr git tag (this needs to be available forever)" FORCE)
+set(CMKR_TAG "v0.2.19" CACHE STRING "cmkr git tag (this needs to be available forever)" FORCE)
 set(CMKR_COMMIT_HASH "" CACHE STRING "cmkr git commit hash (optional)" FORCE)
 
 # To bootstrap/generate a cmkr project: cmake -P cmkr.cmake

docs/_config.yml

@@ -21,4 +21,22 @@ gh_edit_branch: "main"
 gh_edit_view_mode: "edit"
 gh_edit_source: docs
 
-production_url : https://cmkr.build
+ga_tracking: G-DY172KY7Z9
+
+production_url : https://cmkr.build
+footer_content: |
+  <script src="https://giscus.app/client.js"
+          data-repo="build-cpp/cmkr"
+          data-repo-id="MDEwOlJlcG9zaXRvcnkyOTQwMDc3MzY="
+          data-category="Documentation"
+          data-category-id="DIC_kwDOEYYzuM4CTXeA"
+          data-mapping="pathname"
+          data-strict="1"
+          data-reactions-enabled="1"
+          data-emit-metadata="0"
+          data-input-position="top"
+          data-theme="preferred_color_scheme"
+          data-lang="en"
+          crossorigin="anonymous"
+          async>
+  </script>

docs/basics.md

@@ -0,0 +1,76 @@
+---
+layout: page
+title: Basics
+nav_order: 1
+---
+
+# Basics
+
+To effectively use cmkr it helps to understand the basic concepts of CMake.
+
+## Projects
+
+A CMake **project** is a collection of targets. In the context of libraries the project usually corresponds to the **package** that other projects can depend on.
+
+<sub>Visual Studio: a CMake **project** corresponds to a _solution_.</sub>
+
+## Targets
+
+The basic unit of CMake is called a **target**. A target (also referred to as [binary target](https://cmake.org/cmake/help/latest/manual/cmake-buildsystem.7.html#binary-targets) in the CMake documentation) corresponds to an executable or library you can build. There are also [pseudo targets](https://cmake.org/cmake/help/latest/manual/cmake-buildsystem.7.html#pseudo-targets), but we ignore them for now.
+
+<sub>Visual Studio: a **target** corresponds to a _project_.</sub>
+
+## Target Properties
+
+Targets have a collection of **properties** that describe how to build them.
+
+Examples of properties:
+
+- _Sources_: the `*.cpp` files used to build the target.
+- _Compile options_: Command line flags for the compiler.
+- _Link libraries_: The **dependencies** required to build this target.
+
+<sub>See the [CMake documentation](https://cmake.org/cmake/help/latest/manual/cmake-properties.7.html#properties-on-targets) for an exhaustive list of target properties.</sub>
+
+**Important**: The term **link** has a slightly different meaning in CMake than you might expect. In addition to adding a library to the command line of the linker, CMake also propagates properties of the target you link to.
+
+<sub>You can think of **linking** as _depending on_.</sub>
+
+The propagation of properties depends on their **visibility**:
+
+- **Private**: properties that are only used when building the target itself.
+- **Interface**: properties that are used when depending on this target.
+- **Public**: combination of private and interface.
+
+In practice you default to **private**, unless consumers of your library _require_ the property to build their target. In that case you use **public**.
+
+### Example
+
+The most intuitive example is with _include directories_. Imagine there are two targets:
+
+1. `StringUtils`: A library with string utilities.
+   - _Sources_: `StringUtils/src/stringutils.cpp`
+   - _Include directories_: `StringUtils/include`
+2. `DataProcessor`: An executable that uses functionality from `StringUtils` to process some data.
+   - _Sources_: `DataProcessor/src/main.cpp`
+   - _Link libraries_: `StringUtils`
+
+The _include directories_ property of `StringUtils` has to be **public**. If it was **private**, the `DataProcessor` target would fail to `#include <stringutils.hpp>` since the _include directories_ property is not propagated.
+
+The `cmake.toml` for this example would look something like this:
+
+```toml
+[project]
+name = "DataProcessor"
+
+[target.StringUtils]
+type = "static"
+sources = ["StringUtils/src/stringutils.cpp"]
+headers = ["StringUtils/include/stringutils.hpp"]
+include-directories = ["StringUtils/include"]
+
+[target.DataProcessor]
+type = "executable"
+sources = ["DataProcessor/src/main.cpp"]
+link-libraries = ["StringUtils"]
+```

docs/cmake-toml.md

@@ -2,14 +2,15 @@
 layout: page
 title: Reference
 permalink: /cmake-toml/
-nav_order: 1
+nav_order: 3
 ---
 
 # Reference
 
 This page is a reference for the options in the `cmake.toml` file. If you think anything is missing or unclear, please [edit this page](https://github.com/build-cpp/cmkr/edit/main/docs/cmake-toml.md) or open an [issue](https://github.com/build-cpp/cmkr/issues).
 
-See the [examples](/examples) section for concrete examples.
+This is a reference page. Check out the [examples](/examples) and the [cmkr topic](https://github.com/topics/cmkr) as well.
+{:.info}
 
 ## CMake configuration
 
@@ -44,8 +45,8 @@ You can specify your own conditions and use them in any `condition` field:
 
 ```toml
 [conditions]
-arch64 = "CMAKE_SIZEOF_VOID_P EQUALS 8"
-arch32 = "CMAKE_SIZEOF_VOID_P EQUALS 4"
+arch64 = "CMAKE_SIZEOF_VOID_P EQUAL 8"
+arch32 = "CMAKE_SIZEOF_VOID_P EQUAL 4"
 ```
 
 This will make the `arch64` and `arch32` conditions available with their respective CMake expressions. 
@@ -71,7 +72,7 @@ unix = "UNIX"
 bsd = "CMAKE_SYSTEM_NAME MATCHES \"BSD\""
 linux = "CMAKE_SYSTEM_NAME MATCHES \"Linux\""
 gcc = "CMAKE_CXX_COMPILER_ID STREQUAL \"GNU\" OR CMAKE_C_COMPILER_ID STREQUAL \"GNU\""
-clang = "CMAKE_CXX_COMPILER_ID MATCHES \"Clang\" OR CMAKE_C_COMPILER_ID MATCHES \"Clang\""
+clang = "(CMAKE_CXX_COMPILER_ID MATCHES \"Clang\" AND NOT CMAKE_CXX_COMPILER_FRONTEND_VARIANT MATCHES \"^MSVC$\") OR (CMAKE_C_COMPILER_ID MATCHES \"Clang\" AND NOT CMAKE_C_COMPILER_FRONTEND_VARIANT MATCHES \"^MSVC$\")"
 msvc = "MSVC"
 root = "CMKR_ROOT_PROJECT"
 x64 = "CMAKE_SIZEOF_VOID_P EQUAL 8"
@@ -93,6 +94,26 @@ include-before = ["cmake/before-subdir.cmake"]
 include-after = ["cmake/after-subdir.cmake"]
 ```
 
+## Options
+
+```toml
+[options]
+MYPROJECT_BUILD_TESTS = false
+MYPROJECT_SPECIAL_OPTION = { value = true, help = "Docstring for this option." }
+```
+
+Options correspond to [CMake cache variables](https://cmake.org/cmake/help/book/mastering-cmake/chapter/CMake%20Cache.html) that can be used to customize your project at configure-time. You can configure with `cmake -DMYPROJECT_BUILD_TESTS=ON` to enable the option. Every options automatically gets a corresponding [condition](#conditions).
+
+## Variables
+
+```toml
+[variables]
+MYBOOL = true
+MYSTRING = "hello"
+```
+
+Variables emit a [`set`](https://cmake.org/cmake/help/latest/command/set.html) and can be used to configure subprojects and packages.
+
 ## Vcpkg
 
 ```toml
@@ -126,6 +147,7 @@ components = ["mycomponent"]
 condition = "mycondition"
 git = "https://github.com/myuser/gitcontent"
 tag = "v0.1"
+shallow = false
 
 [fetch-content.svncontent]
 condition = "mycondition"
@@ -135,7 +157,10 @@ rev = "svn_rev"
 [fetch-content.urlcontent]
 condition = "mycondition"
 url = "https://content-host.com/urlcontent.zip"
-hash = "123123123123"
+# These are equivalent, supported algorithms:
+# md5, sha1, sha224, sha256, sha384, sha512, sha3_224, sha3_256, sha3_384, sha3_512
+hash = "SHA1 502a4e25b8b209889c99c7fa0732102682c2e4ff"
+sha1 = "502a4e25b8b209889c99c7fa0732102682c2e4ff"
 ```
 
 ## Targets

docs/examples/vcpkg.md

@@ -19,7 +19,7 @@ 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"
+version = "2022.11.14"
 packages = ["fmt"]
 
 [find-package]

docs/index.md

@@ -1,12 +1,12 @@
 ---
 layout: home
-title: Index
+title: Documentation
 nav_order: 0
 ---
 
-# Index
+# Documentation
 
-`cmkr`, pronounced "cmaker", is a modern build system based on [CMake](https://cmake.org/) and [TOML](https://toml.io).
+[`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).
 
 `cmkr` parses `cmake.toml` files and generates a modern, idiomatic `CMakeLists.txt` for you. A minimal example:
 
@@ -19,27 +19,29 @@ type = "executable"
 sources = ["src/main.cpp"]
 ```
 
-`cmkr` can bootstrap itself from CMake and you only need CMake to use it.
+`cmkr` can bootstrap itself, and you only need CMake and a C++ compiler to use it.
 
 ## Getting started
 
-To get started run the following commands from your project directory:
+To get started, run the following commands from your project directory:
 
 ```sh
 curl https://raw.githubusercontent.com/build-cpp/cmkr/main/cmake/cmkr.cmake -o cmkr.cmake
 cmake -P cmkr.cmake
 ```
 
-After the bootstrapping process finishes, modify [`cmake.toml`](https://build-cpp.github.io/cmkr/cmake-toml) and open the project in your favorite IDE or build with CMake:
+After the bootstrapping process finishes, customize [`cmake.toml`](./cmake-toml) for your project and run CMake:
 
 ```sh
 cmake -B build
 cmake --build build
 ```
 
-Once bootstrapped, `cmkr` does not introduce extra steps to your workflow. After modifying `cmake.toml` you simply build/configure your CMake project and `cmkr` will automatically regenerate `CMakeLists.txt`.
+Once bootstrapped, `cmkr` does not introduce extra steps to your workflow. After modifying `cmake.toml` you simply build/configure your CMake project and `cmkr` will automatically regenerate `CMakeLists.txt` when necessary.
 
-In CI settings the `cmkr` bootstrapping process is skipped so there is no extra configure-time overhead in your pipelines.
+<sub>**Note**: The `cmake.toml` project file, generated `CMakeLists.txt` and `cmkr.cmake` bootstrapping script are all intended to be added to source control.</sub>
+
+In CI environments the `cmkr` bootstrapping process is skipped, so there is no additional overhead in your pipelines.
 
 ## Template repositories
 
@@ -59,10 +61,10 @@ Optionally you can put a [`cmkr` release](https://github.com/build-cpp/cmkr/rele
 ```
 Usage: cmkr [arguments]
 arguments:
-    init    [executable|library|shared|static|interface] Starts a new project in the same directory.
+    init    [executable|library|shared|static|interface] Create a project.
     gen                                                  Generates CMakeLists.txt file.
     build   <extra cmake args>                           Run cmake and build.
-    install                                              Run cmake --install. Needs admin privileges.
+    install                                              Run cmake --install.
     clean                                                Clean the build directory.
     help                                                 Show help.
     version                                              Current cmkr version.
@@ -70,8 +72,10 @@ arguments:
 
 ## Credits
 
-- https://github.com/gulrak/filesystem
-- https://github.com/Tessil/ordered-map
-- https://github.com/ToruNiina/toml11
-- https://github.com/mpark/variant
-- https://www.svgrepo.com/svg/192268/hammer
+- [gulrak/filesystem](https://github.com/gulrak/filesystem)
+- [Tessil/ordered-map](https://github.com/Tessil/ordered-map)
+- [ToruNiina/toml11](https://github.com/ToruNiina/toml11)
+- [mpark/variant](https://github.com/mpark/variant)
+- [SVG Repo Hammer](https://www.svgrepo.com/svg/192268/hammer)
+- [can1357](https://github.com/can1357) for buying `cmkr.build` ❤️
+- [JustasMasiulis](https://github.com/JustasMasiulis) for fixing the dark theme ❤️

docs/philosophy.md

@@ -0,0 +1,83 @@
+---
+layout: page
+title: Philosophy
+nav_order: 2
+published: false
+---
+
+# Philosophy
+
+## Problem statement
+
+Similar to writing good C++, writing good CMake is difficult. The main difference is that nobody actually wants to learn CMake. The build system is something that should "just work".
+
+There have been many attempts at creating new build systems (with varying levels of success). Naturally this causes [competing standards](https://xkcd.com/927/), which is undesirable. CMake is pretty much the de facto standard, and it has seen extensive use in complex software projects.
+
+One of the main issues of CMake is the turing-complete scripting language you use to describe your projects. As your project gets more complex this can be very helpful, but it also unnecessarily complicates simple projects. There have been discussions about a declarative language on the [CMake issue tracker](https://gitlab.kitware.com/cmake/cmake/-/issues/19891) to solve this problem, but it looks like a "LISP-like" language is seriously being considered...
+
+## The solution
+
+The way cmkr (pronounced "cmaker") solves this problem is by using [TOML](https://toml.io/). Below is a minimal `cmake.toml` project:
+
+```toml
+[project]
+name = "cmkr_for_beginners"
+
+[target.hello_world]
+type = "executable"
+sources = ["src/main.cpp"]
+```
+
+The key difference between `cmkr` and other build systems is that it _generates_ CMake. This means that your projects are fully compatible with the CMake ecosystem, and you can try it out without having to rewrite your whole build system.
+
+TODO: link/include more examples? Talk about conditions, packaging (missing)
+
+### Another layer?!
+
+A common issue people have with cmkr is that it introduces an additional layer of indirection to your build system. CMake is already a meta-buildsystem, which means you could call cmkr a "meta-meta-buildsystem".
+
+Presumably the reason for this friction is that additional layers of abstraction introduce additional complexity. Because of this cmkr has been designed to be completely seamless:
+
+- The user doesn't have to install any additional software to use cmkr. All you need is a semi-recent version of CMake and a C++ compiler.
+- Modifying `cmake.toml` automatically triggers a regeneration of `CMakeLists.txt`. There is no change to your build process.
+- The `CMakeLists.txt` is generated to be human-readable. This means you can easily "eject" from cmkr and go back to CMake.
+
+An additional argument for cmkr is that anecdotally people say it "just works". Because of its simplicity it's also easy to teach, even to people without programming experience.
+
+There is also precedent in the JavaScript community. Bundlers and translators are the norm there and their developer experience is miles ahead of C++.
+
+<sub>Not to say the JavaScript ecosystem is without its flaws, but generators does not appear to be one of them</sub>
+
+### Unsupported features
+
+Because cmkr is still in early in development there are many missing/unfinished features. It was decided that users can bridge the gap by including CMake at arbitrary locations.
+
+This has the advantage that it forces complexity in the build system to be self-contained and modular, a problem all too common in projects as they age.
+
+## Enterprise
+
+Words like "bootstrapping" and "generating code" might worry engineers working in an enterprise environment, and rightly so. From the beginning it has been a priority to make cmkr suitable for use in big corporations with strict protocols for security and reproducibility.
+
+### No additional dependencies
+
+As mentioned above, the only thing you need is a working C++ compiler and a semi-recent version of CMake. It is assumed that you are already building (and executing) C++ projects on your servers, so cmkr does not introduce additional requirements.
+
+All the logic for downloading and compiling the `cmkr` executable is self-contained in a ~250 line `cmkr.cmake` script. You can easily audit it and see if it's up to your standards.
+
+### Reproducibility
+
+Per default the `cmkr.cmake` bootstrapping script contains the exact version of cmkr used to generate your project. As long as the cmkr repository is available you will build the exact same version of cmkr, which will generate the exact same `CMakeLists.txt` file.
+
+This also means that cmkr can decide to break backwards compatibility without affecting legacy projects. An effort will always be made to maintain backwards compatibility though.
+
+### Integrity
+
+As an additional safeguard you can modify `cmkr.cmake` to pin the version tag to a commit hash. This hash is checked to ensure the integrity of the upstream repository.
+
+### Availability
+
+You can easily point `cmkr.cmake` to a mirror of the cmkr repository to ensure availability should something catastrophic happen.
+
+### Not executed in CI
+
+The final (and key) feature is that the bootstrapping process is never executed in CI environments. This means `cmkr` is only ever executed on your developer's machines and not on your infrastructure.

docs/run-locally.sh

@@ -1,2 +0,0 @@
-bundle exec just-the-docs rake search:init
-bundle exec jekyll serve --livereload

docs/serve.sh

@@ -1,2 +1,2 @@
 bundle install
-bundle exec jekyll serve --force_polling --livereload --incremental
+bundle exec jekyll serve --force_polling --livereload --incremental

include/arguments.hpp

@@ -7,5 +7,3 @@ const char *handle_args(int argc, char **argv);
 
 } // namespace args
 } // namespace cmkr
-
-const char *cmkr_args_handle_args(int, char **);

include/project_parser.hpp

@@ -3,6 +3,7 @@
 #include <mpark/variant.hpp>
 #include <string>
 #include <tsl/ordered_map.h>
+#include <tsl/ordered_set.h>
 #include <vector>
 
 namespace cmkr {
@@ -13,18 +14,18 @@ using Condition = tsl::ordered_map<std::string, T>;
 
 using ConditionVector = Condition<std::vector<std::string>>;
 
-struct Setting {
+struct Variable {
     std::string name;
-    std::string comment;
-    mpark::variant<bool, std::string> val;
+    std::string help;
+    mpark::variant<bool, std::string> value;
     bool cache = false;
     bool force = false;
 };
 
 struct Option {
     std::string name;
-    std::string comment;
-    bool val = false;
+    std::string help;
+    bool value = false;
 };
 
 struct Package {
@@ -179,12 +180,13 @@ struct Project {
     std::string project_version;
     std::string project_description;
     std::vector<std::string> project_languages;
+    bool project_allow_unknown_languages = false;
     MsvcRuntimeType project_msvc_runtime = msvc_last;
     Condition<std::string> cmake_before;
     Condition<std::string> cmake_after;
     ConditionVector include_before;
     ConditionVector include_after;
-    std::vector<Setting> settings;
+    std::vector<Variable> variables;
     std::vector<Option> options;
     std::vector<Package> packages;
     Vcpkg vcpkg;
@@ -198,6 +200,7 @@ struct Project {
 
     Project(const Project *parent, const std::string &path, bool build);
     const Project *root() const;
+    bool cmake_minimum_version(int major, int minor) const;
 };
 
 bool is_root_path(const std::string &path);

src/arguments.cpp

@@ -37,17 +37,17 @@ const char *handle_args(int argc, char **argv) {
     } else if (main_arg == "build") {
         auto ret = build::run(argc, argv);
         if (ret)
-            return "CMake build error!";
+            throw std::runtime_error("CMake build failed!");
         return "CMake build completed!";
     } else if (main_arg == "install") {
         auto ret = build::install();
         if (ret)
-            return "CMake install error!";
+            throw std::runtime_error("CMake install failed!");
         return "CMake install completed!";
     } else if (main_arg == "clean") {
         auto ret = build::clean();
         if (ret)
-            return "CMake clean error!";
+            throw std::runtime_error("CMake clean failed!");
         return "Cleaned build directory!";
     } else {
         throw std::runtime_error(cmkr::help::message());
@@ -55,13 +55,3 @@ const char *handle_args(int argc, char **argv) {
 }
 } // namespace args
 } // namespace cmkr
-
-const char *cmkr_args_handle_args(int argc, char **argv) {
-    try {
-        return cmkr::args::handle_args(argc, argv);
-    } catch (const std::exception &e) {
-        return e.what();
-    } catch (...) {
-        return "Unknown error!";
-    }
-}

src/cmake_generator.cpp

@@ -4,6 +4,7 @@
 #include <resources/cmkr.hpp>
 
 #include "fs.hpp"
+#include "project_parser.hpp"
 #include <cstdio>
 #include <fstream>
 #include <memory>
@@ -13,6 +14,35 @@
 namespace cmkr {
 namespace gen {
 
+/*
+Location: CMake/share/cmake-3.26/Modules
+rg "set\(CMAKE_(.+)_SOURCE_FILE_EXTENSIONS"
+
+Links:
+- https://gitlab.kitware.com/cmake/cmake/-/issues/24340
+- https://cmake.org/cmake/help/latest/command/enable_language.html
+*/
+
+static tsl::ordered_map<std::string, std::vector<std::string>> known_languages = {
+    {"ASM", {".s", ".S", ".asm", ".abs", ".msa", ".s90", ".s43", ".s85", ".s51"}},
+    {"ASM-ATT", {".s", ".asm"}},
+    {"ASM_MARMASM", {".asm"}},
+    {"ASM_MASM", {".asm"}},
+    {"ASM_NASM", {".nasm", ".asm"}},
+    {"C", {".c", ".m"}},
+    {"CSharp", {".cs"}},
+    {"CUDA", {".cu"}},
+    {"CXX", {".C", ".M", ".c++", ".cc", ".cpp", ".cxx", ".m", ".mm", ".mpp", ".CPP", ".ixx", ".cppm"}},
+    {"Fortran", {".f", ".F", ".fpp", ".FPP", ".f77", ".F77", ".f90", ".F90", ".for", ".For", ".FOR", ".f95", ".F95", ".cuf", ".CUF"}},
+    {"HIP", {".hip"}},
+    {"ISPC", {".ispc"}},
+    {"Java", {".java"}},
+    {"OBJC", {".m"}},
+    {"OBJCXX", {".M", ".m", ".mm"}},
+    {"RC", {".rc", ".RC"}},
+    {"Swift", {".swift"}},
+};
+
 static std::string format(const char *format, tsl::ordered_map<std::string, std::string> variables) {
     std::string s = format;
     for (const auto &itr : variables) {
@@ -25,7 +55,7 @@ static std::string format(const char *format, tsl::ordered_map<std::string, std:
     return s;
 }
 
-static std::vector<std::string> expand_cmake_path(const fs::path &name, const fs::path &toml_dir, bool root_project) {
+static std::vector<std::string> expand_cmake_path(const fs::path &name, const fs::path &toml_dir, bool is_root_project) {
     std::vector<std::string> temp;
 
     auto extract_suffix = [](const fs::path &base, const fs::path &full) {
@@ -38,7 +68,7 @@ static std::vector<std::string> expand_cmake_path(const fs::path &name, const fs
     auto stem = name.filename().stem().string();
     auto ext = name.extension();
 
-    if (root_project && stem == "**" && name == name.filename()) {
+    if (is_root_project && stem == "**" && name == name.filename()) {
         throw std::runtime_error("Recursive globbing not allowed in project root: " + name.string());
     }
 
@@ -66,11 +96,11 @@ static std::vector<std::string> expand_cmake_path(const fs::path &name, const fs
     return temp;
 }
 
-static std::vector<std::string> expand_cmake_paths(const std::vector<std::string> &sources, const fs::path &toml_dir, bool root_project) {
+static std::vector<std::string> expand_cmake_paths(const std::vector<std::string> &sources, const fs::path &toml_dir, bool is_root_project) {
     // TODO: add duplicate checking
     std::vector<std::string> result;
     for (const auto &src : sources) {
-        auto expanded = expand_cmake_path(src, toml_dir, root_project);
+        auto expanded = expand_cmake_path(src, toml_dir, is_root_project);
         for (const auto &f : expanded) {
             result.push_back(f);
         }
@@ -416,9 +446,10 @@ struct Generator {
                 }
 
                 if (!condition.empty()) {
-                    cmd("endif")();
+                    cmd("endif")().endl();
+                } else if (!itr.second.empty()) {
+                    endl();
                 }
-                endl();
             }
         }
     }
@@ -505,9 +536,20 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
     }
 
     // Root project doesn't have a parent
-    auto root_project = parent_project == nullptr;
+    auto is_root_project = parent_project == nullptr;
 
     parser::Project project(parent_project, path, false);
+
+    for (auto const &lang : project.project_languages) {
+        if (known_languages.find(lang) == known_languages.end()) {
+            if (project.project_allow_unknown_languages) {
+                printf("Unknown language '%s' specified\n", lang.c_str());
+            } else {
+                throw std::runtime_error("Unknown language '" + lang + "' specified");
+            }
+        }
+    }
+
     Generator gen(project);
 
     // Helper lambdas for more convenient CMake generation
@@ -521,12 +563,24 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
     comment("See " + cmkr_url + " for more information");
     endl();
 
-    if (root_project) {
+    if (is_root_project) {
         cmd("cmake_minimum_required")("VERSION", project.cmake_version).endl();
 
         if (project.project_msvc_runtime != parser::msvc_last) {
             comment("Enable support for MSVC_RUNTIME_LIBRARY");
-            cmd("cmake_policy")("SET", "CMP0091", "NEW").endl();
+            cmd("cmake_policy")("SET", "CMP0091", "NEW");
+
+            switch (project.project_msvc_runtime) {
+            case parser::msvc_dynamic:
+                cmd("set")("CMAKE_MSVC_RUNTIME_LIBRARY", "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL");
+                break;
+            case parser::msvc_static:
+                cmd("set")("CMAKE_MSVC_RUNTIME_LIBRARY", "MultiThreaded$<$<CONFIG:Debug>:Debug>");
+                break;
+            default:
+                break;
+            }
+            endl();
         }
 
         // clang-format on
@@ -538,14 +592,13 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
             // clang-format on
         }
 
-        comment("Regenerate CMakeLists.txt automatically in the root project");
         cmd("set")("CMKR_ROOT_PROJECT", "OFF");
         // clang-format off
         cmd("if")("CMAKE_CURRENT_SOURCE_DIR", "STREQUAL", "CMAKE_SOURCE_DIR");
             cmd("set")("CMKR_ROOT_PROJECT", "ON").endl();
 
             if (!project.cmkr_include.empty()) {
-                comment("Bootstrap cmkr");
+                comment("Bootstrap cmkr and automatically regenerate CMakeLists.txt");
                 cmd("include")(project.cmkr_include, "OPTIONAL", "RESULT_VARIABLE", "CMKR_INCLUDE_RESULT");
                 cmd("if")("CMKR_INCLUDE_RESULT");
                     cmd("cmkr")();
@@ -553,7 +606,10 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
             }
 
             comment("Enable folder support");
-            cmd("set_property")("GLOBAL", "PROPERTY", "USE_FOLDERS", "ON");
+            cmd("set_property")("GLOBAL", "PROPERTY", "USE_FOLDERS", "ON").endl();
+
+            comment("Create a configure-time dependency on cmake.toml to improve IDE support");
+            cmd("configure_file")("cmake.toml", "cmake.toml", "COPYONLY");
         cmd("endif")().endl();
         // clang-format on
 
@@ -561,15 +617,15 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
         if (!project.cmkr_include.empty() && !fs::exists(cmkr_include) && cmkr_include.is_relative()) {
             create_file(cmkr_include, resources::cmkr);
         }
+    } else {
+        // clang-format off
+        comment("Create a configure-time dependency on cmake.toml to improve IDE support");
+        cmd("if")("CMKR_ROOT_PROJECT");
+            cmd("configure_file")("cmake.toml", "cmake.toml", "COPYONLY");
+        cmd("endif")().endl();
+        // clang-format on
     }
 
-    // clang-format off
-    comment("Create a configure-time dependency on cmake.toml to improve IDE support");
-    cmd("if")("CMKR_ROOT_PROJECT");
-        cmd("configure_file")("cmake.toml", "cmake.toml", "COPYONLY");
-    cmd("endif")().endl();
-    // clang-format on
-
     // TODO: remove support and replace with global compile-features
     if (!project.cppflags.empty()) {
         ss << "set(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} \"";
@@ -600,25 +656,25 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
     if (!project.options.empty()) {
         comment("Options");
         for (const auto &opt : project.options) {
-            cmd("option")(opt.name, RawArg(Command::quote(opt.comment)), opt.val ? "ON" : "OFF");
+            cmd("option")(opt.name, RawArg(Command::quote(opt.help)), opt.value ? "ON" : "OFF");
         }
         endl();
     }
 
-    if (!project.settings.empty()) {
-        comment("Settings");
-        for (const auto &set : project.settings) {
+    if (!project.variables.empty()) {
+        comment("Variables");
+        for (const auto &set : project.variables) {
             std::string set_val;
-            if (set.val.index() == 1) {
-                set_val = mpark::get<1>(set.val);
+            if (set.value.index() == 1) {
+                set_val = mpark::get<1>(set.value);
             } else {
-                set_val = mpark::get<0>(set.val) ? "ON" : "OFF";
+                set_val = mpark::get<0>(set.value) ? "ON" : "OFF";
             }
 
             if (set.cache) {
-                auto typ = set.val.index() == 1 ? "STRING" : "BOOL";
+                auto typ = set.value.index() == 1 ? "STRING" : "BOOL";
                 auto force = set.force ? "FORCE" : "";
-                cmd("set")(set.name, set_val, typ, set.comment, force);
+                cmd("set")(set.name, set_val, typ, set.help, force);
             } else {
                 cmd("set")(set.name, set_val);
             }
@@ -634,6 +690,13 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
         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();
+
+        for (const auto &language : project.project_languages) {
+            if (language == "CSharp") {
+                cmd("include")("CSharpUtilities").endl();
+                break;
+            }
+        }
     }
 
     gen.conditional_includes(project.include_after);
@@ -777,7 +840,7 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
 
     auto add_subdir = [&](const std::string &dir) {
         // clang-format off
-        comment(dir);
+        comment("Subdirectory: " + dir);
         cmd("set")("CMKR_CMAKE_FOLDER", "${CMAKE_FOLDER}");
         cmd("if")("CMAKE_FOLDER");
             cmd("set")("CMAKE_FOLDER", "${CMAKE_FOLDER}/" + dir);
@@ -787,17 +850,19 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
         // clang-format on
 
         cmd("add_subdirectory")(dir);
-        cmd("set")("CMAKE_FOLDER", "${CMKR_CMAKE_FOLDER}").endl();
+        cmd("set")("CMAKE_FOLDER", "${CMKR_CMAKE_FOLDER}");
     };
 
     // 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);
+            for (size_t i = 0; i < subdirs.size(); i++) {
+                add_subdir(subdirs[i]);
+                if (i + 1 < subdirs.size()) {
+                    endl();
+                }
             }
         });
-        endl();
     }
     for (const auto &subdir : project.subdirs) {
         ConditionScope cs(gen, subdir.condition);
@@ -806,23 +871,45 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
         gen.conditional_cmake(subdir.cmake_before);
 
         add_subdir(subdir.name);
+        endl();
 
         gen.conditional_includes(subdir.include_after);
         gen.conditional_cmake(subdir.cmake_after);
     }
 
-    if (!project.targets.empty()) {
-        auto root_project = project.root();
-        for (size_t i = 0; i < project.targets.size(); i++) {
-            if (i > 0) {
-                endl();
-            }
+    // The implicit default is ["C", "CXX"], so make sure this list isn't
+    // empty or projects without languages explicitly defined will error.
+    auto project_languages = project.project_languages;
+    if (project_languages.empty())
+        project_languages = {"C", "CXX"};
 
+    // All acceptable extensions based off our given languages.
+    tsl::ordered_set<std::string> project_extensions;
+    for (const auto &language : project_languages) {
+        auto itr = known_languages.find(language);
+        if (itr != known_languages.end()) {
+            project_extensions.insert(itr->second.begin(), itr->second.end());
+        }
+    }
+
+    auto contains_language_source = [&project_extensions](const std::vector<std::string>& sources) {
+        for (const auto &source : sources) {
+            auto extension = fs::path(source).extension().string();
+            if (project_extensions.count(extension) > 0) {
+                return true;
+            }
+        }
+        return false;
+    };
+
+    if (!project.targets.empty()) {
+        auto project_root = project.root();
+        for (size_t i = 0; i < project.targets.size(); i++) {
             const auto &target = project.targets[i];
             const parser::Template *tmplate = nullptr;
             std::unique_ptr<ConditionScope> tmplate_cs{};
 
-            comment("Target " + target.name);
+            comment("Target: " + target.name);
 
             // Check if this target is using a template.
             if (target.type == parser::target_template) {
@@ -836,56 +923,131 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
 
             ConditionScope cs(gen, target.condition);
 
-            cmd("set")("CMKR_TARGET", target.name);
+            // Detect if there is cmake included before/after the target
+            auto has_include_before = false;
+            auto has_include_after = false;
+            {
+                auto has_include = [](const parser::ConditionVector &includes) {
+                    for (const auto &itr : includes) {
+                        for (const auto &jtr : itr.second) {
+                            return true;
+                        }
+                    }
+                    return false;
+                };
+                auto has_include_helper = [&](const parser::Target &target) {
+                    if (!target.cmake_before.empty() || has_include(target.include_before)) {
+                        has_include_before = true;
+                    }
+                    if (!target.cmake_after.empty() || has_include(target.include_after)) {
+                        has_include_after = true;
+                    }
+                };
+                if (tmplate != nullptr) {
+                    has_include_helper(tmplate->outline);
+                }
+                has_include_helper(target);
+            }
 
+            // Generate the include before
+            if (has_include_before) {
+                cmd("set")("CMKR_TARGET", target.name);
+            }
             if (tmplate != nullptr) {
                 gen.conditional_includes(tmplate->outline.include_before);
                 gen.conditional_cmake(tmplate->outline.cmake_before);
             }
-
             gen.conditional_includes(target.include_before);
             gen.conditional_cmake(target.cmake_before);
 
-            auto sources_var = target.name + "_SOURCES";
+            // Merge the sources from the template and the target. The sources
+            // without condition need to be processed first
+            parser::Condition<tsl::ordered_set<std::string>> msources;
+            msources[""].clear();
 
-            bool added_toml = false;
-            cmd("set")(sources_var, RawArg("\"\"")).endl();
-
-            if (tmplate != nullptr) {
-                gen.handle_condition(tmplate->outline.sources, [&](const std::string &condition, const std::vector<std::string> &condition_sources) {
-                    auto sources = expand_cmake_paths(condition_sources, path, root_project);
-                    if (sources.empty()) {
-                        auto source_key = condition.empty() ? "sources" : (condition + ".sources");
-                        throw std::runtime_error(target.name + " " + source_key + " wildcard found 0 files");
+            auto merge_sources = [&msources](const parser::ConditionVector &sources) {
+                for (const auto &itr : sources) {
+                    auto &source_list = msources[itr.first];
+                    for (const auto &source : itr.second) {
+                        source_list.insert(source);
                     }
-                    cmd("list")("APPEND", sources_var, sources);
-                });
+                }
+            };
+            if (tmplate != nullptr) {
+                merge_sources(tmplate->outline.sources);
+            }
+            merge_sources(target.sources);
+
+            // Improve IDE support
+            if (target.type != parser::target_interface) {
+                msources[""].insert("cmake.toml");
             }
 
-            gen.handle_condition(target.sources, [&](const std::string &condition, const std::vector<std::string> &condition_sources) {
-                auto sources = expand_cmake_paths(condition_sources, path, root_project);
+            // If there are only conditional sources we generate a 'set' to
+            // create an empty source list. The rest is then appended using
+            // 'list(APPEND ...)'
+            auto has_sources = false;
+            for (const auto &itr : msources) {
+                if (!itr.second.empty()) {
+                    has_sources = true;
+                    break;
+                }
+            }
+            auto sources_var = target.name + "_SOURCES";
+            auto sources_with_set = true;
+            if (has_sources && msources[""].empty()) {
+                sources_with_set = false;
+                cmd("set")(sources_var, RawArg("\"\"")).endl();
+            }
+
+            gen.handle_condition(msources, [&](const std::string &condition, const tsl::ordered_set<std::string> &source_set) {
+                std::vector<std::string> condition_sources;
+                condition_sources.reserve(source_set.size());
+                for (const auto &source : source_set) {
+                    condition_sources.push_back(source);
+                }
+                auto sources = expand_cmake_paths(condition_sources, path, is_root_project);
                 if (sources.empty()) {
                     auto source_key = condition.empty() ? "sources" : (condition + ".sources");
                     throw std::runtime_error(target.name + " " + source_key + " wildcard found 0 files");
                 }
-                // Do not add cmake.toml twice
-                if (!added_toml && std::find(sources.begin(), sources.end(), "cmake.toml") != sources.end()) {
-                    added_toml = true;
+
+                // Make sure there are source files for the languages used by the project
+                switch (target.type) {
+                case parser::target_executable:
+                case parser::target_library:
+                case parser::target_shared:
+                case parser::target_static:
+                case parser::target_object:
+                    if (!contains_language_source(sources)) {
+                        throw std::runtime_error("There were no source files linked within the target " + target.name);
+                    }
+                    break;
+                default:
+                    break;
+                }
+
+                if (sources_with_set) {
+                    // This is a sanity check to make sure the unconditional sources are first
+                    if (!condition.empty()) {
+                        throw std::runtime_error("Unreachable code, make sure unconditional sources are first");
+                    }
+                    cmd("set")(sources_var, sources);
+                    sources_with_set = false;
+                } else {
+                    cmd("list")("APPEND", sources_var, sources);
                 }
-                cmd("list")("APPEND", sources_var, sources);
             });
 
             auto target_type = target.type;
 
             if (tmplate != nullptr) {
+                if (target_type != parser::target_template) {
+                    throw std::runtime_error("Unreachable code, unexpected target type for template");
+                }
                 target_type = tmplate->outline.type;
             }
 
-            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 + "}");
-
             std::string add_command;
             std::string target_type_string;
             std::string target_scope;
@@ -941,34 +1103,20 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
                     cmd(add_command)(target.name, target_type_string, "${" + sources_var + "}");
                 } else {
                     cmd(add_command)(target.name, target_type_string).endl();
-
-                    // clang-format off
-                    cmd("if")(sources_var);
-                        cmd("target_sources")(target.name, target_type == parser::target_interface ? "INTERFACE" : "PRIVATE", "${" + sources_var + "}");
-                    cmd("endif")().endl();
-                    // clang-format on
+                    if (has_sources) {
+                        cmd("target_sources")(target.name, target_type == parser::target_interface ? "INTERFACE" : "PRIVATE",
+                                              "${" + sources_var + "}");
+                    }
                 }
             } else {
                 cmd(add_command)(target.name, target_type_string).endl();
-
-                // clang-format off
-                cmd("if")(sources_var);
+                if (has_sources) {
                     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 == 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");
-                    cmd("set_property")("DIRECTORY", "${PROJECT_SOURCE_DIR}", "PROPERTY", "VS_STARTUP_PROJECT", target.name);
-                cmd("endif")().endl();
-                // clang-format on
-            }
-
-            if (!target.sources.empty()) {
+            // TODO: support sources from other directories
+            if (has_sources) {
                 cmd("source_group")("TREE", "${CMAKE_CURRENT_SOURCE_DIR}", "FILES", "${" + sources_var + "}").endl();
             }
 
@@ -1023,7 +1171,7 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
                 gen.handle_condition(props, [&](const std::string &, const tsl::ordered_map<std::string, std::string> &properties) {
                     for (const auto &propItr : properties) {
                         if (propItr.first == "MSVC_RUNTIME_LIBRARY") {
-                            if (root_project->project_msvc_runtime == parser::msvc_last) {
+                            if (project_root->project_msvc_runtime == parser::msvc_last) {
                                 throw std::runtime_error("You cannot set [target].msvc-runtime without setting the root [project].msvc-runtime");
                             }
                         }
@@ -1032,19 +1180,28 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
                 });
             }
 
+            // The first executable target will become the Visual Studio startup project
+            // TODO: this is not working properly
+            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");
+                    cmd("set_property")("DIRECTORY", "${PROJECT_SOURCE_DIR}", "PROPERTY", "VS_STARTUP_PROJECT", target.name);
+                cmd("endif")().endl();
+                // clang-format on
+            }
+
+            // Generate the include after
+            if (!has_include_before && has_include_after) {
+                cmd("set")("CMKR_TARGET", target.name);
+            }
             gen.conditional_includes(target.include_after);
             gen.conditional_cmake(target.cmake_after);
-
             if (tmplate != nullptr) {
                 gen.conditional_includes(tmplate->outline.include_after);
                 gen.conditional_cmake(tmplate->outline.cmake_after);
             }
-
-            cmd("unset")("CMKR_TARGET");
-            cmd("unset")("CMKR_SOURCES");
         }
-
-        endl();
     }
 
     if (!project.tests.empty()) {
@@ -1070,7 +1227,7 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
             auto dirs = std::make_pair("DIRS", inst.dirs);
             std::vector<std::string> files_data;
             if (!inst.files.empty()) {
-                files_data = expand_cmake_paths(inst.files, path, root_project);
+                files_data = expand_cmake_paths(inst.files, path, is_root_project);
                 if (files_data.empty()) {
                     throw std::runtime_error("[[install]] files wildcard did not resolve to any files");
                 }

src/project_parser.cpp

@@ -4,8 +4,6 @@
 #include <deque>
 #include <stdexcept>
 #include <toml.hpp>
-#include <tsl/ordered_map.h>
-#include <tsl/ordered_set.h>
 
 namespace cmkr {
 namespace parser {
@@ -34,14 +32,14 @@ static MsvcRuntimeType parse_msvcRuntimeType(const std::string &name) {
 
 using TomlBasicValue = toml::basic_value<toml::discard_comments, tsl::ordered_map, std::vector>;
 
-static std::string format_key_error(const std::string &error, const toml::key &ky, const TomlBasicValue &value) {
+static std::string format_key_message(const std::string &message, const toml::key &ky, const TomlBasicValue &value) {
     auto loc = value.location();
     auto line_number_str = std::to_string(loc.line());
     auto line_width = line_number_str.length();
     auto line_str = loc.line_str();
 
     std::ostringstream oss;
-    oss << "[error] " << error << '\n';
+    oss << message << "\n";
     oss << " --> " << loc.file_name() << ':' << loc.line() << '\n';
 
     oss << std::string(line_width + 2, ' ') << "|\n";
@@ -59,6 +57,14 @@ static std::string format_key_error(const std::string &error, const toml::key &k
     return oss.str();
 }
 
+static void throw_key_error(const std::string &error, const toml::key &ky, const TomlBasicValue &value) {
+    throw std::runtime_error(format_key_message("[error] " + error, ky, value));
+}
+
+static void print_key_warning(const std::string &message, const toml::key &ky, const TomlBasicValue &value) {
+    puts(format_key_message("[warning] " + message, ky, value).c_str());
+}
+
 class TomlChecker {
     const TomlBasicValue &m_v;
     tsl::ordered_set<toml::key> m_visited;
@@ -135,27 +141,27 @@ class TomlChecker {
             const auto &ky = itr.first;
             if (m_conditionVisited.contains(ky)) {
                 if (!conditions.contains(ky)) {
-                    throw std::runtime_error(format_key_error("Unknown condition '" + ky + "'", ky, itr.second));
+                    throw_key_error("Unknown condition '" + ky + "'", ky, itr.second);
                 }
 
                 for (const auto &jtr : itr.second.as_table()) {
                     if (!m_visited.contains(jtr.first)) {
-                        throw std::runtime_error(format_key_error("Unknown key '" + jtr.first + "'", jtr.first, jtr.second));
+                        throw_key_error("Unknown key '" + jtr.first + "'", jtr.first, jtr.second);
                     }
                 }
             } else if (!m_visited.contains(ky)) {
                 if (itr.second.is_table()) {
                     for (const auto &jtr : itr.second.as_table()) {
                         if (!m_visited.contains(jtr.first)) {
-                            throw std::runtime_error(format_key_error("Unknown key '" + jtr.first + "'", jtr.first, jtr.second));
+                            throw_key_error("Unknown key '" + jtr.first + "'", jtr.first, jtr.second);
                         }
                     }
                 }
-                throw std::runtime_error(format_key_error("Unknown key '" + ky + "'", ky, itr.second));
+                throw_key_error("Unknown key '" + ky + "'", ky, itr.second);
             } else if (ky == "condition") {
                 std::string condition = itr.second.as_string();
                 if (!conditions.contains(condition)) {
-                    throw std::runtime_error(format_key_error("Unknown condition '" + condition + "'", condition, itr.second));
+                    throw_key_error("Unknown condition '" + condition + "'", condition, itr.second);
                 }
             }
         }
@@ -193,7 +199,7 @@ class TomlCheckerRoot {
         if (check_root) {
             for (const auto &itr : m_root.as_table()) {
                 if (!m_visisted.contains(itr.first)) {
-                    throw std::runtime_error(format_key_error("Unknown key '" + itr.first + "'", itr.first, itr.second));
+                    throw_key_error("Unknown key '" + itr.first + "'", itr.first, itr.second);
                 }
             }
         }
@@ -221,7 +227,7 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
         cmake.required("version", cmake_version);
 
         if (cmake.contains("bin-dir")) {
-            throw std::runtime_error("bin-dir has been renamed to build-dir");
+            throw_key_error("bin-dir has been renamed to build-dir", "bin-dir", cmake.find("bin-dir"));
         }
 
         cmake.optional("build-dir", build_dir);
@@ -259,7 +265,8 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
         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["clang"] =
+            R"cmake((CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND NOT CMAKE_CXX_COMPILER_FRONTEND_VARIANT MATCHES "^MSVC$") OR (CMAKE_C_COMPILER_ID MATCHES "Clang" AND NOT CMAKE_C_COMPILER_FRONTEND_VARIANT MATCHES "^MSVC$"))cmake";
         conditions["msvc"] = R"cmake(MSVC)cmake";
         conditions["root"] = R"cmake(CMKR_ROOT_PROJECT)cmake";
         conditions["x64"] = R"cmake(CMAKE_SIZEOF_VOID_P EQUAL 8)cmake";
@@ -282,6 +289,7 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
         project.optional("version", project_version);
         project.optional("description", project_description);
         project.optional("languages", project_languages);
+        project.optional("allow-unknown-languages", project_allow_unknown_languages);
         project.optional("cmake-before", cmake_before);
         project.optional("cmake-after", cmake_after);
         project.optional("include-before", include_before);
@@ -299,7 +307,7 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
                     error += "  - " + type_name + "\n";
                 }
                 error.pop_back(); // Remove last newline
-                throw std::runtime_error(format_key_error(error, msvc_runtime, project.find("msvc-runtime")));
+                throw_key_error(error, msvc_runtime, project.find("msvc-runtime"));
             }
         }
     }
@@ -321,32 +329,42 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
         }
     }
 
-    if (checker.contains("settings")) {
+    if (checker.contains("variables")) {
         using set_map = tsl::ordered_map<std::string, TomlBasicValue>;
-        const auto &sets = toml::find<set_map>(toml, "settings");
-        for (const auto &itr : sets) {
-            Setting s;
+        auto vars = toml::find<set_map>(toml, "variables");
+        if (checker.contains("settings")) {
+            print_key_warning("[settings] has been renamed to [variables]", "settings", toml.at("settings"));
+            const auto &sets = toml::find<set_map>(toml, "settings");
+            for (const auto &itr : sets) {
+                if (!vars.insert(itr).second) {
+                    throw_key_error("Key '" + itr.first + "' shadows existing variable", itr.first, itr.second);
+                }
+            }
+        }
+
+        for (const auto &itr : vars) {
+            Variable s;
             s.name = itr.first;
             const auto &value = itr.second;
             if (value.is_boolean()) {
-                s.val = value.as_boolean();
+                s.value = value.as_boolean();
             } else if (value.is_string()) {
-                s.val = value.as_string();
+                s.value = value.as_string();
             } else {
                 auto &setting = checker.create(value);
-                setting.optional("comment", s.comment);
+                setting.optional("help", s.help);
                 if (setting.contains("value")) {
                     const auto &v = setting.find("value");
                     if (v.is_boolean()) {
-                        s.val = v.as_boolean();
+                        s.value = v.as_boolean();
                     } else {
-                        s.val = v.as_string();
+                        s.value = v.as_string();
                     }
                 }
                 setting.optional("cache", s.cache);
                 setting.optional("force", s.force);
             }
-            settings.push_back(s);
+            variables.push_back(s);
         }
     }
 
@@ -358,13 +376,14 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
             o.name = itr.first;
             const auto &value = itr.second;
             if (value.is_boolean()) {
-                o.val = value.as_boolean();
+                o.value = value.as_boolean();
             } else {
                 auto &option = checker.create(value);
-                option.optional("comment", o.comment);
-                option.optional("value", o.val);
+                option.optional("help", o.help);
+                option.optional("value", o.value);
             }
             options.push_back(o);
+            conditions.emplace(o.name, o.name);
         }
     }
 
@@ -456,7 +475,7 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
                 } else if (is_cmake_arg(key)) {
                     // allow passthrough of ExternalProject options
                 } else if (!c.visisted(key)) {
-                    throw std::runtime_error(format_key_error("Unknown key '" + argItr.first + "'", argItr.first, argItr.second));
+                    throw_key_error("Unknown key '" + argItr.first + "'", argItr.first, argItr.second);
                 }
 
                 // Make sure not to emit keys like "condition" in the FetchContent call
@@ -471,7 +490,7 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
     }
 
     if (checker.contains("bin")) {
-        throw std::runtime_error("[[bin]] has been renamed to [[target]]");
+        throw_key_error("[[bin]] has been renamed to [target.<name>]", "", toml.at("bin"));
     }
 
     auto parse_target = [&](const std::string &name, TomlChecker &t, bool isTemplate) {
@@ -510,7 +529,7 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
                 }
             }
             error.pop_back(); // Remove last newline
-            throw std::runtime_error(format_key_error(error, target.type_name, t.find("type")));
+            throw_key_error(error, target.type_name, t.find("type"));
         }
 
         t.optional("sources", target.sources);
@@ -572,7 +591,7 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
                 } else {
                     report = &t.find(condItr.first).as_table().find("msvc-runtime").value();
                 }
-                throw std::runtime_error(format_key_error(error, condItr.second, *report));
+                throw_key_error(error, condItr.second, *report);
             }
             }
         }
@@ -628,13 +647,13 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
 
             for (const auto &type_name : targetTypeNames) {
                 if (name == type_name) {
-                    throw std::runtime_error(format_key_error("Reserved template name '" + name + "'", name, itr.second));
+                    throw_key_error("Reserved template name '" + name + "'", name, itr.second);
                 }
             }
 
             for (const auto &tmplate : templates) {
                 if (name == tmplate.outline.name) {
-                    throw std::runtime_error(format_key_error("Template '" + name + "' already defined", name, itr.second));
+                    throw_key_error("Template '" + name + "' already defined", name, itr.second);
                 }
             }
 
@@ -643,6 +662,7 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
 
             t.optional("add-function", tmplate.add_function);
             t.optional("pass-sources-to-add-function", tmplate.pass_sources_to_add_function);
+            t.optional("pass-sources", tmplate.pass_sources_to_add_function);
 
             templates.push_back(tmplate);
         }
@@ -709,7 +729,7 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
                     package.features.emplace_back(feature);
                 }
             } else {
-                throw std::runtime_error("Invalid vcpkg package '" + package_str + "'");
+                throw_key_error("Invalid package name '" + package_str + "'", "packages", p);
             }
             vcpkg.packages.emplace_back(std::move(package));
         }
@@ -725,6 +745,26 @@ const Project *Project::root() const {
     return root;
 }
 
+bool Project::cmake_minimum_version(int major, int minor) const {
+    // NOTE: this code is like pulling teeth, sorry
+    auto root_version = root()->cmake_version;
+    puts(root_version.c_str());
+    auto range_index = root_version.find("...");
+    if (range_index != std::string::npos) {
+        root_version.resize(range_index);
+    }
+
+    auto period_index = root_version.find('.');
+    auto root_major = atoi(root_version.substr(0, period_index).c_str());
+    int root_minor = 0;
+    if (period_index != std::string::npos) {
+        auto end_index = root_version.find('.', period_index + 1);
+        root_minor = atoi(root_version.substr(period_index + 1, end_index).c_str());
+    }
+
+    return std::tie(root_major, root_minor) >= std::tie(major, minor);
+}
+
 bool is_root_path(const std::string &path) {
     const auto toml_path = fs::path(path) / "cmake.toml";
     if (!fs::exists(toml_path)) {

tests/interface/src/main.cpp

@@ -4,5 +4,5 @@
 
 int main()
 {
-    printf("mylib version: %s\n", mylib::version())
-}
+    printf("mylib version: %s\n", mylib::version());
+}

tests/vcpkg/cmake.toml

@@ -7,7 +7,7 @@ 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"
+version = "2022.11.14"
 packages = ["fmt"]
 
 [find-package]