feat: Clean LaTeX escape sequences in journal/conference names (fixes #71) (#83)

Add LaTeX escape sequence cleaning to BibTeX parser to properly handle
special characters in venue names. This fixes cases where journals like
"Computers \& Security" were not matching in backend databases due to
unprocessed escape sequences.

Changes:
- Add _clean_latex_escapes() method to handle common LaTeX escapes
- Integrate escape cleaning into _remove_nested_braces() workflow
- Handle both single and double backslash patterns
- Add comprehensive unit tests for escape sequence cleaning

Handles escape sequences: \& \' \" \{ \} \$ \% \# \_ \^ \~

[AI-assisted]

Co-authored-by: florath-ai-assistant[bot] <Andreas.Florath@telekom.de>

Author: coding-ai-assistant[bot]

src/aletheia_probe/bibtex_parser.py

@@ -356,27 +356,86 @@ def _get_field_safely(entry: Entry, field_name: str) -> str | None:
             detail_logger.debug(f"Error getting field '{field_name}': {e}")
             return None
 
+    @staticmethod
+    def _clean_latex_escapes(value: str) -> str:
+        """Clean LaTeX escape sequences from BibTeX field values.
+
+        BibTeX files often contain LaTeX escape sequences like \\& or \\'
+        that need to be converted to their actual characters for proper
+        database matching and display.
+
+        Args:
+            value: BibTeX field value that may contain LaTeX escape sequences
+
+        Returns:
+            Value with LaTeX escape sequences converted to actual characters
+
+        Examples:
+            "Computers \\& Security" -> "Computers & Security"
+            "Journal of \\"Research\\"" -> 'Journal of "Research"'
+            "Test\\_Case" -> "Test_Case"
+        """
+        import re
+
+        # Map of LaTeX escape sequences to their actual characters
+        # Handle both single and double backslash patterns
+        escape_mappings = [
+            (r"\\\\&", "&"),  # Double backslash (raw string in files)
+            (r"\\&", "&"),  # Single backslash
+            (r"\\\\'", "'"),
+            (r"\\'", "'"),
+            (r'\\\\"', '"'),
+            (r'\\"', '"'),
+            (r"\\\\{", "{"),
+            (r"\\{", "{"),
+            (r"\\\\}", "}"),
+            (r"\\}", "}"),
+            (r"\\\\\$", "$"),
+            (r"\\\$", "$"),
+            (r"\\\\%", "%"),
+            (r"\\%", "%"),
+            (r"\\\\#", "#"),
+            (r"\\#", "#"),
+            (r"\\\\_", "_"),
+            (r"\\_", "_"),
+            (r"\\\\\^", "^"),
+            (r"\\\^", "^"),
+            (r"\\\\~", "~"),
+            (r"\\~", "~"),
+        ]
+
+        # Apply all escape sequence replacements
+        for pattern, replacement in escape_mappings:
+            value = re.sub(pattern, replacement, value)
+
+        return value
+
     @staticmethod
     def _remove_nested_braces(value: str) -> str:
-        """Remove nested curly braces from BibTeX field values.
+        """Remove nested curly braces and clean LaTeX escapes from BibTeX field values.
 
-        BibTeX often uses nested braces like {{IEEE}} or {{{CLOUD}}} for formatting.
-        This method recursively removes all levels of curly braces.
+        BibTeX often uses nested braces like {{IEEE}} or {{{CLOUD}}} for formatting,
+        and LaTeX escape sequences like \\& for special characters.
+        This method removes all levels of curly braces and converts escape sequences.
 
         Args:
-            value: BibTeX field value that may contain nested braces
+            value: BibTeX field value that may contain nested braces and escapes
 
         Returns:
-            Value with all curly braces removed
+            Value with all curly braces removed and LaTeX escapes cleaned
 
         Examples:
             "{{IEEE}} Conference" -> "IEEE Conference"
             "{{{CLOUD}}}" -> "CLOUD"
+            "Computers \\& Security" -> "Computers & Security"
             "Normal text" -> "Normal text"
         """
         import re
 
-        # Remove nested curly braces iteratively until none remain
+        # First, clean LaTeX escape sequences
+        value = BibtexParser._clean_latex_escapes(value)
+
+        # Then remove nested curly braces iteratively until none remain
         # This handles multiple levels like {{{text}}} -> {{text}} -> {text} -> text
         while re.search(r"\{[^{}]*\}", value):
             value = re.sub(r"\{([^{}]*)\}", r"\1", value)

tests/unit/test_bibtex_parser.py

@@ -817,3 +817,102 @@ def test_brace_removal_edge_cases(self):
         # Test braces with special characters
         result = BibtexParser._remove_nested_braces("{{IEEE-802.11}} {Conference}")
         assert result == "IEEE-802.11 Conference"
+
+    def test_clean_latex_escapes(self):
+        """Test cleaning of LaTeX escape sequences."""
+        # Test ampersand escape
+        result = BibtexParser._clean_latex_escapes("Computers \\& Security")
+        assert result == "Computers & Security"
+
+        # Test double backslash ampersand
+        result = BibtexParser._clean_latex_escapes("Computers \\\\& Security")
+        assert result == "Computers & Security"
+
+        # Test quote escapes
+        result = BibtexParser._clean_latex_escapes(r"Journal of \"Research\"")
+        assert result == 'Journal of "Research"'
+
+        # Test apostrophe escape
+        result = BibtexParser._clean_latex_escapes(r"Author\'s Work")
+        assert result == "Author's Work"
+
+        # Test underscore escape
+        result = BibtexParser._clean_latex_escapes(r"Test\_Case")
+        assert result == "Test_Case"
+
+        # Test multiple escapes in same string
+        result = BibtexParser._clean_latex_escapes(r"A \& B: \"Test\" \% Done")
+        assert result == 'A & B: "Test" % Done'
+
+        # Test all common escapes
+        result = BibtexParser._clean_latex_escapes(
+            r"Test\& \' \" \{ \} \$ \% \# \_ \^ \~"
+        )
+        assert result == "Test& ' \" { } $ % # _ ^ ~"
+
+        # Test text without escapes
+        result = BibtexParser._clean_latex_escapes("Normal text")
+        assert result == "Normal text"
+
+        # Test empty string
+        result = BibtexParser._clean_latex_escapes("")
+        assert result == ""
+
+    def test_remove_nested_braces_with_latex_escapes(self):
+        """Test that _remove_nested_braces also cleans LaTeX escapes."""
+        # Test combined braces and escapes
+        result = BibtexParser._remove_nested_braces(r"{Computers \& Security}")
+        assert result == "Computers & Security"
+
+        # Test nested braces with escapes
+        result = BibtexParser._remove_nested_braces(r"{{IEEE}} \& {{ACM}}")
+        assert result == "IEEE & ACM"
+
+        # Test complex combination
+        result = BibtexParser._remove_nested_braces(
+            r"{Journal of \"Machine Learning\"} \& {{AI}}"
+        )
+        assert result == 'Journal of "Machine Learning" & AI'
+
+    def test_parse_bibtex_file_with_latex_escapes(self, tmp_path):
+        """Test parsing BibTeX file with LaTeX escape sequences in journal names."""
+        bibtex_content = """
+@article{test_latex_escapes,
+    title={Test Article with LaTeX Escapes},
+    journal={Computers \\& Security},
+    author={Test Author},
+    year={2023}
+}
+
+@article{test_quotes,
+    title={Article with Quotes},
+    journal={Journal of \\"Research\\"},
+    author={Another Author},
+    year={2024}
+}
+
+@article{test_multiple,
+    title={Multiple Escapes},
+    journal={Test \\& Review: \\"Quality\\" \\% Assessment},
+    author={Third Author},
+    year={2025}
+}
+"""
+        test_file = tmp_path / "test_latex.bib"
+        test_file.write_text(bibtex_content, encoding="utf-8")
+
+        entries = BibtexParser.parse_bibtex_file(test_file)
+
+        assert len(entries) == 3
+
+        # Check first entry with ampersand escape
+        entry1 = [e for e in entries if e.key == "test_latex_escapes"][0]
+        assert entry1.journal_name == "Computers & Security"
+
+        # Check second entry with quote escapes
+        entry2 = [e for e in entries if e.key == "test_quotes"][0]
+        assert entry2.journal_name == 'Journal of "Research"'
+
+        # Check third entry with multiple escapes
+        entry3 = [e for e in entries if e.key == "test_multiple"][0]
+        assert entry3.journal_name == 'Test & Review: "Quality" % Assessment'