mirror of
https://github.com/nlohmann/json.git
synced 2026-07-05 10:05:10 +00:00
Add std::format and fmt support (#5224)
* ✨ add std::format and fmt support Signed-off-by: Niels Lohmann <mail@nlohmann.me> * ♻️ reorganize PR Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 🧛 fix build Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 🧛 fix build Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 🧛 fix build Signed-off-by: Niels Lohmann <mail@nlohmann.me> --------- Signed-off-by: Niels Lohmann <mail@nlohmann.me>
This commit is contained in:
Niels Lohmann
GitHub
@@ -195,3 +195,18 @@ add_subdirectory(cmake_add_subdirectory)
|
||||
add_subdirectory(cmake_fetch_content)
|
||||
add_subdirectory(cmake_fetch_content2)
|
||||
add_subdirectory(cmake_target_include_directories)
|
||||
|
||||
# fmt (fetched by tests/fmt_formatter) requires a genuinely modern, C++17-capable
|
||||
# toolchain; skip it on legacy/niche toolchains where fmt itself is known not to build
|
||||
set(JSON_FMT_FORMATTER_TEST_SUPPORTED ${compiler_supports_cpp_17})
|
||||
# fmt 12's 128-bit integer emulation does not build with 32-bit MinGW
|
||||
if (MINGW AND CMAKE_SIZEOF_VOID_P EQUAL 4)
|
||||
set(JSON_FMT_FORMATTER_TEST_SUPPORTED FALSE)
|
||||
endif()
|
||||
# the MSVC STL rejects Clang versions older than 19 as a host compiler
|
||||
if (WIN32 AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.0)
|
||||
set(JSON_FMT_FORMATTER_TEST_SUPPORTED FALSE)
|
||||
endif()
|
||||
if (JSON_FMT_FORMATTER_TEST_SUPPORTED)
|
||||
add_subdirectory(fmt_formatter)
|
||||
endif()
|
||||
|
||||
@@ -0,0 +1,22 @@
|
||||
# fmt's CMakeLists.txt unconditionally sets the VERSION/SOVERSION/DEBUG_POSTFIX
|
||||
# properties on its (always-configured) INTERFACE_LIBRARY "fmt-header-only" target;
|
||||
# CMake rejected those properties on INTERFACE_LIBRARY targets before CMake 3.19
|
||||
if (${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.19.0")
|
||||
add_test(NAME fmt_formatter_configure
|
||||
COMMAND ${CMAKE_COMMAND}
|
||||
-G "${CMAKE_GENERATOR}"
|
||||
-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/project
|
||||
)
|
||||
add_test(NAME fmt_formatter_build
|
||||
COMMAND ${CMAKE_COMMAND} --build .
|
||||
)
|
||||
set_tests_properties(fmt_formatter_configure PROPERTIES
|
||||
FIXTURES_SETUP fmt_formatter
|
||||
LABELS "git_required;not_reproducible"
|
||||
)
|
||||
set_tests_properties(fmt_formatter_build PROPERTIES
|
||||
FIXTURES_REQUIRED fmt_formatter
|
||||
LABELS "git_required;not_reproducible"
|
||||
)
|
||||
endif()
|
||||
@@ -0,0 +1,36 @@
|
||||
cmake_minimum_required(VERSION 3.14)
|
||||
|
||||
project(FmtFormatterTest CXX)
|
||||
|
||||
include(FetchContent)
|
||||
|
||||
get_filename_component(GIT_REPOSITORY_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/../../.. ABSOLUTE)
|
||||
FetchContent_Declare(json GIT_REPOSITORY ${GIT_REPOSITORY_DIRECTORY} GIT_TAG HEAD)
|
||||
|
||||
set(FMT_TEST OFF CACHE BOOL "" FORCE)
|
||||
set(FMT_DOC OFF CACHE BOOL "" FORCE)
|
||||
set(FMT_INSTALL OFF CACHE BOOL "" FORCE)
|
||||
FetchContent_Declare(fmt
|
||||
GIT_REPOSITORY https://github.com/fmtlib/fmt.git
|
||||
GIT_TAG 12.2.0
|
||||
GIT_SHALLOW TRUE
|
||||
)
|
||||
|
||||
FetchContent_MakeAvailable(json fmt)
|
||||
|
||||
if(MSVC)
|
||||
add_compile_options(/EHsc)
|
||||
endif()
|
||||
|
||||
add_executable(fmt_formatter_test main.cpp)
|
||||
target_link_libraries(fmt_formatter_test PRIVATE nlohmann_json::nlohmann_json fmt::fmt)
|
||||
target_compile_features(fmt_formatter_test PRIVATE cxx_std_17)
|
||||
|
||||
# Fail the build itself (and therefore the ctest "build" step that drives it) if the
|
||||
# recipe's runtime assertions don't hold -- there is no separate "run" step, since the
|
||||
# executable's location varies by platform/generator, but CMake resolves a target name
|
||||
# passed to a custom command's COMMAND for us.
|
||||
add_custom_command(TARGET fmt_formatter_test POST_BUILD
|
||||
COMMAND fmt_formatter_test
|
||||
COMMENT "Running fmt::formatter<nlohmann::json> recipe test"
|
||||
)
|
||||
@@ -0,0 +1,94 @@
|
||||
#include <cassert>
|
||||
#include <fmt/format.h>
|
||||
#include <nlohmann/json.hpp>
|
||||
|
||||
// A fmt::formatter<nlohmann::json> specialization mirroring std::formatter<basic_json>
|
||||
// (see docs/mkdocs/docs/api/basic_json/std_formatter.md), for use with fmt versions that
|
||||
// no longer pick up format_as() (fmt >= 11.1.0), or to get the same "{:#}"/width/
|
||||
// fill-and-align spec support with any fmt version.
|
||||
// --8<-- [start:formatter_recipe]
|
||||
template <>
|
||||
struct fmt::formatter<nlohmann::json>
|
||||
{
|
||||
// -1 means compact output (dump()); any value >= 0 means pretty-printed
|
||||
// output with that many spaces (or indent_char) per level.
|
||||
int indent = -1;
|
||||
char indent_char = ' ';
|
||||
|
||||
constexpr auto parse(format_parse_context& ctx) -> format_parse_context::iterator
|
||||
{
|
||||
auto it = ctx.begin();
|
||||
const auto end = ctx.end();
|
||||
constexpr auto is_align = [](char c)
|
||||
{
|
||||
return c == '<' || c == '>' || c == '^';
|
||||
};
|
||||
|
||||
// [[fill] align] - repurposed here to pick a custom indent character
|
||||
if (it != end && it + 1 != end && is_align(it[1]))
|
||||
{
|
||||
indent_char = *it;
|
||||
it += 2;
|
||||
}
|
||||
else if (it != end && is_align(*it))
|
||||
{
|
||||
++it;
|
||||
}
|
||||
|
||||
// ['#'] - "alternate form", used here to request pretty-printing with a
|
||||
// default indent of 4 (overridden by an explicit width below, if given)
|
||||
if (it != end && *it == '#')
|
||||
{
|
||||
indent = 4;
|
||||
++it;
|
||||
}
|
||||
|
||||
// [width] - repurposed here to pick the indent size; a width without '#'
|
||||
// implies pretty-printing since an indent otherwise has no meaning
|
||||
if (it != end && *it >= '1' && *it <= '9')
|
||||
{
|
||||
indent = 0;
|
||||
while (it != end && *it >= '0' && *it <= '9')
|
||||
{
|
||||
indent = (indent * 10) + (*it - '0');
|
||||
++it;
|
||||
}
|
||||
}
|
||||
|
||||
if (it != end && *it != '}')
|
||||
{
|
||||
throw fmt::format_error("invalid format args for nlohmann::json");
|
||||
}
|
||||
|
||||
return it;
|
||||
}
|
||||
|
||||
auto format(const nlohmann::json& j, format_context& ctx) const
|
||||
{
|
||||
const auto dumped = j.dump(indent, indent_char);
|
||||
return fmt::format_to(ctx.out(), "{}", dumped);
|
||||
}
|
||||
};
|
||||
// --8<-- [end:formatter_recipe]
|
||||
|
||||
int main()
|
||||
{
|
||||
const nlohmann::json j = {{"foo", 1}, {"bar", {1, 2, 3}}};
|
||||
|
||||
assert(fmt::format("{}", j) == j.dump());
|
||||
assert(fmt::format("{:#}", j) == j.dump(4));
|
||||
assert(fmt::format("{:2}", j) == j.dump(2));
|
||||
assert(fmt::format("{:#2}", j) == j.dump(2));
|
||||
assert(fmt::format("{:.>#}", j) == j.dump(4, '.'));
|
||||
|
||||
bool threw = false;
|
||||
try
|
||||
{
|
||||
(void)fmt::vformat("{:x}", fmt::make_format_args(j));
|
||||
}
|
||||
catch (const fmt::format_error&)
|
||||
{
|
||||
threw = true;
|
||||
}
|
||||
assert(threw);
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
// __ _____ _____ _____
|
||||
// __| | __| | | | JSON for Modern C++ (supporting code)
|
||||
// | | |__ | | | | | | version 3.12.0
|
||||
// |_____|_____|_____|_|___| https://github.com/nlohmann/json
|
||||
//
|
||||
// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include "doctest_compatibility.h"
|
||||
|
||||
#include <nlohmann/json.hpp>
|
||||
using json = nlohmann::json;
|
||||
using ordered_json = nlohmann::ordered_json;
|
||||
|
||||
namespace
|
||||
{
|
||||
// call format_as() the same way fmt's ADL-based dispatch would: unqualified,
|
||||
// found only via argument-dependent lookup on the (namespace-qualified) argument type.
|
||||
template<typename BasicJsonType>
|
||||
std::string call_format_as_via_adl(const BasicJsonType& j)
|
||||
{
|
||||
return format_as(j);
|
||||
}
|
||||
} // namespace
|
||||
|
||||
TEST_CASE("format_as<nlohmann::json>")
|
||||
{
|
||||
// null
|
||||
CHECK(format_as(json(nullptr)) == json(nullptr).dump());
|
||||
|
||||
// boolean
|
||||
CHECK(format_as(json(true)) == json(true).dump());
|
||||
CHECK(format_as(json(false)) == json(false).dump());
|
||||
|
||||
// string (including a value that needs escaping/UTF-8 handling)
|
||||
CHECK(format_as(json("")) == json("").dump());
|
||||
CHECK(format_as(json("foo")) == json("foo").dump());
|
||||
CHECK(format_as(json("foo\"bar\\baz\nqux")) == json("foo\"bar\\baz\nqux").dump());
|
||||
CHECK(format_as(json("\xc3\xa4\xc3\xb6\xc3\xbc")) == json("\xc3\xa4\xc3\xb6\xc3\xbc").dump());
|
||||
|
||||
// number
|
||||
CHECK(format_as(json(0)) == json(0).dump());
|
||||
CHECK(format_as(json(-1)) == json(-1).dump());
|
||||
CHECK(format_as(json(static_cast<unsigned>(42))) == json(static_cast<unsigned>(42)).dump());
|
||||
CHECK(format_as(json(42.23)) == json(42.23).dump());
|
||||
|
||||
// array
|
||||
CHECK(format_as(json::array()) == json::array().dump());
|
||||
CHECK(format_as(json::array({1, 2, 3})) == json::array({1, 2, 3}).dump());
|
||||
|
||||
// object
|
||||
CHECK(format_as(json::object()) == json::object().dump());
|
||||
CHECK(format_as(json::object({{"foo", "bar"}})) == json::object({{"foo", "bar"}}).dump());
|
||||
|
||||
// nested/mixed structure
|
||||
const json j_nested = {{"foo", 1}, {"bar", {1, 2, 3}}, {"baz", {{"a", nullptr}, {"b", false}}}};
|
||||
CHECK(format_as(j_nested) == j_nested.dump());
|
||||
|
||||
// binary
|
||||
CHECK(format_as(json::binary({})) == json::binary({}).dump());
|
||||
CHECK(format_as(json::binary({1, 2, 3}, 42)) == json::binary({1, 2, 3}, 42).dump());
|
||||
|
||||
// discarded
|
||||
CHECK(format_as(json(json::value_t::discarded)) == json(json::value_t::discarded).dump());
|
||||
}
|
||||
|
||||
TEST_CASE("format_as<nlohmann::ordered_json>")
|
||||
{
|
||||
// spot-check a non-default basic_json instantiation, since
|
||||
// NLOHMANN_BASIC_JSON_TPL_DECLARATION must deduce correctly there too
|
||||
CHECK(format_as(ordered_json(nullptr)) == ordered_json(nullptr).dump());
|
||||
CHECK(format_as(ordered_json::object({{"foo", "bar"}, {"baz", 42}})) ==
|
||||
ordered_json::object({{"foo", "bar"}, {"baz", 42}}).dump());
|
||||
CHECK(format_as(ordered_json::array({1, 2, 3})) == ordered_json::array({1, 2, 3}).dump());
|
||||
}
|
||||
|
||||
TEST_CASE("format_as<nlohmann::json> is found via ADL")
|
||||
{
|
||||
// this is how fmt actually calls it: unqualified, relying on argument-dependent
|
||||
// lookup finding nlohmann::format_as via the argument's namespace
|
||||
const json j = {{"foo", 1}, {"bar", {1, 2, 3}}};
|
||||
CHECK(call_format_as_via_adl(j) == j.dump());
|
||||
|
||||
const ordered_json oj = {{"foo", 1}, {"bar", {1, 2, 3}}};
|
||||
CHECK(call_format_as_via_adl(oj) == oj.dump());
|
||||
}
|
||||
@@ -0,0 +1,96 @@
|
||||
// __ _____ _____ _____
|
||||
// __| | __| | | | JSON for Modern C++ (supporting code)
|
||||
// | | |__ | | | | | | version 3.12.0
|
||||
// |_____|_____|_____|_|___| https://github.com/nlohmann/json
|
||||
//
|
||||
// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
// cmake/test.cmake selects the C++ standard versions with which to build a
|
||||
// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
|
||||
// When using macros that are only defined for particular versions of the standard
|
||||
// (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
|
||||
// version macro in a comment close by, like this:
|
||||
// JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)
|
||||
|
||||
#include "doctest_compatibility.h"
|
||||
|
||||
#include <nlohmann/json.hpp>
|
||||
using json = nlohmann::json;
|
||||
|
||||
// JSON_HAS_CPP_20 (do not remove; see note at top of file)
|
||||
#if JSON_HAS_STD_FORMAT
|
||||
|
||||
#include <iterator>
|
||||
#include <string>
|
||||
|
||||
TEST_CASE("std::formatter<nlohmann::json>")
|
||||
{
|
||||
SECTION("compact formatting matches dump()")
|
||||
{
|
||||
CHECK(std::format("{}", json(nullptr)) == json(nullptr).dump());
|
||||
CHECK(std::format("{}", json(true)) == json(true).dump());
|
||||
CHECK(std::format("{}", json(42)) == json(42).dump());
|
||||
CHECK(std::format("{}", json(42.23)) == json(42.23).dump());
|
||||
CHECK(std::format("{}", json("foo")) == json("foo").dump());
|
||||
CHECK(std::format("{}", json::array({1, 2, 3})) == json::array({1, 2, 3}).dump());
|
||||
|
||||
const json j = {{"foo", 1}, {"bar", {1, 2, 3}}};
|
||||
CHECK(std::format("{}", j) == j.dump());
|
||||
}
|
||||
|
||||
SECTION("'#' triggers pretty-printing with an indent of 4, like dump(4)")
|
||||
{
|
||||
const json j = {{"foo", 1}, {"bar", {1, 2, 3}}};
|
||||
CHECK(std::format("{:#}", j) == j.dump(4));
|
||||
CHECK(std::format("{:#}", json::array()) == json::array().dump(4));
|
||||
}
|
||||
|
||||
SECTION("a width sets the indent, like dump(width), with or without '#'")
|
||||
{
|
||||
const json j = {{"foo", 1}, {"bar", {1, 2, 3}}};
|
||||
CHECK(std::format("{:2}", j) == j.dump(2));
|
||||
CHECK(std::format("{:#2}", j) == j.dump(2));
|
||||
CHECK(std::format("{:8}", j) == j.dump(8));
|
||||
}
|
||||
|
||||
SECTION("fill-and-align sets the indent character, like dump(indent, indent_char)")
|
||||
{
|
||||
const json j = {{"foo", 1}, {"bar", {1, 2, 3}}};
|
||||
CHECK(std::format("{:.>#}", j) == j.dump(4, '.'));
|
||||
CHECK(std::format("{:.>#3}", j) == j.dump(3, '.'));
|
||||
CHECK(std::format("{:.>3}", j) == j.dump(3, '.'));
|
||||
// the alignment direction itself ('<', '>', '^') has no separate meaning for
|
||||
// JSON values -- only the fill character before it is used as the indent character
|
||||
CHECK(std::format("{:.<3}", j) == j.dump(3, '.'));
|
||||
CHECK(std::format("{:.^3}", j) == j.dump(3, '.'));
|
||||
}
|
||||
|
||||
SECTION("format args with no meaning for JSON values are rejected")
|
||||
{
|
||||
// std::vformat parses the format string at runtime (unlike std::format, whose
|
||||
// format_string type is checked at compile time), so it lets us verify that an
|
||||
// invalid spec throws std::format_error without needing a compile-time-illegal
|
||||
// format string.
|
||||
const json j = 42;
|
||||
CHECK_THROWS_AS(std::vformat("{:x}", std::make_format_args(j)), std::format_error);
|
||||
CHECK_THROWS_AS(std::vformat("{:+}", std::make_format_args(j)), std::format_error); // sign
|
||||
CHECK_THROWS_AS(std::vformat("{:-}", std::make_format_args(j)), std::format_error); // sign
|
||||
CHECK_THROWS_AS(std::vformat("{: }", std::make_format_args(j)), std::format_error); // sign
|
||||
CHECK_THROWS_AS(std::vformat("{:04}", std::make_format_args(j)), std::format_error); // '0' flag
|
||||
CHECK_THROWS_AS(std::vformat("{:.2}", std::make_format_args(j)), std::format_error); // precision
|
||||
CHECK_THROWS_AS(std::vformat("{:L}", std::make_format_args(j)), std::format_error); // locale
|
||||
const int dynamic_width = 4;
|
||||
CHECK_THROWS_AS(std::vformat("{:{}}", std::make_format_args(j, dynamic_width)), std::format_error); // dynamic width
|
||||
}
|
||||
|
||||
SECTION("std::format_to writes through an arbitrary output iterator")
|
||||
{
|
||||
const json j = {{"foo", 1}, {"bar", {1, 2, 3}}};
|
||||
std::string out;
|
||||
std::format_to(std::back_inserter(out), "{}", j);
|
||||
CHECK(out == j.dump());
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user