Add support for target condition

Implement conditional properties

.github/workflows/build.yml

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

CMakeLists.txt

@@ -32,6 +32,8 @@ project(cmkr
 		"CMakeLists generator from TOML"
 )
 
+include("cmake/generate_documentation.cmake")
+
 # third_party
 set(CMKR_CMAKE_FOLDER ${CMAKE_FOLDER})
 if(CMAKE_FOLDER)
@@ -54,6 +56,22 @@ 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 "")
@@ -108,10 +126,12 @@ target_link_libraries(cmkr PRIVATE
 	ghc_filesystem
 	mpark_variant
 	ordered_map
+	nlohmann_json
 )
 
 unset(CMKR_TARGET)
 unset(CMKR_SOURCES)
+
 install(
 	TARGETS
 		cmkr

README.md

@@ -2,8 +2,6 @@
 
 `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` parses `cmake.toml` files and generates a modern, idiomatic `CMakeLists.txt` for you. A minimal example:
 
 ```toml
@@ -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,4 +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
+- https://www.svgrepo.com/svg/192268/hammer

cmake.toml

@@ -7,13 +7,20 @@ version = "0.1.4"
 description = "CMakeLists generator from TOML"
 languages = ["CXX"]
 subdirs = ["third_party", "tests"]
+include-after = ["cmake/generate_documentation.cmake"]
+
+[target.cmkr_generate_documentation]
+type = "interface"
+cmake-after = """
+generate_documentation()
+"""
 
 [target.cmkr]
 type = "executable"
 sources = ["src/*.cpp", "include/*.hpp"]
 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"]
 
 [[install]]
 targets = ["cmkr"]

cmake/cmkr.cmake

@@ -2,14 +2,14 @@ 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(CMKR_TAG "archive_2450cfb2" 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)
+if(DEFINED ENV{CI} OR CMKR_SKIP_GENERATION)
     message(STATUS "[cmkr] Skipping automatic cmkr generation")
     macro(cmkr)
     endmacro()
@@ -83,6 +83,7 @@ else()
         "-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"
@@ -131,10 +132,15 @@ macro(cmkr)
 
         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
-            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

cmake/example.md.in

@@ -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>

cmake/generate_documentation.cmake

@@ -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()

docs/.gitignore

@@ -1 +1,2 @@
-_site
+_site/
+.jekyll-metadata

docs/_config.yml

@@ -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

docs/examples/basic.md

@@ -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>

docs/examples/cpp-version-change.markdown

@@ -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" ]
-```

docs/examples/fetch-content.md

@@ -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>

docs/examples/import-from-git.markdown

@@ -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"]
-```

docs/examples/index.markdown

@@ -1,10 +0,0 @@
----
-layout: default
-title: Examples
-permalink: /examples/
-nav_order: 4
-has_children: true
----
-
-# Examples
-

docs/examples/index.md

@@ -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).

docs/examples/interface.md

@@ -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>

docs/examples/quickstart.markdown

@@ -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" ]
-```

docs/examples/vcpkg.md

@@ -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>

docs/index.md

@@ -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:
 

docs/run-wsl.sh

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

include/cmake.hpp

@@ -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;

src/cmake.cpp

@@ -55,6 +55,7 @@ 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);
     }
@@ -163,7 +164,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 +181,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,15 +291,9 @@ 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)

src/gen.cpp

@@ -8,7 +8,10 @@
 #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);
     }
 };
@@ -323,18 +332,18 @@ struct Generator {
     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) {
@@ -387,7 +396,7 @@ struct Generator {
                         // TODO: somehow print line number information here?
                         throw std::runtime_error("Unknown condition '" + condition + "'");
                     }
-                    cmd("if")(RawArg(cmake.conditions[condition]));
+                    cmd("if", condition)(RawArg(cmake.conditions[condition]));
                 }
 
                 if (!itr.second.empty()) {
@@ -403,6 +412,31 @@ struct Generator {
     }
 };
 
+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);
+    }
+
+    const std::regex reserved("prn|aux|nul|con|lpt[1-9]|com[1-9]|core|default");
+    const std::regex ok("[a-z0-9]+(-[a-z0-9]+)*");
+    std::cmatch m;
+    if (!std::regex_match(escaped.c_str(), m, reserved) && std::regex_match(escaped.c_str(), m, ok)) {
+        return escaped;
+    } else {
+        throw std::runtime_error("The escaped project name '" + escaped + "' is not usable with [vcpkg]");
+    }
+}
+
 int generate_cmake(const char *path, bool root) {
     if (!fs::exists(fs::path(path) / "cmake.toml")) {
         throw std::runtime_error("No cmake.toml found!");
@@ -413,14 +447,15 @@ int generate_cmake(const char *path, bool root) {
 
     // 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) {
@@ -520,15 +555,46 @@ 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 (!cmake.vcpkg.packages.empty()) {
+        // Allow the user to specify a url or derive it from the version
+        auto url = cmake.vcpkg.url;
+        if (url.empty()) {
+            if (cmake.vcpkg.version.empty()) {
+                throw std::runtime_error("You need either [vcpkg].version or [vcpkg].url");
+            }
+            url = "https://github.com/microsoft/vcpkg/archive/refs/tags/" + cmake.vcpkg.version + ".tar.gz";
+        }
+
+        // CMake to bootstrap vcpkg and download the packages
+        // clang-format off
+        cmd("if")("CMKR_ROOT_PROJECT", "AND", "NOT", "CMKR_DISABLE_VCPKG");
+            cmd("include")("FetchContent");
+            cmd("message")("STATUS", "Fetching vcpkg...");
+            cmd("FetchContent_Declare")("vcpkg", "URL", url);
+            cmd("FetchContent_MakeAvailable")("vcpkg");
+            cmd("include")("${vcpkg_SOURCE_DIR}/scripts/buildsystems/vcpkg.cmake");
+        cmd("endif")();
+        endl();
+        // clang-format on
+
+        // Generate vcpkg.json
+        using namespace nlohmann;
+        json j;
+        j["$cmkr"] = "This file is automatically generated from cmake.toml - DO NOT EDIT";
+        j["$cmkr-url"] = cmkr_url;
+        j["$schema"] = "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json";
+        j["name"] = vcpkg_escape_identifier(cmake.project_name);
+        j["version-string"] = cmake.project_version;
+        j["dependencies"] = cmake.vcpkg.packages;
+        if (!cmake.project_description.empty()) {
+            j["description"] = cmake.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()) {
@@ -597,6 +663,15 @@ int generate_cmake(const char *path, bool root) {
     if (!cmake.targets.empty()) {
         for (const auto &target : cmake.targets) {
             comment("Target " + target.name);
+
+            if (!target.condition.empty()) {
+                const auto &condition = target.condition;
+                if (cmake.conditions.count(condition) == 0) {
+                    throw std::runtime_error("Unknown condition '" + condition + "' for [target." + target.name + "]");
+                }
+                gen.cmd("if", condition)(RawArg(cmake.conditions[condition]));
+            }
+
             cmd("set")("CMKR_TARGET", target.name);
 
             gen.handle_condition(target.include_before,
@@ -683,28 +758,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 cmake::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,6 +806,12 @@ int generate_cmake(const char *path, bool root) {
 
             cmd("unset")("CMKR_TARGET");
             cmd("unset")("CMKR_SOURCES");
+
+            if (!target.condition.empty()) {
+                cmd("endif")();
+            }
+
+            endl();
         }
     }
 
@@ -721,7 +820,11 @@ int generate_cmake(const char *path, bool root) {
         for (const auto &test : cmake.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();

tests/CMakeLists.txt

@@ -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,9 @@ add_test(
 
 add_test(
 	NAME
-		interface
+		vcpkg
 	WORKING_DIRECTORY
-		"${CMAKE_CURRENT_LIST_DIR}/interface"
+		"${CMAKE_CURRENT_LIST_DIR}/vcpkg"
 	COMMAND
 		$<TARGET_FILE:cmkr>
 		build

tests/basic/cmake.toml

@@ -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)`.

tests/cmake.toml

@@ -1,17 +1,29 @@
 [[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"
+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"]

tests/conditions/cmake.toml

@@ -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"

tests/fetch-content/cmake.toml

@@ -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).

tests/fetch-content/src/main.cpp

@@ -0,0 +1,6 @@
+#include <fmt/core.h>
+
+int main()
+{
+    fmt::print("Hello, world!\n");
+}

tests/interface/cmake.toml

@@ -1,5 +1,6 @@
 [project]
 name = "interface"
+description = "Header-only library"
 
 [target.mylib]
 type = "interface"

tests/vcpkg/cmake.toml

@@ -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`.

tests/vcpkg/src/main.cpp

@@ -0,0 +1,6 @@
+#include <fmt/core.h>
+
+int main()
+{
+    fmt::print("Hello, world!\n");
+}

tests/vcpkg/vcpkg.json

@@ -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": "Example of using vcpkg",
+  "name": "vcpkg",
+  "version-string": ""
+}

third_party/CMakeLists.txt

@@ -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)

third_party/nlohmann-3.9.1/LICENSE

@@ -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.