CMake: relink when linked package is rebuilt - c++

Question

I apologize if this has been asked already but I can't find online the right way to get this thing to work.
I have a cmake project Foo which depends on another cmake project Bar. Goal: whenever Bar is reinstalled (changing only the libraries, not the headers), then Foo should re-link (without rebuilding, of course).
So, in the CMakeLists.txt in the top folder of project Foo (which has only one target, an executable) I have the cmake command
FIND_PACKAGE(Bar REQUIRED)
Which, correctly, finds project Bar at configure time. In the part where I create the target, I have
LINK_DIRECTORIES (${BAR_LIBRARY_DIRS} )
ADD_EXECUTABLE(foo.exe main.cpp)
TARGET_LINK_LIBRARIES(foo.exe ${BAR_LIBRARIES})
The two variables in there are defined in BarConfig.cmake, which is the one that FIND_PACKAGE(Bar) looks for, and contains only the following instructions
SET(BAR_INCLUDE_DIRS "${CMAKE_CURRENT_LIST_DIR}/../../../include")
SET(BAR_LIBRARY_DIRS "${CMAKE_CURRENT_LIST_DIR}/../../../lib")
SET(BAR_LIBRARIES bar)
I printed on screen those variables and they contain what you expect them to contain (/path/to/folder/include, /path/to/folder/lib and bar).
So, I read somewhere that cmake cannot add a dependency to a library which is not specified with its complete path. One should write
TARGET_LINK_LIBRARIES (foo.exe full-path-to-bar-libraries)
In that case, it works. But it's unsatisfactory. First, cause the path can change. But you can read it from a variable, you might say. True. But, second, even in that case, if the project Bar contains a number of libraries that is not known, one would have to sweat to create the correct string to add there...
However, I also read that if that library is also built and installed with cmake, it should work automatically. As a matter of fact, I have another project pair, A depends on B, both built with cmake. In that case the dependence works. Unfortunately, the project B is HUGE, and defines TONS of cmake macros, and I can't identify the part where it sets up the right variables.
Do you have any idea of how to get Foo to re-link (without rebuilding) every time that the library Bar is reinstalled? I would like to avoid to use full path.
Thanks
Edit: to be more clear: if library Bar set up a variable BAR_LIBRARIES containing all its libraries with the full path, then TARGET_LINK_LIBRARIES would work. However, most likely BAR_LIBRARIES would contain 'bar', rather than '/some/path/libbar.a'. I'd like cmake to be able, given the directories provided with LINK_DIRECTORIES and the library names provided with TARGET_LINK_LIBRARIES to put the two pieces together. E.g. if BAR_LIBRARY_DIRS contains '/folder1/;/folder2/' and BAR_LIBRARIES contains 'bar1;bar2', I'd like cmake to establish a dependency on libbar1.a and libbar2.a, found in any of the following:
/folder1/libbar1.a
/folder2/libbar1.a
/folder1/libbar2.a
/folder2/libbar2.a
And relink if any of the ones upon which a dependency has been created is changed since the last linking.

Answer 1

and contains only the following instructions
You don't need to set all this variables manually, just use CMakePackageConfigHelpers module:
configure_package_config_file(
"./FooConfig.cmake.in"
"${foo_config}"
INSTALL_DESTINATION ${CONFIG_INSTALL_DESTINATION}
PATH_VARS CONFIG_INSTALL_DESTINATION
)
install(
FILES "${foo_config}"
DESTINATION ${CONFIG_INSTALL_DESTINATION}
)
and install targets:
install(
TARGETS foo DESTINATION ${LIB_INSTALL_DESTINATION} EXPORT FooTargets
)
install(
EXPORT FooTargets NAMESPACE Foo:: DESTINATION ${CONFIG_INSTALL_DESTINATION}
)
Usage in other project:
find_package(Foo CONFIG REQUIRED)
target_link_libraries(boo Foo::foo)
That's all. Work like a charm (Makefile generator example):
> cmake -HFoo -B_builds/Foo -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX="`pwd`/_install"
> cmake --build _builds/Foo/ --target install
> cmake -HBoo -B_builds/Boo -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX="`pwd`/_install" -DCMAKE_VERBOSE_MAKEFILE=ON
> cmake --build _builds/Boo
One more time (check no relink):
> cmake --build _builds/Boo
Modify target Foo and reinstall:
> echo "void some(){}" >> Foo/foo.cpp
> cmake --build _builds/Foo/ --target install
Now build Boo:
> cmake --build _builds/Boo
...
Linking CXX executable boo.exe
...
Relink!