Merge branch 'main' into bump-ystdlib-cpp

Author: Bill-hbrhbr

.gitignore

@@ -1,3 +1,4 @@
+__pycache__/
 .clang-format
 .clang-tidy
 .lint-venv/

components/core/src/clp/EncodedVariableInterpreter.hpp

@@ -6,6 +6,8 @@
 #include <unordered_set>
 #include <vector>
 
+#include <string_utils/string_utils.hpp>
+
 #include "ffi/ir_stream/decoding_methods.hpp"
 #include "ir/LogEvent.hpp"
 #include "ir/types.hpp"
@@ -455,7 +457,8 @@ bool EncodedVariableInterpreter::encode_and_search_dictionary(
         add_float_var(logtype);
         sub_query.add_non_dict_var(encoded_var);
     } else {
-        auto const entries = var_dict.get_entry_matching_value(var_str, ignore_case);
+        auto const unescaped_var_string{string_utils::unescape_string(var_str)};
+        auto const entries = var_dict.get_entry_matching_value(unescaped_var_string, ignore_case);
         if (entries.empty()) {
             // Not in dictionary
             return false;

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

@@ -3,6 +3,8 @@
 #include <algorithm>
 #include <charconv>
 #include <cstring>
+#include <string>
+#include <string_view>
 
 using std::string;
 using std::string_view;
@@ -188,6 +190,22 @@ string clean_up_wildcard_search_string(string_view str) {
     return cleaned_str;
 }
 
+auto unescape_string(std::string_view str) -> std::string {
+    std::string unescaped_str;
+    bool escaped{false};
+    for (auto const c : str) {
+        if (escaped) {
+            unescaped_str.push_back(c);
+            escaped = false;
+        } else if ('\\' == c) {
+            escaped = true;
+        } else {
+            unescaped_str.push_back(c);
+        }
+    }
+    return unescaped_str;
+}
+
 bool wildcard_match_unsafe(string_view tame, string_view wild, bool case_sensitive_match) {
     if (case_sensitive_match) {
         return wildcard_match_unsafe_case_sensitive(tame, wild);

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

@@ -4,6 +4,7 @@
 #include <charconv>
 #include <concepts>
 #include <string>
+#include <string_view>
 
 namespace clp::string_utils {
 /**
@@ -87,6 +88,17 @@ void to_lower(std::string& str);
  */
 std::string clean_up_wildcard_search_string(std::string_view str);
 
+/**
+ * Unescapes a string according to the following rules:
+ * <ul>
+ *   <li>Escape sequences `\<char>` are replaced by `<char>`</li>
+ *   <li>Lone dangling `\` is removed from the end of the string</li>
+ * </ul>
+ * @param str
+ * @return An unescaped version of `str`.
+ */
+[[nodiscard]] auto unescape_string(std::string_view str) -> std::string;
+
 /**
  * Checks if character is a wildcard
  * @param c

components/core/src/clp_s/search/QueryRunner.cpp

@@ -886,19 +886,7 @@ void QueryRunner::populate_string_queries(std::shared_ptr<Expression> const& exp
 
             std::unordered_set<int64_t>& matching_vars = m_string_var_match_map[query_string];
             if (false == ast::has_unescaped_wildcards(query_string)) {
-                std::string unescaped_query_string;
-                bool escape = false;
-                for (char const c : query_string) {
-                    if (escape) {
-                        unescaped_query_string.push_back(c);
-                        escape = false;
-                    } else if (c == '\\') {
-                        escape = true;
-                    } else {
-                        unescaped_query_string.push_back(c);
-                    }
-                }
-
+                auto const unescaped_query_string{clp::string_utils::unescape_string(query_string)};
                 auto const entries = m_var_dict->get_entry_matching_value(
                         unescaped_query_string,
                         m_ignore_case

components/core/tests/test-EncodedVariableInterpreter.cpp

@@ -1,5 +1,9 @@
 #include <unistd.h>
 
+#include <string>
+#include <string_view>
+#include <vector>
+
 #include <catch2/catch_test_macros.hpp>
 
 #include "../src/clp/EncodedVariableInterpreter.hpp"
@@ -15,6 +19,7 @@ using clp::EncodedVariableInterpreter;
 using clp::enum_to_underlying_type;
 using clp::ir::VariablePlaceholder;
 using std::string;
+using std::string_view;
 using std::to_string;
 using std::vector;
 
@@ -439,14 +444,15 @@ TEST_CASE("EncodedVariableInterpreter", "[EncodedVariableInterpreter]") {
 
         string large_val_str = to_string(cVariableDictionaryIdMax) + "0";
         vector<string> var_strs
-                = {"4938", large_val_str, "-25.5196868642755", "-00.00", "python2.7.3"};
+                = {"4938", large_val_str, "-25.5196868642755", "-00.00", "python2.7.3", "\\a1"};
         // clang-format off
         msg = "here is a string with a small int " + var_strs[0]
               + " and a very large int " + var_strs[1]
               + " and a double " + var_strs[2]
               + " and a weird double " + var_strs[3]
-              + " and a str with numbers "
-              + var_strs[4] + " and an escape "
+              + " and a str with numbers " + var_strs[4]
+              + " and a str with a backslash and numbers " + var_strs[5]
+              + " and an escape "
               + enum_to_underlying_type(VariablePlaceholder::Escape)
               + " and an int placeholder "
               + enum_to_underlying_type(VariablePlaceholder::Integer)
@@ -530,6 +536,30 @@ TEST_CASE("EncodedVariableInterpreter", "[EncodedVariableInterpreter]") {
                 search_logtype,
                 sub_query
         ));
+        auto escape_handler = [](std::string_view str) -> std::string {
+            std::string escaped_string;
+            for (auto const c : str) {
+                if ('*' == c || '?' == c
+                    || enum_to_underlying_type(VariablePlaceholder::Escape) == c
+                    || enum_to_underlying_type(VariablePlaceholder::Integer) == c
+                    || enum_to_underlying_type(VariablePlaceholder::Float) == c
+                    || enum_to_underlying_type(VariablePlaceholder::Dictionary) == c)
+                {
+                    escaped_string.push_back(enum_to_underlying_type(VariablePlaceholder::Escape));
+                }
+                escaped_string.push_back(c);
+            }
+            return escaped_string;
+        };
+        search_logtype += " and a str with a backslash and numbers ";
+        REQUIRE(EncodedVariableInterpreter::encode_and_search_dictionary(
+                escape_handler(var_strs[5]),
+                var_dict_reader,
+                false,
+                search_logtype,
+                sub_query
+        ));
+
         search_logtype += " and an escape ";
         search_logtype += enum_to_underlying_type(VariablePlaceholder::Escape);
         search_logtype += enum_to_underlying_type(VariablePlaceholder::Escape);

components/core/tests/test-clp_s-search.cpp

@@ -203,12 +203,10 @@ TEST_CASE("clp-s-search", "[clp-s][search]") {
             {R"aa(msg: "Msg 1: \"Abc123\"")aa", {1}},
             {R"aa(msg: "Msg 2: 'Abc123'")aa", {2}},
             {R"aa(msg: "Msg 3: \nAbc123")aa", {3}},
-            // CLP incorrectly generates no subqueries in Grep::process_raw_query for the following
-            // query, so we skip it for now.
-            //{R"aa(msg: "Msg 4: \\Abc123")aa", {4}}
+            {R"aa(msg: "Msg 4: \\Abc123")aa", {4}},
             {R"aa(msg: "Msg 5: \rAbc123")aa", {5}},
             {R"aa(msg: "Msg 6: \tAbc123")aa", {6}},
-            {R"aa(msg: "*Abc123*")aa", {1, 2, 3, 5, 6}},
+            {R"aa(msg: "*Abc123*")aa", {1, 2, 3, 4, 5, 6}},
             {R"aa(arr.b > 1000)aa", {7, 8}},
             {R"aa(var_string: *)aa", {9}},
             {R"aa(clp_string: *)aa", {9}},

components/core/tests/test-string_utils.cpp

@@ -1,4 +1,5 @@
 #include <iostream>
+#include <limits>
 
 #include <boost/foreach.hpp>
 #include <boost/range/combine.hpp>
@@ -13,6 +14,7 @@ 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::unescape_string;
 using clp::string_utils::wildcard_match_unsafe;
 using clp::string_utils::wildcard_match_unsafe_case_sensitive;
 using std::chrono::duration;
@@ -111,6 +113,29 @@ TEST_CASE("clean_up_wildcard_search_string", "[clean_up_wildcard_search_string]"
     REQUIRE(clean_up_wildcard_search_string(str) == "abc");
 }
 
+TEST_CASE("unescape_string", "[string_utils][unescape_string]") {
+    SECTION("Simple string unescaping") {
+        REQUIRE("*?\\" == unescape_string("\\*\\?\\\\"));
+        REQUIRE("abcd" == unescape_string("abcd\\"));
+    }
+
+    SECTION("Exhaustive string unescaping") {
+        std::string unescaped_string;
+        std::string escaped_string;
+        char c{std::numeric_limits<char>::min()};
+        while (true) {
+            escaped_string.push_back('\\');
+            escaped_string.push_back(c);
+            unescaped_string.push_back(c);
+            if (c == std::numeric_limits<char>::max()) {
+                break;
+            }
+            ++c;
+        }
+        REQUIRE(unescaped_string == unescape_string(escaped_string));
+    }
+}
+
 SCENARIO("Test case sensitive wild card match in all possible ways", "[wildcard]") {
     std::string tameString, wildString;
 

components/core/tests/test_log_files/test_search.jsonl

@@ -2,7 +2,7 @@
 {"idx": 1, "msg": "Msg 1: \"Abc123\""}
 {"idx": 2, "msg": "Msg 2: 'Abc123'"}
 {"idx": 3, "msg": "Msg 3: \nAbc123"}
-{"idx": 4, "skip_msg": "Msg 4: \\Abc123"}
+{"idx": 4, "msg": "Msg 4: \\Abc123"}
 {"idx": 5, "msg": "Msg 5: \rAbc123"}
 {"idx": 6, "msg": "Msg 6: \tAbc123"}
 {"idx": 7, "arr": [{"a": 999}, {"b": 1001}]}

components/webui/client/eslint.config.mjs

@@ -31,16 +31,12 @@ const EslintConfig = [
             "new-cap": [
                 "error",
                 {
+                    // TypeBox imports
                     capIsNewExceptions: [
-                        // TypeBox imports
                         "Decode",
                         "Encode",
-                        "Type.Literal",
-                        "Type.Optional",
-                        "Type.Transform",
-                        "Type.Union",
-                        "Value.Parse",
                     ],
+                    capIsNewExceptionPattern: "^(Type|Value)\\.",
                 },
             ],
         },