refactor(format): extract regex construction and usage

thekaveman · thekaveman · commit 26392d2686f2 · 2024-10-17T00:18:07.000Z
diff --git a/conventional_pre_commit/format.py b/conventional_pre_commit/format.py
@@ -96,22 +96,52 @@ def conventional_types(types=[]):
     return types
 
 
-def is_conventional(input, types=DEFAULT_TYPES, optional_scope=True, scopes: Optional[List[str]] = None):
+def conventional_regex(types=DEFAULT_TYPES, optional_scope=True, scopes: Optional[List[str]] = None):
+    types = conventional_types(types)
+
+    types_pattern = f"^(?P<type>{r_types(types)})?"
+    scope_pattern = f"(?P<scope>{r_scope(optional_scope, scopes=scopes)})?"
+    delim_pattern = f"(?P<delim>{r_delim()})?"
+    subject_pattern = f"(?P<subject>{r_subject()})?"
+    body_pattern = f"(?P<body>{r_body()})?"
+    pattern = types_pattern + scope_pattern + delim_pattern + subject_pattern + body_pattern
+
+    return re.compile(pattern, re.MULTILINE)
+
+
+def clean_input(input: str):
+    """
+    Prepares an input message for conventional commits format check.
+    """
+    input = strip_verbose_commit_ignored(input)
+    input = strip_comments(input)
+    return input
+
+
+def conventional_match(input: str, types=DEFAULT_TYPES, optional_scope=True, scopes: Optional[List[str]] = None):
+    """
+    Returns an `re.Match` object for the input against the Conventional Commits format.
+    """
+    input = clean_input(input)
+    regex = conventional_regex(types, optional_scope, scopes)
+    return regex.match(input)
+
+
+def is_conventional(input: str, types=DEFAULT_TYPES, optional_scope=True, scopes: Optional[List[str]] = None) -> bool:
     """
     Returns True if input matches Conventional Commits formatting
     https://www.conventionalcommits.org
 
     Optionally provide a list of additional custom types.
     """
-    input = strip_verbose_commit_ignored(input)
-    input = strip_comments(input)
-    types = conventional_types(types)
-    pattern = f"^({r_types(types)}){r_scope(optional_scope, scopes=scopes)}{r_delim()}{r_subject()}{r_body()}"
-    regex = re.compile(pattern, re.MULTILINE)
-
-    result = regex.match(input)
+    result = conventional_match(input, types, optional_scope, scopes)
     is_valid = bool(result)
-    if is_valid and result.group("multi") and not result.group("sep"):
+
+    if result and result.group("multi") and not result.group("sep"):
+        is_valid = False
+    if result and not all(
+        [result.group("type"), optional_scope or result.group("scope"), result.group("delim"), result.group("subject")]
+    ):
         is_valid = False
 
     return is_valid
diff --git a/tests/test_format.py b/tests/test_format.py
@@ -436,6 +436,34 @@ def test_strip_verbose_commit_ignored__strips_double_verbose_ignored():
     assert result == expected
 
 
+def test_conventional_regex():
+    regex = format.conventional_regex()
+
+    assert isinstance(regex, re.Pattern)
+    assert "type" in regex.groupindex
+    assert "scope" in regex.groupindex
+    assert "delim" in regex.groupindex
+    assert "subject" in regex.groupindex
+    assert "body" in regex.groupindex
+    assert "multi" in regex.groupindex
+    assert "sep" in regex.groupindex
+
+
+def test_conventional_match():
+    match = format.conventional_match(
+        """test(scope): subject line
+
+body copy
+"""
+    )
+    assert match
+    assert match.group("type") == "test"
+    assert match.group("scope") == "(scope)"
+    assert match.group("delim") == ":"
+    assert match.group("subject").strip() == "subject line"
+    assert match.group("body").strip() == "body copy"
+
+
 @pytest.mark.parametrize("type", format.DEFAULT_TYPES)
 def test_is_conventional__default_type(type):
     input = f"{type}: message"
