Simplify mention parsing and remove text extraction

Author: joshuadavidthomas

src/django_github_app/mentions.py

@@ -2,16 +2,11 @@
 
 import re
 from dataclasses import dataclass
-from datetime import datetime
 from enum import Enum
 from typing import NamedTuple
 
-from django.conf import settings
-from django.utils import timezone
 from gidgethub import sansio
 
-from .conf import app_settings
-
 
 class EventAction(NamedTuple):
     event: str
@@ -76,8 +71,6 @@ class RawMention:
 CODE_BLOCK_PATTERN = re.compile(r"```[\s\S]*?```", re.MULTILINE)
 INLINE_CODE_PATTERN = re.compile(r"`[^`]+`")
 BLOCKQUOTE_PATTERN = re.compile(r"^\s*>.*$", re.MULTILINE)
-
-
 # GitHub username rules:
 # - 1-39 characters long
 # - Can only contain alphanumeric characters or hyphens
@@ -127,63 +120,47 @@ def for_mention_in_comment(cls, comment: str, mention_position: int):
         return cls(lineno=line_number, text=line_text)
 
 
-def extract_mention_text(
-    body: str, current_index: int, all_mentions: list[RawMention], mention_end: int
-) -> str:
-    text_start = mention_end
-
-    # Find next @mention (any mention, not just matched ones) to know where this text ends
-    next_mention_index = None
-    for j in range(current_index + 1, len(all_mentions)):
-        next_mention_index = j
-        break
-
-    if next_mention_index is not None:
-        text_end = all_mentions[next_mention_index].position
-    else:
-        text_end = len(body)
-
-    return body[text_start:text_end].strip()
-
-
 @dataclass
 class ParsedMention:
     username: str
-    text: str
     position: int
     line_info: LineInfo
-    match: re.Match[str] | None = None
     previous_mention: ParsedMention | None = None
     next_mention: ParsedMention | None = None
 
 
+def matches_pattern(text: str, pattern: str | re.Pattern[str]) -> bool:
+    match pattern:
+        case re.Pattern():
+            return pattern.fullmatch(text) is not None
+        case str():
+            return text.strip().lower() == pattern.strip().lower()
+
+
 def extract_mentions_from_event(
     event: sansio.Event, username_pattern: str | re.Pattern[str] | None = None
 ) -> list[ParsedMention]:
-    comment = event.data.get("comment", {}).get("body", "")
+    comment_key = "comment" if event.event != "pull_request_review" else "review"
+    comment = event.data.get(comment_key, {}).get("body", "")
 
     if not comment:
         return []
 
-    if username_pattern is None:
-        username_pattern = app_settings.SLUG
-
     mentions: list[ParsedMention] = []
     potential_mentions = extract_all_mentions(comment)
-    for i, raw_mention in enumerate(potential_mentions):
-        if not matches_pattern(raw_mention.username, username_pattern):
+    for raw_mention in potential_mentions:
+        if username_pattern and not matches_pattern(
+            raw_mention.username, username_pattern
+        ):
             continue
 
-        text = extract_mention_text(comment, i, potential_mentions, raw_mention.end)
-        line_info = LineInfo.for_mention_in_comment(comment, raw_mention.position)
-
         mentions.append(
             ParsedMention(
                 username=raw_mention.username,
-                text=text,
                 position=raw_mention.position,
-                line_info=line_info,
-                match=None,
+                line_info=LineInfo.for_mention_in_comment(
+                    comment, raw_mention.position
+                ),
                 previous_mention=None,
                 next_mention=None,
             )
@@ -198,63 +175,8 @@ def extract_mentions_from_event(
     return mentions
 
 
-@dataclass
-class Comment:
-    body: str
-    author: str
-    created_at: datetime
-    url: str
-    mentions: list[ParsedMention]
-
-    @property
-    def line_count(self) -> int:
-        if not self.body:
-            return 0
-        return len(self.body.splitlines())
-
-    @classmethod
-    def from_event(cls, event: sansio.Event) -> Comment:
-        match event.event:
-            case "issue_comment" | "pull_request_review_comment" | "commit_comment":
-                comment_data = event.data.get("comment")
-            case "pull_request_review":
-                comment_data = event.data.get("review")
-            case _:
-                comment_data = None
-
-        if not comment_data:
-            raise ValueError(f"Cannot extract comment from event type: {event.event}")
-
-        if created_at_str := comment_data.get("created_at", ""):
-            # GitHub timestamps are in ISO format: 2024-01-01T12:00:00Z
-            created_at_aware = datetime.fromisoformat(
-                created_at_str.replace("Z", "+00:00")
-            )
-            if settings.USE_TZ:
-                created_at = created_at_aware
-            else:
-                created_at = timezone.make_naive(
-                    created_at_aware, timezone.get_default_timezone()
-                )
-        else:
-            created_at = timezone.now()
-
-        author = comment_data.get("user", {}).get("login", "")
-        if not author and "sender" in event.data:
-            author = event.data.get("sender", {}).get("login", "")
-
-        return cls(
-            body=comment_data.get("body", ""),
-            author=author,
-            created_at=created_at,
-            url=comment_data.get("html_url", ""),
-            mentions=[],
-        )
-
-
 @dataclass
 class Mention:
-    comment: Comment
     mention: ParsedMention
     scope: MentionScope | None
 
@@ -264,50 +186,8 @@ def from_event(
         event: sansio.Event,
         *,
         username: str | re.Pattern[str] | None = None,
-        pattern: str | re.Pattern[str] | None = None,
         scope: MentionScope | None = None,
     ):
-        event_scope = MentionScope.from_event(event)
-        if scope is not None and event_scope != scope:
-            return
-
         mentions = extract_mentions_from_event(event, username)
-        if not mentions:
-            return
-
-        comment = Comment.from_event(event)
-        comment.mentions = mentions
-
         for mention in mentions:
-            if pattern is not None:
-                match = get_match(mention.text, pattern)
-                if not match:
-                    continue
-                mention.match = match
-
-            yield cls(
-                comment=comment,
-                mention=mention,
-                scope=event_scope,
-            )
-
-
-def matches_pattern(text: str, pattern: str | re.Pattern[str]) -> bool:
-    match pattern:
-        case re.Pattern():
-            return pattern.fullmatch(text) is not None
-        case str():
-            return text.strip().lower() == pattern.strip().lower()
-
-
-def get_match(text: str, pattern: str | re.Pattern[str] | None) -> re.Match[str] | None:
-    match pattern:
-        case None:
-            return re.match(r"(.*)", text, re.IGNORECASE | re.DOTALL)
-        case re.Pattern():
-            # Use the pattern directly, preserving its flags
-            return pattern.match(text)
-        case str():
-            # For strings, do exact match (case-insensitive)
-            # Escape the string to treat it literally
-            return re.match(re.escape(pattern), text, re.IGNORECASE)
+            yield cls(mention=mention, scope=scope)

src/django_github_app/routing.py

@@ -67,7 +67,6 @@ def decorator(func: CB) -> CB:
     def mention(
         self,
         *,
-        pattern: str | re.Pattern[str] | None = None,
         username: str | re.Pattern[str] | None = None,
         scope: MentionScope | None = None,
         **kwargs: Any,
@@ -77,17 +76,25 @@ def decorator(func: CB) -> CB:
             async def async_wrapper(
                 event: sansio.Event, gh: AsyncGitHubAPI, *args: Any, **kwargs: Any
             ) -> None:
+                event_scope = MentionScope.from_event(event)
+                if scope is not None and event_scope != scope:
+                    return
+
                 for mention in Mention.from_event(
-                    event, username=username, pattern=pattern, scope=scope
+                    event, username=username, scope=event_scope
                 ):
                     await func(event, gh, *args, context=mention, **kwargs)  # type: ignore[func-returns-value]
 
             @wraps(func)
             def sync_wrapper(
                 event: sansio.Event, gh: SyncGitHubAPI, *args: Any, **kwargs: Any
             ) -> None:
+                event_scope = MentionScope.from_event(event)
+                if scope is not None and event_scope != scope:
+                    return
+
                 for mention in Mention.from_event(
-                    event, username=username, pattern=pattern, scope=scope
+                    event, username=username, scope=event_scope
                 ):
                     func(event, gh, *args, context=mention, **kwargs)
 

tests/conftest.py

@@ -280,11 +280,11 @@ def _create_event(event_type, delivery_id=None, **data):
             in ["issue_comment", "pull_request_review_comment", "commit_comment"]
             and "comment" not in data
         ):
-            data["comment"] = {"body": faker.sentence()}
+            data["comment"] = {"body": f"@{faker.user_name()} {faker.sentence()}"}
 
         # Auto-create review field for pull request review events
         if event_type == "pull_request_review" and "review" not in data:
-            data["review"] = {"body": faker.sentence()}
+            data["review"] = {"body": f"@{faker.user_name()} {faker.sentence()}"}
 
         # Add user to comment if not present
         if "comment" in data and "user" not in data["comment"]: