feat: Allow for non-escaped hyphens outside of regex ranges (fixes #200).

docs/schema.md

@@ -112,11 +112,11 @@ header:Log (?<pid>\d+) (?<timestamp>\[\d{8}\-\d{2}:\d{2}:\d{2}\]){0,1}
 delimiters: \t\r\n:,!;%
 
 // Keywords
-header:(?<timestamp>\d{4}\-\d{2}\-\d{2} \d{2}:\d{2}:\d{2}(\.\d{3}){0,1})
-header:Log (?<pid>\d+) (?<timestamp>\[\d{8}\-\d{2}:\d{2}:\d{2}\]){0,1}
+header:(?<timestamp>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(\.\d{3}){0,1})
+header:Log (?<pid>\d+) (?<timestamp>\[\d{8}-\d{2}:\d{2}:\d{2}\]){0,1}
 header:--- Log:
-int:\-{0,1}\d+
-float:\-{0,1}\d+\.\d+
+int:-{0,1}\d+
+float:-{0,1}\d+\.\d+
 
 // Custom variables
 hex:[a-fA-F]+

src/log_surgeon/SchemaParser.cpp

@@ -540,7 +540,6 @@ auto SchemaParser::add_lexical_rules() -> void {
 }
 
 auto SchemaParser::add_productions() -> void {
-    // add_production("Schema", {}, new_schema_rule);
     add_production("Schema", {"Comment"}, new_schema_rule);
     add_production("Schema", {"SchemaVar"}, new_schema_rule_with_var);
     add_production(
@@ -617,6 +616,7 @@ auto SchemaParser::add_productions() -> void {
     add_production("CompleteGroup", {"Wildcard"}, regex_identity_rule);
     add_production("CompleteGroup", {"Shorthand"}, regex_identity_rule);
     add_production("CompleteGroup", {"Literal"}, regex_identity_rule);
+    add_production("CompleteGroup", {"Dash"}, regex_literal_rule);
     add_production(
             "IncompleteGroup",
             {"IncompleteGroup", "LiteralRange"},
@@ -645,31 +645,15 @@ auto SchemaParser::add_productions() -> void {
     add_production("Literal", {"Percent"}, regex_literal_rule);
     add_production("Literal", {"Ampersand"}, regex_literal_rule);
     add_production("Literal", {"Apostrophe"}, regex_literal_rule);
-    add_production("Literal", {"Backslash", "Lparen"}, regex_cancel_literal_rule);
-    add_production("Literal", {"Backslash", "Rparen"}, regex_cancel_literal_rule);
-    add_production("Literal", {"Backslash", "Star"}, regex_cancel_literal_rule);
-    add_production("Literal", {"Backslash", "Plus"}, regex_cancel_literal_rule);
     add_production("Literal", {"Comma"}, regex_literal_rule);
-    add_production("Literal", {"Backslash", "Dash"}, regex_cancel_literal_rule);
-    add_production("Literal", {"Backslash", "Dot"}, regex_cancel_literal_rule);
     add_production("Literal", {"ForwardSlash"}, regex_literal_rule);
     add_production("Literal", {"AlphaNumeric"}, regex_literal_rule);
     add_production("Literal", {"Colon"}, regex_literal_rule);
     add_production("Literal", {"SemiColon"}, regex_literal_rule);
     add_production("Literal", {"Equal"}, regex_literal_rule);
     add_production("Literal", {"At"}, regex_literal_rule);
-    add_production("Literal", {"Backslash", "Lbracket"}, regex_cancel_literal_rule);
-    add_production("Literal", {"Backslash", "Backslash"}, regex_cancel_literal_rule);
-    add_production("Literal", {"Backslash", "Rbracket"}, regex_cancel_literal_rule);
-    add_production("Literal", {"Backslash", "Hat"}, regex_cancel_literal_rule);
     add_production("Literal", {"Underscore"}, regex_literal_rule);
     add_production("Literal", {"Backtick"}, regex_literal_rule);
-    add_production("Literal", {"Backslash", "Lbrace"}, regex_cancel_literal_rule);
-    add_production("Literal", {"Backslash", "Vbar"}, regex_cancel_literal_rule);
-    add_production("Literal", {"Backslash", "Rbrace"}, regex_cancel_literal_rule);
-    add_production("Literal", {"Backslash", "Langle"}, regex_cancel_literal_rule);
-    add_production("Literal", {"Backslash", "Rangle"}, regex_cancel_literal_rule);
-    add_production("Literal", {"Backslash", "QuestionMark"}, regex_cancel_literal_rule);
     add_production("Literal", {"Tilde"}, regex_literal_rule);
     add_production(
             "Literal",

tests/test-buffer-parser.cpp

@@ -424,10 +424,10 @@ TEST_CASE("single_line_with_optional_capture", "[BufferParser]") {
 TEST_CASE("single_line_with_clp_default_vars", "[BufferParser]") {
     constexpr string_view cDelimitersSchema{R"(delimiters: \n\r[:,)"};
     constexpr string_view cVarSchema1{
-            R"(header:(?<timestamp>(\d{4}\-\d{2}\-\d{2} \d{2}:\d{2}:\d{2}[,\.]\d{0,3})))"
+            R"(header:(?<timestamp>(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}[,\.]\d{0,3})))"
     };
-    constexpr string_view cVarSchema2{R"(int:\-{0,1}[0-9]+)"};
-    constexpr string_view cVarSchema3{R"(float:\-{0,1}[0-9]+\.[0-9]+)"};
+    constexpr string_view cVarSchema2{R"(int:-{0,1}[0-9]+)"};
+    constexpr string_view cVarSchema3{R"(float:-{0,1}[0-9]+\.[0-9]+)"};
     constexpr string_view cVarSchema4{R"(hex:[a-fA-F]+)"};
     constexpr string_view cVarSchema5{
             R"(keyValuePair:[^ \r\n=]+=(?<val>[^ \r\n]*[A-Za-z0-9][^ \r\n]*))"
@@ -492,7 +492,7 @@ TEST_CASE("single_line_with_clp_default_vars", "[BufferParser]") {
  * ### Schema Definition
  * @code
  * delimiters: \n\r[:,
- * int: \-{0,1}[0-9]+
+ * int: -{0,1}[0-9]+
  * @endcode
  *
  * ### Test Input
@@ -516,7 +516,7 @@ TEST_CASE("single_line_with_clp_default_vars", "[BufferParser]") {
  */
 TEST_CASE("multi_line_with_newline_static_var_sequence", "[BufferParser]") {
     constexpr string_view cDelimitersSchema{R"(delimiters: \n\r[:,)"};
-    constexpr string_view cVarSchema{R"(int:\-{0,1}[0-9]+)"};
+    constexpr string_view cVarSchema{R"(int:-{0,1}[0-9]+)"};
     constexpr string_view cInput{"1234567\nText 1234567"};
     ExpectedEvent const expected_event1{
             .m_logtype{R"(<int><newLine>)"},
@@ -549,7 +549,7 @@ TEST_CASE("multi_line_with_newline_static_var_sequence", "[BufferParser]") {
  * ### Schema Definition
  * @code
  * delimiters: \n\r[:,
- * int: \-{0,1}[0-9]+
+ * int: -{0,1}[0-9]+
  * @endcode
  *
  * ### Test Input
@@ -574,7 +574,7 @@ TEST_CASE("multi_line_with_newline_static_var_sequence", "[BufferParser]") {
  */
 TEST_CASE("multi_line_with_static_newline_static_var_sequence", "[BufferParser]") {
     constexpr string_view cDelimitersSchema{R"(delimiters: \n\r[:,)"};
-    constexpr string_view cVarSchema{R"(int:\-{0,1}[0-9]+)"};
+    constexpr string_view cVarSchema{R"(int:-{0,1}[0-9]+)"};
     constexpr string_view cInput{"1234567 abc\nText 1234567"};
     ExpectedEvent const expected_event1{
             .m_logtype{R"(<int> abc<newLine>)"},
@@ -605,7 +605,7 @@ TEST_CASE("multi_line_with_static_newline_static_var_sequence", "[BufferParser]"
  * ### Schema Definition
  * @code
  * delimiters: \n\r[:,
- * int: \-{0,1}[0-9]+
+ * int: -{0,1}[0-9]+
  * @endcode
  *
  * ### Test Input
@@ -629,7 +629,7 @@ TEST_CASE("multi_line_with_static_newline_static_var_sequence", "[BufferParser]"
  */
 TEST_CASE("multi_line_with_static_newline_var_sequence", "[BufferParser]") {
     constexpr string_view cDelimitersSchema{R"(delimiters: \n\r[:,)"};
-    constexpr string_view cVarSchema{R"(int:\-{0,1}[0-9]+)"};
+    constexpr string_view cVarSchema{R"(int:-{0,1}[0-9]+)"};
     constexpr string_view cInput{"1234567 abc\n1234567"};
     ExpectedEvent const expected_event1{
             .m_logtype{"<int> abc\n"},
@@ -662,7 +662,7 @@ TEST_CASE("multi_line_with_static_newline_var_sequence", "[BufferParser]") {
  * ### Schema Definition
  * @code
  * delimiters: \n\r[:,
- * int: \-{0,1}[0-9]+
+ * int: -{0,1}[0-9]+
  * @endcode
  *
  * ### Test Input
@@ -687,7 +687,7 @@ TEST_CASE("multi_line_with_static_newline_var_sequence", "[BufferParser]") {
  */
 TEST_CASE("multi_line_with_static_newline_var_newline_sequence", "[BufferParser]") {
     constexpr string_view cDelimitersSchema{R"(delimiters: \n\r[:,)"};
-    constexpr string_view cVarSchema{R"(int:\-{0,1}[0-9]+)"};
+    constexpr string_view cVarSchema{R"(int:-{0,1}[0-9]+)"};
     constexpr string_view cInput{"1234567 abc\n1234567\n"};
     ExpectedEvent const expected_event1{
             .m_logtype{"<int> abc\n"},
@@ -720,7 +720,7 @@ TEST_CASE("multi_line_with_static_newline_var_newline_sequence", "[BufferParser]
  * ### Schema Definition
  * @code
  * delimiters: \n\r[:,
- * int: \-{0,1}[0-9]+
+ * int: -{0,1}[0-9]+
  * @endcode
  *
  * ### Input Example
@@ -744,7 +744,7 @@ TEST_CASE("multi_line_with_static_newline_var_newline_sequence", "[BufferParser]
  */
 TEST_CASE("multi_line_with_delim_newline_var_sequence", "[BufferParser]") {
     constexpr string_view cDelimitersSchema{R"(delimiters: \n\r[:,)"};
-    constexpr string_view cRule{R"(int:\-{0,1}[0-9]+)"};
+    constexpr string_view cRule{R"(int:-{0,1}[0-9]+)"};
     constexpr string_view cInput{"1234567 \n1234567"};
     ExpectedEvent const expected_event1{
             .m_logtype{"<int> \n"},
@@ -923,7 +923,7 @@ TEST_CASE("multi_line_with_delimited_vars", "[BufferParser]") {
  * ### Schema Definition
  * @code
  * delimiters: \n\r[:,
- * header:(?<timestamp>\d{4}\-\d{2}\-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}) (?<PID>\d{4}) (?<TID>\d{4})
+ * header:(?<timestamp>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}) (?<PID>\d{4}) (?<TID>\d{4})
  * \
  *        (?<LogLevel>I|D|E|W)
  * @endcode
@@ -948,7 +948,7 @@ TEST_CASE("multi_line_with_delimited_vars", "[BufferParser]") {
  */
 TEST_CASE("multi_capture_one", "[BufferParser]") {
     constexpr string_view cDelimitersSchema{R"(delimiters: \n\r[:,)"};
-    constexpr string_view cTime{R"((?<timestamp>\d{4}\-\d{2}\-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}))"};
+    constexpr string_view cTime{R"((?<timestamp>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}))"};
     constexpr string_view cPid{R"((?<PID>\d{4}))"};
     constexpr string_view cTid{R"((?<TID>\d{4}))"};
     constexpr string_view cLogLevel{R"((?<LogLevel>I|D|E|W))"};
@@ -995,7 +995,7 @@ TEST_CASE("multi_capture_one", "[BufferParser]") {
  * @code
  * delimiters: \n\r[:,
  * header:(?<timestamp>[A-Za-z]{3} \d{2} \d{2}:\d{2}:\d{2})
- * ip\-(?<IP>\d{3}\-\d{2}\-\d{2}\-\d{2}) \
+ * ip-(?<IP>\d{3}-\d{2}-\d{2}-\d{2}) \
  *        ku\[(?<PID>\d{4})\]: (?<LogLevel>I|D|E|W)(?<LID>\d{4}) \
  *        (?<LTime>\d{2}:\d{2}:\d{2}\.\d{4})    (?<TID>\d{4})
  * @endcode
@@ -1020,7 +1020,7 @@ TEST_CASE("multi_capture_one", "[BufferParser]") {
 TEST_CASE("multi_capture_two", "[BufferParser]") {
     constexpr string_view cDelimitersSchema{R"(delimiters: \n\r[:,)"};
     constexpr string_view cTime{R"((?<timestamp>[A-Za-z]{3} \d{2} \d{2}:\d{2}:\d{2}))"};
-    constexpr string_view cIp{R"((?<IP>\d{3}\-\d{2}\-\d{2}\-\d{2}))"};
+    constexpr string_view cIp{R"((?<IP>\d{3}-\d{2}-\d{2}-\d{2}))"};
     constexpr string_view cPid{R"((?<PID>\d{4}))"};
     constexpr string_view cLogLevel{R"((?<LogLevel>I|D|E|W))"};
     constexpr string_view cLid{R"((?<LID>\d{4}))"};
@@ -1030,7 +1030,7 @@ TEST_CASE("multi_capture_two", "[BufferParser]") {
                                  "    1111 Y failed"};
 
     string const header_rule{fmt::format(
-            R"(header:{} ip\-{} ku\[{}\]: {}{} {}    {})",
+            R"(header:{} ip-{} ku\[{}\]: {}{} {}    {})",
             cTime,
             cIp,
             cPid,

tests/test-dfa.cpp

@@ -189,7 +189,7 @@ TEST_CASE("multi_valued_capture_containing_repetition", "[DFA]") {
  * @brief Create a DFA for matching an integer.
  */
 TEST_CASE("int_var", "[DFA]") {
-    string const var_schema{"int:\\-{0,1}\\d+"};
+    string const var_schema{"int:-{0,1}\\d+"};
     string const expected_serialized_dfa{
             "0:byte_transitions={--()->1,0-()->2,1-()->2,2-()->2,3-()->2,4-()->2,5-()->2,6-()->2,7-"
             "()->2,8-()->2,9-()->2}\n"

tests/test-nfa.cpp

@@ -189,7 +189,7 @@ TEST_CASE("multi_valued_capture_containing_repetition", "[NFA]") {
  * @brief Create a NFA for matching an integer.
  */
 TEST_CASE("int_var", "[NFA]") {
-    string const var_schema{"int:\\-{0,1}\\d+"};
+    string const var_schema{"int:-{0,1}\\d+"};
     string const expected_serialized_nfa{
             "0:byte_transitions={--->1},spontaneous_transition={1[]}\n"
             "1:byte_transitions={0-->2,1-->2,2-->2,3-->2,4-->2,5-->2,6-->2,7-->2,8-->2,9-->2},"

tests/test-schema.cpp

@@ -145,8 +145,8 @@ TEST_CASE("add_invalid_vars", "[Schema]") {
  */
 TEST_CASE("add_invalid_var_priorities", "[Schema]") {
     constexpr string_view cVarString1{"uId:userID=123"};
-    constexpr string_view cVarString2{R"(int:\-{0,1}\d+)"};
-    constexpr string_view cVarString3{R"(float:\-{0,1}\d+\.\d+)"};
+    constexpr string_view cVarString2{R"(int:-{0,1}\d+)"};
+    constexpr string_view cVarString3{R"(float:-{0,1}\d+\.\d+)"};
     constexpr int32_t invalidPos1{3};
     constexpr int32_t invalidPos2{-2};
 
@@ -191,11 +191,12 @@ TEST_CASE("add_underscore_name", "[Schema]") {
  * @brief Create a schema, adding non-unique capture group names.
  */
 TEST_CASE("non_unique_capture_names", "[Schema]") {
-    Schema schema;
     vector<string> const var_names{"var_name1", "var_name2", "var_name3"};
     string const cap_name{"cap_name"};
 
     for (auto const& var_name : var_names) {
+        CAPTURE(var_name);
+        Schema schema;
         string const var_schema{var_name + string(":a(?<") + cap_name + string(">_)b")};
         schema.add_variable(string_view(var_schema), -1);
         auto const schema_ast = schema.release_schema_ast_ptr();
@@ -216,3 +217,35 @@ TEST_CASE("non_unique_capture_names", "[Schema]") {
         REQUIRE(cap_name == captures.at(0)->get_name());
     }
 }
+
+/**
+ * @ingroup unit_tests_schema
+ * @brief Create a schema, adding non-escaped hyphens.
+ */
+TEST_CASE("non_escaped_hyphens", "[Schema]") {
+    vector<string> const vars{R"(v1:ID-(?<id>\d{4}))", R"(v2:\d{4}-\d{4}-\d{4})", R"(v3:[a\-z])"};
+
+    Schema schema;
+    schema.add_variable(string_view(vars[0]), -1);
+    schema.add_variable(string_view(vars[1]), -1);
+    schema.add_variable(string_view(vars[2]), -1);
+    auto const schema_ast = schema.release_schema_ast_ptr();
+    REQUIRE(schema_ast->m_schema_vars.size() == 3);
+    REQUIRE(schema.release_schema_ast_ptr()->m_schema_vars.empty());
+
+    REQUIRE(nullptr != schema_ast->m_schema_vars.at(0));
+    REQUIRE(nullptr != schema_ast->m_schema_vars.at(1));
+    REQUIRE(nullptr != schema_ast->m_schema_vars.at(2));
+    auto& schema_var_ast0 = dynamic_cast<SchemaVarAST&>(*schema_ast->m_schema_vars.at(0));
+    auto& schema_var_ast1 = dynamic_cast<SchemaVarAST&>(*schema_ast->m_schema_vars.at(1));
+    auto& schema_var_ast2 = dynamic_cast<SchemaVarAST&>(*schema_ast->m_schema_vars.at(2));
+    REQUIRE_NOTHROW([&]() -> void {
+        std::ignore = dynamic_cast<RegexASTCatByte&>(*schema_var_ast0.m_regex_ptr);
+    }());
+    REQUIRE_NOTHROW([&]() -> void {
+        std::ignore = dynamic_cast<RegexASTCatByte&>(*schema_var_ast1.m_regex_ptr);
+    }());
+    REQUIRE_NOTHROW([&]() -> void {
+        std::ignore = dynamic_cast<RegexASTGroupByte&>(*schema_var_ast2.m_regex_ptr);
+    }());
+}