build(deps): bump watchdog from 7.0.0 to 7.1.0 in /tools/serve_header

Bumps [watchdog](https://github.com/gorakhargosh/watchdog) from 7.0.0 to 7.1.0.
- [Release notes](https://github.com/gorakhargosh/watchdog/releases)
- [Changelog](https://github.com/gorakhargosh/watchdog/blob/master/changelog.rst)
- [Commits](https://github.com/gorakhargosh/watchdog/compare/v7.0.0...v7.1.0)

---
updated-dependencies:
- dependency-name: watchdog
  dependency-version: 7.1.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

include/nlohmann/detail/view/compare.hpp

@@ -905,8 +905,6 @@ void resume_array(const lockstep_path& /*path*/, const A& /*a*/, const B& /*b*/,
 template<typename BasicJsonType, typename ViewA, typename ViewB>
 bool floats_equal(const view_side<BasicJsonType, ViewA>& a, const view_side<BasicJsonType, ViewB>& b)
 {
-    // float_token_is_nan() reads at most the node length of the token, which is not null terminated
-    // NOLINTNEXTLINE(bugprone-suspicious-stringview-data-usage)
     return (a.value_node()->extra == b.value_node()->extra && a.float_token() == b.float_token() && !(view_side<BasicJsonType, ViewA>::nav::editable() && float_token_is_nan(*a.value_node(), a.float_token().data()))) || std::equal_to<typename BasicJsonType::number_float_t>()(a.floating(), b.floating());
 }
 

include/nlohmann/detail/view/document_data.hpp

@@ -158,8 +158,7 @@ struct document_data
     {
         const auto overlaps = [p, n](const char* b, std::size_t m) noexcept
         {
-            // (std::less: a total order also for pointers into different objects; std::less<> needs C++14)
-            // NOLINTNEXTLINE(modernize-use-transparent-functors)
+            // (std::less: a total order also for pointers into different objects)
             return n != 0 && m != 0 && std::less<const char*>()(p, b + m) && std::less<const char*>()(b, p + n);
         };
         return overlaps(owned.data(), owned.capacity())

single_include/nlohmann/json_view.hpp

@@ -502,8 +502,7 @@ struct document_data
     {
         const auto overlaps = [p, n](const char* b, std::size_t m) noexcept
         {
-            // (std::less: a total order also for pointers into different objects; std::less<> needs C++14)
-            // NOLINTNEXTLINE(modernize-use-transparent-functors)
+            // (std::less: a total order also for pointers into different objects)
             return n != 0 && m != 0 && std::less<const char*>()(p, b + m) && std::less<const char*>()(b, p + n);
         };
         return overlaps(owned.data(), owned.capacity())
@@ -4089,8 +4088,6 @@ void resume_array(const lockstep_path& /*path*/, const A& /*a*/, const B& /*b*/,
 template<typename BasicJsonType, typename ViewA, typename ViewB>
 bool floats_equal(const view_side<BasicJsonType, ViewA>& a, const view_side<BasicJsonType, ViewB>& b)
 {
-    // float_token_is_nan() reads at most the node length of the token, which is not null terminated
-    // NOLINTNEXTLINE(bugprone-suspicious-stringview-data-usage)
     return (a.value_node()->extra == b.value_node()->extra && a.float_token() == b.float_token() && !(view_side<BasicJsonType, ViewA>::nav::editable() && float_token_is_nan(*a.value_node(), a.float_token().data()))) || std::equal_to<typename BasicJsonType::number_float_t>()(a.floating(), b.floating());
 }
 

tests/src/unit-conversions2.cpp

@@ -761,8 +761,9 @@ TEST_CASE("std::u8string")
         CHECK(json(with_nul).template get<std::u8string>() == with_nul);
 
         // the lvalue and rvalue paths, and in containers
-        CHECK(json(utf8).template get<std::u8string>() == utf8);
-        CHECK(json(std::u8string(utf8)).template get<std::u8string>() == utf8);
+        std::u8string lvalue = utf8;
+        CHECK(json(lvalue).template get<std::u8string>() == utf8);
+        CHECK(json(std::move(lvalue)).template get<std::u8string>() == utf8);
         const std::vector<std::u8string> vec = {utf8, u8"x"};
         json const j_vec = vec;
         CHECK(j_vec.is_array());
@@ -811,7 +812,7 @@ TEST_CASE("std::u8string")
         CHECK(j_view.is_array());
         CHECK(j_view.size() == 8);
 
-        const char8_t arr[] = u8"ab"; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+        const char8_t arr[] = u8"ab";
         json const j_arr = arr;
         CHECK(j_arr == json::array({0x61, 0x62, 0}));
     }

tests/src/unit-json_patch.cpp

@@ -2682,27 +2682,25 @@ TEST_CASE("JSON patch - consecutive operations with paths that share a prefix")
         const json doc = json::parse(R"({"a": [{"b": [1, 2, 3]}, {"b": [4, 5, 6]}], "c": {"d": {"e": 7}}})");
 
         // an element inserted before the elements of an array moves them
-        const json inserted = json::parse(R"([
+        CHECK(doc.patch(json::parse(R"([
             {"op": "test", "path": "/a/0/b/2", "value": 3},
             {"op": "add", "path": "/a/0", "value": {"b": [9]}},
             {"op": "test", "path": "/a/1/b/2", "value": 3},
             {"op": "test", "path": "/a/0/b/0", "value": 9},
             {"op": "test", "path": "/a/2/b/0", "value": 4}
-        ])");
-        CHECK(doc.patch(inserted) == json::parse(R"({"a": [{"b": [9]}, {"b": [1, 2, 3]}, {"b": [4, 5, 6]}], "c": {"d": {"e": 7}}})"));
+        ])")) == json::parse(R"({"a": [{"b": [9]}, {"b": [1, 2, 3]}, {"b": [4, 5, 6]}], "c": {"d": {"e": 7}}})"));
 
         // an element removed from the front
-        const json removed_front = json::parse(R"([
+        CHECK(doc.patch(json::parse(R"([
             {"op": "test", "path": "/a/1/b/2", "value": 6},
             {"op": "remove", "path": "/a/0"},
             {"op": "test", "path": "/a/0/b/2", "value": 6},
             {"op": "replace", "path": "/a/0/b/2", "value": 60},
             {"op": "test", "path": "/a/0/b/2", "value": 60}
-        ])");
-        CHECK(doc.patch(removed_front) == json::parse(R"({"a": [{"b": [4, 5, 60]}], "c": {"d": {"e": 7}}})"));
+        ])")) == json::parse(R"({"a": [{"b": [4, 5, 60]}], "c": {"d": {"e": 7}}})"));
 
         // a value replaced above the path that was resolved before
-        const json replaced_above = json::parse(R"([
+        CHECK(doc.patch(json::parse(R"([
             {"op": "test", "path": "/c/d/e", "value": 7},
             {"op": "replace", "path": "/c/d", "value": {"e": 8, "f": {"g": 9}}},
             {"op": "test", "path": "/c/d/e", "value": 8},
@@ -2710,8 +2708,7 @@ TEST_CASE("JSON patch - consecutive operations with paths that share a prefix")
             {"op": "remove", "path": "/c/d/f"},
             {"op": "add", "path": "/c/d/f", "value": [1]},
             {"op": "test", "path": "/c/d/f/0", "value": 1}
-        ])");
-        CHECK(doc.patch(replaced_above) == json::parse(R"({"a": [{"b": [1, 2, 3]}, {"b": [4, 5, 6]}], "c": {"d": {"e": 8, "f": [1]}}})"));
+        ])")) == json::parse(R"({"a": [{"b": [1, 2, 3]}, {"b": [4, 5, 6]}], "c": {"d": {"e": 8, "f": [1]}}})"));
 
 #if !defined(JSON_NOEXCEPTION)
         // a value removed above the path that was resolved before is gone

tests/src/unit-json_view_builder.cpp

@@ -916,15 +916,14 @@ TEST_CASE("json_view document_data::holds() (the debug check of read())")
 
     SECTION("owned text")
     {
-        d->owned = R"({"a":"some text that does not fit a short string"})";
+        d->owned = "{\"a\":\"some text that does not fit a short string\"}";
         const char* const b = d->owned.data();
         CHECK(d->holds(b, 1));
         CHECK(d->holds(b + 5, 3));
         CHECK(d->holds(b + d->owned.size() - 1, 1));
         // also after clear(), which keeps the buffer that the next parse writes
         d->owned.clear();
-        // (b is only compared with the buffer, never read)
-        CHECK(d->holds(b, 4)); // NOLINT(clang-analyzer-cplusplus.InnerPointer)
+        CHECK(d->holds(b, 4));
         CHECK(!d->holds(other.data(), other.size()));
         CHECK(!d->holds(b, 0));
     }
@@ -947,7 +946,7 @@ TEST_CASE("json_view document_data::holds() (the debug check of read())")
     {
         d->edits.reset(new document_data::edit_state()); // NOLINT(cppcoreguidelines-owning-memory)
         CHECK(!d->holds(other.data(), other.size()));
-        d->edits->texts.emplace_back(new char[16]); // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,cppcoreguidelines-owning-memory)
+        d->edits->texts.emplace_back(new char[16]); // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
         d->edits->text_cap = 16;
         CHECK(d->holds(d->edits->texts.back().get() + 3, 3));
         CHECK(!d->holds(other.data(), other.size()));

tests/src/unit-recursion_depth_limit.cpp

@@ -494,7 +494,7 @@ TEST_CASE("walks over values nested around the recursion depth limit")
         for_each_value([](const std::string & kinds)
         {
             const json a = build(kinds, 1);
-            const std::hash<json> hash{};
+            const std::hash<json> hash;
             CHECK(hash(a) == hash(json(a)));
             CHECK(hash(a) == hash(json::parse(expected_compact(kinds, "1"))));
             CHECK(hash(a) != hash(build(kinds, 2)));

tools/serve_header/requirements.txt

@@ -1,2 +1,2 @@
 PyYAML==6.0.3
-watchdog==7.0.0
+watchdog==7.1.0