Merge branch 'main' into modernize-zlib-install

Author: Bill-hbrhbr

components/core/CMakeLists.txt

@@ -156,7 +156,7 @@ if(CLP_NEED_BOOST)
     if(CLP_USE_STATIC_LIBS)
         set(Boost_USE_STATIC_LIBS ON)
     endif()
-    find_package(Boost 1.81 REQUIRED iostreams program_options filesystem system regex url)
+    find_package(Boost 1.89 REQUIRED iostreams program_options filesystem regex url)
     if(Boost_FOUND)
         message(STATUS "Found Boost ${Boost_VERSION}")
     else()

components/core/src/clp/GrepCore.hpp

@@ -10,6 +10,7 @@
 #include <vector>
 
 #include <log_surgeon/Lexer.hpp>
+#include <string_utils/constants.hpp>
 #include <string_utils/string_utils.hpp>
 
 #include "Defs.h"
@@ -162,15 +163,16 @@ std::optional<Query> GrepCore::process_raw_query(
     bool is_var;
     std::string search_string_for_sub_queries{search_string};
     if (use_heuristic) {
-        // Replace '?' wildcards with '*' wildcards since we currently have no support for
+        // Replace unescaped '?' wildcards with '*' wildcards since we currently have no support for
         // generating sub-queries with '?' wildcards. The final wildcard match on the decompressed
         // message uses the original wildcards, so correctness will be maintained.
-        std::replace(
-                search_string_for_sub_queries.begin(),
-                search_string_for_sub_queries.end(),
-                '?',
-                '*'
+        string_utils::replace_unescaped_char(
+                string_utils::cWildcardEscapeChar,
+                string_utils::cSingleCharWildcard,
+                string_utils::cZeroOrMoreCharsWildcard,
+                search_string_for_sub_queries
         );
+
         // Clean-up in case any instances of "?*" or "*?" were changed into "**"
         search_string_for_sub_queries
                 = string_utils::clean_up_wildcard_search_string(search_string_for_sub_queries);

components/core/src/clp/regex_utils/constants.hpp

@@ -24,10 +24,6 @@ constexpr size_t cCharBitarraySize = 128;
     return bit_array;
 }
 
-// Wildcard meta characters
-constexpr char cZeroOrMoreCharsWildcard{'*'};
-constexpr char cSingleCharWildcard{'?'};
-
 // Regex meta characters
 constexpr char cRegexZeroOrMore{'*'};
 constexpr char cRegexOneOrMore{'+'};

components/core/src/clp/regex_utils/regex_translation_utils.cpp

@@ -5,6 +5,7 @@
 #include <string>
 #include <string_view>
 
+#include <string_utils/constants.hpp>
 #include <string_utils/string_utils.hpp>
 #include <ystdlib/error_handling/Result.hpp>
 
@@ -13,6 +14,8 @@
 #include "RegexToWildcardTranslatorConfig.hpp"
 
 namespace clp::regex_utils {
+using clp::string_utils::cSingleCharWildcard;
+using clp::string_utils::cZeroOrMoreCharsWildcard;
 using clp::string_utils::is_alphabet;
 using std::optional;
 using std::string;

components/core/src/clp/string_utils/constants.hpp

@@ -0,0 +1,12 @@
+#ifndef CLP_STRING_UTILS_CONSTANTS_HPP
+#define CLP_STRING_UTILS_CONSTANTS_HPP
+
+namespace clp::string_utils {
+// Wildcard meta characters
+constexpr char cZeroOrMoreCharsWildcard{'*'};
+constexpr char cSingleCharWildcard{'?'};
+
+constexpr char cWildcardEscapeChar{'\\'};
+}  // namespace clp::string_utils
+
+#endif  // CLP_STRING_UTILS_CONSTANTS_HPP

components/core/src/clp/string_utils/string_utils.cpp

@@ -113,6 +113,28 @@ string replace_characters(
     return new_value;
 }
 
+auto replace_unescaped_char(
+        char const escape_char,
+        char const from_char,
+        char const to_char,
+        std::string& str
+) -> void {
+    bool escaped{false};
+
+    auto should_replace_char = [&](char c) -> bool {
+        if (escaped) {
+            escaped = false;
+        } else if (escape_char == c) {
+            escaped = true;
+        } else if (from_char == c) {
+            return true;
+        }
+        return false;
+    };
+
+    std::replace_if(str.begin(), str.end(), should_replace_char, to_char);
+}
+
 void to_lower(string& str) {
     std::transform(str.cbegin(), str.cend(), str.begin(), [](unsigned char c) {
         return std::tolower(c);

components/core/src/clp/string_utils/string_utils.hpp

@@ -55,6 +55,20 @@ std::string replace_characters(
         bool escape
 );
 
+/**
+ * Replace unescaped instances of `from_char` with `to_char` in `str`.
+ *
+ * NOTE: `from_char` and `escape_char` must not be the same character. If they are, the function's
+ * behaviour is undefined.
+ *
+ * @param escape_char The character used for escaping
+ * @param from_char
+ * @param to_char
+ * @param str String in which to replace the characters
+ */
+auto replace_unescaped_char(char escape_char, char from_char, char to_char, std::string& str)
+        -> void;
+
 /**
  * Converts a string to lowercase
  * @param str

components/core/src/reducer/CMakeLists.txt

@@ -44,7 +44,6 @@ if(CLP_BUILD_EXECUTABLES)
         target_link_libraries(reducer-server
                 PRIVATE
                 Boost::program_options
-                Boost::system
                 clp::string_utils
                 fmt::fmt
                 ${MONGOCXX_TARGET}

components/core/tests/test-string_utils.cpp

@@ -3,10 +3,15 @@
 #include <boost/foreach.hpp>
 #include <boost/range/combine.hpp>
 #include <catch2/catch.hpp>
+#include <string_utils/constants.hpp>
 #include <string_utils/string_utils.hpp>
 
 using clp::string_utils::clean_up_wildcard_search_string;
 using clp::string_utils::convert_string_to_int;
+using clp::string_utils::cSingleCharWildcard;
+using clp::string_utils::cWildcardEscapeChar;
+using clp::string_utils::cZeroOrMoreCharsWildcard;
+using clp::string_utils::replace_unescaped_char;
 using clp::string_utils::wildcard_match_unsafe;
 using clp::string_utils::wildcard_match_unsafe_case_sensitive;
 using std::chrono::duration;
@@ -22,6 +27,57 @@ TEST_CASE("to_lower", "[to_lower]") {
     REQUIRE(str == "test123test");
 }
 
+TEST_CASE("replace_unescaped_char", "[replace_unescaped_char]") {
+    auto check = [](char escape_char,
+                    char from_char,
+                    char to_char,
+                    std::string in,
+                    std::string const& expected) {
+        replace_unescaped_char(escape_char, from_char, to_char, in);
+        REQUIRE((in == expected));
+    };
+
+    SECTION("Conventional escape and wildcard characters") {
+        auto [str, expected] = GENERATE(
+                as<std::pair<string, string>>{},
+
+                // Replacements with no escape chars present
+                std::pair{R"(a?b)", R"(a*b)"},
+                std::pair{R"(?leading)", R"(*leading)"},
+                std::pair{R"(trailing?)", R"(trailing*)"},
+                std::pair{R"(multiple??q)", R"(multiple**q)"},
+
+                // Replacements with escape chars present
+                std::pair{R"(a\\?b)", R"(a\\*b)"},
+                std::pair{R"(\\?abc)", R"(\\*abc)"},
+                std::pair{R"(abc\\?)", R"(abc\\*)"},
+
+                // No replacements with escape chars present
+                std::pair{R"(a\?b)", R"(a\?b)"},
+                std::pair{R"(\?abc)", R"(\?abc)"},
+                std::pair{R"(abc\?)", R"(abc\?)"},
+
+                // Mixed
+                std::pair{R"(a\\?b a\?b a?b)", R"(a\\*b a\?b a*b)"},
+                std::pair{R"(\\?abc \?abc a?b)", R"(\\*abc \?abc a*b)"},
+                std::pair{R"(abc\\? abc\? a?b)", R"(abc\\* abc\? a*b)"},
+
+                // Additional edge cases
+                std::pair{R"(no change)", R"(no change)"},
+                std::pair{R"()", R"()"},
+                std::pair{R"(\)", R"(\)"},
+                std::pair{R"(\\)", R"(\\)"},
+                std::pair{R"(?\)", R"(*\)"}
+        );
+
+        check(cWildcardEscapeChar, cSingleCharWildcard, cZeroOrMoreCharsWildcard, str, expected);
+    }
+
+    SECTION("Unconventional escape and wildcard characters") {
+        check('q', 'w', 'e', R"(aqqwb aqwb awb)", R"(aqqeb aqwb aeb)");
+    }
+}
+
 TEST_CASE("clean_up_wildcard_search_string", "[clean_up_wildcard_search_string]") {
     string str;
 

components/core/tools/scripts/lib_install/centos-stream-9/install-packages-from-source.sh

@@ -10,7 +10,7 @@ script_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
 lib_install_scripts_dir="${script_dir}/.."
 
 # NOTE: The remaining installation scripts depend on boost, so we install it beforehand.
-"${lib_install_scripts_dir}/install-boost.sh" 1.87.0
+"${lib_install_scripts_dir}/install-boost.sh" 1.89.0
 
 "${lib_install_scripts_dir}/liblzma.sh" 5.8.1
 "${lib_install_scripts_dir}/msgpack.sh" 7.0.0