napcok/calamares
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
a64a54ff04
calamares/src/modules/CMakeLists.txt

93 lines
3.5 KiB
CMake
Raw Normal View History

REUSE: Giant boilerplate cleanup - point to main Calamares site in the 'part of' headers instead of to github (this is the "this file is part of Calamares" opening line for most files). - remove boilerplate from all source files, CMake modules and completions, this is the 3-paragraph summary of the GPL-3.0-or-later, which has a meaning entirely covered by the SPDX tag.
2020-08-25 16:05:56 +02:00
# === This file is part of Calamares - <https://calamares.io> ===
REUSE: (BSD-2-Clause) all CMakeLists The build instructions are not that interesting, it's a toss-up between CC0 and BSD-2, but because other CMake bits are BSD-2-Clause, apply that to more CMakeLists. The copyright date isn't all that accurate, but these are just inconsequential files. While here, tidy up and get rid of some useless intermediates.
2020-08-26 00:24:52 +02:00
#
# SPDX-FileCopyrightText: 2020 Adriaan de Groot <groot@kde.org>
# SPDX-License-Identifier: BSD-2-Clause
#
CMake: explain which modules are skipped Modules may be skipped for different reasons: SKIP_MODULES is the traditional approach to suppress some, but other modules may have unmet build requirements (e.g. Plasma Look-and-Feel, or the Partitioning module) and should be able to opt-out of being built. For all those skipped, log it explicitly after all the modules have been examined. Only CMake-based (e.g. C++) modules support opting-out in this way.
2017-12-24 22:08:48 +01:00
# The variable SKIP_MODULES can be set to skip particular modules;
# individual modules can also decide they must be skipped (e.g. OS-specific
# modules, or ones with unmet dependencies). Collect the skipped modules
# in this list.
set( LIST_SKIPPED_MODULES "" )
[modules] The modules can include libcalamares and libcalamaresui - Remove (heavy-handed) top-level include_directories, in favor of more focused ones; this helps to make sure that the dependencies ordering is correct.
2019-05-07 13:47:24 +02:00
include_directories(
${CMAKE_SOURCE_DIR}/src/libcalamares
${CMAKE_BINARY_DIR}/src/libcalamares
${CMAKE_SOURCE_DIR}/src/libcalamaresui
)
Do not build modules listed in SKIP_MODULES.
2015-08-03 17:59:07 +02:00
string( REPLACE " " ";" SKIP_LIST "${SKIP_MODULES}" )
CMake: build modules alphabetically
2018-01-24 10:29:06 +01:00
file( GLOB SUBDIRECTORIES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "*" )
list( SORT SUBDIRECTORIES )
CMake: improve error-handling for USE_* If USE_<foo> is given a value that doesn't match **anything**, then bail out. Since USE_* is an explicit distro choice for a specific implementation, it's an error if that implementation is not there.
2018-06-26 11:33:01 +02:00
set( _use_categories "" )
set( _found_categories "" )
CMake: introduce USE_<foo> When there are multiple modules doing a thing and it really only makes sense to have one of them in a given Calamares compilation, the USE_<foo> variables allow you to select one, while ignoring all the other implementations. If USE_<foo> is not set, all implementations are included (as usual).
2018-06-26 11:18:10 +02:00
Add CalamaresAddModuleSubdirectory, a CMake function for modules that do not require building through a CMakeLists.txt.
2014-07-14 16:26:10 +02:00
foreach( SUBDIRECTORY ${SUBDIRECTORIES} )
Do not build modules listed in SKIP_MODULES.
2015-08-03 17:59:07 +02:00
list( FIND SKIP_LIST ${SUBDIRECTORY} DO_SKIP )
CMake: introduce USE_<foo> When there are multiple modules doing a thing and it really only makes sense to have one of them in a given Calamares compilation, the USE_<foo> variables allow you to select one, while ignoring all the other implementations. If USE_<foo> is not set, all implementations are included (as usual).
2018-06-26 11:18:10 +02:00
set( _skip_reason "user request" )
CMake: improve error-handling for USE_* If USE_<foo> is given a value that doesn't match **anything**, then bail out. Since USE_* is an explicit distro choice for a specific implementation, it's an error if that implementation is not there.
2018-06-26 11:33:01 +02:00
# Handle the USE_<foo> variables by looking for subdirectories
# with a <foo>-<implementation> kind of name.
CMake: introduce USE_<foo> When there are multiple modules doing a thing and it really only makes sense to have one of them in a given Calamares compilation, the USE_<foo> variables allow you to select one, while ignoring all the other implementations. If USE_<foo> is not set, all implementations are included (as usual).
2018-06-26 11:18:10 +02:00
if( SUBDIRECTORY MATCHES "^[a-zA-Z0-9_]+-" )
string( REGEX REPLACE "^[^-]+-" "" _implementation ${SUBDIRECTORY} )
string( REGEX REPLACE "-.*" "" _category ${SUBDIRECTORY} )
if( USE_${_category} )
CMake: improve error-handling for USE_* If USE_<foo> is given a value that doesn't match **anything**, then bail out. Since USE_* is an explicit distro choice for a specific implementation, it's an error if that implementation is not there.
2018-06-26 11:33:01 +02:00
list( APPEND _use_categories ${_category} )
if( "${_implementation}" STREQUAL "${USE_${_category}}" )
list( APPEND _found_categories ${_category} )
else()
CMake: introduce USE_<foo> When there are multiple modules doing a thing and it really only makes sense to have one of them in a given Calamares compilation, the USE_<foo> variables allow you to select one, while ignoring all the other implementations. If USE_<foo> is not set, all implementations are included (as usual).
2018-06-26 11:18:10 +02:00
list( APPEND SKIP_LIST ${SUBDIRECTORY} )
set( _skip_reason "USE_${_category}=${USE_${_category}}" )
set( DO_SKIP 1 )
endif()
endif()
endif()
Do not build modules listed in SKIP_MODULES.
2015-08-03 17:59:07 +02:00
if( NOT DO_SKIP EQUAL -1 )
message( "${ColorReset}-- Skipping module ${BoldRed}${SUBDIRECTORY}${ColorReset}." )
message( "" )
CMake: introduce USE_<foo> When there are multiple modules doing a thing and it really only makes sense to have one of them in a given Calamares compilation, the USE_<foo> variables allow you to select one, while ignoring all the other implementations. If USE_<foo> is not set, all implementations are included (as usual).
2018-06-26 11:18:10 +02:00
list( APPEND LIST_SKIPPED_MODULES "${SUBDIRECTORY} (${_skip_reason})" )
Do not build modules listed in SKIP_MODULES.
2015-08-03 17:59:07 +02:00
elseif( ( IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${SUBDIRECTORY}" ) AND
( DO_SKIP EQUAL -1 ) )
CMake: explain which modules are skipped Modules may be skipped for different reasons: SKIP_MODULES is the traditional approach to suppress some, but other modules may have unmet build requirements (e.g. Plasma Look-and-Feel, or the Partitioning module) and should be able to opt-out of being built. For all those skipped, log it explicitly after all the modules have been examined. Only CMake-based (e.g. C++) modules support opting-out in this way.
2017-12-24 22:08:48 +01:00
set( SKIPPED_MODULES )
Add CalamaresAddModuleSubdirectory, a CMake function for modules that do not require building through a CMakeLists.txt.
2014-07-14 16:26:10 +02:00
calamares_add_module_subdirectory( ${SUBDIRECTORY} )
CMake: explain which modules are skipped Modules may be skipped for different reasons: SKIP_MODULES is the traditional approach to suppress some, but other modules may have unmet build requirements (e.g. Plasma Look-and-Feel, or the Partitioning module) and should be able to opt-out of being built. For all those skipped, log it explicitly after all the modules have been examined. Only CMake-based (e.g. C++) modules support opting-out in this way.
2017-12-24 22:08:48 +01:00
if ( SKIPPED_MODULES )
list( APPEND LIST_SKIPPED_MODULES "${SKIPPED_MODULES}" )
endif()
Added CMake magic for plugin infrastructure. Added ViewManager. Added dummy Settings class. Added dummy plugin interface (UI plugins only). Added dummy greeting plugin. Added DLLEXPORT macros for UI plugin interface and plugins.
2014-06-11 13:37:10 +02:00
endif()
endforeach()
CMake: shuffle translations macros into CMakeModules/
2017-08-09 20:33:32 +02:00
CMake: factor out explanation of skipped modules. Make a function out of explaining-skipped-modules, and call it not only after collecting all the modules, but also after the feature summary, so that it's quite clear which modules are skipped.
2018-01-10 15:20:49 +01:00
# This is *also* done in top-level, so list is displayed
# both before and after the feature summary.
calamares_explain_skipped_modules( ${LIST_SKIPPED_MODULES} )
CMake: explain which modules are skipped Modules may be skipped for different reasons: SKIP_MODULES is the traditional approach to suppress some, but other modules may have unmet build requirements (e.g. Plasma Look-and-Feel, or the Partitioning module) and should be able to opt-out of being built. For all those skipped, log it explicitly after all the modules have been examined. Only CMake-based (e.g. C++) modules support opting-out in this way.
2017-12-24 22:08:48 +01:00
CMake: improve error-handling for USE_* If USE_<foo> is given a value that doesn't match **anything**, then bail out. Since USE_* is an explicit distro choice for a specific implementation, it's an error if that implementation is not there.
2018-06-26 11:33:01 +02:00
foreach( _category ${_use_categories} )
list( FIND _found_categories ${_category} _found )
CMake: add support for USE_*=none (from the os-modules branch)
2020-06-22 13:39:36 +02:00
if ( ${USE_${_category}} STREQUAL "none" )
set( _found 0 )
endif()
CMake: improve error-handling for USE_* If USE_<foo> is given a value that doesn't match **anything**, then bail out. Since USE_* is an explicit distro choice for a specific implementation, it's an error if that implementation is not there.
2018-06-26 11:33:01 +02:00
if ( _found EQUAL -1 )
message( FATAL_ERROR "USE_${_category} is set to ${USE_${_category}} and no module matches." )
endif()
endforeach()
CI: apply schema-validation to the example config files - Any config file with a schema gets a test (validate-<module>) to test the file.
2020-06-16 14:38:13 +02:00
# TODO:3.3: Use FindPython3
CI: add a BUILD_SCHEMA_TESTING - ON by default, so if tests are built and the script works, those tests will run as well. - Check that the script works by invoking it once.
2020-06-16 17:36:59 +02:00
if ( BUILD_TESTING AND BUILD_SCHEMA_TESTING AND PYTHONINTERP_FOUND AND PYTHON_EXECUTABLE )
CI: apply schema-validation to the example config files - Any config file with a schema gets a test (validate-<module>) to test the file.
2020-06-16 14:38:13 +02:00
# The tests for each config file are independent of whether the
# module is enabled or not: the config file should match its schema
# regardless.
foreach( SUBDIRECTORY ${SUBDIRECTORIES} )
set( _schema_file "${CMAKE_CURRENT_SOURCE_DIR}/${SUBDIRECTORY}/${SUBDIRECTORY}.schema.yaml" )
set( _conf_file "${CMAKE_CURRENT_SOURCE_DIR}/${SUBDIRECTORY}/${SUBDIRECTORY}.conf" )
if ( EXISTS "${_schema_file}" AND EXISTS "${_conf_file}" )
add_test(
NAME validate-${SUBDIRECTORY}
COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_SOURCE_DIR}/ci/configvalidator.py" "${_schema_file}" "${_conf_file}"
)
endif()
endforeach()
endif()
Reference in New Issue Copy Permalink