liblore 0.8.0__tar.gz → 0.8.2__tar.gz

{liblore-0.8.0 → liblore-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liblore
-Version: 0.8.0
+Version: 0.8.2
 Summary: Shared library for public-inbox / lore.kernel.org access
 Author-email: Konstantin Ryabitsev <konstantin@linuxfoundation.org>
 License-Expression: GPL-2.0-or-later

{liblore-0.8.0 → liblore-0.8.2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "liblore"
-version = "0.8.0"
+version = "0.8.2"
 description = "Shared library for public-inbox / lore.kernel.org access"
 readme = "README.md"
 requires-python = ">=3.9"

{liblore-0.8.0 → liblore-0.8.2}/src/liblore/__init__.py

@@ -6,7 +6,7 @@ import email.charset
 import email.policy
 from email.message import EmailMessage
 
-__version__ = '0.8.0'
+__version__ = '0.8.2'
 
 # Email policy used for parsing and serialising messages
 emlpolicy = email.policy.EmailPolicy(

{liblore-0.8.0 → liblore-0.8.2}/src/liblore/utils.py

@@ -79,10 +79,21 @@ def clean_header(hdrval: str | None) -> str:
 
 
 def get_clean_msgid(msg: EmailMessage, header: str = 'Message-Id') -> str | None:
-    """Extract a clean message ID (without angle brackets) from a header."""
+    """Extract a clean message ID (without angle brackets) from a header.
+
+    Message-IDs are always ASCII and enclosed in angle brackets, and
+    RFC 2047 forbids encoded words in msg-id headers (Message-Id,
+    In-Reply-To, References).  We therefore extract straight from the
+    raw value and deliberately avoid :func:`clean_header`, whose
+    address-parsing path would mangle a bare message-ID when the header
+    also carries an encoded-word comment (e.g. Gnus-style In-Reply-To).
+
+    This mirrors :func:`_clean_msgid_raw`, which does the same on raw
+    message bytes.
+    """
     raw = msg.get(header)
     if raw:
-        matches = re.search(r'<([^>]+)>', clean_header(raw))
+        matches = re.search(r'<([^>]+)>', str(raw))
         if matches:
             return matches.groups()[0]
     return None
@@ -383,6 +394,13 @@ def get_strict_thread(
                 for hval in msg.get_all(hdr_name, []):
                     raw_refs += re.findall(r'<([^>]+)>', str(hval))
 
+            # Some tooling emits messages that reference their own Message-ID.
+            # A self-reference is never meaningful for threading, so drop it
+            # before it can be mistaken for a parent.
+            if c_msgid in raw_refs:
+                logger.debug('Ignoring self-reference in %s', c_msgid)
+                raw_refs = [ref for ref in raw_refs if ref != c_msgid]
+
             # If noparent, pretend our target message has no references
             if noparent and msgid == c_msgid:
                 logger.info('Breaking thread to remove parents of %s', msgid)

{liblore-0.8.0 → liblore-0.8.2}/src/liblore.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liblore
-Version: 0.8.0
+Version: 0.8.2
 Summary: Shared library for public-inbox / lore.kernel.org access
 Author-email: Konstantin Ryabitsev <konstantin@linuxfoundation.org>
 License-Expression: GPL-2.0-or-later

liblore-0.8.2/tests/test_message.py

@@ -0,0 +1,149 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+"""Tests for liblore.message."""
+
+from __future__ import annotations
+
+from email.message import EmailMessage
+
+from conftest import MsgFactory
+
+from liblore.utils import clean_header, get_clean_msgid, parse_message
+
+
+class TestCleanHeader:
+    def test_plain_header(self) -> None:
+        assert clean_header('Hello World') == 'Hello World'
+
+    def test_none_returns_empty(self) -> None:
+        assert clean_header(None) == ''
+
+    def test_rfc2047_encoded(self) -> None:
+        encoded = '=?utf-8?q?Caf=C3=A9?='
+        assert clean_header(encoded) == 'Caf\u00e9'
+
+    def test_folded_whitespace(self) -> None:
+        assert clean_header('Hello\n World') == 'Hello World'
+
+    def test_encoded_address(self) -> None:
+        # formataddr re-encodes Unicode names, so we just check
+        # the address is preserved and the result is valid
+        hdr = '=?utf-8?q?=C3=89ric?= <eric@example.com>'
+        result = clean_header(hdr)
+        assert 'eric@example.com' in result
+
+    def test_special_chars_in_name(self) -> None:
+        hdr = '=?utf-8?q?O=27Brien=2C_Joe?= <joe@example.com>'
+        result = clean_header(hdr)
+        assert 'joe@example.com' in result
+
+
+class TestGetCleanMsgid:
+    def test_extracts_msgid(self, make_msg: MsgFactory) -> None:
+        msg = make_msg(msgid='test123@example.com')
+        assert get_clean_msgid(msg) == 'test123@example.com'
+
+    def test_missing_header(self) -> None:
+        msg = EmailMessage()
+        assert get_clean_msgid(msg) is None
+
+    def test_custom_header(self, make_msg: MsgFactory) -> None:
+        msg = make_msg(in_reply_to='parent@example.com')
+        assert get_clean_msgid(msg, 'In-Reply-To') == 'parent@example.com'
+
+    def test_in_reply_to_with_encoded_comment(self) -> None:
+        """Gnus appends an RFC 2047 encoded comment after the message-ID.
+
+        The encoded-word comment must not send us down clean_header's
+        address-parsing path, which would destroy the message-ID.
+        """
+        msg = EmailMessage()
+        msg['In-Reply-To'] = (
+            '<patch-v1-1-abc123@example.com>'
+            ' (=?utf-8?Q?=22Marc-Andr=C3=A9?= Lureau"\'s'
+            ' message of "Mon, 20 Jul 2026 11:55:30 +0400")'
+        )
+        assert get_clean_msgid(msg, 'In-Reply-To') == 'patch-v1-1-abc123@example.com'
+
+    def test_in_reply_to_with_encoded_comment_parsed(self) -> None:
+        """Same case, but via a message parsed under the modern policy."""
+        raw = (
+            b'From: x@example.com\r\n'
+            b'Message-Id: <child@example.com>\r\n'
+            b'In-Reply-To: <patch-v1-1-abc123@example.com>'
+            b' (=?utf-8?Q?=22Marc-Andr=C3=A9?= Lureau"\'s'
+            b' message of "Mon, 20 Jul 2026 11:55:30 +0400")\r\n'
+            b'\r\nbody\r\n'
+        )
+        msg = parse_message(raw)
+        assert get_clean_msgid(msg, 'In-Reply-To') == 'patch-v1-1-abc123@example.com'
+
+    # --- Non-compliant / malformed headers ---------------------------------
+    # These document how extraction copes with headers that violate
+    # RFC 5322.  The contract is deliberately simple: we return the
+    # contents of the first ``<...>`` pair, or None when there isn't one.
+
+    def test_missing_angle_brackets(self) -> None:
+        """A bare address without angle brackets yields no message-ID."""
+        msg = EmailMessage()
+        msg['Message-Id'] = 'bare@example.com'
+        assert get_clean_msgid(msg) is None
+
+    def test_empty_angle_brackets(self) -> None:
+        """An empty ``<>`` has nothing to extract."""
+        msg = EmailMessage()
+        msg['In-Reply-To'] = '<>'
+        assert get_clean_msgid(msg, 'In-Reply-To') is None
+
+    def test_no_at_sign_inside_brackets(self) -> None:
+        """We trust the angle brackets and do not require an ``@``."""
+        msg = EmailMessage()
+        msg['Message-Id'] = '<garbage-no-at>'
+        assert get_clean_msgid(msg) == 'garbage-no-at'
+
+    def test_leading_comment_before_id(self) -> None:
+        """A comment preceding the message-ID must not confuse extraction."""
+        msg = EmailMessage()
+        msg['In-Reply-To'] = '(sent earlier) <parent@example.com>'
+        assert get_clean_msgid(msg, 'In-Reply-To') == 'parent@example.com'
+
+    def test_multiple_ids_returns_first(self) -> None:
+        """Some broken clients cram several IDs into In-Reply-To."""
+        msg = EmailMessage()
+        msg['In-Reply-To'] = '<first@example.com> <second@example.com>'
+        assert get_clean_msgid(msg, 'In-Reply-To') == 'first@example.com'
+
+    def test_rfc2047_encoded_msgid(self) -> None:
+        """A nonconformant fully RFC 2047-encoded ``<foo@bar>``.
+
+        RFC 2047 forbids encoded words in msg-id headers, but if one
+        shows up the modern EmailPolicy decodes it on read, so we still
+        recover the ID -- no clean_header fallback required.
+        """
+        msg = EmailMessage()
+        msg['Message-Id'] = '=?utf-8?q?=3Cfoo=40bar=3E?='
+        assert get_clean_msgid(msg) == 'foo@bar'
+
+    def test_rfc2047_encoded_msgid_parsed(self) -> None:
+        """Same nonconformant case, parsed under the real policy."""
+        raw = (
+            b'From: x@example.com\r\n'
+            b'Message-Id: =?utf-8?q?=3Cfoo=40bar=3E?=\r\n'
+            b'\r\nbody\r\n'
+        )
+        msg = parse_message(raw)
+        assert get_clean_msgid(msg) == 'foo@bar'
+
+
+class TestParseMessage:
+    def test_roundtrip(self) -> None:
+        raw = (
+            b'From: test@example.com\r\n'
+            b'Subject: Test\r\n'
+            b'Message-Id: <test@example.com>\r\n'
+            b'\r\n'
+            b'Body text\r\n'
+        )
+        msg = parse_message(raw)
+        assert isinstance(msg, EmailMessage)
+        assert msg['Subject'] == 'Test'
+        assert msg['From'] == 'test@example.com'

{liblore-0.8.0 → liblore-0.8.2}/tests/test_thread.py

@@ -47,6 +47,57 @@ class TestGetStrictThread:
         assert 'child@x.com' in ids
         assert 'grandchild@x.com' in ids
 
+    def test_noparent_self_referencing_cover(self, make_msg: MsgFactory) -> None:
+        # Some tooling emits a cover letter whose In-Reply-To/References point
+        # at its own Message-ID.  Breaking the thread there must not treat the
+        # cover's own msgid as a reference to ignore, or every patch that
+        # legitimately replies to the cover gets dropped.
+        cover = make_msg(
+            msgid='cover@x.com',
+            subject='[PATCH 0/2] Something',
+            in_reply_to='cover@x.com',
+            references=['cover@x.com'],
+        )
+        patch1 = make_msg(
+            msgid='p1@x.com',
+            subject='[PATCH 1/2] First',
+            in_reply_to='cover@x.com',
+            references=['cover@x.com'],
+        )
+        patch2 = make_msg(
+            msgid='p2@x.com',
+            subject='[PATCH 2/2] Second',
+            in_reply_to='cover@x.com',
+            references=['cover@x.com'],
+        )
+        review = make_msg(
+            msgid='review@x.com',
+            subject='Re: [PATCH 2/2] Second',
+            in_reply_to='p2@x.com',
+            references=['cover@x.com', 'p2@x.com'],
+        )
+        want = {'cover@x.com', 'p1@x.com', 'p2@x.com', 'review@x.com'}
+        # Cover first in the list is the worst case: without the fix only the
+        # cover survives.  Ordering must not matter, so check both.
+        for msgs in ([cover, patch1, patch2, review], [patch1, cover, patch2, review]):
+            result = get_strict_thread(msgs, 'cover@x.com', noparent=True)
+            assert result is not None
+            assert {get_clean_msgid(m) for m in result} == want
+
+    def test_self_reference_is_not_a_parent(self, make_msg: MsgFactory) -> None:
+        # A self-referencing message must not be treated as a reply to itself,
+        # even without noparent: it is a thread root, and starting the walk at
+        # its child still has to pull it in.
+        root = make_msg(
+            msgid='root@x.com',
+            in_reply_to='root@x.com',
+            references=['root@x.com'],
+        )
+        reply = make_msg(msgid='reply@x.com', in_reply_to='root@x.com')
+        result = get_strict_thread([root, reply], 'reply@x.com')
+        assert result is not None
+        assert {get_clean_msgid(m) for m in result} == {'root@x.com', 'reply@x.com'}
+
     def test_references_chain(self, make_msg: MsgFactory) -> None:
         msg1 = make_msg(msgid='a@x.com')
         msg2 = make_msg(msgid='b@x.com', references=['a@x.com'])

liblore-0.8.0/tests/test_message.py

@@ -1,66 +0,0 @@
-# SPDX-License-Identifier: GPL-2.0-or-later
-"""Tests for liblore.message."""
-
-from __future__ import annotations
-
-from email.message import EmailMessage
-
-from conftest import MsgFactory
-
-from liblore.utils import clean_header, get_clean_msgid, parse_message
-
-
-class TestCleanHeader:
-    def test_plain_header(self) -> None:
-        assert clean_header('Hello World') == 'Hello World'
-
-    def test_none_returns_empty(self) -> None:
-        assert clean_header(None) == ''
-
-    def test_rfc2047_encoded(self) -> None:
-        encoded = '=?utf-8?q?Caf=C3=A9?='
-        assert clean_header(encoded) == 'Caf\u00e9'
-
-    def test_folded_whitespace(self) -> None:
-        assert clean_header('Hello\n World') == 'Hello World'
-
-    def test_encoded_address(self) -> None:
-        # formataddr re-encodes Unicode names, so we just check
-        # the address is preserved and the result is valid
-        hdr = '=?utf-8?q?=C3=89ric?= <eric@example.com>'
-        result = clean_header(hdr)
-        assert 'eric@example.com' in result
-
-    def test_special_chars_in_name(self) -> None:
-        hdr = '=?utf-8?q?O=27Brien=2C_Joe?= <joe@example.com>'
-        result = clean_header(hdr)
-        assert 'joe@example.com' in result
-
-
-class TestGetCleanMsgid:
-    def test_extracts_msgid(self, make_msg: MsgFactory) -> None:
-        msg = make_msg(msgid='test123@example.com')
-        assert get_clean_msgid(msg) == 'test123@example.com'
-
-    def test_missing_header(self) -> None:
-        msg = EmailMessage()
-        assert get_clean_msgid(msg) is None
-
-    def test_custom_header(self, make_msg: MsgFactory) -> None:
-        msg = make_msg(in_reply_to='parent@example.com')
-        assert get_clean_msgid(msg, 'In-Reply-To') == 'parent@example.com'
-
-
-class TestParseMessage:
-    def test_roundtrip(self) -> None:
-        raw = (
-            b'From: test@example.com\r\n'
-            b'Subject: Test\r\n'
-            b'Message-Id: <test@example.com>\r\n'
-            b'\r\n'
-            b'Body text\r\n'
-        )
-        msg = parse_message(raw)
-        assert isinstance(msg, EmailMessage)
-        assert msg['Subject'] == 'Test'
-        assert msg['From'] == 'test@example.com'