From 2f14936a5a21ba3d6ebda699f7e3f0475510a189 Mon Sep 17 00:00:00 2001 From: Micah Snyder Date: Tue, 6 Sep 2022 14:42:48 -0700 Subject: [PATCH] Specify source AND binary dirs in `add_rust_*` fun. Breaks API! Changed the `add_rust_*` functions to have SOURCE_DIRECTORY and BINARY_DIRECTORY parameters instead of WORKING_DIRECTORY. This allows you to build and run the Rust unit tests from the same BINARY_DIRECTORy as you do for the Rust library build. That means it won't recompile all of the dependencies when building the unit test executable. A side-effect of this change is that the CMakeLists.txt file that uses `add_rust_library()` must be in the same directory as the Rust module. I.e. you should co-locate the CMakeLists.txt with the Cargo.toml file. You can no longer have a parent directory's CMakeFiles.txt add a library for a subdirectory. The reason is that CMake will set the INTERFACE_INCLUDE_DIRECTORIES property for your library's CMake target use both the SOURCE_DIRECTORY and BINARY_DIRECTORY. This ensures that generated headers will be placed in the include path for any downstream CMake targets. CMake requires both directories to exist. When CMake does the build, it will create subdirectories in the build path for each CMakeLists.txt file. Co-locating CMakeLists.txt with Cargo.toml ensures that the BUILD_DIRECTORY is automatically created by CMake. Important: This commit breaks the API for the FindRust.cmake module! --- README.md | 45 ++++++++++++++---- app_rust/CMakeLists.txt | 5 +- cmake/FindRust.cmake | 87 +++++++++++++++++++--------------- common/CMakeLists.txt | 13 +---- common/gen_uuid/CMakeLists.txt | 20 ++++++++ lib/rust/CMakeLists.txt | 5 +- test/CMakeLists.txt | 5 +- 7 files changed, 118 insertions(+), 62 deletions(-) create mode 100644 common/gen_uuid/CMakeLists.txt diff --git a/README.md b/README.md index 82fc30a..b8e1712 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ ![Build Test](https://github.com/micahsnyder/cmake-rust-demo/workflows/Build%20Test/badge.svg) -A C CMake demo using Rust static library components. +A C CMake demo using Rust static library components and building Rust executables. The notable feature of this project is [cmake/FindRust.cmake](cmake/FindRust.cmake) ## Usage @@ -13,21 +13,34 @@ Add `FindRust.cmake` to your project's `cmake` directory and use the following t find_package(Rust REQUIRED) ``` +### Rust-based C-style Static Libraries + To build a rust library and link it into your app, use: ```cmake -add_rust_library(TARGET yourlib WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/yourlib") +add_rust_library(TARGET yourlib + SOURCE_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + BINARY_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" +) add_executable(yourexe) target_sources(yourexe PRIVATE yourexe.c) target_link_libraries(yourexe yourlib) ``` +### Rust Library Unit Tests + For unit test support, you can use the `add_rust_test()` function, like this: ```cmake -add_rust_library(TARGET yourlib WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/yourlib") -add_rust_test(NAME yourlib WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/yourlib") +add_rust_library(TARGET yourlib + SOURCE_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + BINARY_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" +) +add_rust_test(NAME yourlib + SOURCE_DIRECTORY "${CMAKE_SOURCE_DIR}/path/to/yourlib" + BINARY_DIRECTORY "${CMAKE_BINARY_DIR}/path/to/yourlib" +) ``` And don't forget to enable CTest early in your top-level `CMakeLists.txt` file: @@ -40,6 +53,18 @@ if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME) endif() ``` +### Rust-based Executables + +To build a rust executable use: + +```cmake +add_rust_executable(TARGET yourexe + SOURCE_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + BINARY_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" +) +add_executable(YourProject::yourexe ALIAS yourexe) +``` + ## Minimum Rust version You may set the CMake variable `RUSTC_MINIMUM_REQUIRED` to enforce a minimum Rust version, such as "1.56" for the 2021 edition support. @@ -118,28 +143,28 @@ Rust binaries aren't treated quite the same by CMake as native C binaries, but y The first thing you'll probably need if you want to use CMake to install stuff, whether or not you bundle in some Rust binaries, is to include the GNUEInstallDirs module somewhere at the top of your top-level `CMakeLists.txt`: -```c +```cmake include(GNUInstallDirs) ``` Now with a regular C library or executable CMake target, you might configure them for installation like this: -```c +```cmake install(TARGETS demo DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT libraries) ``` or: -```c +```cmake install(TARGETS app DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT programs) ``` -Rust library CMake targets aren't normal CMake binary targets though. They're "custom" targets, which means you will instead have to use `install(FILES` instead of `install(TARGETS`, and then point CMake at the specific file you need installed instead of at a target. Our `FindRust.cmake`'s `add_rust_library()` function makes this easy. WHen you add a Rust library, it sets the target properties such that you can simply use CMake's `$` [generator expression](https://cmake.org/cmake/help/latest/manual/cmake-generator-expressions.7.html) to provide the file path. +Rust library CMake targets aren't normal CMake binary targets though. They're "custom" targets, which means you will instead have to use `install(FILES` instead of `install(TARGETS`, and then point CMake at the specific file you need installed instead of at a target. Our `FindRust.cmake`'s `add_rust_library()` function makes this easy. When you add a Rust library, it sets the target properties such that you can simply use CMake's `$` [generator expression](https://cmake.org/cmake/help/latest/manual/cmake-generator-expressions.7.html) to provide the file path. In this demo, we configure installation for our `demorust` Rust static library like this: -```c +```cmake install(FILES $ DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT libraries) ``` And for our `app_rust` Rust executable, we install like this: -```c +```cmake get_target_property(app_rust_EXECUTABLE app_rust IMPORTED_LOCATION) install(PROGRAMS ${app_rust_EXECUTABLE} DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT programs) ``` diff --git a/app_rust/CMakeLists.txt b/app_rust/CMakeLists.txt index 95a7e36..4e69f17 100644 --- a/app_rust/CMakeLists.txt +++ b/app_rust/CMakeLists.txt @@ -6,7 +6,10 @@ # Example app that links with our C (and Rust) libs. # -add_rust_executable(TARGET app_rust WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/.") +add_rust_executable(TARGET app_rust + SOURCE_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + BINARY_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" +) # Linking with C libraries is done within `build.rs` # Linking with nearby Rust crates is done within `Cargo.toml` get_target_property(app_rust_EXECUTABLE app_rust IMPORTED_LOCATION) diff --git a/cmake/FindRust.cmake b/cmake/FindRust.cmake index 13a717e..155e496 100644 --- a/cmake/FindRust.cmake +++ b/cmake/FindRust.cmake @@ -48,7 +48,9 @@ # Example `add_rust_library()` usage: # # ```cmake -# add_rust_library(TARGET yourlib WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") +# add_rust_library(TARGET yourlib +# SOURCE_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") +# BINARY_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}") # add_library(YourProject::yourlib ALIAS yourlib) # # add_executable(yourexe) @@ -78,7 +80,10 @@ # Example `add_rust_test()` usage: # # ```cmake -# add_rust_test(NAME yourlib WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}/yourlib") +# add_rust_test(NAME yourlib +# SOURCE_DIRECTORY "${CMAKE_SOURCE_DIR}/path/to/yourlib" +# BINARY_DIRECTORY "${CMAKE_BINARY_DIR}/path/to/yourlib" +# ) # set_property(TEST yourlib PROPERTY ENVIRONMENT ${ENVIRONMENT}) # ``` # @@ -96,7 +101,9 @@ # For example: # # ```cmake -# add_rust_test(NAME yourlib WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}/yourlib" +# add_rust_test(NAME yourlib +# SOURCE_DIRECTORY "${CMAKE_SOURCE_DIR}/yourlib" +# BINARY_DIRECTORY "${CMAKE_BINARY_DIR}/yourlib" # PRECOMPILE_TESTS TRUE # DEPENDS ClamAV::libclamav # ENVIRONMENT "${ENVIRONMENT}" @@ -112,11 +119,11 @@ # Example `add_rust_executable()` usage: # # ```cmake -# add_rust_executable(TARGET yourapp WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") -# add_executable(YourProject::yourapp ALIAS yourapp) -# -# add_executable(yourexe) -# target_link_libraries(yourexe YourProject::yourlib) +# add_rust_executable(TARGET yourexe +# SOURCE_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" +# BINARY_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" +# ) +# add_executable(YourProject::yourexe ALIAS yourexe) # ``` if(NOT DEFINED CARGO_HOME) @@ -166,19 +173,19 @@ endfunction() function(cargo_vendor) set(options) - set(oneValueArgs TARGET WORKING_DIRECTORY) + set(oneValueArgs TARGET SOURCE_DIRECTORY BINARY_DIRECTORY) cmake_parse_arguments(ARGS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) - if(NOT EXISTS ${ARGS_WORKING_DIRECTORY}}/.cargo/config.toml) + if(NOT EXISTS ${ARGS_SOURCE_DIRECTORY}/.cargo/config.toml) # Vendor the dependencies and create .cargo/config.toml # Vendored dependencies will be used during the build. # This will allow us to package vendored dependencies in source tarballs # for online builds when we run `cpack --config CPackSourceConfig.cmake` message(STATUS "Running `cargo vendor` to collect dependencies for ${ARGS_TARGET}. This may take a while if the local crates.io index needs to be updated ...") - make_directory(${ARGS_WORKING_DIRECTORY}/.cargo) + make_directory(${ARGS_SOURCE_DIRECTORY}/.cargo) execute_process( - COMMAND ${CMAKE_COMMAND} -E env "CARGO_TARGET_DIR=${CMAKE_CURRENT_BINARY_DIR}" ${cargo_EXECUTABLE} vendor ".cargo/vendor" - WORKING_DIRECTORY "${ARGS_WORKING_DIRECTORY}" + COMMAND ${CMAKE_COMMAND} -E env "CARGO_TARGET_DIR=${ARGS_BINARY_DIRECTORY}" ${cargo_EXECUTABLE} vendor ".cargo/vendor" + WORKING_DIRECTORY "${ARGS_SOURCE_DIRECTORY}" OUTPUT_VARIABLE CARGO_VENDOR_OUTPUT ERROR_VARIABLE CARGO_VENDOR_ERROR RESULT_VARIABLE CARGO_VENDOR_RESULT @@ -190,7 +197,7 @@ function(cargo_vendor) message("Success!") endif() - write_file(${ARGS_WORKING_DIRECTORY}/.cargo/config.toml " + write_file(${ARGS_SOURCE_DIRECTORY}/.cargo/config.toml " [source.crates-io] replace-with = \"vendored-sources\" @@ -203,7 +210,7 @@ endfunction() function(add_rust_executable) set(options) - set(oneValueArgs TARGET WORKING_DIRECTORY) + set(oneValueArgs TARGET SOURCE_DIRECTORY BINARY_DIRECTORY) cmake_parse_arguments(ARGS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) if(WIN32) @@ -212,7 +219,7 @@ function(add_rust_executable) set(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${RUST_COMPILER_TARGET}/${CARGO_BUILD_TYPE}/${ARGS_TARGET}") endif() - file(GLOB_RECURSE EXE_SOURCES "${ARGS_WORKING_DIRECTORY}/*.rs") + file(GLOB_RECURSE EXE_SOURCES "${ARGS_SOURCE_DIRECTORY}/*.rs") set(MY_CARGO_ARGS ${CARGO_ARGS}) list(APPEND MY_CARGO_ARGS "--target-dir" ${CMAKE_CURRENT_BINARY_DIR}) @@ -221,10 +228,10 @@ function(add_rust_executable) # Build the executable. add_custom_command( OUTPUT "${OUTPUT}" - COMMAND ${CMAKE_COMMAND} -E env "CARGO_TARGET_DIR=${CMAKE_CURRENT_BINARY_DIR}" ${cargo_EXECUTABLE} ARGS ${MY_CARGO_ARGS} - WORKING_DIRECTORY "${ARGS_WORKING_DIRECTORY}" + COMMAND ${CMAKE_COMMAND} -E env "CARGO_TARGET_DIR=${ARGS_BINARY_DIRECTORY}" ${cargo_EXECUTABLE} ARGS ${MY_CARGO_ARGS} + WORKING_DIRECTORY "${ARGS_SOURCE_DIRECTORY}" DEPENDS ${EXE_SOURCES} - COMMENT "Building ${ARGS_TARGET} in ${ARGS_WORKING_DIRECTORY} with:\n\t ${cargo_EXECUTABLE} ${MY_CARGO_ARGS_STRING}") + COMMENT "Building ${ARGS_TARGET} in ${ARGS_BINARY_DIRECTORY} with:\n\t ${cargo_EXECUTABLE} ${MY_CARGO_ARGS_STRING}") # Create a target from the build output add_custom_target(${ARGS_TARGET}_target @@ -241,13 +248,16 @@ function(add_rust_executable) # Vendor the dependencies, if desired if(VENDOR_DEPENDENCIES) - cargo_vendor(TARGET "${ARGS_TARGET}" WORKING_DIRECTORY "${ARGS_WORKING_DIRECTORY}") + cargo_vendor(TARGET "${ARGS_TARGET}" + SOURCE_DIRECTORY "${ARGS_SOURCE_DIRECTORY}" + BINARY_DIRECTORY "${ARGS_BINARY_DIRECTORY}" + ) endif() endfunction() function(add_rust_library) set(options) - set(oneValueArgs TARGET WORKING_DIRECTORY PRECOMPILE_TESTS) + set(oneValueArgs TARGET SOURCE_DIRECTORY BINARY_DIRECTORY PRECOMPILE_TESTS) cmake_parse_arguments(ARGS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) if(WIN32) @@ -256,7 +266,7 @@ function(add_rust_library) set(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${RUST_COMPILER_TARGET}/${CARGO_BUILD_TYPE}/lib${ARGS_TARGET}.a") endif() - file(GLOB_RECURSE LIB_SOURCES "${ARGS_WORKING_DIRECTORY}/*.rs") + file(GLOB_RECURSE LIB_SOURCES "${ARGS_SOURCE_DIRECTORY}/*.rs") set(MY_CARGO_ARGS ${CARGO_ARGS}) if(ARGS_PRECOMPILE_TESTS) @@ -269,20 +279,20 @@ function(add_rust_library) if("${CMAKE_OSX_ARCHITECTURES}" MATCHES "^(arm64;x86_64|x86_64;arm64)$") add_custom_command( OUTPUT "${OUTPUT}" - COMMAND ${CMAKE_COMMAND} -E env "CARGO_CMD=build" "CARGO_TARGET_DIR=${CMAKE_CURRENT_BINARY_DIR}" "MAINTAINER_MODE=${MAINTAINER_MODE}" "RUSTFLAGS=\"${RUSTFLAGS}\"" ${cargo_EXECUTABLE} ARGS ${MY_CARGO_ARGS} --target=x86_64-apple-darwin - COMMAND ${CMAKE_COMMAND} -E env "CARGO_CMD=build" "CARGO_TARGET_DIR=${CMAKE_CURRENT_BINARY_DIR}" "MAINTAINER_MODE=${MAINTAINER_MODE}" "RUSTFLAGS=\"${RUSTFLAGS}\"" ${cargo_EXECUTABLE} ARGS ${MY_CARGO_ARGS} --target=aarch64-apple-darwin + COMMAND ${CMAKE_COMMAND} -E env "CARGO_CMD=build" "CARGO_TARGET_DIR=${ARGS_BINARY_DIRECTORY}" "MAINTAINER_MODE=${MAINTAINER_MODE}" "RUSTFLAGS=\"${RUSTFLAGS}\"" ${cargo_EXECUTABLE} ARGS ${MY_CARGO_ARGS} --target=x86_64-apple-darwin + COMMAND ${CMAKE_COMMAND} -E env "CARGO_CMD=build" "CARGO_TARGET_DIR=${ARGS_BINARY_DIRECTORY}" "MAINTAINER_MODE=${MAINTAINER_MODE}" "RUSTFLAGS=\"${RUSTFLAGS}\"" ${cargo_EXECUTABLE} ARGS ${MY_CARGO_ARGS} --target=aarch64-apple-darwin COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_CURRENT_BINARY_DIR}/${RUST_COMPILER_TARGET}/${CARGO_BUILD_TYPE}" COMMAND lipo ARGS -create ${CMAKE_CURRENT_BINARY_DIR}/x86_64-apple-darwin/${CARGO_BUILD_TYPE}/lib${ARGS_TARGET}.a ${CMAKE_CURRENT_BINARY_DIR}/aarch64-apple-darwin/${CARGO_BUILD_TYPE}/lib${ARGS_TARGET}.a -output "${OUTPUT}" - WORKING_DIRECTORY "${ARGS_WORKING_DIRECTORY}" + WORKING_DIRECTORY "${ARGS_SOURCE_DIRECTORY}" DEPENDS ${LIB_SOURCES} - COMMENT "Building ${ARGS_TARGET} in ${ARGS_WORKING_DIRECTORY} with: ${cargo_EXECUTABLE} ${MY_CARGO_ARGS_STRING}") + COMMENT "Building ${ARGS_TARGET} in ${ARGS_BINARY_DIRECTORY} with: ${cargo_EXECUTABLE} ${MY_CARGO_ARGS_STRING}") else() add_custom_command( OUTPUT "${OUTPUT}" - COMMAND ${CMAKE_COMMAND} -E env "CARGO_CMD=build" "CARGO_TARGET_DIR=${CMAKE_CURRENT_BINARY_DIR}" "MAINTAINER_MODE=${MAINTAINER_MODE}" "RUSTFLAGS=\"${RUSTFLAGS}\"" ${cargo_EXECUTABLE} ARGS ${MY_CARGO_ARGS} - WORKING_DIRECTORY "${ARGS_WORKING_DIRECTORY}" + COMMAND ${CMAKE_COMMAND} -E env "CARGO_CMD=build" "CARGO_TARGET_DIR=${ARGS_BINARY_DIRECTORY}" "MAINTAINER_MODE=${MAINTAINER_MODE}" "RUSTFLAGS=\"${RUSTFLAGS}\"" ${cargo_EXECUTABLE} ARGS ${MY_CARGO_ARGS} + WORKING_DIRECTORY "${ARGS_SOURCE_DIRECTORY}" DEPENDS ${LIB_SOURCES} - COMMENT "Building ${ARGS_TARGET} in ${ARGS_WORKING_DIRECTORY} with: ${cargo_EXECUTABLE} ${MY_CARGO_ARGS_STRING}") + COMMENT "Building ${ARGS_TARGET} in ${ARGS_BINARY_DIRECTORY} with: ${cargo_EXECUTABLE} ${MY_CARGO_ARGS_STRING}") endif() # Create a target from the build output @@ -298,18 +308,20 @@ function(add_rust_library) set_target_properties(${ARGS_TARGET} PROPERTIES IMPORTED_LOCATION "${OUTPUT}" - INTERFACE_INCLUDE_DIRECTORIES "${ARGS_WORKING_DIRECTORY};${CMAKE_CURRENT_BINARY_DIR}" + INTERFACE_INCLUDE_DIRECTORIES "${ARGS_SOURCE_DIRECTORY};${ARGS_BINARY_DIRECTORY}" ) # Vendor the dependencies, if desired if(VENDOR_DEPENDENCIES) - cargo_vendor(TARGET "${ARGS_TARGET}" WORKING_DIRECTORY "${ARGS_WORKING_DIRECTORY}") + cargo_vendor(TARGET "${ARGS_TARGET}" + SOURCE_DIRECTORY "${ARGS_SOURCE_DIRECTORY}" + BINARY_DIRECTORY "${ARGS_BINARY_DIRECTORY}") endif() endfunction() function(add_rust_test) set(options) - set(oneValueArgs NAME WORKING_DIRECTORY PRECOMPILE_TESTS DEPENDS) + set(oneValueArgs NAME SOURCE_DIRECTORY BINARY_DIRECTORY PRECOMPILE_TESTS DEPENDS) set(multiValueArgs ENVIRONMENT) cmake_parse_arguments(ARGS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) @@ -323,21 +335,22 @@ function(add_rust_test) list(APPEND MY_CARGO_ARGS "--release") endif() - list(APPEND MY_CARGO_ARGS "--target-dir" ${CMAKE_CURRENT_BINARY_DIR}) + list(APPEND MY_CARGO_ARGS "--target-dir" ${ARGS_BINARY_DIRECTORY}) list(JOIN MY_CARGO_ARGS " " MY_CARGO_ARGS_STRING) if(ARGS_PRECOMPILE_TESTS) - list(APPEND ARGS_ENVIRONMENT "CARGO_CMD=test" "CARGO_TARGET_DIR=${CMAKE_CURRENT_BINARY_DIR}") - add_custom_target(${ARGS_NAME}_precompile ALL + list(APPEND ARGS_ENVIRONMENT "CARGO_CMD=test" "CARGO_TARGET_DIR=${ARGS_BINARY_DIRECTORY}") + add_custom_target(${ARGS_NAME}_tests ALL COMMAND ${CMAKE_COMMAND} -E env ${ARGS_ENVIRONMENT} ${cargo_EXECUTABLE} ${MY_CARGO_ARGS} --color always --no-run DEPENDS ${ARGS_DEPENDS} + WORKING_DIRECTORY ${ARGS_SOURCE_DIRECTORY} ) endif() add_test( NAME ${ARGS_NAME} - COMMAND ${CMAKE_COMMAND} -E env "CARGO_CMD=test" "CARGO_TARGET_DIR=${CMAKE_CURRENT_BINARY_DIR}" ${cargo_EXECUTABLE} ${MY_CARGO_ARGS} --color always - WORKING_DIRECTORY ${ARGS_WORKING_DIRECTORY} + COMMAND ${CMAKE_COMMAND} -E env "CARGO_CMD=test" "CARGO_TARGET_DIR=${ARGS_BINARY_DIRECTORY}" ${cargo_EXECUTABLE} ${MY_CARGO_ARGS} --color always + WORKING_DIRECTORY ${ARGS_SOURCE_DIRECTORY} ) endfunction() diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt index e600729..c383625 100644 --- a/common/CMakeLists.txt +++ b/common/CMakeLists.txt @@ -1,14 +1,3 @@ # Copyright (C) 2020-2022 Micah Snyder. -# -# Libraries that may be used by the applications. -# - -# A library to generate UUID's -add_rust_library(TARGET gen_uuid WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/gen_uuid") - -# The unit tests for this module have no dependencies on C libraries or other special -# test environment considerations, so we may as well add the test right here instead of -# adding it in the `test/CMakeLists.txt` file. -add_rust_test(NAME gen_uuid WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/gen_uuid") -add_library(demo::gen_uuid ALIAS gen_uuid) +add_subdirectory(gen_uuid) diff --git a/common/gen_uuid/CMakeLists.txt b/common/gen_uuid/CMakeLists.txt new file mode 100644 index 0000000..f3946b6 --- /dev/null +++ b/common/gen_uuid/CMakeLists.txt @@ -0,0 +1,20 @@ +# Copyright (C) 2020-2022 Micah Snyder. + +# +# Libraries that may be used by the applications. +# + +# A library to generate UUID's +add_rust_library(TARGET gen_uuid + SOURCE_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + BINARY_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" +) + +# The unit tests for this module have no dependencies on C libraries or other special +# test environment considerations, so we may as well add the test right here instead of +# adding it in the `test/CMakeLists.txt` file. +add_rust_test(NAME gen_uuid + SOURCE_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + BINARY_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" +) +add_library(demo::gen_uuid ALIAS gen_uuid) diff --git a/lib/rust/CMakeLists.txt b/lib/rust/CMakeLists.txt index a23df6c..29fdaa6 100644 --- a/lib/rust/CMakeLists.txt +++ b/lib/rust/CMakeLists.txt @@ -6,7 +6,10 @@ # Note: The rust port will be compiled to static library target and must be added as # a dependency to both the C object targets and shared/static library targets. # -add_rust_library(TARGET demorust WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") +add_rust_library(TARGET demorust + SOURCE_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + BINARY_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" +) if (WIN32) # You can add link library dependencies for the rust libarry target, if you need. target_link_libraries(demorust PUBLIC INTERFACE Userenv) diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index f8487ae..6e9e576 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -14,5 +14,8 @@ set(ENVIRONMENT LIBDEMO=${LIBDEMO} ) -add_rust_test(NAME demorust WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}/lib/rust") +add_rust_test(NAME demorust + SOURCE_DIRECTORY "${CMAKE_SOURCE_DIR}/lib/rust" + BINARY_DIRECTORY "${CMAKE_BINARY_DIR}/lib/rust" +) set_property(TEST demorust PROPERTY ENVIRONMENT ${ENVIRONMENT})