forked from lix-project/lix
cc22cf662b
When computing a lock file, we now respect the lock files of flake
inputs. This is important for usability / reproducibility. For
example, the 'nixops' flake depends on the 'nixops-aws' and
'nixops-hetzner' repositories. So when the 'nixops' flake is used in
another flake, we want the versions of 'nixops-aws' and
'nixops-hetzner' locked by the the 'nixops' flake because those
presumably have been tested.
This can lead to a proliferation of versions of flakes like 'nixpkgs'
(since every flake's lock file could depend on a different version of
'nixpkgs'). This is not a major issue when using Nixpkgs overlays or
NixOS modules, since then the top-level flake composes those
overlays/modules into *its* version of Nixpkgs and all other versions
are ignored. Lock file computation has been made a bit more lazy so it
won't try to fetch all those versions of 'nixpkgs'.
However, in case it's necessary to minimize flake versions, there now
are two input attributes that allow this. First, you can copy an input
from another flake, as follows:
inputs.nixpkgs.follows = "dwarffs/nixpkgs";
This states that the calling flake's 'nixpkgs' input shall be the same
as the 'nixpkgs' input of the 'dwarffs' input.
Second, you can override inputs of inputs:
inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>;
inputs.nixops.inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>;
or equivalently, using 'follows':
inputs.nixpkgs.url = github:edolstra/nixpkgs/<hash>;
inputs.nixops.inputs.nixpkgs.follows = "nixpkgs";
This states that the 'nixpkgs' input of the 'nixops' input shall be
the same as the calling flake's 'nixpkgs' input.
Finally, at '-v' Nix now prints the changes to the lock file, e.g.
$ nix flake update ~/Misc/eelco-configurations/hagbard
inputs of flake 'git+file:///home/eelco/Misc/eelco-configurations?subdir=hagbard' changed:
updated 'nixpkgs': 'github:edolstra/nixpkgs/7845bf5f4b3013df1cf036e9c9c3a55a30331db9' -> 'github:edolstra/nixpkgs/03f3def66a104a221aac8b751eeb7075374848fd'
removed 'nixops'
removed 'nixops/nixops-aws'
removed 'nixops/nixops-hetzner'
removed 'nixops/nixpkgs'
131 lines
3.4 KiB
C++
131 lines
3.4 KiB
C++
#include "parse.hh"
|
|
#include "util.hh"
|
|
#include "regex.hh"
|
|
|
|
namespace nix::fetchers {
|
|
|
|
std::regex refRegex(refRegexS, std::regex::ECMAScript);
|
|
std::regex revRegex(revRegexS, std::regex::ECMAScript);
|
|
std::regex flakeIdRegex(flakeIdRegexS, std::regex::ECMAScript);
|
|
|
|
ParsedURL parseURL(const std::string & url)
|
|
{
|
|
static std::regex uriRegex(
|
|
"(((" + schemeRegex + "):"
|
|
+ "(//(" + authorityRegex + "))?"
|
|
+ "(" + pathRegex + "))"
|
|
+ "(?:\\?(" + queryRegex + "))?"
|
|
+ "(?:#(" + queryRegex + "))?"
|
|
+ ")",
|
|
std::regex::ECMAScript);
|
|
|
|
std::smatch match;
|
|
|
|
if (std::regex_match(url, match, uriRegex)) {
|
|
auto & base = match[2];
|
|
std::string scheme = match[3];
|
|
auto authority = match[4].matched
|
|
? std::optional<std::string>(match[5]) : std::nullopt;
|
|
std::string path = match[6];
|
|
auto & query = match[7];
|
|
auto & fragment = match[8];
|
|
|
|
auto isFile = scheme.find("file") != std::string::npos;
|
|
|
|
if (authority && *authority != "" && isFile)
|
|
throw Error("file:// URL '%s' has unexpected authority '%s'",
|
|
url, *authority);
|
|
|
|
if (isFile && path.empty())
|
|
path = "/";
|
|
|
|
return ParsedURL{
|
|
.url = url,
|
|
.base = base,
|
|
.scheme = scheme,
|
|
.authority = authority,
|
|
.path = path,
|
|
.query = decodeQuery(query),
|
|
.fragment = percentDecode(std::string(fragment))
|
|
};
|
|
}
|
|
|
|
else
|
|
throw BadURL("'%s' is not a valid URL", url);
|
|
}
|
|
|
|
std::string percentDecode(std::string_view in)
|
|
{
|
|
std::string decoded;
|
|
for (size_t i = 0; i < in.size(); ) {
|
|
if (in[i] == '%') {
|
|
if (i + 2 >= in.size())
|
|
throw BadURL("invalid URI parameter '%s'", in);
|
|
try {
|
|
decoded += std::stoul(std::string(in, i + 1, 2), 0, 16);
|
|
i += 3;
|
|
} catch (...) {
|
|
throw BadURL("invalid URI parameter '%s'", in);
|
|
}
|
|
} else
|
|
decoded += in[i++];
|
|
}
|
|
return decoded;
|
|
}
|
|
|
|
std::map<std::string, std::string> decodeQuery(const std::string & query)
|
|
{
|
|
std::map<std::string, std::string> result;
|
|
|
|
for (auto s : tokenizeString<Strings>(query, "&")) {
|
|
auto e = s.find('=');
|
|
if (e != std::string::npos)
|
|
result.emplace(
|
|
s.substr(0, e),
|
|
percentDecode(std::string_view(s).substr(e + 1)));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
std::string percentEncode(std::string_view s)
|
|
{
|
|
std::string res;
|
|
for (auto & c : s)
|
|
if ((c >= 'a' && c <= 'z')
|
|
|| (c >= 'A' && c <= 'Z')
|
|
|| (c >= '0' && c <= '9')
|
|
|| strchr("-._~!$&'()*+,;=:@", c))
|
|
res += c;
|
|
else
|
|
res += fmt("%%%02x", (unsigned int) c);
|
|
return res;
|
|
}
|
|
|
|
std::string encodeQuery(const std::map<std::string, std::string> & ss)
|
|
{
|
|
std::string res;
|
|
bool first = true;
|
|
for (auto & [name, value] : ss) {
|
|
if (!first) res += '&';
|
|
first = false;
|
|
res += percentEncode(name);
|
|
res += '=';
|
|
res += percentEncode(value);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
std::string ParsedURL::to_string() const
|
|
{
|
|
return
|
|
scheme
|
|
+ ":"
|
|
+ (authority ? "//" + *authority : "")
|
|
+ path
|
|
+ (query.empty() ? "" : "?" + encodeQuery(query))
|
|
+ (fragment.empty() ? "" : "#" + percentEncode(fragment));
|
|
}
|
|
|
|
}
|