feat: Implement groups into NFAEvaluator (proper greedy matches)

Author: tkarabela

README.md

@@ -13,7 +13,7 @@ import regex_automata
 
 pattern = regex_automata.compile(r"(foo)*bar|baz")  # regex_automata.Pattern
 
-pattern.fullmatch("foofoobar")                      # regex_automata.Match(span=(0, 9), match='foofoobar')
+pattern.fullmatch("foofoobar")                      # regex_automata.Match
 pattern.fullmatch("foo")                            # None
 
 pattern.ast                                         # regex_automata.parser.ast.AstNode
@@ -44,14 +44,14 @@ Finite automaton accepting `(foo)*bar|baz`:
 
 - Library
   - `match()`, `fullmatch()`, `search()` and `finditer()` methods
-  - `Match` object containing span and matched text (but no groups)
+  - `Match` object containing span, matched text and groups
   - flags `DOTALL`, `IGNORECASE` and `MULTILINE`
 
 - Syntax
   - character sets: `.`, `[...]` (special sequences such as `\w` are supported, but not inside square brackets)
   - repetition: `*`, `?`, `+`, `{n,k}`
   - boundary assertions: `^`, `$`, `\b`, `\B`, `\A`, `\Z`
-  - basic groups: `(...)` that behave like `(?:...)` ie. non-capturing
+  - basic groups: `(...)` (named and non-capturing groups are not supported)
 
 ## Implementation overview
 

src/regex_automata/regex/match.py

@@ -1,15 +1,53 @@
 from dataclasses import dataclass
-from typing import Self
+from typing import TYPE_CHECKING
 
+if TYPE_CHECKING:
+    from .pattern import Pattern
 
-@dataclass
+
+@dataclass(repr=False)
 class Match:
-    span: tuple[int, int]
+    re: "Pattern"
+    pos: int | None
+    endpos: int | None
     match: str
+    groupspandict: dict[int, tuple[int, int]]
+
+    def group(self, *indices: int) -> (str | None) | tuple[str | None, ...]:
+        match len(indices):
+            case 0:
+                return self._group(0)
+            case 1:
+                return self._group(indices[0])
+            case _:
+                return tuple(map(self._group, indices))
+
+    def _group(self, i: int) -> str | None:
+        start, end = self.span(i)
+        if start == -1:
+            return None
+        else:
+            match_start = self.start()
+            return self.match[start - match_start : end - match_start]
+
+    def groupdict(self) -> dict[int, str | None]:
+        return {i: self._group(i) for i in self.groupspandict}
+
+    def span(self, i: int = 0) -> tuple[int, int]:
+        return self.groupspandict.get(i, (-1, -1))
+
+    def start(self, i: int = 0) -> int:
+        return self.span(i)[0]
+
+    def end(self, i: int = 0) -> int:
+        return self.span(i)[1]
+
+    def __getitem__(self, i: int) -> str | None:
+        return self._group(i)
 
-    @classmethod
-    def from_span_and_text(cls, start: int, end: int, text: str) -> Self:
-        return cls((start, end), text[start:end])
+    @property
+    def string(self) -> str:
+        return self.re.pattern
 
-    def group(self) -> str:
-        return self.match
+    def __repr__(self) -> str:
+        return f"<Match span={self.span()!r}, match={self.match!r}>"