lix-project/lix-releng-staging
0
0
Fork 0
Code Packages Activity

Merge "Remove HintFmt::operator%" into main

Browse source
This commit is contained in:
Rebecca Turner 2024-03-29 01:13:45 +00:00 committed by Gerrit Code Review
parent 55350bd68d 8e63eca912
commit 236bc046ba
6 changed files with 138 additions and 121 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

45
src/build-remote/build-remote.cc
View file

@ -185,16 +185,6 @@ static int main_build_remote(int argc, char * * argv)
std::cerr << "# postpone\n";
else
{
// build the hint template.
std::string errorText =
"Failed to find a machine for remote build!\n"
"derivation: %s\nrequired (system, features): (%s, [%s])";
errorText += "\n%s available machines:";
errorText += "\n(systems, maxjobs, supportedFeatures, mandatoryFeatures)";
for (unsigned int i = 0; i < machines.size(); ++i)
errorText += "\n([%s], %s, [%s], [%s])";
// add the template values.
std::string drvstr;
if (drvPath.has_value())
@ -202,19 +192,30 @@ static int main_build_remote(int argc, char * * argv)
else
drvstr = "<unknown>";
auto error = HintFmt::fromFormatString(errorText);
error
% drvstr
% neededSystem
% concatStringsSep<StringSet>(", ", requiredFeatures)
% machines.size();
std::string machinesFormatted;
for (auto & m : machines)
error
% concatStringsSep<StringSet>(", ", m.systemTypes)
% m.maxJobs
% concatStringsSep<StringSet>(", ", m.supportedFeatures)
% concatStringsSep<StringSet>(", ", m.mandatoryFeatures);
for (auto & m : machines) {
machinesFormatted += HintFmt(
"\n([%s], %s, [%s], [%s])",
concatStringsSep<StringSet>(", ", m.systemTypes),
m.maxJobs,
concatStringsSep<StringSet>(", ", m.supportedFeatures),
concatStringsSep<StringSet>(", ", m.mandatoryFeatures)
).str();
}
auto error = HintFmt(
"Failed to find a machine for remote build!\n"
"derivation: %s\n"
"required (system, features): (%s, [%s])\n"
"%s available machines:\n"
"(systems, maxjobs, supportedFeatures, mandatoryFeatures)%s",
drvstr,
neededSystem,
concatStringsSep<StringSet>(", ", requiredFeatures),
machines.size(),
Uncolored(machinesFormatted)
);
printMsg(couldBuildLocally ? lvlChatty : lvlWarn, error.str());

2
src/libexpr/print.cc
View file

@ -608,7 +608,7 @@ std::ostream & operator<<(std::ostream & output, const ValuePrinter & printer)
}
template<>
HintFmt & HintFmt::operator%(const ValuePrinter & value)
fmt_internal::HintFmt & fmt_internal::HintFmt::operator%(const ValuePrinter & value)
{
fmt % value;
return *this;

2
src/libexpr/print.hh
View file

@ -86,6 +86,6 @@ std::ostream & operator<<(std::ostream & output, const ValuePrinter & printer);
* magenta.
*/
template<>
HintFmt & HintFmt::operator%(const ValuePrinter & value);
fmt_internal::HintFmt & fmt_internal::HintFmt::operator%(const ValuePrinter & value);
}

183
src/libutil/fmt.hh
View file

@ -5,43 +5,94 @@
#include <string>
#include "ansicolor.hh"
namespace nix {
namespace {
/**
* A helper for writing `boost::format` expressions.
* Values wrapped in this struct are printed in magenta.
*
* These are equivalent:
*
* ```
* formatHelper(formatter, a_0, ..., a_n)
* formatter % a_0 % ... % a_n
* ```
*
* With a single argument, `formatHelper(s)` is a no-op.
* By default, arguments to `HintFmt` are printed in magenta. To avoid this,
* either wrap the argument in `Uncolored` or add a specialization of
* `HintFmt::operator%`.
*/
template<class F>
inline void formatHelper(F & f)
{ }
template<class F, typename T, typename... Args>
inline void formatHelper(F & f, const T & x, const Args & ... args)
template<class T>
struct Magenta
{
// Interpolate one argument and then recurse.
formatHelper(f % x, args...);
Magenta(const T & s) : value(s) {}
const T & value;
};
template<class T>
std::ostream & operator<<(std::ostream & out, const Magenta<T> & y)
{
return out << ANSI_MAGENTA << y.value << ANSI_NORMAL;
}
/**
* Values wrapped in this class are printed without coloring.
*
* By default, arguments to `HintFmt` are printed in magenta (see `Magenta`).
*/
template<class T>
struct Uncolored
{
Uncolored(const T & s) : value(s) {}
const T & value;
};
template<class T>
std::ostream & operator<<(std::ostream & out, const Uncolored<T> & y)
{
return out << ANSI_NORMAL << y.value;
}
namespace fmt_internal {
/**
* Set the correct exceptions for `fmt`.
*/
void setExceptions(boost::format & fmt)
inline void setExceptions(boost::format & fmt)
{
fmt.exceptions(
boost::io::all_error_bits ^
boost::io::too_many_args_bit ^
boost::io::too_few_args_bit);
boost::io::all_error_bits ^ boost::io::too_many_args_bit ^ boost::io::too_few_args_bit
);
}
/**
* Helper class for `HintFmt` that supports the evil `operator%`.
*
* See: https://git.lix.systems/lix-project/lix/issues/178
*/
struct HintFmt
{
boost::format fmt;
template<typename... Args>
HintFmt(boost::format && fmt, const Args &... args) : fmt(std::move(fmt))
{
setExceptions(fmt);
(*this % ... % args);
}
template<class T>
HintFmt & operator%(const T & value)
{
fmt % Magenta(value);
return *this;
}
template<class T>
HintFmt & operator%(const Uncolored<T> & value)
{
fmt % value.value;
return *this;
}
boost::format into_format()
{
return std::move(fmt);
}
};
}
/**
@ -77,52 +128,14 @@ inline std::string fmt(const char * s)
}
template<typename... Args>
inline std::string fmt(const std::string & fs, const Args & ... args)
inline std::string fmt(const std::string & fs, const Args &... args)
{
boost::format f(fs);
setExceptions(f);
formatHelper(f, args...);
fmt_internal::setExceptions(f);
(f % ... % args);
return f.str();
}
/**
* Values wrapped in this struct are printed in magenta.
*
* By default, arguments to `HintFmt` are printed in magenta. To avoid this,
* either wrap the argument in `Uncolored` or add a specialization of
* `HintFmt::operator%`.
*/
template <class T>
struct Magenta
{
Magenta(const T &s) : value(s) {}
const T & value;
};
template <class T>
std::ostream & operator<<(std::ostream & out, const Magenta<T> & y)
{
return out << ANSI_WARNING << y.value << ANSI_NORMAL;
}
/**
* Values wrapped in this class are printed without coloring.
*
* By default, arguments to `HintFmt` are printed in magenta (see `Magenta`).
*/
template <class T>
struct Uncolored
{
Uncolored(const T & s) : value(s) {}
const T & value;
};
template <class T>
std::ostream & operator<<(std::ostream & out, const Uncolored<T> & y)
{
return out << ANSI_NORMAL << y.value;
}
/**
* A wrapper around `boost::format` which colors interpolated arguments in
* magenta by default.
@ -137,46 +150,28 @@ public:
* Format the given string literally, without interpolating format
* placeholders.
*/
HintFmt(const std::string & literal)
: HintFmt("%s", Uncolored(literal))
{ }
static HintFmt fromFormatString(const std::string & format) {
return HintFmt(boost::format(format));
}
HintFmt(const std::string & literal) : HintFmt("%s", Uncolored(literal)) {}
/**
* Interpolate the given arguments into the format string.
*/
template<typename... Args>
HintFmt(const std::string & format, const Args & ... args)
HintFmt(const std::string & format, const Args &... args)
: HintFmt(boost::format(format), args...)
{ }
{
}
HintFmt(const HintFmt & hf)
: fmt(hf.fmt)
{ }
HintFmt(const HintFmt & hf) : fmt(hf.fmt) {}
template<typename... Args>
HintFmt(boost::format && fmt, const Args & ... args)
: fmt(std::move(fmt))
HintFmt(boost::format && fmt, const Args &... args)
: fmt(fmt_internal::HintFmt(std::move(fmt), args...).into_format())
{
setExceptions(fmt);
formatHelper(*this, args...);
}
template<class T>
HintFmt & operator%(const T & value)
{
fmt % Magenta(value);
return *this;
}
template<class T>
HintFmt & operator%(const Uncolored<T> & value)
{
fmt % value.value;
return *this;
if (this->fmt.remaining_args() != 0) {
throw boost::io::too_few_args(
this->fmt.bound_args() + this->fmt.fed_args(), this->fmt.expected_args()
);
}
}
std::string str() const

4
src/libutil/logging.hh
View file

@ -230,9 +230,7 @@ extern Verbosity verbosity;
template<typename... Args>
inline void warn(const std::string & fs, const Args & ... args)
{
boost::format f(fs);
formatHelper(f, args...);
logger->warn(f.str());
logger->warn(HintFmt(fs, args...).str());
}
#define warnOnce(haveWarned, args...) \

23
tests/unit/libutil/fmt.cc Normal file
View file

@ -0,0 +1,23 @@
#include "fmt.hh"
#include "ansicolor.hh"
#include <gtest/gtest.h>
namespace nix {
TEST(HintFmt, arg_count)
{
// Single arg is treated as a literal string.
ASSERT_EQ(HintFmt("%s").str(), "%s");
// Other strings format as expected:
ASSERT_EQ(HintFmt("%s", 1).str(), ANSI_MAGENTA "1" ANSI_NORMAL);
ASSERT_EQ(HintFmt("%1%", "hello").str(), ANSI_MAGENTA "hello" ANSI_NORMAL);
// Argument counts are detected at construction.
ASSERT_THROW(HintFmt("%s %s", 1), boost::io::too_few_args);
ASSERT_THROW(HintFmt("%s", 1, 2), boost::io::too_many_args);
}
}