Contributing¶
Thank you for your interest in contributing to mp-units! 👍🎉
Before contributing, we strongly recommend familiarizing yourself with the official documentation.
This file is a part of MkDocs documentation
This file is part of the documentation and uses some MkDocs‑specific formatting that may look unusual in a plain Markdown renderer. For the fully rendered version, visit the Contributing chapter.
Where to Start¶
- See good first issues for beginner-friendly tasks.
- help wanted and high priority labels highlight other important work.
Preconfigured Development Environment¶
The easiest way to start coding is to use our containerized development environment in GitHub Codespaces. You can either click the button below
or navigate to the main page of the repository and click "Code" button -> "Codespaces" tab -> "Create codespace on master".
You can also use the pre-configured devcontainer and Docker image manually within your IDE.
Setting Up Your Codespace¶
- Fork the repository on GitHub (if you haven't already)
-
Create a CodeSpace from your fork
- Navigate to your forked repository
- Click "Code" → "Codespaces" → "Create codespace on master"
- Choose a 4-core machine or larger for better performance
-
Wait for initialization (~3–5 minutes)
- Container will download and start automatically
- Conan will be configured for your environment
- All VS Code extensions will be installed
Helpful commands¶
# Test with a single compiler configuration
conan build . -pr gcc15 -c user.mp-units.build:all=True -b missing
# Build and test with all supported compilers
.devcontainer/check_all.sh create
# Generating API Reference
.devcontainer/api_reference.sh
# Preview documentation locally
mkdocs serve
# Run pre-commit checks
pre-commit run --all-files
For more, see the official documentation and
.devcontainer/README.md
.
Tips¶
- Use the provided scripts for building, testing, and packaging. See the docs for advanced Conan/CMake options.
- For documentation, see the Material for MkDocs guide.
- Run
.devcontainer/check_all.sh
to test across all supported compilers. - Use
pre-commit
to auto-format code and check style before committing. - See the C++ compiler support page for supported toolchains.
Alternative: Custom Development Environment
Custom Development Environment¶
Alternatively, please refer to our official docs for download, build, and install instructions with the below changes if you want to set up a development environment on your local machine.
Building the entire repository¶
To build all the mp-units source code (with unit tests and examples), you should:
- Use the CMakeLists.txt from the top-level directory.
- Run Conan with
user.mp-units.build:all
=True
.
git clone https://github.com/mpusz/mp-units.git && cd mp-units
conan build . -pr <your_conan_profile> -s compiler.cppstd=23 -c user.mp-units.build:all=True -b missing
The above will download and install all of the dependencies needed for the development of the library, build all of the source code, and run unit tests.
If you prefer to build the project via CMake rather than Conan, then you should replace
the conan build
with conan install
command and then follow with a regular CMake build and testing:
conan install . -pr <your_conan_profile> -s compiler.cppstd=23 -c user.mp-units.build:all=True -b missing
cmake --preset conan-default
cmake --build --preset conan-release
cmake --build --preset conan-release --target all_verify_interface_header_sets
cmake --build --preset conan-release --target test
Hint
To ensure that we always build all the targets and to save some typing of the Conan commands,
we can set the following in the ~/.conan2/global.conf
:
Packaging¶
To test CMake installation and Conan packaging run:
conan create . --user <username> --channel <channel> -pr <your_conan_profile> -s compiler.cppstd=23 \
-c user.mp-units.build:all=True -b missing
The above will create a Conan package and run tests provided in ./test_package directory.
In case you would like to upload mp-units package to the Conan server, do the following:
Building documentation¶
We are building our documentation using Material for MkDocs.
The easiest way to install all the required dependencies is with pip
:
Additionally, a Cairo Graphics library is required by Material for MkDocs. Please follow the official MkDocs documentation to install it.
After that, you can either:
Generating API reference¶
We need to take a few steps to set up our environment so that we are ready to generate API reference documents.
First, we need to satisfy the requirements described in https://github.com/cplusplus/draft and https://github.com/Eelis/cxxdraft-htmlgen. On the Ubuntu platform, this is equivalent to the following instructions run from the user's home directory:
sudo apt install latexmk texlive-latex-recommended texlive-latex-extra texlive-fonts-recommended lmodern
sudo apt install haskell-stack graphviz nodejs npm ghc cabal-install
npm install split mathjax-full mathjax-node-sre mathjax-node-cli yargs@16.2.0
cabal update
On some platforms, installing mathjax-node-cli
through npm
does not update the system's PATH
environment variable resulting in tex2html
not found errors. In such cases we need to add
the .bin
folder to the PATH
environment variable manually:
Now, we are ready to start building our API reference using our automated script:
This script will:
- Configure CMake with the correct module paths
- Build both PDF and HTML documentation
- Create a symlink to the generated documentation
If you only want to setup CMake without building the documentation, use:
Custom Dependency Directory¶
By default, the script downloads dependencies to ../api_reference_deps
relative to the
project root. You can specify a custom directory using the -d
parameter:
# Use a custom directory for dependencies
.devcontainer/api_reference.sh -d /path/to/custom/deps
# Combine with setup-only mode
.devcontainer/api_reference.sh -s -d ./local_deps
The dependency directory will contain:
jegp.cmake_modules
: CMake modules for documentation generationdraft
: C++ standard draft sources for reference formattingcxxdraft-htmlgen
: HTML generation tools for standardese-style output
This is useful when you want to:
- Share dependencies across multiple project checkouts
- Avoid re-downloading dependencies for development containers
Manual documentation generation¶
Alternatively, you can run the individual steps manually.
First, we need to clone the following git repositories:
- https://github.com/JohelEGP/jegp.cmake_modules
standardese_sources_base
branch of https://github.com/JohelEGP/draftstandardese_sources_base
branch of https://github.com/JohelEGP/cxxdraft-htmlgen
For example:
git clone https://github.com/JohelEGP/jegp.cmake_modules.git --depth=1
git clone https://github.com/JohelEGP/draft.git --branch=standardese_sources_base --depth=1
git clone https://github.com/JohelEGP/cxxdraft-htmlgen.git --branch=standardese_sources_base --depth=1
Next, configure CMake with the following:
cmake -S docs/api_reference/src -B build/docs/api_reference \
-DCMAKE_MODULE_PATH="<path to gh:JohelEGP/jegp.cmake_modules>/modules" \
-DJEGP_STANDARDESE_SOURCES_GIT_REPOSITORY="<path to gh:JohelEGP/draft>" \
-DJEGP_CXXDRAFT_HTMLGEN_GIT_REPOSITORY="<path to gh:JohelEGP/cxxdraft-htmlgen>"
Then build the documentation with CMake:
The generated documentation will be available at:
- PDF:
build/docs/api_reference/mp-units.pdf
- HTML:
build/docs/api_reference/mp-units.html/
In the end, we need to move the generated documentation to the docs/api_reference/gen
subdirectory:
or just link the entire directory:
Configuration Options for Developers and Contributors¶
Conan¶
user.mp-units.build:all
-
Enables compilation of all the source code, including tests and examples. To support this, it requires some additional Conan build dependencies described in Repository directory tree and dependencies. It also runs unit tests during the Conan build (unless
tools.build:skip_test
configuration property is set toTrue
).
user.mp-units.analyze:clang-tidy
-
Enables clang-tidy analysis.
CMake¶
-
2.2.0 ·
ON
/OFF
(Default:OFF
)Enables include-what-you-use analysis.
-
2.2.0 ·
ON
/OFF
(Default:OFF
)Enables clang-tidy analysis.
-
2.5.0 ·
NONE
/ALL
/MODULES
/HEADERS
(Default:NONE
)Enables compilation performance data collection with
-ftime-trace
for clang compilers.All our unit tests compile only for headers and never for modules. To allow fair comparison,
MODULES
andHEADERS
do not enable the data collection for unit tests. This means that they affect only the core, systems, and examples.Please use
ALL
to profile unit tests as well.
Before committing git changes¶
There are a few recommended checks before committing and pushing changes.
Naming conventions¶
Here are the main rules for naming things in this repo:
- types, functions, variables use
standard_case
, - template parameters use
PascalCase
, - C++ concepts:
PascalCase
(subject to change)
Unified code formatting¶
A formatting standard is enforced with the pre-commit
script. Before committing your changes,
please do the following:
This will run:
clang-format
for code formatting with the.clang-format
file provided in the repo,cmake-format
to format the CMake files,- some other checks (e.g., python script checkers, whitespaces, etc.).
The script will run on all the files in the repo and will apply the changes in place when needed. After it finishes review and stage all modified files.
Backward compatibility¶
Before submission, please remember to check if the code compiles fine on the supported compilers. The CI will check it anyway, but it is good to check at least some of the configurations before pushing changes. Especially older compilers can be tricky as those do not have full C++20 conformance. The official list of supported compilers can always be found in the C++ compiler support (API/ABI) chapter of our documentation.
CI/CD Integration¶
Each pull request triggers a comprehensive CI pipeline:
- Multi-compiler builds: GCC 12-15, Clang 16-21 across different configurations
- Code formatting: clang-format and pre-commit checks
- Static analysis: clang-tidy analysis for code quality
- Documentation: Verification that docs build successfully
- Package testing: Conan package creation and consumption tests
- Dependency security: Automated vulnerability and license scanning