1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

#include "lix/libfetchers/fetchers.hh"
#include "lix/libfetchers/builtin-fetchers.hh"
#include "lix/libutil/regex.hh"
#include "lix/libutil/url-parts.hh"
#include "lix/libstore/path.hh"

namespace nix::fetchers {

std::regex flakeRegex = regex::parse("[a-zA-Z][a-zA-Z0-9_-]*", std::regex::ECMAScript);

static const std::set<std::string> allowedIndirectAttrs = {
    "id",
    "ref",
    "rev",
};

struct IndirectInputScheme : InputScheme
{
    std::string schemeType() const override { return "indirect"; }

    const std::set<std::string> & allowedAttrs() const override {
        return allowedIndirectAttrs;
    }

    std::optional<Input> inputFromURL(const ParsedURL & url, bool requireTree) const override
    {
        if (url.scheme != "flake") return {};

        auto path = tokenizeString<std::vector<std::string>>(url.path, "/");

        std::optional<Hash> rev;
        std::optional<std::string> ref;

        Attrs attrs;

        if (path.size() == 1) {
        } else if (path.size() == 2) {
            if (std::regex_match(path[1], revRegex))
                rev = Hash::parseAny(path[1], HashType::SHA1);
            else if (std::regex_match(path[1], refRegex))
                ref = path[1];
            else
                throw BadURL("in flake URL '%s', '%s' is not a commit hash or branch/tag name", url.url, path[1]);
        } else if (path.size() == 3) {
            ref = path[1];
            rev = Hash::parseAny(path[2], HashType::SHA1);
        } else
            throw BadURL("indirect URL '%s' is invalid", url.url);

        std::string id = path[0];

        attrs.emplace("type", "indirect");
        attrs.emplace("id", id);
        if (rev) attrs.emplace("rev", rev->gitRev());
        if (ref) attrs.emplace("ref", *ref);

        emplaceURLQueryIntoAttrs(url, attrs, {}, {});

        return inputFromAttrs(attrs);
    }

    Attrs preprocessAttrs(const Attrs & attrs) const override {
        auto id = getStrAttr(attrs, "id");
        if (!std::regex_match(id, flakeRegex))
            throw BadURL("'%s' is not a valid flake ID", id);

        // TODO come up with a nicer error message for those two.
        if (auto rev = maybeGetStrAttr(attrs, "rev")) {
            if (!std::regex_match(*rev, revRegex)) {
                throw BadURL("in flake '%s', '%s' is not a commit hash", id, *rev);
            }
        }
        if (auto ref = maybeGetStrAttr(attrs, "ref")) {
            if (!std::regex_match(*ref, refRegex)) {
                throw BadURL("in flake '%s', '%s' is not a valid branch/tag name", id, *ref);
            }
        }

        return attrs;
    }

    std::optional<Input> inputFromAttrs(const Attrs & attrs) const override
    {
        std::optional<Input> input = InputScheme::inputFromAttrs(attrs);

        if (input) {
            input->direct = false;
        }

        return input;
    }

    ParsedURL toURL(const Input & input) const override
    {
        ParsedURL url;
        url.scheme = "flake";
        url.path = getStrAttr(input.attrs, "id");
        if (auto ref = input.getRef()) { url.path += '/'; url.path += *ref; };
        if (auto rev = input.getRev()) { url.path += '/'; url.path += rev->gitRev(); };
        return url;
    }

    bool isLockedByRev() const override { return false; }

    bool hasAllInfo(const Input & input) const override
    {
        return false;
    }

    Input applyOverrides(
        const Input & _input,
        std::optional<std::string> ref,
        std::optional<Hash> rev) const override
    {
        auto input(_input);
        if (rev) input.attrs.insert_or_assign("rev", rev->gitRev());
        if (ref) input.attrs.insert_or_assign("ref", *ref);
        return input;
    }

    kj::Promise<Result<std::pair<StorePath, Input>>>
    fetch(ref<Store> store, const Input & input) override
    try {
        throw Error("indirect input '%s' cannot be fetched directly", input.to_string());
    } catch (...) {
        return {result::current_exception()};
    }
};

std::unique_ptr<InputScheme> makeIndirectInputScheme()
{
    return std::make_unique<IndirectInputScheme>();
}

}