[Lib] Custom escape function to ignore newline and carriage returns

ttiimm · ttiimm · commit a63dac0fa326 · 2025-09-16T17:04:51.000-04:00
diff --git a/src/lib.rs b/src/lib.rs
@@ -602,6 +602,40 @@ fn namedarg(name: &str) {
         assert!(ptr::eq(result.unwrap(), &src_refs[0]));
     }
 
+    const MULTILINE_SOURCE: &str = r#"
+#[macro_use]
+extern crate log;
+
+fn main() {
+    env_logger::init();
+    debug!("you're only as funky\n as your last cut");
+}
+"#;
+    #[test]
+    fn test_link_multiline() {
+        let lf = LogFormat::new(
+            r#"^\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z \w+ \w+\]\s+(?<body>.*)"#.to_string(),
+        );
+        let log_ref = LogRef::with_format(
+            "[2024-05-09T19:58:53Z DEBUG main] you're only as funky\n as your last cut",
+            lf,
+        );
+        let code = CodeSource::new(
+            &PathBuf::from("in-mem.rs"),
+            Box::new(MULTILINE_SOURCE.as_bytes()),
+        )
+        .unwrap();
+        let src_refs = extract_logging(&[code], &ProgressTracker::new())
+            .pop()
+            .unwrap()
+            .log_statements;
+        assert_eq!(src_refs.len(), 1);
+        println!("`{}`", log_ref.body());
+        println!("`{}`", src_refs[0].matcher);
+        let result = link_to_source(&log_ref, &src_refs);
+        assert!(ptr::eq(result.unwrap(), &src_refs[0]));
+    }
+
     #[test]
     fn test_link_to_source_no_matches() {
         let log_ref = LogRef::new("nope!");
diff --git a/src/log_format.rs b/src/log_format.rs
@@ -1,4 +1,4 @@
-use regex::{Captures, Regex};
+use regex::{Captures, Regex, RegexBuilder};
 
 use crate::LogRef;
 
@@ -11,7 +11,13 @@ impl LogFormat {
     pub fn new(format: String) -> LogFormat {
         LogFormat {
             // TODO handle more gracefully if wrong format
-            regex: Regex::new(&format).unwrap(),
+            regex: RegexBuilder::new(&format)
+                // XXX: This is kinda a hack to support multiline matching in lnav, but
+                // not really useful for log2src atm because its still filtering line-by-line,
+                // so this case would never come up
+                .dot_matches_new_line(true)
+                .build()
+                .unwrap(),
         }
     }
 
diff --git a/src/source_ref.rs b/src/source_ref.rs
@@ -116,7 +116,7 @@ fn build_matcher(
     let mut exact_len = 0;
     for cap in placeholder_regex_for(language).captures_iter(text) {
         let placeholder = cap.get(0).unwrap();
-        let text = regex::escape(&text[last_end..placeholder.start()]);
+        let text = escape_ignore_newlines(&text[last_end..placeholder.start()]);
         exact_len += text.len();
         pattern.push_str(text.as_str());
         last_end = placeholder.end();
@@ -128,7 +128,7 @@ fn build_matcher(
             (None, None) => FormatArgument::Placeholder,
         });
     }
-    let text = regex::escape(&text[last_end..]);
+    let text = escape_ignore_newlines(&text[last_end..]);
     exact_len += text.len();
     if exact_len == 0 {
         None
@@ -139,6 +139,24 @@ fn build_matcher(
     }
 }
 
+/// Escape special chars except newlines and carriage returns in order to support multiline strings
+fn escape_ignore_newlines(segment: &str) -> String {
+    let mut result = String::with_capacity(segment.len() * 2);
+    for c in segment.chars() {
+        match c {
+            '\n' => result.push_str(r"\n"), // Use actual newline in regex
+            '\r' => result.push_str(r"\r"), // Handle carriage returns too
+            // Escape regex special chars
+            '.' | '+' | '*' | '?' | '^' | '$' | '(' | ')' | '[' | ']' | '{' | '}' | '|' => {
+                result.push('\\');
+                result.push(c);
+            }
+            _ => result.push(c),
+        }
+    }
+    result
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -176,7 +194,10 @@ mod tests {
     #[test]
     fn test_build_matcher_positional() {
         let (matcher, _pat, args) = build_matcher("second={2}", SourceLanguage::Rust).unwrap();
-        assert_eq!(Regex::new(r#"^second=(.+)$"#).unwrap().as_str(), matcher.as_str());
+        assert_eq!(
+            Regex::new(r#"^second=(.+)$"#).unwrap().as_str(),
+            matcher.as_str()
+        );
         assert_eq!(args[0], FormatArgument::Positional(2));
     }
 
@@ -193,8 +214,22 @@ mod tests {
 
     #[test]
     fn test_build_matcher_none() {
-        let build_res =
-            build_matcher("%s", SourceLanguage::Cpp);
+        let build_res = build_matcher("%s", SourceLanguage::Cpp);
         assert!(build_res.is_none());
     }
+
+    #[test]
+    fn test_build_matcher_multiline() {
+        let (matcher, _pat, _args) = build_matcher(
+            "you're only as funky\n as your last cut",
+            SourceLanguage::Rust,
+        )
+        .unwrap();
+        assert_eq!(
+            Regex::new(r#"^you're only as funky\n as your last cut$"#)
+                .unwrap()
+                .as_str(),
+            matcher.as_str()
+        );
+    }
 }
