Dopamine package manager

Package manager for compiled languages.

Dopamine PM is a tool for developers that helps to download and build dependencies in a predictible way.

Dopamine is still under development and cannot be used yet in production.

Goals

Ease interoperability of C / C++ / D
Build-system agnosticity
Highly flexible package recipe
Consume DUB packages as dependency
Drop-in replacement of dub client
Ease to package 3rdparty code without patching (packages not aware of Dopamine)
Allows to look-up for system-installed dependency before downloading and build
Lock dependency versions for deterministic dependencies
Reduce compilation time by uploading/downloading pre-built packages

Design

The dop command line tool provide commands for all aspects of building and packaging.
- Setup compilation profile
- Get the source
- Resolve and lock dependencies
- Build (using the build system provided by the source package)
- Package/publish
- Upload a build
- See the client spec for more details.
Recipes are Lua scripts.
- Recipes provide some descriptive fields and functions for:
  - package metadata
  - downloading source (if the source is not packaged with the recipe)
  - patch (if needed)
  - build
- Most of recipes tasks are helped by a comprehensive dop lua library, pre-loaded by the client.
- Thanks to Lua's functional flexibility, most recipes can look purely declarative
Dependencies are resolved with a DAG. See dag.d.
Compilation profiles are saved in INI files, that can be saved user-wide and reused at will
- The dop client provide helpers to edit them, but can also be done by hand.
- Each profile gets a unique identifier based on the build options, platform, compilers versions and ABI etc.
Everything that can alter the build (profile id, resolved dependencies versions...) is reduced to a unique build identifier.
- This identifier allows to upload a built package
- A consumer can consume this pre-built package as dependency if the same ID is computed.
- If no build is found, the recipe is used to build the package (and optionally upload it after the build).
A part of the design is inspired by conan

Example of Recipe

Here is an example of recipe that would build and package libpng. Because it is packaging a 3rd party library, it has to download the source, and perform a few adjustement in the build options.

name = 'libpng'
version = '1.6.37'
description = 'The PNG reference library'
authors = {'The PNG Reference Library Authors'}
license = 'http://www.libpng.org/pub/png/src/libpng-LICENSE.txt'
copyright = 'Copyright (c) 1995-2019 The PNG Reference Library Authors'
tools = {'cc'}

dependencies = {zlib = '>=1.2.5'}

function source()
    local folder = 'libpng-' .. version
    local archive = folder .. '.tar.xz'
    dop.download {
        'https://download.sourceforge.net/libpng/' .. archive,
        dest = archive,
    }
    dop.checksum {
        archive,
        sha256 = '505e70834d35383537b6491e7ae8641f1a4bed1876dbfe361201fc80868d88ca',
    }
    dop.extract_archive { archive, outdir = '.' }

    return folder
end

function build(dirs, config, dep_infos)

    local cmake = dop.CMake:new(config.profile)

    local defs = {
        ['PNG_TESTS'] = false,
    }
    -- if zlib is not in the system but in the dependency cache
    if dep_infos and dep_infos.zlib then
        local zlib = dep_infos.zlib.install_dir
        local libname = dop.windows and 'zlibstatic' or 'z'
        defs['ZLIB_INCLUDE_DIR'] = dop.path(zlib, 'include')
        defs['ZLIB_LIBRARY'] = dop.find_libfile(dop.path(zlib, 'lib'), libname, 'static')
    end

    cmake:configure({
        src_dir = dirs.src,
        install_dir = dirs.install,
        defs = defs,
    })
    cmake:build()
    cmake:install()
end

Build dopamine

Dopamine is developed and built with meson. You need the following tools:

meson (>= 0.63)
ninja
a D compiler (either DMD or LDC)
Dub (dopamine depends on vibe-d)
a C compiler
- C libraries are compiled if not found on the system (Lua + compression libraries)

Linux

DC=ldc meson setup build-ldc
cd build-ldc
ninja # or meson compile
ninja test # or meson test

# you can now run the dop client
packages/client/dop -h

Windows

Windows is always more complex to setup. Only MSVC is supported as C compiler, as D compilers do not link to MingW out of the box. Also you need to run both meson and ninja from a VS prompt. If you have [vswhere](https://github.com/microsoft/vswhere) in your Path, win_env_vs.bat is provided to setup the VS environment from your regular CMD prompt (do not work with powershell). Alternatively, the modern Windows Terminal app is also helpful.

win_env_vs.bat
rem Windows is so slow to compile, you are better off with a fast D compiler
set DC=dmd
meson setup build-dmd
cd build-dmd
ninja rem or meson compile
ninja test rem or meson test

rem you can now run the dop client
packages\client\dop.exe -h