Merge branch 'develop' into fix/json_pointer_create_object_5357

Signed-off-by: Niels Lohmann <mail@nlohmann.me>

.github/workflows/ubuntu.yml

@@ -31,45 +31,6 @@ jobs:
       - name: Build
         run: cmake --build build --target ci_test_gcc
 
-  ci_meson_install:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
-      - name: Install Meson
-        run: pip install meson
-      - name: Install with Meson
-        run: |
-          meson setup build-meson --prefix=${{ github.workspace }}/install
-          meson install -C build-meson
-      - name: Use the installed package with find_package
-        run: |
-          cmake -S tests/cmake_import/project -B build-import -DCMAKE_PREFIX_PATH=${{ github.workspace }}/install
-          cmake --build build-import
-      - name: Install with Meson and non-default options
-        run: |
-          meson setup build-meson-options --prefix=${{ github.workspace }}/install-options -DMultipleHeaders=true -DDiagnostics=true -DGlobalUDLs=false
-          meson install -C build-meson-options
-      - name: Check that the options reach the installed files
-        run: |
-          test -d install-options/include/nlohmann/detail
-          cflags=$(PKG_CONFIG_PATH=${{ github.workspace }}/install-options/share/pkgconfig pkg-config --cflags nlohmann_json)
-          echo "$cflags"
-          echo "$cflags" | grep -q -- '-DJSON_DIAGNOSTICS=1'
-          echo "$cflags" | grep -q -- '-DJSON_USE_GLOBAL_UDLS=0'
-          grep -q 'JSON_USE_GLOBAL_UDLS=0;JSON_DIAGNOSTICS=1' install-options/share/cmake/nlohmann_json/nlohmann_jsonTargets.cmake
-          cmake -S tests/cmake_import/project -B build-import-options -DCMAKE_PREFIX_PATH=${{ github.workspace }}/install-options
-          cmake --build build-import-options
-      - name: Install with Meson and the include directory outside the prefix
-        run: |
-          meson setup build-meson-split --prefix=${{ github.workspace }}/install-split --includedir=${{ github.workspace }}/install-split-dev/include
-          meson install -C build-meson-split
-          cmake -S tests/cmake_import/project -B build-import-split -DCMAKE_PREFIX_PATH=${{ github.workspace }}/install-split
-          cmake --build build-import-split
-
   ci_infer:
     runs-on: ubuntu-latest
     steps:

CMakeLists.txt

@@ -168,30 +168,7 @@ if (MSVC)
     )
 endif()
 
-# Install a pkg-config file, so other tools can find this. It carries the same
-# compile definitions as the target above.
-set(NLOHMANN_JSON_PKGCONFIG_CFLAGS "")
-if (NOT JSON_GlobalUDLs)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_USE_GLOBAL_UDLS=0")
-endif()
-if (NOT JSON_ImplicitConversions)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_USE_IMPLICIT_CONVERSIONS=0")
-endif()
-if (JSON_DisableEnumSerialization)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_DISABLE_ENUM_SERIALIZATION=1")
-endif()
-if (JSON_Diagnostics)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_DIAGNOSTICS=1")
-endif()
-if (JSON_Diagnostic_Positions)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_DIAGNOSTIC_POSITIONS=1")
-endif()
-if (JSON_LegacyDiscardedValueComparison)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1")
-endif()
-if (JSON_StrictNulHandling)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_STRICT_NUL_HANDLING=1")
-endif()
+# Install a pkg-config file, so other tools can find this.
 configure_file(
     "${CMAKE_CURRENT_SOURCE_DIR}/cmake/pkg-config.pc.in"
     "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc"

FILES.md

@@ -260,29 +260,9 @@ make BUILD.bazel
 
 The "Check amalgamation" workflow fails if the file is out of date.
 
-### `meson.build` and `meson_options.txt`
+### `meson.build`
 
-Meson build definitions suitable for use as a subproject ("wrap" in Meson terminology).
-
-Projects wishing to use the wrap can execute:
-```sh
-meson wrap install nlohmann_json
-```
-
-Which allows Meson to build from source when a system provided dependency isn't available.
-
-To build directly:
-```sh
-meson setup builddir
-ninja -C builddir
-```
-
-`meson_options.txt` defines the options, which mirror the CMake options that change the library's target (for example,
-`-DDiagnostics=true`). Meson requires this file next to `meson.build`, so it is also part of `include.zip`.
-
-When installing, `meson.build` installs the headers, a pkg-config file, and the CMake package config files, so that
-`find_package(nlohmann_json)` works. As Meson cannot generate `nlohmann_jsonTargets.cmake` itself, it is created from
-the template `cmake/nlohmann_jsonTargets.cmake.in`, which is only used by Meson.
+The build definition for the [Meson](https://mesonbuild.com) build system.
 
 ### `Package.swift`
 

Makefile

@@ -222,7 +222,7 @@ json.tar.xz:
 # We use `-X` to make the resulting ZIP file reproducible, see
 # <https://content.pivotal.io/blog/barriers-to-deterministic-reproducible-zip-files>.
 include.zip: BUILD.bazel
-	zip -9 --recurse-paths -X include.zip $(SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) BUILD.bazel MODULE.bazel meson.build meson_options.txt LICENSE.MIT
+	zip -9 --recurse-paths -X include.zip $(SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) BUILD.bazel MODULE.bazel meson.build LICENSE.MIT
 
 # Create the files for a release and add signatures and hashes.
 release: include.zip json.tar.xz

cmake/nlohmann_jsonTargets.cmake.in

@@ -1,38 +0,0 @@
-# Imported target for installations made with Meson (see meson.build).
-#
-# CMake installations generate this file with install(EXPORT ...). Meson cannot
-# do that, but as the library is header-only, the target only needs an include
-# directory, the C++ standard, and the compile definitions of the options that
-# differ from their defaults. Paths are computed relative to this file so that
-# the installation can be relocated (e.g., into a sysroot), unless includedir or
-# datadir is outside the prefix.
-
-if(TARGET @PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@)
-    return()
-endif()
-
-get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_DIR}/@NLOHMANN_JSON_CONFIG_TO_PREFIX@" ABSOLUTE)
-
-add_library(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ INTERFACE IMPORTED)
-set_target_properties(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ PROPERTIES
-    INTERFACE_INCLUDE_DIRECTORIES "@NLOHMANN_JSON_INCLUDE_DIR@"
-)
-if(CMAKE_VERSION VERSION_LESS 3.8)
-    set_target_properties(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ PROPERTIES
-        INTERFACE_COMPILE_FEATURES cxx_range_for
-    )
-else()
-    set_target_properties(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ PROPERTIES
-        INTERFACE_COMPILE_FEATURES cxx_std_11
-    )
-endif()
-
-set(_NLOHMANN_JSON_COMPILE_DEFINITIONS "@NLOHMANN_JSON_COMPILE_DEFINITIONS@")
-if(_NLOHMANN_JSON_COMPILE_DEFINITIONS)
-    set_target_properties(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ PROPERTIES
-        INTERFACE_COMPILE_DEFINITIONS "${_NLOHMANN_JSON_COMPILE_DEFINITIONS}"
-    )
-endif()
-
-unset(_NLOHMANN_JSON_COMPILE_DEFINITIONS)
-unset(_IMPORT_PREFIX)

cmake/pkg-config.pc.in

@@ -4,4 +4,4 @@ includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
 Name: @PROJECT_NAME@
 Description: JSON for Modern C++
 Version: @PROJECT_VERSION@
-Cflags: -I${includedir}@NLOHMANN_JSON_PKGCONFIG_CFLAGS@
+Cflags: -I${includedir}

docs/mkdocs/docs/api/basic_json/operator[].md

@@ -128,10 +128,13 @@ Strong exception safety: if an exception occurs, the original value stays intact
 
         When the JSON pointer traverses intermediate levels that don't exist at all yet (not just a missing
         leaf), each missing level is created as an array or an object depending on whether the corresponding
-        pointer token parses as a non-negative integer: a numeric token creates an array, a non-numeric token
-        creates an object. For example, on an initially `#!json null` value, `/foo/0/0/0` creates nested arrays,
-        while `/foo/one/one/one` creates nested objects. This is not specified by the JSON Pointer RFC; it is
-        this library's own, intentional disambiguation rule. See also [JSON Pointer](../../features/json_pointer.md).
+        pointer token is a valid array index: the token `0`, a sequence of digits that does not begin with `0`,
+        or the token `-` creates an array, and every other token creates an object. For example, on an
+        initially `#!json null` value, `/foo/0/0/0` creates nested arrays, while `/foo/one/one/one` creates
+        nested objects. Tokens such as `01` or the empty token cannot be array indices (cf. RFC 6901, Sect. 4)
+        and therefore create objects, just as they would if the level already existed as an object. This is not
+        specified by the JSON Pointer RFC; it is this library's own, intentional disambiguation rule. See also
+        [JSON Pointer](../../features/json_pointer.md).
 
 ## Examples
 

docs/mkdocs/docs/integration/package_managers.md

@@ -121,23 +121,10 @@ meson wrap install nlohmann_json
 Please see the Meson project for any issues regarding the packaging.
 
 The provided `meson.build` can also be used as an alternative to CMake for installing `nlohmann_json` system-wide in
-which case a pkg-config file and the CMake package config files are installed. To use it, have your build system require
-the `nlohmann_json` pkg-config dependency, or use [`find_package(nlohmann_json)`](cmake.md#external) in CMake. In Meson,
-it is preferred to use the [`dependency()`](https://mesonbuild.com/Reference-manual.html#dependency) object with a
-subproject fallback, rather than using the subproject directly.
-
-The options that change the library's configuration are available in Meson as well, named like the
-[CMake options](cmake.md#cmake-options) without the `JSON_` prefix: `MultipleHeaders`, `GlobalUDLs`,
-`ImplicitConversions`, `DisableEnumSerialization`, `Diagnostics`, `Diagnostic_Positions`,
-`LegacyDiscardedValueComparison`, and `StrictNulHandling`. They have the same defaults as in CMake, except that
-`MultipleHeaders` is `false`. Set them with `-D` when setting up the build, or with the subproject name as prefix when
-the library is used as a subproject:
-
-```shell
-meson setup build -Dnlohmann_json:Diagnostics=true
-```
-
-The resulting compile definitions are part of the Meson dependency, the pkg-config file, and the CMake target.
+which case a pkg-config file is installed. To use it, have your build system require the `nlohmann_json`
+pkg-config dependency. In Meson, it is preferred to use the
+[`dependency()`](https://mesonbuild.com/Reference-manual.html#dependency) object with a subproject fallback, rather than
+using the subproject directly.
 
 ??? example "Example: Wrap"
 

include/nlohmann/detail/json_pointer.hpp

@@ -416,15 +416,19 @@ class json_pointer
             // convert null values to arrays or objects before continuing
             if (ptr->is_null())
             {
-                // check if the reference token is a number
-                const bool nums =
-                    std::all_of(reference_token.begin(), reference_token.end(),
-                                [](const unsigned char x)
+                // check if the reference token is a valid array index, that is
+                // a nonempty sequence of digits without a leading '0'
+                // (cf. RFC 6901, Sect. 4); tokens that could never be a valid
+                // array index (such as "01" or "") are treated as object keys
+                const bool nums = !reference_token.empty()
+                                  && (reference_token.size() == 1 || reference_token[0] != '0')
+                                  && std::all_of(reference_token.begin(), reference_token.end(),
+                                                 [](const unsigned char x)
                 {
                     return std::isdigit(x);
                 });
 
-                // change value to an array for numbers or "-" or to object otherwise
+                // change value to an array for array indices or "-" or to object otherwise
                 *ptr = (nums || reference_token == "-")
                        ? detail::value_t::array
                        : detail::value_t::object;

meson.build

@@ -2,111 +2,23 @@ project('nlohmann_json',
     'cpp',
     version : '3.12.0',
     license : 'MIT',
-    meson_version : '>= 0.64',
-    default_options: ['cpp_std=c++11'],
 )
 
-if get_option('MultipleHeaders')
-    incdir = 'include'
-else
-    incdir = 'single_include'
-endif
-
-# The same compile definitions as the CMake target (see target_compile_definitions
-# in CMakeLists.txt): only an option that differs from its default adds one.
-json_defines = []
-if not get_option('GlobalUDLs')
-    json_defines += 'JSON_USE_GLOBAL_UDLS=0'
-endif
-if not get_option('ImplicitConversions')
-    json_defines += 'JSON_USE_IMPLICIT_CONVERSIONS=0'
-endif
-if get_option('DisableEnumSerialization')
-    json_defines += 'JSON_DISABLE_ENUM_SERIALIZATION=1'
-endif
-if get_option('Diagnostics')
-    json_defines += 'JSON_DIAGNOSTICS=1'
-endif
-if get_option('Diagnostic_Positions')
-    json_defines += 'JSON_DIAGNOSTIC_POSITIONS=1'
-endif
-if get_option('LegacyDiscardedValueComparison')
-    json_defines += 'JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1'
-endif
-if get_option('StrictNulHandling')
-    json_defines += 'JSON_STRICT_NUL_HANDLING=1'
-endif
-
-cpp_args = []
-foreach define : json_defines
-    cpp_args += '-D' + define
-endforeach
-
 nlohmann_json_dep = declare_dependency(
-    compile_args: cpp_args,
-    include_directories: include_directories(incdir)
+    include_directories: include_directories('single_include')
 )
-meson.override_dependency('nlohmann_json', nlohmann_json_dep)
 
-# The multi-header version under the name earlier versions of this file used
 nlohmann_json_multiple_headers = declare_dependency(
-    compile_args: cpp_args,
     include_directories: include_directories('include')
 )
 
 if not meson.is_subproject()
-    install_subdir(
-        incdir / 'nlohmann',
-        install_dir: get_option('includedir'),
-        install_tag: 'devel',
-    )
+install_headers('single_include/nlohmann/json.hpp', subdir: 'nlohmann')
+install_headers('single_include/nlohmann/json_fwd.hpp', subdir: 'nlohmann')
 
-    pkgc = import('pkgconfig')
-    pkgc.generate(name: 'nlohmann_json',
-        version: meson.project_version(),
-        description: 'JSON for Modern C++',
-        extra_cflags: cpp_args,
-        install_dir: get_option('datadir') / 'pkgconfig',
-    )
-
-    # CMake package config files, so that find_package(nlohmann_json) works. The
-    # include directory is given relative to the config files, so that the
-    # installation can be relocated. This is not possible if includedir or datadir
-    # is an absolute path outside the prefix (e.g., with the separate outputs of
-    # Nix); then the absolute include directory is used, as CMake does.
-    fs = import('fs')
-    cmake_install_dir = get_option('datadir') / 'cmake' / meson.project_name()
-    cmake_to_prefix = []
-    if fs.is_absolute(get_option('includedir')) or fs.is_absolute(cmake_install_dir)
-        cmake_include_dir = (get_option('prefix') / get_option('includedir')).replace('\\', '/')
-    else
-        foreach component : cmake_install_dir.split('/')
-            cmake_to_prefix += '..'
-        endforeach
-        cmake_include_dir = '${_IMPORT_PREFIX}/' + get_option('includedir')
-    endif
-
-    cmake_conf = configuration_data()
-    cmake_conf.set('PROJECT_NAME', meson.project_name())
-    cmake_conf.set('PROJECT_VERSION', meson.project_version())
-    cmake_conf.set('PROJECT_VERSION_MAJOR', meson.project_version().split('.')[0])
-    cmake_conf.set('NLOHMANN_JSON_TARGET_NAME', meson.project_name())
-    cmake_conf.set('NLOHMANN_JSON_TARGETS_EXPORT_NAME', meson.project_name() + 'Targets')
-    cmake_conf.set('NLOHMANN_JSON_INCLUDE_DIR', cmake_include_dir)
-    cmake_conf.set('NLOHMANN_JSON_CONFIG_TO_PREFIX', '/'.join(cmake_to_prefix))
-    cmake_conf.set('NLOHMANN_JSON_COMPILE_DEFINITIONS', ';'.join(json_defines))
-
-    foreach cmake_file : [
-        ['cmake/config.cmake.in', 'nlohmann_jsonConfig.cmake'],
-        ['cmake/nlohmann_jsonConfigVersion.cmake.in', 'nlohmann_jsonConfigVersion.cmake'],
-        ['cmake/nlohmann_jsonTargets.cmake.in', 'nlohmann_jsonTargets.cmake'],
-    ]
-        configure_file(
-            input: cmake_file[0],
-            output: cmake_file[1],
-            configuration: cmake_conf,
-            format: 'cmake@',
-            install_dir: cmake_install_dir,
-        )
-    endforeach
+pkgc = import('pkgconfig')
+pkgc.generate(name: 'nlohmann_json',
+    version: meson.project_version(),
+    description: 'JSON for Modern C++'
+)
 endif

meson_options.txt

@@ -1,48 +0,0 @@
-option(
-    'MultipleHeaders',
-    type: 'boolean',
-    value: false,
-    description: 'Use non-amalgamated version of the library',
-)
-option(
-    'GlobalUDLs',
-    type: 'boolean',
-    value: true,
-    description: 'Place user-defined string literals in the global namespace',
-)
-option(
-    'ImplicitConversions',
-    type: 'boolean',
-    value: true,
-    description: 'Enable implicit conversions',
-)
-option(
-    'DisableEnumSerialization',
-    type: 'boolean',
-    value: false,
-    description: 'Disable default integer enum serialization',
-)
-option(
-    'Diagnostics',
-    type: 'boolean',
-    value: false,
-    description: 'Use extended diagnostic messages',
-)
-option(
-    'Diagnostic_Positions',
-    type: 'boolean',
-    value: false,
-    description: 'Enable diagnostic positions',
-)
-option(
-    'LegacyDiscardedValueComparison',
-    type: 'boolean',
-    value: false,
-    description: 'Enable legacy discarded value comparison',
-)
-option(
-    'StrictNulHandling',
-    type: 'boolean',
-    value: false,
-    description: 'Enable strict NUL-byte handling',
-)

single_include/nlohmann/json.hpp

@@ -19060,15 +19060,19 @@ class json_pointer
             // convert null values to arrays or objects before continuing
             if (ptr->is_null())
             {
-                // check if the reference token is a number
-                const bool nums =
-                    std::all_of(reference_token.begin(), reference_token.end(),
-                                [](const unsigned char x)
+                // check if the reference token is a valid array index, that is
+                // a nonempty sequence of digits without a leading '0'
+                // (cf. RFC 6901, Sect. 4); tokens that could never be a valid
+                // array index (such as "01" or "") are treated as object keys
+                const bool nums = !reference_token.empty()
+                                  && (reference_token.size() == 1 || reference_token[0] != '0')
+                                  && std::all_of(reference_token.begin(), reference_token.end(),
+                                                 [](const unsigned char x)
                 {
                     return std::isdigit(x);
                 });
 
-                // change value to an array for numbers or "-" or to object otherwise
+                // change value to an array for array indices or "-" or to object otherwise
                 *ptr = (nums || reference_token == "-")
                        ? detail::value_t::array
                        : detail::value_t::object;

tests/src/unit-json_pointer.cpp

@@ -438,6 +438,72 @@ TEST_CASE("JSON pointers")
         }
     }
 
+    SECTION("creating intermediate levels")
+    {
+        SECTION("tokens that are valid array indices create arrays")
+        {
+            json j;
+            j["/0"_json_pointer] = 1;
+            CHECK(j == json({1}));
+
+            json j2;
+            j2["/2"_json_pointer] = 1;
+            CHECK(j2 == json({nullptr, nullptr, 1}));
+
+            json j3;
+            j3["/-"_json_pointer] = 1;
+            CHECK(j3 == json({1}));
+
+            json j4;
+            j4["/foo/0/0"_json_pointer] = 1;
+            CHECK(j4 == json({{"foo", {{1}}}}));
+        }
+
+        SECTION("tokens that are no valid array indices create objects")
+        {
+            json j;
+            j["/one"_json_pointer] = 1;
+            CHECK(j == json({{"one", 1}}));
+
+            // leading '0' can never be a valid array index (RFC 6901, Sect. 4)
+            json j2;
+            j2["/01"_json_pointer] = 1;
+            CHECK(j2 == json({{"01", 1}}));
+
+            // the empty token is a valid object key, but no valid array index
+            json j3;
+            j3["/"_json_pointer] = 1;
+            CHECK(j3 == json({{"", 1}}));
+        }
+
+        SECTION("creating a level yields the same result as reusing it (#5357)")
+        {
+            json j;
+            j["/a/b/01/d"_json_pointer] = "value";
+
+            json j_init = json::object();
+            j_init["/a/b"_json_pointer] = json::object();
+            j_init["/a/b/01/d"_json_pointer] = "value";
+
+            const json expected = json::parse(R"({"a":{"b":{"01":{"d":"value"}}}})");
+            CHECK(j == expected);
+            CHECK(j_init == expected);
+
+            // unflatten uses the same key
+            const json flat = {{"/a/b/01/d", "value"}};
+            CHECK(flat.unflatten() == expected);
+        }
+
+        SECTION("existing arrays still reject invalid indices")
+        {
+            json j = {1, 2, 3};
+            CHECK_THROWS_WITH_AS(j["/01"_json_pointer],
+                                 "[json.exception.parse_error.106] parse error: array index '01' must not begin with '0'", json::parse_error&);
+            CHECK_THROWS_WITH_AS(j.at("/01"_json_pointer),
+                                 "[json.exception.parse_error.106] parse error: array index '01' must not begin with '0'", json::parse_error&);
+        }
+    }
+
     SECTION("flatten")
     {
         json j =