style(clang-tidy): fix modernize-use-ranges checks (#1802)

Signed-off-by: Balakrishna Avulapati <ba@bavulapati.com>

Author: bavulapati

src/core/json/json_value.cc

@@ -777,7 +777,7 @@ auto JSON::push_back_if_unique(const JSON &value)
     -> std::pair<std::reference_wrapper<const JSON>, bool> {
   assert(this->is_array());
   auto &array_data{this->as_array().data};
-  const auto match{std::find(array_data.cbegin(), array_data.cend(), value)};
+  const auto match{std::ranges::find(array_data, value)};
   if (match == array_data.cend()) {
     array_data.push_back(value);
     return {array_data.back(), true};
@@ -790,7 +790,7 @@ auto JSON::push_back_if_unique(JSON &&value)
     -> std::pair<std::reference_wrapper<const JSON>, bool> {
   assert(this->is_array());
   auto &array_data{this->as_array().data};
-  const auto match{std::find(array_data.cbegin(), array_data.cend(), value)};
+  const auto match{std::ranges::find(array_data, value)};
   if (match == array_data.cend()) {
     array_data.push_back(std::move(value));
     return {array_data.back(), true};

src/core/json/stringify.h

@@ -425,7 +425,7 @@ auto stringify(
     std::transform(std::cbegin(document), std::cend(document),
                    std::back_inserter(keys),
                    [](const auto &property) { return property.first; });
-    std::sort(std::begin(keys), std::end(keys), compare);
+    std::ranges::sort(keys, compare);
     const auto end{std::cend(keys)};
     for (auto iterator = std::cbegin(keys); iterator != end; ++iterator) {
       stringify<Allocator>(*iterator, stream);
@@ -529,7 +529,7 @@ auto prettify(
     std::transform(std::cbegin(document), std::cend(document),
                    std::back_inserter(keys),
                    [](const auto &property) { return property.first; });
-    std::sort(std::begin(keys), std::end(keys), compare);
+    std::ranges::sort(keys, compare);
     const auto end{std::cend(keys)};
     for (auto iterator = std::cbegin(keys); iterator != end; ++iterator) {
       stream.put(internal::token_whitespace_line_feed<typename JSON::Char>);

src/core/jsonschema/frame.cc

@@ -250,8 +250,8 @@ auto traverse_origin_instance_locations(
     sourcemeta::core::SchemaFrame::Instances::mapped_type &destination)
     -> void {
   if (accumulator.has_value() &&
-      std::find(destination.cbegin(), destination.cend(),
-                accumulator.value()) == destination.cend()) {
+      std::ranges::find(destination, accumulator.value()) ==
+          destination.cend()) {
     destination.push_back(accumulator.value());
   }
 
@@ -319,8 +319,7 @@ auto repopulate_instance_locations(
         result.emplace_back(token);
       }
 
-      if (std::find(destination.cbegin(), destination.cend(), result) ==
-          destination.cend()) {
+      if (std::ranges::find(destination, result) == destination.cend()) {
         destination.push_back(result);
       }
 
@@ -423,10 +422,9 @@ auto SchemaFrame::analyse(const JSON &root, const SchemaWalker &walker,
   for (const auto &path : paths) {
     // Passing paths that overlap is undefined behavior. No path should
     // start with another one, else you are doing something wrong
-    assert(
-        std::all_of(paths.cbegin(), paths.cend(), [&path](const auto &other) {
-          return path == other || !path.starts_with(other);
-        }));
+    assert(std::ranges::all_of(paths, [&path](const auto &other) {
+      return path == other || !path.starts_with(other);
+    }));
 
     const auto &schema{get(root, path)};
 
@@ -730,7 +728,7 @@ auto SchemaFrame::analyse(const JSON &root, const SchemaWalker &walker,
     const auto pointer_walker{sourcemeta::core::PointerWalker{schema}};
     std::vector<sourcemeta::core::Pointer> pointers{pointer_walker.cbegin(),
                                                     pointer_walker.cend()};
-    std::sort(pointers.begin(), pointers.end(), std::less<>());
+    std::ranges::sort(pointers, std::less<>());
 
     // Pre-compute every possible pointer to the schema
     for (const auto &relative_pointer : pointers) {
@@ -995,19 +993,17 @@ auto SchemaFrame::references() const noexcept -> const References & {
 }
 
 auto SchemaFrame::standalone() const -> bool {
-  return std::all_of(
-      this->references_.cbegin(), this->references_.cend(),
-      [&](const auto &reference) {
-        assert(!reference.first.second.empty());
-        assert(reference.first.second.back().is_property());
-        // TODO: This check might need to be more elaborate given
-        // https://github.com/sourcemeta/core/issues/1390
-        return reference.first.second.back().to_property() == "$schema" ||
-               this->locations_.contains({SchemaReferenceType::Static,
-                                          reference.second.destination}) ||
-               this->locations_.contains({SchemaReferenceType::Dynamic,
-                                          reference.second.destination});
-      });
+  return std::ranges::all_of(this->references_, [&](const auto &reference) {
+    assert(!reference.first.second.empty());
+    assert(reference.first.second.back().is_property());
+    // TODO: This check might need to be more elaborate given
+    // https://github.com/sourcemeta/core/issues/1390
+    return reference.first.second.back().to_property() == "$schema" ||
+           this->locations_.contains(
+               {SchemaReferenceType::Static, reference.second.destination}) ||
+           this->locations_.contains(
+               {SchemaReferenceType::Dynamic, reference.second.destination});
+  });
 }
 
 auto SchemaFrame::vocabularies(const Location &location,

src/core/jsonschema/walker.cc

@@ -481,8 +481,8 @@ sourcemeta::core::SchemaKeywordIterator::SchemaKeywordIterator(
   }
 
   // Sort keywords based on priority for correct evaluation
-  std::sort(
-      this->entries.begin(), this->entries.end(),
+  std::ranges::sort(
+      this->entries,
       [&vocabularies, &walker](const auto &left, const auto &right) -> bool {
         // These cannot be empty or indexes, as we created
         // the entries array from a JSON object

src/core/uri/escaping.cc

@@ -89,7 +89,7 @@ auto uri_unescape(std::istream &input, std::ostream &output) -> void {
   const std::string input_string{input_stream.str()};
   auto const buffer = new std::string::value_type[input_string.size() + 1];
   try {
-    std::copy(input_string.cbegin(), input_string.cend(), buffer);
+    std::ranges::copy(input_string, buffer);
   } catch (...) {
     delete[] buffer;
     throw;

src/core/uri/uri.cc

@@ -734,7 +734,7 @@ auto URI::from_path(const std::filesystem::path &path) -> URI {
   const auto is_unc{normalized.starts_with("\\\\")};
   const auto is_windows_absolute{normalized.size() >= 2 &&
                                  normalized[1] == ':'};
-  std::replace(normalized.begin(), normalized.end(), '\\', '/');
+  std::ranges::replace(normalized, '\\', '/');
   const auto is_unix_absolute{normalized.starts_with("/")};
   if (!is_unix_absolute && !is_windows_absolute && !is_unc) {
     throw URIError(

src/extension/alterschema/alterschema.cc

@@ -11,10 +11,9 @@ namespace sourcemeta::core {
 static auto
 contains_any(const Vocabularies &container,
              const std::set<typename Vocabularies::key_type> &values) -> bool {
-  return std::any_of(std::cbegin(container), std::cend(container),
-                     [&values](const auto &element) {
-                       return values.contains(element.first);
-                     });
+  return std::ranges::any_of(container, [&values](const auto &element) {
+    return values.contains(element.first);
+  });
 }
 
 template <typename T>

src/extension/alterschema/linter/non_applicable_type_specific_keywords.h

@@ -59,10 +59,10 @@ class NonApplicableTypeSpecificKeywords final : public SchemaTransformRule {
 
       // If none of the types that the keyword applies to is a valid
       // type for the current schema, then by definition we can remove it
-      if (std::none_of(metadata.instances.cbegin(), metadata.instances.cend(),
-                       [&current_types](const auto keyword_type) {
-                         return current_types.contains(keyword_type);
-                       })) {
+      if (std::ranges::none_of(metadata.instances,
+                               [&current_types](const auto keyword_type) {
+                                 return current_types.contains(keyword_type);
+                               })) {
         this->blacklist.emplace_back(entry.first);
       }
     }