DUBに対応したD言語のREPL/Jupyter

struct DUBEngine {
    /// 他の部分はDMDEngineのコピペ
    this(string[] packages, CompilerOpt compiler, string tmpDir) {
        ...
        packages.each!(p => this.registerPackage(p));
    }

    /// REPLをビルドする dub.json から package を抽出
    void registerPackage(string _package) {
        import std.file : exists;
        import std.algorithm : map;
        import std.json : parseJSON;
        import std.range : chain;
        import std.process : execute;

        auto dubDescribe = execute(["dub", "describe", _package,
                "--compiler=" ~ _compiler.compiler]);
        if (dubDescribe.status != 0) {
            throw new Exception("failed: $ dub describe " ~ _package ~ "\n"
                    ~ dubDescribe.output ~ "\n\nsuggest: $ dub fetch " ~ _package);
        }
        auto dubInfo = parseJSON(dubDescribe.output);
        auto target = dubInfo["targets"][0];
        assert(target["rootPackage"].str == _package);
        auto build = target["buildSettings"];
        auto read(string key) {
            return build[key].array.map!"a.str".array;
        }

        _dubFlags.insert(chain(read("importPaths").map!(a => "-I" ~ a),
                               read("libs").map!(a => "-L-l" ~ a),
                               read("versions").map!(a => _compiler.ver ~ "=" ~ a),
                               read("linkerFiles")));

        immutable targetFileName = build["targetPath"].str ~ "/lib" ~ build["targetName"]
            .str ~ ".a";
        if (targetFileName.exists) {
            _dubFlags.insert(targetFileName);
        }
    }

    string compileModule(string path) {
        import std.process : execute;
        import std.format : format;
        import std.file : exists;
        import std.regex : ctRegex, replaceAll;
        import std.range : chain;

        logger.trace("compile path: ", path);
        // DUBのビルド設定を追記してモジュールを動的ライブラリにコンパイル
        auto args = chain(_compiler.cmd,
                          ["-I" ~ _tmpDir, "-of" ~ path ~ ".so", "-shared", path, "-L-l:libphobos2.so"],
                          _dubFlags[]).array;

        foreach (i; 0 .. _id)
            args ~= "-L" ~ _tmpDir ~ format("/_mod%s.so", i);

        logger.trace("compile with: ", args);
        auto dmd = execute(args);
        enum cleanErr = ctRegex!(`^.*Error: `, "m");
        if (dmd.status != 0)
            return dmd.output.replaceAll(cleanErr, "");
        if (!exists(path ~ ".so"))
            return path ~ ".so not found";
        return "";
    }
}

import jupyterd.interpreter;
final class DynamicDUBInterpreter : Interpreter
{
    LanguageInfo li = LanguageInfo("D", __VERSION__, ".d", "text/plain");

    private import drepl.engines;
    InterpreterResult last; 
    typeof(drepl.engines.Interpreter!DUBEngine) intp;

    this(DUBEngine engine)
    {
        import std.algorithm : move;
        intp = interpreter!DUBEngine(move(engine));
    }

    // ここ以外 jupyterd.interpreter.DInterpreterのコピペ
    ...
}


int main(string[] args) {
    Interpreter i = new DynamicDUBInterpreter(
        DUBEngine(packages.split,
                  CompilerOpt(compiler, build, flags))
    );
    ...
}