WIP: restructure

A stupid attempt to reduce code duplication led me to believe that all
the scripts could use _a bit_ of refactoring.
This is going to be a major pain (factoring out all the things), which
I'll take gladly.
All the links and usage examples are broken right now, but nobody cares,
so whatevs.

14 files changed, 1285 insertions, 0 deletions

diff --git a/project/__init__.py b/project/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/project/__init__.py
diff --git a/project/boost/README.md b/project/boost/README.md
new file mode 100644
index 0000000..c1f903e
--- /dev/null
+++ b/project/boost/README.md
@@ -0,0 +1,13 @@
+Boost
+=====
+
+Download & build the Boost libraries in a cross-platform way.
+Consult the output of `build.py --help` for details.
+
+A simple usage example to download and build Boost 1.71.0:
+
+    $ python3 build.py download 1.71.0
+    ...
+
+    $ python3 build.py build -- boost_1_71_0/ --with-filesystem --with-program_options
+    ...
diff --git a/project/boost/__init__.py b/project/boost/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/project/boost/__init__.py
diff --git a/project/boost/build.py b/project/boost/build.py
new file mode 100644
index 0000000..8da8c9e
--- /dev/null
+++ b/project/boost/build.py
@@ -0,0 +1,566 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2019 Egor Tensin <Egor.Tensin@gmail.com>
+# This file is part of the "cmake-common" project.
+# For details, see https://github.com/egor-tensin/cmake-common.
+# Distributed under the MIT License.
+
+'''Download & build Boost.
+
+This script downloads and builds the Boost libraries.  It's main purpose is to:
+1) provide a cross-platform way to download & unpack the Boost distribution
+archive,
+2) set the correct --stagedir parameter value to avoid name clashes.
+
+Please pick a command below.  You can execute `%(prog)s COMMAND --help` to view
+its usage message.
+
+A simple usage example:
+
+    $ %(prog)s download 1.71.0
+    ...
+
+    $ %(prog)s build -- boost_1_71_0/ --with-filesystem --with-program_options
+    ...
+'''
+
+import abc
+import argparse
+from collections import namedtuple
+from contextlib import contextmanager
+from enum import Enum
+from functools import total_ordering
+import logging
+import os.path
+import platform
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import urllib.request
+
+
+@contextmanager
+def _chdir(path):
+    cwd = os.getcwd()
+    os.chdir(path)
+    try:
+        yield
+    finally:
+        os.chdir(cwd)
+
+
+def _setup_logging():
+    logging.basicConfig(
+        format='%(asctime)s | %(levelname)s | %(message)s',
+        level=logging.INFO)
+
+
+def _on_windows():
+    return platform.system() == 'Windows'
+
+
+def _on_linux():
+    return not _on_windows()
+
+
+def _run_executable(cmd_line):
+    logging.info('Running executable: %s', cmd_line)
+    return subprocess.run(cmd_line, check=True)
+
+
+class Platform(Enum):
+    X86 = 'x86'
+    X64 = 'x64'
+    WIN32 = 'Win32'
+
+    def __str__(self):
+        return self.value
+
+    @staticmethod
+    def all():
+        return (Platform.X86, Platform.X64)
+
+    def get_address_model(self):
+        if self is Platform.X86:
+            return 32
+        if self is Platform.X64:
+            return 64
+        if self is Platform.WIN32:
+            return 32
+        raise NotImplementedError(f'unsupported platform: {self}')
+
+
+def _parse_platform(s):
+    try:
+        return Platform(s)
+    except ValueError:
+        raise argparse.ArgumentTypeError(f'invalid platform: {s}')
+
+
+class Configuration(Enum):
+    # AFAIK, Boost only supports debug/release, MinSizeRel and RelWithDebInfo
+    # are for compatibility with CMake, they map to "release".
+    # The libraries will still reside in stage/PLATFORM/CONFIGURATION/lib, even
+    # if CONFIGURATION is MinSizeRel/RelWithDebInfo.
+    DEBUG = 'Debug'
+    MINSIZEREL = 'MinSizeRel'
+    RELWITHDEBINFO = 'RelWithDebInfo'
+    RELEASE = 'Release'
+
+    def normalize(self):
+        '''Roughly maps CMake's CMAKE_BUILD_TYPE to Boost's variant.'''
+        if self is Configuration.MINSIZEREL:
+            return Configuration.RELEASE
+        if self is Configuration.RELWITHDEBINFO:
+            return Configuration.RELEASE
+        return self
+
+    @staticmethod
+    def all():
+        return (Configuration.DEBUG, Configuration.RELEASE)
+
+    def __str__(self):
+        return self.value
+
+
+def _parse_configuration(s):
+    try:
+        return Configuration(s)
+    except ValueError:
+        raise argparse.ArgumentTypeError(f'invalid configuration: {s}')
+
+
+class Linkage(Enum):
+    STATIC = 'static'
+    SHARED = 'shared'
+
+    @staticmethod
+    def all():
+        return tuple(Linkage)
+
+    def __str__(self):
+        return self.value
+
+
+def _parse_linkage(s):
+    try:
+        return Linkage(s)
+    except ValueError:
+        raise argparse.ArgumentTypeError(f'invalid linkage: {s}')
+
+
+_Version = namedtuple('_Version', ['major', 'minor', 'patch'])
+
+
+@total_ordering
+class BoostVersion:
+    def __init__(self, major, minor, patch):
+        self._impl = _Version(major, minor, patch)
+
+    @property
+    def major(self):
+        return self._impl.major
+
+    @property
+    def minor(self):
+        return self._impl.minor
+
+    @property
+    def patch(self):
+        return self._impl.patch
+
+    def __lt__(self, other):
+        return self._impl < other._impl
+
+    def __eq__(self, other):
+        return self._impl == other._impl
+
+    @staticmethod
+    def from_string(s):
+        result = re.match(r'^(\d+)\.(\d+)\.(\d+)$', s)
+        if result is None:
+            raise ValueError(f'invalid Boost version: {s}')
+        major = int(result.group(1))
+        minor = int(result.group(2))
+        patch = int(result.group(3))
+        return BoostVersion(major, minor, patch)
+
+    def __str__(self):
+        return f'{self.major}.{self.minor}.{self.patch}'
+
+    @property
+    def archive_ext(self):
+        return '.tar.gz'
+
+    def dir_path(self, parent_dir):
+        return os.path.join(parent_dir, self.dir_name)
+
+    @property
+    def dir_name(self):
+        return f'boost_{self.major}_{self.minor}_{self.patch}'
+
+    @property
+    def archive_name(self):
+        return f'{self.dir_name}{self.archive_ext}'
+
+    def _get_bintray_url(self):
+        return f'https://dl.bintray.com/boostorg/release/{self}/source/{self.archive_name}'
+
+    def _get_sourceforge_url(self):
+        return f'https://sourceforge.net/projects/boost/files/boost/{self}/{self.archive_name}/download'
+
+    def get_download_urls(self):
+        if self._impl < _Version(1, 63, 0):
+            # For versions older than 1.63.0, SourceForge is the only option:
+            return [self._get_sourceforge_url()]
+        # Otherwise, Bintray is preferred (the official website links to it).
+        return [self._get_bintray_url(), self._get_sourceforge_url()]
+
+
+class BoostArchive:
+    def __init__(self, version, path):
+        self.version = version
+        self.path = path
+
+    @property
+    def dir_name(self):
+        return self.version.dir_name
+
+    def unpack(self, dest_dir):
+        path = os.path.join(dest_dir, self.dir_name)
+        if os.path.exists(path):
+            raise RuntimeError(f'Boost directory already exists: {path}')
+        logging.info('Unpacking Boost to: %s', path)
+        shutil.unpack_archive(self.path, dest_dir)
+        return BoostDir(path)
+
+
+class ArchiveStorage(abc.ABC):
+    @contextmanager
+    def download(self, version):
+        path = self.get_archive(version)
+        if path is not None:
+            logging.info('Using existing Boost archive: %s', path)
+            yield BoostArchive(version, path)
+            return
+
+        urls = version.get_download_urls()
+
+        for url in urls:
+            logging.info('Trying URL: %s', url)
+            try:
+                with urllib.request.urlopen(url, timeout=20) as request:
+                    with self.write_archive(version, request.read()) as path:
+                        yield BoostArchive(version, path)
+                        return
+            except urllib.request.URLError as e:
+                logging.error("Couldn't download from this mirror, an error occured:")
+                logging.exception(e)
+
+        raise RuntimeError("Couldn't download Boost from any of the mirrors")
+
+    @abc.abstractmethod
+    def get_archive(self, version):
+        pass
+
+    @contextmanager
+    @abc.abstractmethod
+    def write_archive(self, version, contents):
+        pass
+
+
+class CacheStorage(ArchiveStorage):
+    def __init__(self, cache_dir):
+        self._dir = cache_dir
+
+    def _archive_path(self, version):
+        return os.path.join(self._dir, version.archive_name)
+
+    def get_archive(self, version):
+        path = self._archive_path(version)
+        if os.path.exists(path):
+            return path
+        return None
+
+    @contextmanager
+    def write_archive(self, version, contents):
+        path = self._archive_path(version)
+        logging.info('Writing Boost archive: %s', path)
+        if os.path.exists(path):
+            raise RuntimeError(f'cannot download Boost, file already exists: {path}')
+        with open(path, mode='w+b') as dest:
+            dest.write(contents)
+        yield path
+
+
+class TempStorage(ArchiveStorage):
+    def __init__(self, temp_dir):
+        self._dir = temp_dir
+
+    def get_archive(self, version):
+        return None
+
+    @contextmanager
+    def write_archive(self, version, contents):
+        with tempfile.NamedTemporaryFile(prefix=f'boost_{version}_', suffix=version.archive_ext, dir=self._dir, delete=False) as dest:
+            path = dest.name
+            logging.info('Writing Boost archive: %s', path)
+            dest.write(contents)
+        try:
+            yield path
+        finally:
+            logging.info('Removing temporary Boost archive: %s', path)
+            os.remove(path)
+
+
+class BoostDir:
+    def __init__(self, path):
+        if not os.path.isdir(path):
+            raise RuntimeError(f"Boost directory doesn't exist: {path}")
+        self.path = path
+
+    def _go(self):
+        return _chdir(self.path)
+
+    def build(self, params):
+        with self._go():
+            self._bootstrap_if_required()
+            self._b2(params)
+
+    def _bootstrap_if_required(self):
+        if os.path.isfile(self._b2_path()):
+            logging.info('Not going to bootstrap, b2 is already there')
+            return
+        self.bootstrap()
+
+    def bootstrap(self):
+        with self._go():
+            _run_executable(self._bootstrap_path())
+
+    def _b2(self, params):
+        for b2_params in params.enum_b2_args():
+            _run_executable([self._b2_path()] + b2_params)
+
+    @staticmethod
+    def _bootstrap_path():
+        return os.path.join('.', BoostDir._bootstrap_name())
+
+    @staticmethod
+    def _bootstrap_name():
+        ext = '.sh'
+        if _on_windows():
+            ext = '.bat'
+        return f'bootstrap{ext}'
+
+    @staticmethod
+    def _b2_path():
+        return os.path.join('.', BoostDir._b2_name())
+
+    @staticmethod
+    def _b2_name():
+        ext = ''
+        if _on_windows():
+            ext = '.exe'
+        return f'b2{ext}'
+
+
+class BuildParameters:
+    def __init__(self, args):
+        self.platforms = args.platforms or Platform.all()
+        self.configurations = args.configurations or Configuration.all()
+        self.link = args.link or Linkage.all()
+        self.runtime_link = args.runtime_link
+
+        self.stage_dir = 'stage'
+
+        self.build_dir = args.build_dir
+        self.boost_dir = args.boost_dir
+
+        self.b2_args = args.b2_args
+
+    def enum_b2_args(self):
+        with self._create_build_dir() as build_dir:
+            for platform in self.platforms:
+                for configuration in self.configurations:
+                    for link, runtime_link in self._linkage_options():
+                        yield self._build_params(build_dir, platform, configuration, link, runtime_link)
+
+    def _linkage_options(self):
+        for link in self.link:
+            runtime_link = self.runtime_link
+            if runtime_link is Linkage.STATIC:
+                if link is Linkage.SHARED:
+                    logging.warning("Cannot link the runtime statically to a dynamic library, going to link dynamically")
+                    runtime_link = Linkage.SHARED
+                elif _on_linux():
+                    logging.warning("Cannot link to the GNU C Library (which is assumed) statically, going to link dynamically")
+                    runtime_link = Linkage.SHARED
+            yield link, runtime_link
+
+    @contextmanager
+    def _create_build_dir(self):
+        if self.build_dir is not None:
+            logging.info('Build directory: %s', self.build_dir)
+            yield self.build_dir
+            return
+
+        with tempfile.TemporaryDirectory(dir=os.path.dirname(self.boost_dir)) as build_dir:
+            logging.info('Build directory: %s', build_dir)
+            try:
+                yield build_dir
+            finally:
+                logging.info('Removing build directory: %s', build_dir)
+            return
+
+    def _build_params(self, build_dir, platform, configuration, link, runtime_link):
+        params = []
+        params.append(self._build_dir(build_dir))
+        params.append(self._stagedir(platform, configuration))
+        params.append(self._link(link))
+        params.append(self._runtime_link(runtime_link))
+        params.append(self._address_model(platform))
+        params.append(self._variant(configuration))
+        params += self.b2_args
+        return params
+
+    @staticmethod
+    def _build_dir(build_dir):
+        return f'--build-dir={build_dir}'
+
+    def _stagedir(self, platform, configuration):
+        # Having different --stagedir values for every configuration/platform
+        # combination is unnecessary on Windows.
+        # Even for older Boost versions (when the binaries weren't tagged with
+        # their target platform) only a single --stagedir for every platform
+        # would suffice.
+        # For newer versions, just a single --stagedir would do, as the
+        # binaries are tagged with the target platform, as well as their
+        # configuration (a.k.a. "variant" in Boost's terminology).
+        # Still, uniformity helps.
+        platform = str(platform)
+        configuration = str(configuration)
+        return f'--stagedir={os.path.join(self.stage_dir, platform, configuration)}'
+
+    @staticmethod
+    def _link(link):
+        return f'link={link}'
+
+    @staticmethod
+    def _runtime_link(runtime_link):
+        return f'runtime-link={runtime_link}'
+
+    @staticmethod
+    def _address_model(platform):
+        return f'address-model={platform.get_address_model()}'
+
+    @staticmethod
+    def _variant(configuration):
+        return f'variant={str(configuration.normalize()).lower()}'
+
+
+def _parse_dir(s):
+    return os.path.abspath(os.path.normpath(s))
+
+
+def _parse_args(argv=None):
+    if argv is None:
+        argv = sys.argv[1:]
+    logging.info('Command line arguments: %s', argv)
+
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+
+    subparsers = parser.add_subparsers(dest='command')
+
+    download = subparsers.add_parser('download', help='download & bootstrap Boost')
+
+    download.add_argument('--cache', metavar='DIR', dest='cache_dir',
+                          type=_parse_dir,
+                          help='download directory (temporary file unless specified)')
+    download.add_argument('--unpack', metavar='DIR', dest='unpack_dir',
+                          type=_parse_dir, default='.',
+                          help='directory to unpack the archive to')
+    download.add_argument('boost_version', metavar='VERSION',
+                          type=BoostVersion.from_string,
+                          help='Boost version (in the MAJOR.MINOR.PATCH format)')
+
+    build = subparsers.add_parser('build', help='build the libraries')
+
+    # These are used to put the built libraries into proper stage/
+    # subdirectories (to avoid name clashes).
+    build.add_argument('--platform', metavar='PLATFORM',
+                       nargs='*', dest='platforms', default=[],
+                       type=_parse_platform,
+                       help=f'target platform ({"/".join(map(str, Platform))})')
+    build.add_argument('--configuration', metavar='CONFIGURATION',
+                       nargs='*', dest='configurations', default=[],
+                       type=_parse_configuration,
+                       help=f'target configuration ({"/".join(map(str, Configuration))})')
+    # This is needed because the default behaviour on Linux and Windows is
+    # different: static & dynamic libs are built on Linux, but only static libs
+    # are built on Windows by default.
+    build.add_argument('--link', metavar='LINKAGE',
+                       nargs='*', default=[],
+                       type=_parse_linkage,
+                       help=f'how the libraries are linked ({"/".join(map(str, Linkage))})')
+    # This is used to omit runtime-link=static I'd have to otherwise use a lot,
+    # plus the script validates the link= and runtime-link= combinations.
+    build.add_argument('--runtime-link', metavar='LINKAGE',
+                       type=_parse_linkage, default=Linkage.STATIC,
+                       help=f'how the libraries link to the runtime ({"/".join(map(str, Linkage))})')
+
+    build.add_argument('--build', metavar='DIR', dest='build_dir',
+                       type=_parse_dir,
+                       help='Boost build directory (temporary directory unless specified)')
+    build.add_argument('boost_dir', metavar='DIR',
+                       type=_parse_dir,
+                       help='root Boost directory')
+
+    build.add_argument('b2_args', nargs='*', metavar='B2_ARG', default=[],
+                       help='additional b2 arguments, to be passed verbatim')
+
+    args = parser.parse_args(argv)
+    if args.command is None:
+        parser.error("please specify a command")
+    return args
+
+
+def build(args):
+    build_params = BuildParameters(args)
+    boost_dir = BoostDir(args.boost_dir)
+    boost_dir.build(build_params)
+
+
+def download(args):
+    storage = TempStorage(args.unpack_dir)
+    if args.cache_dir is not None:
+        storage = CacheStorage(args.cache_dir)
+    with storage.download(args.boost_version) as archive:
+        boost_dir = archive.unpack(args.unpack_dir)
+        boost_dir.bootstrap()
+
+
+def main(argv=None):
+    args = _parse_args(argv)
+    if args.command == 'download':
+        download(args)
+    elif args.command == 'build':
+        build(args)
+    else:
+        raise NotImplementedError(f'unsupported command: {args.command}')
+
+
+def _main(argv=None):
+    _setup_logging()
+    try:
+        main(argv)
+    except Exception as e:
+        logging.exception(e)
+        raise
+
+
+if __name__ == '__main__':
+    _main()
diff --git a/project/ci/__init__.py b/project/ci/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/project/ci/__init__.py
diff --git a/project/ci/appveyor/__init__.py b/project/ci/appveyor/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/project/ci/appveyor/__init__.py
diff --git a/project/ci/appveyor/boost.py b/project/ci/appveyor/boost.py
new file mode 100644
index 0000000..4218dd6
--- /dev/null
+++ b/project/ci/appveyor/boost.py
@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2020 Egor Tensin <Egor.Tensin@gmail.com>
+# This file is part of the "cmake-common" project.
+# For details, see https://github.com/egor-tensin/cmake-common.
+# Distributed under the MIT License.
+
+'''Download & build Boost on AppVeyor.
+
+This is similar to build.py, but auto-fills some parameters for build.py from
+the AppVeyor-defined environment variables.  This script is rarely usefull,
+since AppVeyor images come with lots of pre-built Boost distributions, but
+still.
+
+Boost is built in C:\projects\boost.
+'''
+
+import argparse
+import logging
+import os
+import os.path
+import sys
+
+from project.boost.build import BoostVersion, main as build_main
+
+
+def _env(name):
+    if name not in os.environ:
+        raise RuntimeError(f'undefined environment variable: {name}')
+    return os.environ[name]
+
+
+def _check_appveyor():
+    if 'APPVEYOR' not in os.environ:
+        raise RuntimeError('not running on AppVeyor')
+
+
+def _get_build_dir():
+    return 'C:\\projects'
+
+
+def _get_boost_dir():
+    return os.path.join(_get_build_dir(), 'boost')
+
+
+def _get_boost_version():
+    return _env('appveyor_boost_version')
+
+
+def _get_configuration():
+    return _env('CONFIGURATION')
+
+
+def _get_platform():
+    return _env('PLATFORM')
+
+
+def _setup_logging():
+    logging.basicConfig(
+        format='%(asctime)s | %(levelname)s | %(message)s',
+        level=logging.INFO)
+
+
+def _parse_args(argv=None):
+    if argv is None:
+        argv = sys.argv[1:]
+    logging.info('Command line arguments: %s', argv)
+
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument('--link', metavar='LINKAGE', nargs='*',
+                        help='how the libraries are linked (i.e. static/shared)')
+    parser.add_argument('--runtime-link', metavar='LINKAGE',
+                        help='how the libraries link to the runtime')
+    parser.add_argument('b2_args', nargs='*', metavar='B2_ARG', default=[],
+                        help='additional b2 arguments, to be passed verbatim')
+    return parser.parse_args(argv)
+
+
+def build_appveyor(argv=None):
+    args = _parse_args(argv)
+    _check_appveyor()
+
+    version = BoostVersion.from_string(_get_boost_version())
+    appveyor_argv = [
+        'download',
+        '--unpack', _get_build_dir(),
+        '--', str(version)
+    ]
+    build_main(appveyor_argv)
+
+    unpacked_boost_dir = version.dir_path(_get_build_dir())
+    boost_dir = _get_boost_dir()
+    os.rename(unpacked_boost_dir, boost_dir)
+
+    appveyor_argv = [
+        'build',
+        '--configuration', _get_configuration(),
+        '--platform', _get_platform(),
+    ]
+    if args.link is not None:
+        appveyor_argv.append('--link')
+        appveyor_argv += args.link
+    if args.runtime_link is not None:
+        appveyor_argv += ['--runtime-link', args.runtime_link]
+    appveyor_argv += ['--', boost_dir]
+    build_main(appveyor_argv + args.b2_args)
+
+
+def main(argv=None):
+    _setup_logging()
+    try:
+        build_appveyor(argv)
+    except Exception as e:
+        logging.exception(e)
+        raise
+
+
+if __name__ == '__main__':
+    main()
diff --git a/project/ci/appveyor/cmake.py b/project/ci/appveyor/cmake.py
new file mode 100644
index 0000000..e1ebce0
--- /dev/null
+++ b/project/ci/appveyor/cmake.py
@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2019 Egor Tensin <Egor.Tensin@gmail.com>
+# This file is part of the "cmake-common" project.
+# For details, see https://github.com/egor-tensin/cmake-common.
+# Distributed under the MIT License.
+
+'''Build a CMake project on AppVeyor.
+
+This is similar to build.py, but auto-fills some parameters for build.py from
+the AppVeyor-defined environment variables.
+
+The project is built in C:\Projects\build.
+'''
+
+import argparse
+from enum import Enum
+import logging
+import os
+import sys
+
+from project.cmake.build import build
+
+
+class Image(Enum):
+    VS_2013 = 'Visual Studio 2013'
+    VS_2015 = 'Visual Studio 2015'
+    VS_2017 = 'Visual Studio 2017'
+    VS_2019 = 'Visual Studio 2019'
+
+    def __str__(self):
+        return self.value
+
+
+def _parse_image(s):
+    try:
+        return Image(s)
+    except ValueError as e:
+        raise ValueError(f'unsupported AppVeyor image: {s}') from e
+
+
+class Generator(Enum):
+    VS_2013 = 'Visual Studio 12 2013'
+    VS_2015 = 'Visual Studio 14 2015'
+    VS_2017 = 'Visual Studio 15 2017'
+    VS_2019 = 'Visual Studio 16 2019'
+
+    def __str__(self):
+        return self.value
+
+    @staticmethod
+    def from_image(image):
+        if image is Image.VS_2013:
+            return Generator.VS_2013
+        if image is Image.VS_2015:
+            return Generator.VS_2015
+        if image is Image.VS_2017:
+            return Generator.VS_2017
+        if image is Image.VS_2019:
+            return Generator.VS_2019
+        raise RuntimeError(f"don't know which generator to use for image: {image}")
+
+
+class Platform(Enum):
+    x86 = 'Win32'
+    X64 = 'x64'
+
+    def __str__(self):
+        return self.value
+
+
+def _parse_platform(s):
+    try:
+        return Platform(s)
+    except ValueError as e:
+        raise ValueError(f'unsupported AppVeyor platform: {s}') from e
+
+
+def _env(name):
+    if name not in os.environ:
+        raise RuntimeError(f'undefined environment variable: {name}')
+    return os.environ[name]
+
+
+def _check_appveyor():
+    if 'APPVEYOR' not in os.environ:
+        raise RuntimeError('not running on AppVeyor')
+
+
+def _get_src_dir():
+    return _env('APPVEYOR_BUILD_FOLDER')
+
+
+def _get_build_dir():
+    return R'C:\Projects\build'
+
+
+def _get_generator():
+    image = _parse_image(_env('APPVEYOR_BUILD_WORKER_IMAGE'))
+    return str(Generator.from_image(image))
+
+
+def _get_platform():
+    return str(_parse_platform(_env('PLATFORM')))
+
+
+def _get_configuration():
+    return _env('CONFIGURATION')
+
+
+def _setup_logging():
+    logging.basicConfig(
+        format='%(asctime)s | %(levelname)s | %(message)s',
+        level=logging.INFO)
+
+
+def _parse_args(argv=None):
+    if argv is None:
+        argv = sys.argv[1:]
+    logging.info('Command line arguments: %s', argv)
+
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+
+    parser.add_argument('--install', metavar='DIR', dest='install_dir',
+                        help='install directory')
+    parser.add_argument('cmake_args', nargs='*', metavar='CMAKE_ARG', default=[],
+                        help='additional CMake arguments, to be passed verbatim')
+    return parser.parse_args(argv)
+
+
+def build_appveyor(argv=None):
+    args = _parse_args(argv)
+    _check_appveyor()
+
+    appveyor_argv = [
+        '--build', _get_build_dir(),
+        '--configuration', _get_configuration(),
+    ]
+    if args.install_dir is not None:
+        appveyor_argv += [
+            '--install', args.install_dir,
+        ]
+    appveyor_argv += [
+        '--',
+        _get_src_dir(),
+        '-G', _get_generator(),
+        '-A', _get_platform(),
+    ]
+    build(appveyor_argv + args.cmake_args)
+
+
+def main(argv=None):
+    _setup_logging()
+    try:
+        build_appveyor(argv)
+    except Exception as e:
+        logging.exception(e)
+        raise
+
+
+if __name__ == '__main__':
+    main()
diff --git a/project/ci/travis/__init__.py b/project/ci/travis/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/project/ci/travis/__init__.py
diff --git a/project/ci/travis/boost.py b/project/ci/travis/boost.py
new file mode 100644
index 0000000..46ae96b
--- /dev/null
+++ b/project/ci/travis/boost.py
@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2019 Egor Tensin <Egor.Tensin@gmail.com>
+# This file is part of the "cmake-common" project.
+# For details, see https://github.com/egor-tensin/cmake-common.
+# Distributed under the MIT License.
+
+'''Download & build Boost on Travis.
+
+This is similar to build.py, but auto-fills some parameters for build.py from
+the Travis-defined environment variables.
+
+Boost is built in $HOME/boost.
+'''
+
+import argparse
+import logging
+import os
+import os.path
+import sys
+
+from project.boost.build import BoostVersion, main as build_main
+
+
+def _env(name):
+    if name not in os.environ:
+        raise RuntimeError(f'undefined environment variable: {name}')
+    return os.environ[name]
+
+
+def _check_travis():
+    if 'TRAVIS' not in os.environ:
+        raise RuntimeError('not running on Travis')
+
+
+def _get_build_dir():
+    return _env('HOME')
+
+
+def _get_boost_dir():
+    return os.path.join(_get_build_dir(), 'boost')
+
+
+def _get_boost_version():
+    return _env('travis_boost_version')
+
+
+def _get_configuration():
+    return _env('configuration')
+
+
+def _get_platform():
+    return _env('platform')
+
+
+def _setup_logging():
+    logging.basicConfig(
+        format='%(asctime)s | %(levelname)s | %(message)s',
+        level=logging.INFO)
+
+
+def _parse_args(argv=None):
+    if argv is None:
+        argv = sys.argv[1:]
+    logging.info('Command line arguments: %s', argv)
+
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument('--link', metavar='LINKAGE', nargs='*',
+                        help='how the libraries are linked')
+    parser.add_argument('--runtime-link', metavar='LINKAGE',
+                        help='how the libraries link to the runtime')
+    parser.add_argument('b2_args', nargs='*', metavar='B2_ARG', default=[],
+                        help='additional b2 arguments, to be passed verbatim')
+    return parser.parse_args(argv)
+
+
+def build_travis(argv=None):
+    args = _parse_args(argv)
+    _check_travis()
+
+    version = BoostVersion.from_string(_get_boost_version())
+    travis_argv = [
+        'download',
+        '--unpack', _get_build_dir(),
+        '--', str(version)
+    ]
+    build_main(travis_argv)
+
+    unpacked_boost_dir = version.dir_path(_get_build_dir())
+    boost_dir = _get_boost_dir()
+    os.rename(unpacked_boost_dir, boost_dir)
+
+    travis_argv = [
+        'build',
+        '--configuration', _get_configuration(),
+        '--platform', _get_platform(),
+    ]
+    if args.link is not None:
+        travis_argv.append('--link')
+        travis_argv += args.link
+    if args.runtime_link is not None:
+        travis_argv += ['--runtime-link', args.runtime_link]
+    travis_argv += ['--', boost_dir]
+    build_main(travis_argv + args.b2_args)
+
+
+def main(argv=None):
+    _setup_logging()
+    try:
+        build_travis(argv)
+    except Exception as e:
+        logging.exception(e)
+        raise
+
+
+if __name__ == '__main__':
+    main()
diff --git a/project/ci/travis/cmake.py b/project/ci/travis/cmake.py
new file mode 100644
index 0000000..7a1f707
--- /dev/null
+++ b/project/ci/travis/cmake.py
@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2019 Egor Tensin <Egor.Tensin@gmail.com>
+# This file is part of the "cmake-common" project.
+# For details, see https://github.com/egor-tensin/cmake-common.
+# Distributed under the MIT License.
+
+'''Build a CMake project on Travis.
+
+This is similar to build.py, but auto-fills some parameters for build.py from
+the Travis-defined environment variables.
+
+The project is built in $HOME/build.
+'''
+
+import argparse
+import logging
+import os
+import os.path
+import sys
+
+from project.cmake.build import build
+
+
+def _env(name):
+    if name not in os.environ:
+        raise RuntimeError(f'undefined environment variable: {name}')
+    return os.environ[name]
+
+
+def _check_travis():
+    if 'TRAVIS' not in os.environ:
+        raise RuntimeError('not running on Travis')
+
+
+def _get_src_dir():
+    return _env('TRAVIS_BUILD_DIR')
+
+
+def _get_build_dir():
+    return os.path.join(_env('HOME'), 'build')
+
+
+def _get_configuration():
+    return _env('configuration')
+
+
+def _setup_logging():
+    logging.basicConfig(
+        format='%(asctime)s | %(levelname)s | %(message)s',
+        level=logging.INFO)
+
+
+def _parse_args(argv=None):
+    if argv is None:
+        argv = sys.argv[1:]
+    logging.info('Command line arguments: %s', argv)
+
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+
+    parser.add_argument('--install', metavar='DIR', dest='install_dir',
+                        help='install directory')
+    parser.add_argument('cmake_args', nargs='*', metavar='CMAKE_ARG', default=[],
+                        help='additional CMake arguments, to be passed verbatim')
+    return parser.parse_args(argv)
+
+
+def build_travis(argv=None):
+    args = _parse_args(argv)
+    _check_travis()
+
+    travis_argv = [
+        '--build', _get_build_dir(),
+        '--configuration', _get_configuration(),
+    ]
+    if args.install_dir is not None:
+        travis_argv += [
+            '--install', args.install_dir,
+        ]
+    travis_argv += [
+        '--',
+        _get_src_dir(),
+    ]
+    build(travis_argv + args.cmake_args)
+
+
+def main(argv=None):
+    _setup_logging()
+    try:
+        build_travis(argv)
+    except Exception as e:
+        logging.exception(e)
+        raise
+
+
+if __name__ == '__main__':
+    main()
diff --git a/project/cmake/README.md b/project/cmake/README.md
new file mode 100644
index 0000000..b63564d
--- /dev/null
+++ b/project/cmake/README.md
@@ -0,0 +1,13 @@
+CMake
+=====
+
+Build a CMake project.
+Consult the output of `build.py --help` for details.
+
+A simple usage example:
+
+    > python3 build.py --configuration Release --install path/to/somewhere -- ../examples/simple
+    ...
+
+    > ./path/to/somewhere/bin/foo
+    foo
diff --git a/project/cmake/__init__.py b/project/cmake/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/project/cmake/__init__.py
diff --git a/project/cmake/build.py b/project/cmake/build.py
new file mode 100644
index 0000000..695489b
--- /dev/null
+++ b/project/cmake/build.py
@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2019 Egor Tensin <Egor.Tensin@gmail.com>
+# This file is part of the "cmake-common" project.
+# For details, see https://github.com/egor-tensin/cmake-common.
+# Distributed under the MIT License.
+
+R'''Build a CMake project.
+
+This script is used basically to invoke the CMake executable in a
+cross-platform way (provided the platform has Python 3, of course).  The
+motivation was to merge my Travis and AppVeyor build scripts (largely similar,
+but written in bash and PowerShell, respectively).
+
+A simple usage example:
+
+    $ %(prog)s --configuration Release --install path/to/somewhere -- ../examples/simple
+    ...
+
+    $ ./path/to/somewhere/bin/foo
+    foo
+
+Picking the target platform is build system-specific.  On Visual Studio, pass
+the target platform using the `-A` flag like this:
+
+    > %(prog)s --install path\to\somewhere -- ..\examples\simple -A Win32
+    ...
+
+Using GCC-like compilers, the best way is to use CMake toolchain files (see
+cmake/toolchains in this repository for examples).
+
+    $ %(prog)s --install path/to/somewhere -- ../examples/simple -D CMAKE_TOOLCHAIN_FILE="$( pwd )/../toolchains/mingw-x86.cmake"
+    ...
+'''
+
+import argparse
+from contextlib import contextmanager
+import logging
+from enum import Enum
+import os
+import os.path
+import subprocess
+import sys
+import tempfile
+
+
+def _run_executable(cmd_line):
+    logging.info('Running executable: %s', cmd_line)
+    return subprocess.run(cmd_line, check=True)
+
+
+def _run_cmake(cmake_args):
+    _run_executable(['cmake'] + cmake_args)
+
+
+class Configuration(Enum):
+    DEBUG = 'Debug'
+    MINSIZEREL = 'MinSizeRel'
+    RELWITHDEBINFO = 'RelWithDebInfo'
+    RELEASE = 'Release'
+
+    def __str__(self):
+        return self.value
+
+
+def _parse_configuration(s):
+    try:
+        return Configuration(s)
+    except ValueError:
+        raise argparse.ArgumentTypeError(f'invalid configuration: {s}')
+
+
+@contextmanager
+def _create_build_dir(args):
+    if args.build_dir is not None:
+        logging.info('Build directory: %s', args.build_dir)
+        yield args.build_dir
+        return
+
+    with tempfile.TemporaryDirectory(dir=os.path.dirname(args.src_dir)) as build_dir:
+        logging.info('Build directory: %s', build_dir)
+        try:
+            yield build_dir
+        finally:
+            logging.info('Removing build directory: %s', build_dir)
+        return
+
+
+class GenerationPhase:
+    def __init__(self, build_dir, args):
+        self.build_dir = build_dir
+        self.args = args
+
+    def _cmake_args(self):
+        return self._to_cmake_args(self.build_dir, self.args)
+
+    @staticmethod
+    def _to_cmake_args(build_dir, args):
+        result = []
+        if args.install_dir is not None:
+            result += ['-D', f'CMAKE_INSTALL_PREFIX={args.install_dir}']
+        if args.configuration is not None:
+            result += ['-D', f'CMAKE_BUILD_TYPE={args.configuration}']
+        if args.cmake_args is not None:
+            result += args.cmake_args
+        result += [f'-B{build_dir}', f'-H{args.src_dir}']
+        return result
+
+    def run(self):
+        _run_cmake(self._cmake_args())
+
+
+class BuildPhase:
+    def __init__(self, build_dir, args):
+        self.build_dir = build_dir
+        self.args = args
+
+    def _cmake_args(self):
+        return self._to_cmake_args(self.build_dir, self.args)
+
+    @staticmethod
+    def _to_cmake_args(build_dir, args):
+        result = ['--build', build_dir]
+        if args.configuration is not None:
+            result += ['--config', str(args.configuration)]
+        if args.install_dir is not None:
+            result += ['--target', 'install']
+        return result
+
+    def run(self):
+        _run_cmake(self._cmake_args())
+
+
+def _parse_dir(s):
+    return os.path.abspath(os.path.normpath(s))
+
+
+def _parse_args(argv=None):
+    if argv is None:
+        argv = sys.argv[1:]
+    logging.info('Command line arguments: %s', argv)
+
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+
+    parser.add_argument('--build', metavar='DIR', dest='build_dir',
+                        type=_parse_dir,
+                        help='build directory (temporary directory unless specified)')
+    parser.add_argument('--install', metavar='DIR', dest='install_dir',
+                        type=_parse_dir,
+                        help='install directory')
+    parser.add_argument('--configuration', metavar='CONFIG',
+                        type=_parse_configuration, default=Configuration.DEBUG,
+                        help=f'build configuration ({"/".join(map(str, Configuration))})')
+    parser.add_argument('src_dir', metavar='DIR',
+                        type=_parse_dir,
+                        help='source directory')
+    parser.add_argument('cmake_args', nargs='*', metavar='CMAKE_ARG',
+                        help='additional CMake arguments, to be passed verbatim')
+    args = parser.parse_args(argv)
+    return args
+
+
+def _setup_logging():
+    logging.basicConfig(
+        format='%(asctime)s | %(levelname)s | %(message)s',
+        level=logging.INFO)
+
+
+def build(argv=None):
+    args = _parse_args(argv)
+    with _create_build_dir(args) as build_dir:
+        gen_phase = GenerationPhase(build_dir, args)
+        gen_phase.run()
+        build_phase = BuildPhase(build_dir, args)
+        build_phase.run()
+
+
+def main(argv=None):
+    _setup_logging()
+    try:
+        build(argv)
+    except Exception as e:
+        logging.exception(e)
+        raise
+
+
+if __name__ == '__main__':
+    main()