dzmingli/nix-plugin-pijul - Change QA5XRI3RVPCTT2JJIKIGMUF5JKMQGGWCAU4CN7676O72C5BVWY6QC

Add nix 2.31 support

Created by DzmingLi today at 08:28

QA5XRI3RVPCTT2JJIKIGMUF5JKMQGGWCAU4CN7676O72C5BVWY6QC

Dependencies

In channels

main

Change contents

Deletion in src/nixfeat.h at line 3 [8.34]

B:BD[8.105] → [8.105:377]


#ifdef NIX_IS_CPPNIX
#if NIX_VERSION >= 0x021800
#define NIX_INPUTFROMURL_HAS_REQUIRETREE_PARAM
#endif
#if NIX_VERSION >= 0x021900
#define NIX_HAS_PROCESSES_H
#define NIX_INPUTSCHEME_EXTERNAL_URI_CHECKS
#define NIX_GETSOURCEPATH_IS_CONST
#define NIX_HAS_PUTFILE
#endif

Replacement in src/nixfeat.h at line 4 [8.34]

B:BD[8.378] → [8.378:527]

#if NIX_VERSION >= 0x022000
#define NIX_HAS_POSIX_SOURCE_ACCESSOR_H
#define NIX_STORE_PARAM_IS_STORE_REF
#define NIX_POSIX_SOURCE_ACCESSOR_V1
#endif

[8.378]

[8.527]

// Feature detection removed - targeting Nix 2.31 only

Deletion in src/nixfeat.h at line 6 [8.34]

B:BD[8.528] → [8.528:759]

#if NIX_VERSION >= 0x022100
#define NIX_HAS_FS_INPUT_ACCESSOR_H
#define NIX_INPUTSCHEME_EXTERNAL_LOCKED_CHECKS
#define NIX_POSIX_SOURCE_ACCESSOR_V2
#define NIX_CANONPATH_HAS_SLASH_OP
#else
#define NIX_INPUTSCHEME_HAS_PRIVATE_FETCH

Deletion in src/nixfeat.h at line 7 [8.34]

B:BD[8.766] → [8.766:1126]

B:BD[8.1126] → [8.1126:1311]


#if NIX_VERSION >= 0x022200
#define NIX_HAS_LOOKUPPATH
#endif
#if NIX_VERSION >= 0x022300
#define NIX_HAS_STORE_PATH_ACCESSOR_H
#define NIX_INPUTSCHEME_USES_SOURCE_ACCESSOR
#define NIX_HAS_CACHE_KEY_TYPE
#define NIX_POSIX_SOURCE_ACCESSOR_V3
#endif
#if NIX_VERSION >= 0x022400
#define NIX_INPUTFROMURL_HAS_SETTINGS_PARAM
#define NIX_POSIX_SOURCE_ACCESSOR_V4
#endif
#endif
#ifdef NIX_IS_LIX
#define NIX_INPUTFROMURL_HAS_REQUIRETREE_PARAM
#define NIX_HAS_PROCESSES_H
#define NIX_GETSOURCEPATH_IS_CONST
#define NIX_HAS_PUTFILE
#endif
#endif

Deletion in src/meson.build at line 10 [9.36]

B:BD[9.245] → [9.245:362]


if nix_main_dep.version().version_compare('<=2.22')
    lib_extra_cppflags += ['-DHAVE_STRUCT_DIRENT_D_TYPE']
endif

Replacement in src/meson.build at line 23 [9.36]

B:BD[9.660] → [9.660:775]

        f'-DNIX_VERSION=(((0x@nix_major_version@)<<16) | ((0x@nix_minor_version@)<<8) | (0x@nix_patch_version@))',

[9.660]

[6.27]

        f'-DNIX_VERSION=(((@nix_major_version@)<<16) | ((@nix_minor_version@)<<8) | (@nix_patch_version@))',

Deletion in src/fetcher.cpp at line 3 [11.53]
B:BD[10.2275] → [7.0:21]
```
#include "nixfeat.h"
```

Replacement in src/fetcher.cpp at line 8 [11.53]

B:BD[11.73] → [11.73:169]

∅:D[12.60] → [11.169:170]

B:BD[11.169] → [11.169:170]

B:BD[11.170] → [7.22:61]

∅:D[7.61] → [12.89:133]

B:BD[12.89] → [12.89:133]

B:BD[12.133] → [7.62:99]

∅:D[7.99] → [13.28:62]

B:BD[13.28] → [13.28:62]

B:BD[13.62] → [7.100:143]

∅:D[13.92] → [12.161:200]

∅:D[7.143] → [12.161:200]

B:BD[12.161] → [12.161:200]

#include <cache.hh>
#include <fetch-settings.hh>
#include <fetchers.hh>
#include <store-api.hh>
#ifdef NIX_HAS_POSIX_SOURCE_ACCESSOR_H
#include <posix-source-accessor.hh>
#endif
#ifdef NIX_HAS_STORE_PATH_ACCESSOR_H
#include <store-path-accessor.hh>
#elif defined(NIX_HAS_FS_INPUT_ACCESSOR_H)
#include <fs-input-accessor.hh>
#endif

[11.73]

[12.200]

#include <nix/fetchers/cache.hh>
#include <nix/fetchers/fetch-settings.hh>
#include <nix/fetchers/fetchers.hh>
#include <nix/fetchers/store-path-accessor.hh>
#include <nix/store/store-api.hh>
#include <nix/util/posix-source-accessor.hh>

Deletion in src/fetcher.cpp at line 32 [11.53]
B:BD[11.956] → [7.144:193]
```
#if defined(NIX_INPUTFROMURL_HAS_SETTINGS_PARAM)
```

Deletion in src/fetcher.cpp at line 33 [11.53]

B:BD[14.163] → [7.194:248]

∅:D[14.193] → [15.28:141]

∅:D[7.248] → [15.28:141]

B:BD[15.28] → [15.28:141]

∅:D[15.141] → [16.64:153]

B:BD[16.64] → [16.64:153]

B:BD[11.1063] → [16.160:167]

#elif defined(NIX_INPUTFROMURL_HAS_REQUIRETREE_PARAM)
    [[nodiscard]] std::optional<Input> inputFromURL(const ParsedURL &url, bool requireTree) const override
#else
    [[nodiscard]] std::optional<Input> inputFromURL(const ParsedURL &url) const override
#endif

Deletion in src/fetcher.cpp at line 57 [11.53]
B:BD[11.1702] → [7.249:298]
```
#if defined(NIX_INPUTFROMURL_HAS_SETTINGS_PARAM)
```
Deletion in src/fetcher.cpp at line 58 [11.53]
B:BD[14.270] → [14.270:276]
∅:D[14.276] → [11.1702:1740]
B:BD[11.1702] → [11.1702:1740]
B:BD[11.1740] → [14.277:284]
```
#else
        return inputFromAttrs(attrs);
#endif
```
Deletion in src/fetcher.cpp at line 62 [11.53]
B:BD[11.1747] → [7.299:348]
```
#if defined(NIX_INPUTFROMURL_HAS_SETTINGS_PARAM)
```
Deletion in src/fetcher.cpp at line 63 [11.53]
B:BD[14.428] → [14.428:434]
∅:D[14.434] → [11.1747:1836]
B:BD[11.1747] → [11.1747:1836]
B:BD[11.1836] → [14.435:442]
```
#else
    [[nodiscard]] std::optional<Input> inputFromAttrs(const Attrs &attrs) const override
#endif
```

Deletion in src/fetcher.cpp at line 68 [11.53]

B:BD[11.1922] → [11.1922:1933]

B:BD[11.1933] → [7.349:393]

∅:D[12.229] → [11.1933:2221]

∅:D[7.393] → [11.1933:2221]

B:BD[11.1933] → [11.1933:2221]

        }
#ifndef NIX_INPUTSCHEME_EXTERNAL_URI_CHECKS
        for (const auto &[name, _] : attrs) {
            if (name != "type"sv && name != "url"sv && name != "channel"sv && name != "state"sv && name != "narHash"sv && name != "lastModified"sv) {
                throw Error("unsupported Pijul input attribute '%s'"s, name);
            }

Deletion in src/fetcher.cpp at line 69 [11.53]
B:BD[11.2231] → [12.230:237]
```
#endif
```
Deletion in src/fetcher.cpp at line 72 [11.53]
B:BD[11.2277] → [7.394:443]
```
#if defined(NIX_INPUTFROMURL_HAS_SETTINGS_PARAM)
```
Deletion in src/fetcher.cpp at line 73 [11.53]
B:BD[14.502] → [14.502:508]
∅:D[14.508] → [11.2277:2298]
B:BD[11.2277] → [11.2277:2298]
B:BD[11.2298] → [14.509:516]
```
#else
        Input input;
#endif
```
Deletion in src/fetcher.cpp at line 75 [11.53]
B:BD[11.2328] → [7.444:491]
∅:D[12.265] → [11.2328:2467]
∅:D[7.491] → [11.2328:2467]
B:BD[11.2328] → [11.2328:2467]
B:BD[11.2467] → [12.266:273]
∅:D[12.273] → [11.2467:2468]
B:BD[11.2467] → [11.2467:2468]
```
#ifndef NIX_INPUTSCHEME_EXTERNAL_LOCKED_CHECKS
        if (maybeGetStrAttr(input.attrs, "channel") && maybeGetStrAttr(input.attrs, "state")) {
            input.locked = true;
        }
#endif
```
Deletion in src/fetcher.cpp at line 80 [11.53]
B:BD[11.2497] → [7.492:536]
∅:D[12.301] → [11.2497:2651]
∅:D[7.536] → [11.2497:2651]
B:BD[11.2497] → [11.2497:2651]
B:BD[11.2651] → [12.302:309]
∅:D[12.309] → [11.2651:2652]
B:BD[11.2651] → [11.2651:2652]
```
#ifndef NIX_INPUTSCHEME_EXTERNAL_URI_CHECKS
    [[nodiscard]] bool hasAllInfo(const Input &input) const override
    {
        return maybeGetIntAttr(input.attrs, "lastModified").has_value();
    }
#endif
```

Replacement in src/fetcher.cpp at line 103 [11.53]

B:BD[11.3215] → [7.537:578]

∅:D[7.578] → [12.338:434]

B:BD[12.338] → [12.338:434]

∅:D[12.434] → [11.3215:3301]

B:BD[11.3215] → [11.3215:3301]

B:BD[11.3301] → [12.435:442]

#ifdef NIX_INPUTSCHEME_HAS_PRIVATE_FETCH
    std::pair<StorePath, Input> fetchToStore(ref<Store> store, const Input &_input) const
#else
    std::pair<StorePath, Input> fetch(ref<Store> store, const Input &_input) override
#endif

[11.3215]

[11.3301]

    std::optional<std::filesystem::path> getSourcePath(const Input &input) const override

Deletion in src/fetcher.cpp at line 107 [11.53]

∅:D[17.153] → [11.3307:3655]

B:BD[11.3307] → [11.3307:3655]

B:BD[11.3655] → [17.154:171]

∅:D[17.171] → [11.3655:3661]

B:BD[11.3655] → [11.3655:3661]

B:BD[11.3661] → [11.3661:3662]

B:BD[11.3662] → [7.579:613]

∅:D[7.613] → [12.471:550]

B:BD[12.471] → [12.471:550]

∅:D[12.550] → [11.3662:3729]

B:BD[11.3662] → [11.3662:3729]

B:BD[11.3729] → [12.551:558]

∅:D[12.558] → [11.3729:3735]

B:BD[11.3729] → [11.3729:3735]

B:BD[11.3735] → [17.172:191]

        if (auto localPath = getSourcePath(_input)) {
            return fetchLocal(store, _input, *localPath);
        } else {
            auto [storePath, infoAttrs] = doFetch(store, _input);
            Input input(_input);
            mergeAttrs(input.attrs, std::move(infoAttrs));
            return {std::move(storePath), input};
        }
        DBG_END
    }
#ifdef NIX_GETSOURCEPATH_IS_CONST
    std::optional<Path> getSourcePath(const Input &input) const override
#else
    std::optional<Path> getSourcePath(const Input &input) override
#endif
    {
        DBG_BEGIN

Deletion in src/fetcher.cpp at line 118 [11.53]
B:BD[12.560] → [7.614:637]
```
#ifdef NIX_HAS_PUTFILE
```

Replacement in src/fetcher.cpp at line 125 [11.53]

B:BD[12.799] → [7.638:672]

∅:D[7.672] → [12.827:964]

B:BD[12.827] → [12.827:964]

#ifdef NIX_CANONPATH_HAS_SLASH_OP
        writeFile((CanonPath(*root) / path).abs(), contents);
#else
        writeFile((CanonPath(*root) + path).abs(), contents);
#endif

[12.799]

[12.964]

        auto rootStr = root->string();
        writeFile((CanonPath(rootStr) / path).abs(), contents);
        record(*commitMsg, rootStr, {Path(path.rel())});

Deletion in src/fetcher.cpp at line 129 [11.53]
B:BD[12.965] → [10.2316:2371]
B:BD[10.2371] → [17.230:231]
```
        record(*commitMsg, *root, {Path(path.rel())});
```
Deletion in src/fetcher.cpp at line 130 [11.53]
∅:D[17.247] → [12.1146:1158]
∅:D[18.2239] → [12.1146:1158]
∅:D[10.2371] → [12.1146:1158]
B:BD[12.1146] → [12.1146:1158]
∅:D[12.1158] → [11.3937:4058]
B:BD[11.3937] → [11.3937:4058]
B:BD[11.4058] → [12.1159:1223]
∅:D[12.1223] → [11.4134:4135]
B:BD[11.4134] → [11.4134:4135]
B:BD[11.4135] → [10.2372:2428]
```
    }
#else
    void markChangedFile(const Input &input, std::string_view file, std::optional<std::string> commitMsg) override
    {
        auto root = getSourcePath(input);
        assert(root);
        record(*commitMsg, *root, {std::string(file)});
```
Deletion in src/fetcher.cpp at line 131 [11.53]
B:BD[12.1376] → [12.1376:1383]
```
#endif
```
Deletion in src/fetcher.cpp at line 132 [11.53]
B:BD[12.1384] → [7.673:716]
```
#ifdef NIX_INPUTSCHEME_EXTERNAL_URI_CHECKS
```
Deletion in src/fetcher.cpp at line 141 [11.53]
B:BD[12.1632] → [12.1632:1639]
```
#endif
```
Deletion in src/fetcher.cpp at line 142 [11.53]
B:BD[12.1640] → [7.717:763]
```
#ifdef NIX_INPUTSCHEME_EXTERNAL_LOCKED_CHECKS
```
Deletion in src/fetcher.cpp at line 149 [11.53]
B:BD[12.1831] → [7.764:808]
```
#ifdef NIX_INPUTSCHEME_USES_SOURCE_ACCESSOR
```
Deletion in src/fetcher.cpp at line 150 [11.53]
B:BD[13.229] → [13.229:235]
∅:D[13.235] → [12.1831:1938]
B:BD[12.1831] → [12.1831:1938]
B:BD[12.1938] → [13.236:243]
```
#else
    std::pair<ref<InputAccessor>, Input> getAccessor(ref<Store> store, const Input &_input) const override
#endif
```
Deletion in src/fetcher.cpp at line 152 [11.53]
∅:D[17.302] → [12.1944:1973]
B:BD[12.1944] → [12.1944:1973]
```
        Input input(_input);
```

Replacement in src/fetcher.cpp at line 153 [11.53]

B:BD[12.1974] → [12.1974:2032]

        auto [storePath, _] = fetchToStore(store, input);

[12.1974]

[12.2032]

        auto [storePath, input] = fetchToStoreImpl(store, _input);

Insertion in src/fetcher.cpp at line 156 [11.53]
[12.2098]
[17.303]
Deletion in src/fetcher.cpp at line 159 [11.53]
B:BD[11.4322] → [12.2099:2106]
```
#endif
```

Replacement in src/fetcher.cpp at line 161 [11.53]

B:BD[11.4451] → [12.2107:2200]

    static std::pair<StorePath, Attrs> doFetch(const ref<Store> &_store, const Input &input)

[11.4332]

[11.4543]


    std::pair<StorePath, Input> fetchToStoreImpl(ref<Store> store, const Input &_input) const
    {
        DBG_BEGIN
        if (auto localPath = getSourcePath(_input)) {
            return fetchLocal(store, _input, *localPath);
        } else {
            auto [storePath, infoAttrs] = doFetchCached(store, _input);
            Input input(_input);
            mergeAttrs(input.attrs, std::move(infoAttrs));
            return {std::move(storePath), input};
        }
        DBG_END
    }
    static std::pair<StorePath, Attrs> doFetchCached(ref<Store> store, const Input &input)

Deletion in src/fetcher.cpp at line 182 [11.53]
B:BD[17.338] → [7.809:845]
∅:D[7.845] → [12.2229:2310]
B:BD[12.2229] → [12.2229:2310]
```
#ifdef NIX_STORE_PARAM_IS_STORE_REF
        Store &store = *_store;
#else
        const auto &store = _store;
#endif
```
Insertion in src/fetcher.cpp at line 183 [11.53]
[12.2311]
[11.4549]
```
        auto cache = input.settings->getCache();
```

Replacement in src/fetcher.cpp at line 186 [11.53]

B:BD[11.4594] → [11.4594:4701]

        const auto url = parseURL(getStrAttr(input.attrs, "url"));
        const auto &repoUrl = url.base;

[11.4594]

[11.4701]

        auto url = parseURL(getStrAttr(input.attrs, "url"));
        auto baseUrl = url;
        baseUrl.query.clear();
        const auto repoUrl = baseUrl.to_string();

Deletion in src/fetcher.cpp at line 193 [11.53]
B:BD[11.4838] → [7.846:876]
```
#ifdef NIX_HAS_CACHE_KEY_TYPE
```
Replacement in src/fetcher.cpp at line 194 [11.53]
B:BD[13.311] → [13.311:317]
∅:D[13.317] → [11.4970:5004]
B:BD[11.4970] → [11.4970:5004]
B:BD[11.5004] → [13.318:325]
∅:D[13.325] → [11.5004:5035]
B:BD[11.5004] → [11.5004:5035]
```
#else
        std::optional<Attrs> key;
#endif
        bool isLocked = false;
```
[13.311]
[11.5035]
```
        bool isLockedInput = false;
```
Replacement in src/fetcher.cpp at line 197 [11.53]
B:BD[11.5068] → [11.5068:5097]
```
            isLocked = true;
```
[11.5068]
[11.5097]
```
            isLockedInput = true;
```

Replacement in src/fetcher.cpp at line 199 [11.53]

B:BD[11.5098] → [7.877:907]

∅:D[7.907] → [13.354:506]

B:BD[13.354] → [13.354:506]

#ifdef NIX_HAS_CACHE_KEY_TYPE
            key = {"pijul", {
                {"name", name},
                {"channel", *channel},
                {"state", *state},
            }};

[11.5098]

[13.506]

            Attrs keyAttrs;
            keyAttrs.emplace("name"s, name);
            keyAttrs.emplace("channel"s, *channel);
            keyAttrs.emplace("state"s, *state);
            key = Cache::Key{"pijul"sv, std::move(keyAttrs)};

Replacement in src/fetcher.cpp at line 205 [11.53]

B:BD[13.507] → [13.507:578]

B:BD[13.578] → [13.578:653]

            if (auto res = getCache()->lookupStorePath(*key, store)) {
                return {std::move(res->storePath), std::move(res->value)};

[13.507]

[13.653]

            if (auto res = cache->lookupStorePath(*key, *store)) {
                return std::make_pair(std::move(res->storePath), std::move(res->value));

Deletion in src/fetcher.cpp at line 208 [11.53]

B:BD[13.667] → [13.667:673]

∅:D[13.673] → [11.5098:5473]

B:BD[11.5098] → [11.5098:5473]

B:BD[11.5473] → [13.674:681]

#else
            key = {
                {"type", "pijul"},
                {"name", name},
                {"channel", *channel},
                {"state", *state},
            };
            if (auto res = getCache()->lookup(store, *key)) {
                auto &[infoAttrs, storePath] = *res;
                return {std::move(storePath), std::move(infoAttrs)};
            }
#endif

Replacement in src/fetcher.cpp at line 210 [11.53]

B:BD[11.5484] → [7.908:938]

∅:D[7.938] → [13.710:826]

B:BD[13.710] → [13.710:826]

#ifdef NIX_HAS_CACHE_KEY_TYPE
        const Cache::Key impureKey{"pijul", {
            {"name", name},
            {"url", repoUrl},
        }};

[11.5484]

[13.826]

        Attrs impureKeyAttrs;
        impureKeyAttrs.emplace("name"s, name);
        impureKeyAttrs.emplace("url"s, repoUrl);
        const Cache::Key impureKey{"pijul"sv, std::move(impureKeyAttrs)};

Replacement in src/fetcher.cpp at line 215 [11.53]

B:BD[13.827] → [13.827:899]

        if (auto res = getCache()->lookupStorePath(impureKey, store)) {

[13.827]

[13.899]

        if (auto res = cache->lookupStorePath(impureKey, *store)) {

Replacement in src/fetcher.cpp at line 219 [11.53]

B:BD[13.1076] → [13.1076:1150]

                return {std::move(res->storePath), std::move(infoAttrs)};

[13.1076]

[13.1150]

                return std::make_pair(std::move(res->storePath), std::move(infoAttrs));

Deletion in src/fetcher.cpp at line 222 [11.53]

B:BD[13.1174] → [13.1174:1311]

#else
        const Attrs impureKey{
            {"type", "pijul"},
            {"name", name},
            {"url", repoUrl},
        };

Replacement in src/fetcher.cpp at line 223 [11.53]

∅:D[13.1312] → [11.5484:5596]

B:BD[11.5484] → [11.5484:5596]

        if (auto res = getCache()->lookup(store, impureKey)) {
            auto &[infoAttrs, storePath] = *res;

[13.1312]

[11.5596]

        auto [storePath, rs] = doFetchClone(store, name, repoUrl, channel, state);

Deletion in src/fetcher.cpp at line 225 [11.53]

B:BD[11.5597] → [11.5597:5824]

B:BD[11.5824] → [13.1313:1320]

∅:D[13.1320] → [11.5824:5825]

B:BD[11.5824] → [11.5824:5825]

B:BD[11.5825] → [12.2312:2391]

∅:D[12.2391] → [11.5903:5904]

B:BD[11.5903] → [11.5903:5904]

            if ((!channel || *channel == getStrAttr(infoAttrs, "channel")) && (!state || *state == getStrAttr(infoAttrs, "state"))) {
                return {std::move(storePath), std::move(infoAttrs)};
            }
        }
#endif
        auto [storePath, rs] = doFetch(_store, name, repoUrl, channel, state);

Replacement in src/fetcher.cpp at line 226 [11.53]

B:BD[11.5924] → [7.939:969]

∅:D[7.969] → [13.1349:1433]

B:BD[13.1349] → [13.1349:1433]

∅:D[13.1433] → [11.5924:6026]

B:BD[11.5924] → [11.5924:6026]

B:BD[11.6026] → [13.1434:1441]

#ifdef NIX_HAS_CACHE_KEY_TYPE
            key = {"pijul", {
                {"name", name},
            }};
#else
            key = {
                {"type", "pijul"},
                {"name", name},
            };
#endif

[11.5924]

[11.6026]

            Attrs keyAttrs;
            keyAttrs.emplace("name"s, name);
            key = Cache::Key{"pijul"sv, std::move(keyAttrs)};

Replacement in src/fetcher.cpp at line 231 [11.53]

B:BD[11.6037] → [7.970:1000]

∅:D[7.1000] → [13.1470:1508]

B:BD[13.1470] → [13.1470:1508]

∅:D[13.1508] → [11.6037:6062]

B:BD[11.6037] → [11.6037:6062]

B:BD[11.6062] → [13.1509:1516]

∅:D[13.1516] → [11.6062:6198]

B:BD[11.6062] → [11.6062:6198]

#ifdef NIX_HAS_CACHE_KEY_TYPE
        mergeAttrs(key->second,
#else
        mergeAttrs(*key,
#endif
                   {
                       {"channel", rs.channel},
                       {"state", rs.state},
                   });

[11.6037]

[11.6198]

        Attrs toMerge;
        toMerge.emplace("channel"s, rs.channel);
        toMerge.emplace("state"s, rs.state);
        mergeAttrs(key->second, std::move(toMerge));

Replacement in src/fetcher.cpp at line 236 [11.53]

B:BD[11.6199] → [11.6199:6377]

        Attrs infoAttrs = {
            {"channel", std::move(rs.channel)},
            {"state", std::move(rs.state)},
            {"lastModified", rs.lastModified},
        };

[11.6199]

[11.6377]

        Attrs infoAttrs;
        infoAttrs.emplace("channel"s, std::move(rs.channel));
        infoAttrs.emplace("state"s, std::move(rs.state));
        infoAttrs.emplace("lastModified"s, rs.lastModified);

Replacement in src/fetcher.cpp at line 241 [11.53]

B:BD[11.6378] → [11.6378:6403]

B:BD[11.6403] → [7.1001:1031]

∅:D[7.1031] → [13.1545:1617]

B:BD[13.1545] → [13.1545:1617]

B:BD[13.1617] → [13.1617:1623]

∅:D[13.1623] → [11.6403:6479]

B:BD[11.6403] → [11.6403:6479]

B:BD[11.6479] → [13.1624:1631]

        if (!isLocked) {
#ifdef NIX_HAS_CACHE_KEY_TYPE
            getCache()->upsert(impureKey, store, infoAttrs, storePath);
#else
            getCache()->add(store, impureKey, infoAttrs, storePath, false);
#endif

[11.6378]

[11.6479]

        if (!isLockedInput) {
            cache->upsert(impureKey, *store, infoAttrs, storePath);

Replacement in src/fetcher.cpp at line 245 [11.53]
B:BD[11.6490] → [7.1032:1062]
∅:D[7.1062] → [13.1660:1723]
B:BD[13.1660] → [13.1660:1723]
B:BD[13.1723] → [13.1723:1729]
∅:D[13.1729] → [11.6490:6556]
B:BD[11.6490] → [11.6490:6556]
B:BD[11.6556] → [13.1730:1737]
```
#ifdef NIX_HAS_CACHE_KEY_TYPE
        getCache()->upsert(*key, store, infoAttrs, storePath);
#else
        getCache()->add(store, *key, infoAttrs, storePath, true);
#endif
```
[11.6490]
[11.6556]
```
        cache->upsert(*key, *store, infoAttrs, storePath);
```

Replacement in src/fetcher.cpp at line 247 [11.53]

B:BD[11.6557] → [11.6557:6618]

        return {std::move(storePath), std::move(infoAttrs)};

[11.6557]

[17.339]

        return std::make_pair(std::move(storePath), std::move(infoAttrs));

Replacement in src/fetcher.cpp at line 251 [11.53]

B:BD[11.6625] → [11.6625:7072]

    static std::pair<StorePath, RepoStatus> doFetch(const ref<Store> &store,
                                                    const std::string_view &inputName,
                                                    const std::string_view &repoUrl,
                                                    const std::optional<std::string_view> &channel,
                                                    const std::optional<std::string_view> &state)

[11.6625]

[11.7072]

    static std::pair<StorePath, RepoStatus> doFetchClone(ref<Store> store,
                                                          const std::string_view &inputName,
                                                          const std::string_view &repoUrl,
                                                          const std::optional<std::string_view> &channel,
                                                          const std::optional<std::string_view> &state)

Deletion in src/fetcher.cpp at line 276 [11.53]
B:BD[11.7976] → [7.1063:1105]
```
#if defined(NIX_POSIX_SOURCE_ACCESSOR_V3)
```

Deletion in src/fetcher.cpp at line 278 [11.53]

B:BD[13.1891] → [7.1106:1150]

∅:D[7.1150] → [12.2420:2577]

∅:D[13.1921] → [12.2420:2577]

B:BD[12.2420] → [12.2420:2577]

B:BD[12.2577] → [7.1151:1195]

∅:D[7.1195] → [12.2607:2745]

B:BD[12.2607] → [12.2607:2745]

∅:D[12.2745] → [11.7976:8040]

B:BD[11.7976] → [11.7976:8040]

B:BD[11.8040] → [12.2746:2753]

#elif defined(NIX_POSIX_SOURCE_ACCESSOR_V2)
        auto [accessor, canonPath] = PosixSourceAccessor::createAtRoot(repoDir);
        auto storePath = store->addToStore(inputName, accessor, canonPath);
#elif defined(NIX_POSIX_SOURCE_ACCESSOR_V1)
        PosixSourceAccessor accessor;
        auto storePath = store->addToStore(inputName, accessor, CanonPath::fromCwd(repoDir));
#else
        auto storePath = store->addToStore(inputName, repoDir);
#endif

Replacement in src/fetcher.cpp at line 283 [11.53]

B:BD[11.8102] → [10.2429:2543]

    static std::pair<StorePath, Input> fetchLocal(const ref<Store> &store, const Input &_input, const Path &path)

[11.8102]

[11.8228]

    static std::pair<StorePath, Input> fetchLocal(ref<Store> store, const Input &_input, const std::filesystem::path &localPath)

Replacement in src/fetcher.cpp at line 292 [11.53]

B:BD[11.8563] → [18.2350:2390]

        bool dirty = isRepoDirty(path);

[11.8563]

[11.8664]

        bool dirty = isRepoDirty(localPath.string());

Replacement in src/fetcher.cpp at line 295 [11.53]

B:BD[11.8774] → [7.1196:1239]

∅:D[7.1239] → [14.545:687]

B:BD[14.545] → [14.545:687]

∅:D[14.687] → [11.8819:8882]

B:BD[11.8819] → [11.8819:8882]

#ifdef NIX_INPUTFROMURL_HAS_SETTINGS_PARAM
            auto settings = *input.settings;
#else
            auto settings = fetchSettings;
#endif
            if (!settings.allowDirty) {
                throw Error("Pijul tree '%s' is dirty", path);

[11.8774]

[11.8882]

            if (!_input.settings->allowDirty) {
                throw Error("Pijul tree '%s' is dirty", localPath.string());

Replacement in src/fetcher.cpp at line 299 [11.53]

B:BD[11.8897] → [14.688:726]

∅:D[14.726] → [11.8940:8996]

B:BD[11.8940] → [11.8940:8996]

            if (settings.warnDirty) {
                warn("Pijul tree '%s' is dirty", path);

[11.8897]

[11.8996]

            if (_input.settings->warnDirty) {
                warn("Pijul tree '%s' is dirty", localPath.string());

Replacement in src/fetcher.cpp at line 304 [11.53]

B:BD[11.9021] → [18.2391:2435]

        auto files = getTrackedFiles(path);

[11.9021]

[11.9128]

        auto files = getTrackedFiles(localPath.string());

Replacement in src/fetcher.cpp at line 306 [11.53]

B:BD[11.9129] → [11.9129:9175]

        Path actualPath(absPath(Path(path)));

[11.9129]

[11.9175]

        Path actualPath(absPath(Path(localPath.string())));

Replacement in src/fetcher.cpp at line 324 [11.53]

B:BD[11.9697] → [7.1356:1398]

∅:D[7.1398] → [14.755:938]

B:BD[14.755] → [14.755:938]

B:BD[14.938] → [7.1399:1443]

∅:D[14.968] → [13.1950:2126]

∅:D[7.1443] → [13.1950:2126]

B:BD[13.1950] → [13.1950:2126]

B:BD[13.2126] → [7.1444:1488]

∅:D[7.1488] → [12.2782:2987]

∅:D[13.2156] → [12.2782:2987]

B:BD[12.2782] → [12.2782:2987]

B:BD[12.2987] → [7.1489:1563]

#if defined(NIX_POSIX_SOURCE_ACCESSOR_V4)
        auto storePath = store->addToStore(input.getName(), {getFSSourceAccessor(), CanonPath(actualPath)}, ContentAddressMethod::Raw::NixArchive, HashAlgorithm::SHA256, {}, filter);
#elif defined(NIX_POSIX_SOURCE_ACCESSOR_V3)
        auto storePath = store->addToStore(input.getName(), {getFSSourceAccessor(), CanonPath(actualPath)}, FileIngestionMethod::Recursive, HashAlgorithm::SHA256, {}, filter);
#elif defined(NIX_POSIX_SOURCE_ACCESSOR_V1)
        PosixSourceAccessor accessor;
        auto storePath = store->addToStore(input.getName(), accessor, CanonPath{actualPath}, FileIngestionMethod::Recursive, HashAlgorithm::SHA256, {}, filter);
#else
#ifdef NIX_IS_LIX
        const auto htSHA256 = HashType::SHA256;
#endif

[11.9697]

[7.1563]

        auto sourcePath = PosixSourceAccessor::createAtRoot(actualPath);
        auto storePath = store->addToStore(input.getName(), sourcePath, ContentAddressMethod::Raw::NixArchive, HashAlgorithm::SHA256, {}, filter);

Deletion in src/fetcher.cpp at line 327 [11.53]
∅:D[7.1564] → [11.9697:9820]
∅:D[12.2987] → [11.9697:9820]
B:BD[11.9697] → [11.9697:9820]
B:BD[11.9820] → [12.2988:2995]
∅:D[12.2995] → [11.9820:9821]
B:BD[11.9820] → [11.9820:9821]
```
        auto storePath = store->addToStore(input.getName(), actualPath, FileIngestionMethod::Recursive, htSHA256, filter);
#endif
```

Replacement in src/fetcher.cpp at line 328 [11.53]

B:BD[11.9835] → [11.9835:9895]

            const auto [state, timestamp] = getState(path);

[11.9835]

[11.9895]

            const auto [state, timestamp] = getState(localPath.string());

Deletion in src/fetcher.cpp at line 369 [11.53]
B:BD[11.12882] → [7.1565:1583]
```
#ifdef NIX_IS_LIX
```
Deletion in src/fetcher.cpp at line 370 [11.53]
B:BD[7.1646] → [7.1646:1652]
∅:D[7.1652] → [11.12882:12945]
B:BD[11.12882] → [11.12882:12945]
B:BD[11.12945] → [7.1653:1660]
```
#else
    registerInputScheme(std::make_unique<PijulInputScheme>());
#endif
```
Replacement in src/debug.h at line 8 [17.460]
B:BD[17.594] → [17.594:616]
```
#include <logging.hh>
```
[17.594]
[17.616]
```
#include <nix/util/logging.hh>
```
Replacement in src/compat.h at line 5 [10.2586]
B:BD[10.2675] → [10.2675:2715]
```
#include <error.hh>
#include <types.hh>
```
[10.2675]
[10.2715]
```
#include <nix/util/error.hh>
#include <nix/util/types.hh>
```
Deletion in src/compat.cpp at line 3 [10.3946]
B:BD[17.1838] → [7.1661:1682]
```
#include "nixfeat.h"
```
Replacement in src/compat.cpp at line 5 [10.3946]
B:BD[10.3987] → [7.1683:1710]
∅:D[7.1710] → [10.4015:4039]
B:BD[10.4015] → [10.4015:4039]
```
#ifdef NIX_HAS_PROCESSES_H
#include <processes.hh>
```
[10.3987]
[10.4039]
```
#include <nix/util/processes.hh>
```
Deletion in src/compat.cpp at line 7 [10.3946]
B:BD[10.4045] → [10.4045:4077]
```
#include <util.hh>
#endif
#else
```
Deletion in src/compat.cpp at line 31 [10.3946]
B:BD[10.4508] → [7.1745:1776]
```
        #if NIX_HAS_LOOKUPPATH
```
Deletion in src/compat.cpp at line 32 [10.3946]
B:BD[19.64] → [19.64:78]
∅:D[19.78] → [10.4508:4536]
B:BD[10.4508] → [10.4508:4536]
B:BD[10.4536] → [19.79:94]
```
        #else
        .searchPath = true,
        #endif
```

Replacement in meson.build at line 31 [9.1107]

B:BD[6.680] → [6.680:729]

        nix_main_dep = d
        nix_impl = impl

[6.680]

[6.729]

        if d.found()
            nix_main_dep = d
            nix_impl = impl
        endif

Replacement in meson.build at line 37 [9.1107]
B:BD[6.745] → [6.745:766]
```
    if not d.found()
```
[6.745]
[6.766]
```
    if not nix_main_dep.found()
```

Replacement in flake.nix at line 3 [20.34]

B:BD[20.50] → [20.50:96]

    nixpkgs.url = "nixpkgs/nixpkgs-unstable";

[20.50]

[20.96]

    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";

Replacement in flake.nix at line 18 [20.34]

B:BD[11.13706] → [3.10:100]

      nix-plugin-pijul = pkgs.callPackage ./package.nix {nix = pkgs.nixVersions.latest;};

[11.13706]

[11.13766]

      nix-plugin-pijul = pkgs.callPackage ./package.nix {};

Deletion in flake.nix at line 20 [20.34]

B:BD[11.13774] → [21.0:1]

B:BD[21.1] → [22.0:116]

∅:D[22.116] → [21.98:163]

B:BD[21.98] → [21.98:163]

B:BD[21.163] → [22.117:133]

∅:D[22.133] → [21.184:253]

B:BD[21.184] → [21.184:253]

B:BD[21.253] → [2.0:29]

∅:D[2.29] → [21.253:460]

B:BD[21.253] → [21.253:460]

B:BD[21.460] → [2.30:73]


    checks = eachSystem (pkgs: let
      localRepoCheck = nix:
        pkgs.runCommand "localRepoCheck-${nix.name}"
        {
          nativeBuildInputs = [
            pkgs.pijul
            nix
          ];
        }
        ''
          export HOME=$(mktemp -d)
          export EDITOR=true
          pijul identity new --no-link --no-prompt --display-name 'Test User' --email 'test@example.com'
          pijul init repo
          cd repo
          echo "it works" > foo
          pijul add foo
          pijul record --message 'Add foo'

Deletion in flake.nix at line 21 [20.34]

B:BD[21.505] → [21.505:543]

B:BD[21.543] → [22.134:270]

∅:D[22.270] → [21.655:915]

B:BD[21.655] → [21.655:915]

B:BD[21.915] → [21.915:916]

B:BD[21.916] → [21.916:949]

B:BD[21.949] → [22.271:280]

B:BD[22.850] → [22.850:909]

B:BD[22.909] → [23.0:177]

B:BD[23.177] → [3.101:389]

∅:D[23.177] → [21.949:957]

∅:D[3.389] → [21.949:957]

∅:D[22.909] → [21.949:957]

B:BD[21.949] → [21.949:957]

          output=$(
            nix \
              --option plugin-files ${self.packages.${pkgs.system}.nix-plugin-pijul.override {inherit nix;}}/lib/nix/plugins/pijul.so \
              --extra-experimental-features 'nix-command flakes' \
              eval --impure --raw --expr "builtins.readFile ((builtins.fetchTree \"pijul+file://$PWD\") + \"/foo\")"
          )
          echo $output
          [[ "$output" = "it works" ]]
          mkdir $out
        '';
    in {
      nix_2_18 = localRepoCheck pkgs.nixVersions.nix_2_18;
      nix_2_19 = localRepoCheck pkgs.nixVersions.nix_2_19;
      nix_2_20 = localRepoCheck pkgs.nixVersions.nix_2_20;
      nix_2_21 = localRepoCheck pkgs.nixVersions.nix_2_21;
      nix_2_22 = localRepoCheck pkgs.nixVersions.nix_2_22;
      nix_2_23 = localRepoCheck pkgs.nixVersions.nix_2_23;
      nix_2_24 = localRepoCheck pkgs.nixVersions.nix_2_24;
      stable = localRepoCheck pkgs.nixVersions.stable;
      latest = localRepoCheck pkgs.nixVersions.latest;
    });

Replacement in flake.lock at line 5 [20.425]

B:BD[20.476] → [3.391:501]

∅:D[23.288] → [20.586:612]

∅:D[3.501] → [20.586:612]

B:BD[20.586] → [20.586:612]

        "lastModified": 1729658218,
        "narHash": "sha256-9Rg+AqLqvqqJniP/OQB3GtgXoAd8IlazsHp97va042Y=",
        "owner": "NixOS",

[20.476]

[20.612]

        "lastModified": 1771008912,
        "narHash": "sha256-gf2AmWVTs8lEq7z/3ZAsgnZDhWIckkb+ZnAo5RzSxJg=",
        "owner": "nixos",

Replacement in flake.lock at line 9 [20.425]

B:BD[20.639] → [3.502:561]

        "rev": "dfffb2e7a52d29a0ef8e21ec8a0f30487b227f1a",

[20.639]

[20.698]

        "rev": "a82ccc39b39b621151d6732718e3e250109076fa",

Replacement in flake.lock at line 13 [20.425]

B:BD[20.752] → [20.752:839]

        "id": "nixpkgs",
        "ref": "nixpkgs-unstable",
        "type": "indirect"

[20.752]

[20.839]

        "owner": "nixos",
        "ref": "nixos-unstable",
        "repo": "nixpkgs",
        "type": "github"

Replacement in README.md at line 19 [24.34]

B:BD[24.525] → [25.0:471]

B:BD[25.471] → [4.0:13]

B:BD[4.13] → [4.13:14]

B:BD[4.14] → [4.14:105]

NB: The fetcher from this plugin does not automatically get used when running
nix commands (e.g. `nix build`) in a Pijul repository, since this is hardcoded
for Git and Mercurial in Nix. For this, I have a patch that adds the relevant
code for Pijul, it's available as
[nix-pijul](https://git.sr.ht/~dblsaiko/nix-extras/tree/master/item/packages/nix-pijul.nix)
in my *nix-extras* flake. It replaces the normal Nix installation and can be
used in addition to this plugin.
## Releases
Released version archives are available [here](https://dblsaiko.net/pub/nix-plugin-pijul).

[24.525]

[25.471]

**Requires Nix 2.25+.** The plugin executes pijul to actually fetch
repositories, make sure that is available in the PATH.

Replacement in README.md at line 24 [24.34]
B:BD[26.1] → [5.0:37]
```
The package is available in nixpkgs:
```
[26.1]
[26.60]
```
Build from the NUR:
```

Replacement in README.md at line 27 [24.34]

B:BD[26.65] → [5.38:75]

% nix build nixpkgs#nix-plugin-pijul

[26.65]

[26.125]

nix-build -A nix-plugin-pijul https://github.com/DzmingLi/nur-packages/archive/master.tar.gz

Replacement in README.md at line 30 [24.34]

B:BD[24.540] → [25.473:597]

Add the built pijul.so module to plugin-files in nix.conf. Make sure it is built
for the Nix version you are using it with.

[24.540]

[24.599]

Or build from source:

Deletion in README.md at line 32 [24.34]

B:BD[24.600] → [27.0:99]

B:BD[27.99] → [5.76:141]

∅:D[5.141] → [27.99:100]

B:BD[27.99] → [27.99:100]

The plugin executes pijul to actually fetch repositories, make sure
that is available in the PATH.
The package is also available as part of my *nix-extras* flake:

Replacement in README.md at line 33 [24.34]

B:BD[5.146] → [5.146:206]

% nix build sourcehut:~dblsaiko/nix-extras#nix-plugin-pijul

[5.146]

[5.206]

pijul clone https://nest.pijul.com/DzmingLi/nix-plugin-pijul
cd nix-plugin-pijul
nix build

Replacement in README.md at line 38 [24.34]

∅:D[5.211] → [27.100:141]

B:BD[27.100] → [27.100:141]

### NixOS (with the nix-extras overlay):

[5.211]

[24.607]

Add the built pijul.so module to plugin-files in nix.conf. Make sure it is built
for the Nix version you are using it with.
### NixOS

Replacement in README.md at line 44 [24.34]

B:BD[24.615] → [25.636:659]

{pkgs, config, ...}: {

[24.615]

[27.142]

{pkgs, config, ...}:
let
  nur = import (builtins.fetchTarball "https://github.com/DzmingLi/nur-packages/archive/master.tar.gz") { inherit pkgs; };
in {

Replacement in README.md at line 49 [24.34]

∅:D[27.187] → [25.659:911]

B:BD[25.659] → [25.659:911]

  nix.settings.plugin-files = "${pkgs.nix-plugin-pijul.override { nix = config.nix.package; }}/lib/nix/plugins/pijul.so";
  
  # Optional: Use the patched Nix to automatically use Pijul fetcher in local
  # repositories
  nix.package = pkgs.nix-pijul;

[27.187]

[24.686]

  nix.settings.plugin-files = "${nur.nix-plugin-pijul}/lib/nix/plugins/pijul.so";

Replacement in README.md at line 60 [24.34]

B:BD[24.917] → [24.917:1004]

      nix-plugin-pijul.url = "pijul+https://nest.pijul.com/dblsaiko/nix-plugin-pijul";

[24.917]

[24.1004]

      nix-plugin-pijul.url = "pijul+https://nest.pijul.com/DzmingLi/nix-plugin-pijul";

Replacement in README.md at line 62 [24.34]
B:BD[24.1011] → [24.1011:1014]
```
  
```
[24.1011]
[24.1014]

Replacement in README.md at line 71 [24.34]

B:BD[24.1109] → [24.1109:1142]

Code based on the [pijul fetcher

[24.1109]

[24.1142]

- [dblsaiko](https://git.sr.ht/~dblsaiko) — original author
- Code based on the [pijul fetcher

Add nix 2.31 support

Dependencies

In channels

Change contents

Deletion in src/nixfeat.h at line 3 [8.34]

Replacement in src/nixfeat.h at line 4 [8.34]

Deletion in src/nixfeat.h at line 6 [8.34]

Deletion in src/nixfeat.h at line 7 [8.34]

Deletion in src/meson.build at line 10 [9.36]

Replacement in src/meson.build at line 23 [9.36]

Deletion in src/fetcher.cpp at line 3 [11.53]

Replacement in src/fetcher.cpp at line 8 [11.53]

Deletion in src/fetcher.cpp at line 32 [11.53]

Deletion in src/fetcher.cpp at line 33 [11.53]

Deletion in src/fetcher.cpp at line 57 [11.53]

Deletion in src/fetcher.cpp at line 58 [11.53]

Deletion in src/fetcher.cpp at line 62 [11.53]

Deletion in src/fetcher.cpp at line 63 [11.53]

Deletion in src/fetcher.cpp at line 68 [11.53]

Deletion in src/fetcher.cpp at line 69 [11.53]

Deletion in src/fetcher.cpp at line 72 [11.53]

Deletion in src/fetcher.cpp at line 73 [11.53]

Deletion in src/fetcher.cpp at line 75 [11.53]

Deletion in src/fetcher.cpp at line 80 [11.53]

Replacement in src/fetcher.cpp at line 103 [11.53]

Deletion in src/fetcher.cpp at line 107 [11.53]

Deletion in src/fetcher.cpp at line 118 [11.53]

Replacement in src/fetcher.cpp at line 125 [11.53]

Deletion in src/fetcher.cpp at line 129 [11.53]

Deletion in src/fetcher.cpp at line 130 [11.53]

Deletion in src/fetcher.cpp at line 131 [11.53]

Deletion in src/fetcher.cpp at line 132 [11.53]

Deletion in src/fetcher.cpp at line 141 [11.53]

Deletion in src/fetcher.cpp at line 142 [11.53]

Deletion in src/fetcher.cpp at line 149 [11.53]

Deletion in src/fetcher.cpp at line 150 [11.53]

Deletion in src/fetcher.cpp at line 152 [11.53]

Replacement in src/fetcher.cpp at line 153 [11.53]

Insertion in src/fetcher.cpp at line 156 [11.53]

Deletion in src/fetcher.cpp at line 159 [11.53]

Replacement in src/fetcher.cpp at line 161 [11.53]

Deletion in src/fetcher.cpp at line 182 [11.53]

Insertion in src/fetcher.cpp at line 183 [11.53]

Replacement in src/fetcher.cpp at line 186 [11.53]

Deletion in src/fetcher.cpp at line 193 [11.53]

Replacement in src/fetcher.cpp at line 194 [11.53]

Replacement in src/fetcher.cpp at line 197 [11.53]