CPM on monorepos

[gshanemiller]

CPM's ability to fetch dependencies from Github is cool, and something I will eventually get to. I also like there's no need for 61 million helper files like conan or vpkg.

However, in the present case I have a large mono repository ~25 million lines of C/C+ code. This repository has ~250 libraries all inside the repo. As such there is no need to fetch from Github. The libraries are organized with a canonical layout that makes it easy to scan and discover.

Here's what I want to do:

• run a script (that I will provide) to scan the libraries
• from each library create CPM cmake code for that library and its dependencies. Dependencies, say lib_network depends on lib_network_async will come from meta data I provide
• use the output of the previous bullet to autogenerate a Cmakefile with CPM CPMAddPackage commands
• logically extend dependencies in CMakeLists.txt for all the tasks, unit tests, integration tests
• cmake to build

Desired impact:

• Other than manually specifying the dependencies between libraries in a meta-file, the full CMakeLists.txt file is auto-built
• Later I can move individual libraries to Github while keeping the overall process and structure unchanged

Now this will require a CPMAddPackage to understand a dependency is not in github, but rather it's in a directory tree.

Once I have that I can move individual libraries into their own Git repo and revert to CPMAddPackage with Githib urls.

Feasible? My guess: this is not a good use-case since CMake does this out of the box.
Rather once libraries are migrated to standalone Git repos then CPM is well suited.

Meanwhile I'll read your https://gitlab.com/external-packages/cpm.cmake carefully.

Regards!

[TheLartians]

If I understand correctly, your plan is to replace add_subdirectory with CPM calls to treat the subdirectories as individual projects and be able to migrate easier in the future? In that case, yes this is common and a very much supported use-case with CPM, using the SOURCE_DIR option. See here for an example how to include a directory relative to the current CMakeLists.

[aedart]

Hi @TheLartians

I am in a similar situation, in which I would like to create a mono-repository that contains multiple packages (projects), each having own dependencies and inter-dependencies. The standalone example does show how the SOURCE_DIR can be used. But, if the "standalone" project was to be published (by itself), will the Greeter package not fail?

I'm sorry if this is getting a bit strange to read... I'm trying to create a structure as shown below:

/my-root-project
    /packages
        /foo
            /src
            CMakeLists.txt
        /bar
            /src
            CMakeLists.txt
    CMakeLists.txt

In such an example, each project should be able to be "installable" on its own. However, each project might have inter-dependencies, e.g. /bar might depend on /foo, etc, and also 3rd party dependencies.
In this context, "installable" should be interpreted as a "standalone package" that can be obtained using CPM.

Would it be possible for you (or anyone that knows how), to create a minimalistic example of such a project structure, using CPM to manage dependencies?