conventional-pre-commit 3.2.0__tar.gz → 3.4.0__tar.gz

{conventional_pre_commit-3.2.0 → conventional_pre_commit-3.4.0}/.pre-commit-config.yaml

@@ -8,7 +8,7 @@ default_install_hook_types:
 
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.5.0
+    rev: v4.6.0
     hooks:
       - id: trailing-whitespace
       - id: mixed-line-ending
@@ -18,21 +18,21 @@ repos:
       - id: check-added-large-files
 
   - repo: https://github.com/psf/black
-    rev: 24.3.0
+    rev: 24.4.2
     hooks:
       - id: black
         types:
           - python
 
   - repo: https://github.com/PyCQA/flake8
-    rev: 7.0.0
+    rev: 7.1.0
     hooks:
       - id: flake8
         types:
           - python
 
   - repo: https://github.com/pycqa/bandit
-    rev: 1.7.8
+    rev: 1.7.9
     hooks:
       - id: bandit
         args: ["-ll"]

{conventional_pre_commit-3.2.0 → conventional_pre_commit-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conventional_pre_commit
-Version: 3.2.0
+Version: 3.4.0
 Summary: A pre-commit hook that checks commit messages for Conventional Commits formatting.
 Author-email: Compiler LLC <dev@compiler.la>
 License:                                  Apache License
@@ -352,18 +352,19 @@ print(is_conventional("custom: this is a conventional commit", types=["custom"])
 
 ```shell
 $ conventional-pre-commit -h
-usage: conventional-pre-commit [-h] [--force-scope] [--strict] [types ...] input
+usage: conventional-pre-commit [-h] [--force-scope] [--scopes SCOPES] [--strict] [types ...] input
 
 Check a git commit message for Conventional Commits formatting.
 
 positional arguments:
-  types          Optional list of types to support
-  input          A file containing a git commit message
+  types            Optional list of types to support
+  input            A file containing a git commit message
 
 options:
-  -h, --help     show this help message and exit
-  --force-scope  Force commit to have scope defined.
-  --strict       Force commit to strictly follow Conventional Commits formatting. Disallows fixup! style commits.
+  -h, --help       show this help message and exit
+  --force-scope    Force commit to have scope defined.
+  --scopes SCOPES  Optional list of scopes to support. Scopes should be separated by commas with no spaces (e.g. api,client)
+  --strict         Force commit to strictly follow Conventional Commits formatting. Disallows fixup! style commits.
 ```
 
 Supply arguments on the command-line, or via the pre-commit `hooks.args` property:

{conventional_pre_commit-3.2.0 → conventional_pre_commit-3.4.0}/README.md

@@ -129,18 +129,19 @@ print(is_conventional("custom: this is a conventional commit", types=["custom"])
 
 ```shell
 $ conventional-pre-commit -h
-usage: conventional-pre-commit [-h] [--force-scope] [--strict] [types ...] input
+usage: conventional-pre-commit [-h] [--force-scope] [--scopes SCOPES] [--strict] [types ...] input
 
 Check a git commit message for Conventional Commits formatting.
 
 positional arguments:
-  types          Optional list of types to support
-  input          A file containing a git commit message
+  types            Optional list of types to support
+  input            A file containing a git commit message
 
 options:
-  -h, --help     show this help message and exit
-  --force-scope  Force commit to have scope defined.
-  --strict       Force commit to strictly follow Conventional Commits formatting. Disallows fixup! style commits.
+  -h, --help       show this help message and exit
+  --force-scope    Force commit to have scope defined.
+  --scopes SCOPES  Optional list of scopes to support. Scopes should be separated by commas with no spaces (e.g. api,client)
+  --strict         Force commit to strictly follow Conventional Commits formatting. Disallows fixup! style commits.
 ```
 
 Supply arguments on the command-line, or via the pre-commit `hooks.args` property:

{conventional_pre_commit-3.2.0 → conventional_pre_commit-3.4.0}/conventional_pre_commit/format.py

@@ -1,4 +1,5 @@
 import re
+from typing import List, Optional
 
 CONVENTIONAL_TYPES = ["feat", "fix"]
 DEFAULT_TYPES = [
@@ -26,8 +27,20 @@ def r_types(types):
     return "|".join(types)
 
 
-def r_scope(optional=True):
+def _get_scope_pattern(scopes: Optional[List[str]] = None):
+    scopes_str = r_types(scopes)
+    escaped_delimiters = list(map(re.escape, [":", ",", "-", "/"]))  # type: ignore
+    delimiters_pattern = r_types(escaped_delimiters)
+    return rf"\(\s*(?:{scopes_str})(?:\s*(?:{delimiters_pattern})\s*(?:{scopes_str}))*\s*\)"
+
+
+def r_scope(optional=True, scopes: Optional[List[str]] = None):
     """Regex str for an optional (scope)."""
+
+    if scopes:
+        scopes_pattern = _get_scope_pattern(scopes)
+        return scopes_pattern
+
     if optional:
         return r"(\([\w \/:,-]+\))?"
     else:
@@ -54,13 +67,14 @@ def r_autosquash_prefixes():
     return "|".join(AUTOSQUASH_PREFIXES)
 
 
-def r_verbose_diff():
-    """Regex str for verbose diff"""
-    return r"(?P<diff>(^# -* >8 -*$\r?\n)(^# .*$\r?\n)+(diff ){1}(.*\r?\n)*)"
+def r_verbose_commit_ignored():
+    """Regex str for the ignored part of verbose commit message templates"""
+    return r"^# -{24} >8 -{24}\r?\n.*\Z"
 
 
-def strip_verbose_diff(input):
-    return re.sub(r_verbose_diff(), "", input, flags=re.MULTILINE)
+def strip_verbose_commit_ignored(input):
+    """Strip the ignored part of verbose commit message templates."""
+    return re.sub(r_verbose_commit_ignored(), "", input, flags=re.DOTALL | re.MULTILINE)
 
 
 def r_comment():
@@ -79,17 +93,17 @@ def conventional_types(types=[]):
     return types
 
 
-def is_conventional(input, types=DEFAULT_TYPES, optional_scope=True):
+def is_conventional(input, types=DEFAULT_TYPES, optional_scope=True, scopes: Optional[List[str]] = None):
     """
     Returns True if input matches Conventional Commits formatting
     https://www.conventionalcommits.org
 
     Optionally provide a list of additional custom types.
     """
-    input = strip_verbose_diff(input)
+    input = strip_verbose_commit_ignored(input)
     input = strip_comments(input)
     types = conventional_types(types)
-    pattern = f"^({r_types(types)}){r_scope(optional_scope)}{r_delim()}{r_subject()}{r_body()}"
+    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)

{conventional_pre_commit-3.2.0 → conventional_pre_commit-3.4.0}/conventional_pre_commit/hook.py

@@ -23,6 +23,12 @@ def main(argv=[]):
     parser.add_argument(
         "--force-scope", action="store_false", default=True, dest="optional_scope", help="Force commit to have scope defined."
     )
+    parser.add_argument(
+        "--scopes",
+        type=str,
+        default=None,
+        help="Optional list of scopes to support. Scopes should be separated by commas with no spaces (e.g. api,client)",
+    )
     parser.add_argument(
         "--strict",
         action="store_true",
@@ -51,12 +57,16 @@ See {Colors.LBLUE}https://git-scm.com/docs/git-commit/#_discussion{Colors.RESTOR
         """
         )
         return RESULT_FAIL
+    if args.scopes:
+        scopes = args.scopes.split(",")
+    else:
+        scopes = args.scopes
 
     if not args.strict:
         if format.has_autosquash_prefix(message):
             return RESULT_SUCCESS
 
-    if format.is_conventional(message, args.types, args.optional_scope):
+    if format.is_conventional(message, args.types, args.optional_scope, scopes):
         return RESULT_SUCCESS
     else:
         print(

{conventional_pre_commit-3.2.0 → conventional_pre_commit-3.4.0}/conventional_pre_commit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conventional_pre_commit
-Version: 3.2.0
+Version: 3.4.0
 Summary: A pre-commit hook that checks commit messages for Conventional Commits formatting.
 Author-email: Compiler LLC <dev@compiler.la>
 License:                                  Apache License
@@ -352,18 +352,19 @@ print(is_conventional("custom: this is a conventional commit", types=["custom"])
 
 ```shell
 $ conventional-pre-commit -h
-usage: conventional-pre-commit [-h] [--force-scope] [--strict] [types ...] input
+usage: conventional-pre-commit [-h] [--force-scope] [--scopes SCOPES] [--strict] [types ...] input
 
 Check a git commit message for Conventional Commits formatting.
 
 positional arguments:
-  types          Optional list of types to support
-  input          A file containing a git commit message
+  types            Optional list of types to support
+  input            A file containing a git commit message
 
 options:
-  -h, --help     show this help message and exit
-  --force-scope  Force commit to have scope defined.
-  --strict       Force commit to strictly follow Conventional Commits formatting. Disallows fixup! style commits.
+  -h, --help       show this help message and exit
+  --force-scope    Force commit to have scope defined.
+  --scopes SCOPES  Optional list of scopes to support. Scopes should be separated by commas with no spaces (e.g. api,client)
+  --strict         Force commit to strictly follow Conventional Commits formatting. Disallows fixup! style commits.
 ```
 
 Supply arguments on the command-line, or via the pre-commit `hooks.args` property:

{conventional_pre_commit-3.2.0 → conventional_pre_commit-3.4.0}/conventional_pre_commit.egg-info/SOURCES.txt

@@ -33,6 +33,7 @@ tests/messages/conventional_commit_bad_multi_line
 tests/messages/conventional_commit_gbk
 tests/messages/conventional_commit_multi_line
 tests/messages/conventional_commit_utf-8
+tests/messages/conventional_commit_with_multiple_scopes
 tests/messages/conventional_commit_with_scope
 tests/messages/custom_commit
 tests/messages/fixup_commit

{conventional_pre_commit-3.2.0 → conventional_pre_commit-3.4.0}/tests/conftest.py

@@ -52,3 +52,8 @@ def conventional_commit_bad_multi_line_path():
 @pytest.fixture
 def conventional_commit_multi_line_path():
     return get_message_path("conventional_commit_multi_line")
+
+
+@pytest.fixture
+def conventional_commit_with_multiple_scopes_path():
+    return get_message_path("conventional_commit_with_multiple_scopes")

conventional_pre_commit-3.4.0/tests/messages/conventional_commit_with_multiple_scopes

@@ -0,0 +1 @@
+feat(api,client): added new endpoint with client support

{conventional_pre_commit-3.2.0 → conventional_pre_commit-3.4.0}/tests/run.sh

@@ -7,5 +7,5 @@ coverage run -m pytest
 # clean out old coverage results
 rm -rf ./tests/coverage
 
-# regenerate coverate report
+# regenerate coverage report
 coverage html --directory ./tests/coverage

conventional_pre_commit-3.4.0/tests/test_format.py

@@ -0,0 +1,586 @@
+import re
+
+import pytest
+
+from conventional_pre_commit import format
+
+CUSTOM_TYPES = ["one", "two"]
+
+
+def test_r_types():
+    result = format.r_types(CUSTOM_TYPES)
+    regex = re.compile(result)
+
+    assert regex.match("one")
+    assert regex.match("two")
+
+
+def test_r_scope__optional():
+    result = format.r_scope()
+    regex = re.compile(result)
+
+    assert regex.match("")
+
+
+def test_r_scope__not_optional():
+    result = format.r_scope(optional=False)
+    regex = re.compile(result)
+
+    # Assert not optional anymore
+    assert not regex.match("")
+
+
+def test_r_scope__parenthesis_required():
+    result = format.r_scope()
+    regex = re.compile(result)
+
+    # without parens produces a match object with a 0 span
+    # since the (scope) is optional
+    without_parens = regex.match("something")
+    assert without_parens.span() == (0, 0)
+
+    # with parens produces a match object with a span
+    # that covers the input string
+    with_parens = regex.match("(something)")
+    assert with_parens.span() == (0, 11)
+
+
+def test_r_scope__alphanumeric():
+    result = format.r_scope()
+    regex = re.compile(result)
+
+    assert regex.match("(50m3t41N6)")
+
+
+def test_r_scope__special_chars():
+    result = format.r_scope()
+    regex = re.compile(result)
+
+    assert regex.match("(some-thing)")
+    assert regex.match("(some_thing)")
+    assert regex.match("(some/thing)")
+    assert regex.match("(some thing)")
+    assert regex.match("(some:thing)")
+    assert regex.match("(some,thing)")
+
+
+def test_r_scope__scopes():
+    scopes_input = ["api", "client"]
+    result = format.r_scope(scopes=scopes_input)
+    regex = re.compile(result)
+    assert regex.match("(api)")
+    assert regex.match("(client)")
+    assert regex.match("(api, client)")
+    assert regex.match("(api: client)")
+    assert regex.match("(api/client)")
+    assert regex.match("(api-client)")
+    assert not regex.match("(test)")
+    assert not regex.match("(api; client)")
+
+
+def test_r_delim():
+    result = format.r_delim()
+    regex = re.compile(result)
+
+    assert regex.match(":")
+
+
+def test_r_delim__optional_breaking_indicator():
+    result = format.r_delim()
+    regex = re.compile(result)
+
+    assert regex.match("!:")
+
+
+def test_r_subject__starts_with_space():
+    result = format.r_subject()
+    regex = re.compile(result)
+
+    assert not regex.match("something")
+    assert regex.match(" something")
+
+
+def test_r_subject__alphanumeric():
+    result = format.r_subject()
+    regex = re.compile(result)
+
+    assert regex.match(" 50m3t41N6")
+
+
+def test_r_subject__special_chars():
+    result = format.r_subject()
+    regex = re.compile(result)
+
+    assert regex.match(" some-thing")
+    assert regex.match(" some_thing")
+    assert regex.match(" some/thing")
+    assert regex.match(" some thing")
+
+
+def test_r_autosquash_prefixes():
+    result = format.r_autosquash_prefixes()
+    regex = re.compile(result)
+
+    for prefix in format.AUTOSQUASH_PREFIXES:
+        assert regex.match(prefix)
+
+
+def test_conventional_types__default():
+    result = format.conventional_types()
+
+    assert result == format.CONVENTIONAL_TYPES
+
+
+def test_conventional_types__custom():
+    result = format.conventional_types(["custom"])
+
+    assert set(["custom", *format.CONVENTIONAL_TYPES]) == set(result)
+
+
+def test_r_comment_single():
+    regex = re.compile(format.r_comment())
+    assert regex.match("# Some comment")
+    assert not regex.match("Some comment")
+    assert not regex.match(" # Some comment")
+
+
+def test_strip_comments__consecutive():
+    input = """feat(scope): message
+# Please enter the commit message for your changes.
+# These are comments usually added by editors, f.ex. with export EDITOR=vim
+    """
+    result = format.strip_comments(input)
+    assert result.count("\n") == 1
+    assert result.strip() == "feat(scope): message"
+
+
+def test_strip_comments__spaced():
+    input = """feat(scope): message
+# Please enter the commit message for your changes.
+
+# These are comments usually added by editors, f.ex. with export EDITOR=vim
+    """
+    result = format.strip_comments(input)
+    assert result.count("\n") == 2
+    assert result.strip() == "feat(scope): message"
+
+
+def test_r_verbose_commit_ignored__does_not_match_no_verbose():
+    regex = re.compile(format.r_verbose_commit_ignored(), re.DOTALL | re.MULTILINE)
+    input = """feat: some commit message
+# Please enter the commit message for your changes. Lines starting
+# with '#' will be ignored, and an empty message aborts the commit.
+#
+# On branch main
+# Your branch is up to date with 'origin/main'.
+#
+# Changes to be committed:
+#	modified:   README.md
+#
+# Changes not staged for commit:
+#	modified:   README.md
+#
+"""
+
+    assert not regex.search(input)
+
+
+def test_r_verbose_commit_ignored__matches_single_verbose_ignored():
+    regex = re.compile(format.r_verbose_commit_ignored(), re.DOTALL | re.MULTILINE)
+    input = (
+        """feat: some commit message
+# Please enter the commit message for your changes. Lines starting
+# with '#' will be ignored, and an empty message aborts the commit.
+#
+# On branch main
+# Your branch is up to date with 'origin/main'.
+#
+# Changes to be committed:
+#	modified:   README.md
+#
+# Changes not staged for commit:
+#	modified:   README.md
+#
+# ------------------------ >8 ------------------------
+# Do not modify or remove the line above.
+# Everything below it will be ignored.
+diff --git c/README.md i/README.md
+index ea80a93..fe8a527 100644
+--- c/README.md
++++ i/README.md
+@@ -20,3 +20,4 @@ Some hunk header
+ Context 1
+"""
+        + " "  # This is on purpose to preserve the space from overly eager stripping.
+        + """
+ Context 2
++Added line
+"""
+    )
+
+    assert regex.search(input)
+
+
+def test_r_verbose_commit_ignored__matches_double_verbose_ignored():
+    regex = re.compile(format.r_verbose_commit_ignored(), re.DOTALL | re.MULTILINE)
+    input = (
+        """feat: some commit message
+# Please enter the commit message for your changes. Lines starting
+# with '#' will be ignored, and an empty message aborts the commit.
+#
+# On branch main
+# Your branch is up to date with 'origin/main'.
+#
+# Changes to be committed:
+#	modified:   README.md
+#
+# Changes not staged for commit:
+#	modified:   README.md
+#
+# ------------------------ >8 ------------------------
+# Do not modify or remove the line above.
+# Everything below it will be ignored.
+#
+# Changes to be committed:
+diff --git c/README.md i/README.md
+index ea80a93..fe8a527 100644
+--- c/README.md
++++ i/README.md
+@@ -20,3 +20,4 @@ Some staged hunk header
+ Staged Context 1
+"""
+        + " "  # This is on purpose to preserve the space from overly eager stripping.
+        + """
+ Staged Context 2
++Staged added line
+# --------------------------------------------------
+# Changes not staged for commit:
+diff --git i/README.md w/README.md
+index fe8a527..1c00c14 100644
+--- i/README.md
++++ w/README.md
+@@ -10,6 +10,7 @@ Some unstaged hunk header
+ Context 1
+ Context 2
+ Context 3
+-Removed line
++Added line
+"""
+        + " "  # This is on purpose to preserve the space from overly eager stripping.
+        + """
+ Context 4
+"""
+        + " "  # This is on purpose to preserve the space from overly eager stripping.
+        + """
+"""
+    )
+
+    assert regex.search(input)
+
+
+def test_strip_verbose_commit_ignored__does_not_strip_no_verbose():
+    input = """feat: some commit message
+# Please enter the commit message for your changes. Lines starting
+# with '#' will be ignored, and an empty message aborts the commit.
+#
+# On branch main
+# Your branch is up to date with 'origin/main'.
+#
+# Changes to be committed:
+#	modified:   README.md
+#
+# Changes not staged for commit:
+#	modified:   README.md
+#
+"""
+
+    expected = """feat: some commit message
+# Please enter the commit message for your changes. Lines starting
+# with '#' will be ignored, and an empty message aborts the commit.
+#
+# On branch main
+# Your branch is up to date with 'origin/main'.
+#
+# Changes to be committed:
+#	modified:   README.md
+#
+# Changes not staged for commit:
+#	modified:   README.md
+#
+"""
+
+    result = format.strip_verbose_commit_ignored(input)
+    assert result == expected
+
+
+def test_strip_verbose_commit_ignored__strips_single_verbose_ignored():
+    input = (
+        """feat: some commit message
+# Please enter the commit message for your changes. Lines starting
+# with '#' will be ignored, and an empty message aborts the commit.
+#
+# On branch main
+# Your branch is up to date with 'origin/main'.
+#
+# Changes to be committed:
+#	modified:   README.md
+#
+# Changes not staged for commit:
+#	modified:   README.md
+#
+# ------------------------ >8 ------------------------
+# Do not modify or remove the line above.
+# Everything below it will be ignored.
+diff --git c/README.md i/README.md
+index ea80a93..fe8a527 100644
+--- c/README.md
++++ i/README.md
+@@ -20,3 +20,4 @@ Some hunk header
+ Context 1
+"""
+        + " "  # This is on purpose to preserve the space from overly eager stripping.
+        + """
+ Context 2
++Added line
+"""
+    )
+
+    expected = """feat: some commit message
+# Please enter the commit message for your changes. Lines starting
+# with '#' will be ignored, and an empty message aborts the commit.
+#
+# On branch main
+# Your branch is up to date with 'origin/main'.
+#
+# Changes to be committed:
+#	modified:   README.md
+#
+# Changes not staged for commit:
+#	modified:   README.md
+#
+"""
+
+    result = format.strip_verbose_commit_ignored(input)
+    assert result == expected
+
+
+def test_strip_verbose_commit_ignored__strips_double_verbose_ignored():
+    input = (
+        """feat: some commit message
+# Please enter the commit message for your changes. Lines starting
+# with '#' will be ignored, and an empty message aborts the commit.
+#
+# On branch main
+# Your branch is up to date with 'origin/main'.
+#
+# Changes to be committed:
+#	modified:   README.md
+#
+# Changes not staged for commit:
+#	modified:   README.md
+#
+# ------------------------ >8 ------------------------
+# Do not modify or remove the line above.
+# Everything below it will be ignored.
+#
+# Changes to be committed:
+diff --git c/README.md i/README.md
+index ea80a93..fe8a527 100644
+--- c/README.md
++++ i/README.md
+@@ -20,3 +20,4 @@ Some staged hunk header
+ Staged Context 1
+"""
+        + " "  # This is on purpose to preserve the space from overly eager stripping.
+        + """
+ Staged Context 2
++Staged added line
+# --------------------------------------------------
+# Changes not staged for commit:
+diff --git i/README.md w/README.md
+index fe8a527..1c00c14 100644
+--- i/README.md
++++ w/README.md
+@@ -10,6 +10,7 @@ Some unstaged hunk header
+ Context 1
+ Context 2
+ Context 3
+-Removed line
++Added line
+"""
+        + " "  # This is on purpose to preserve the space from overly eager stripping.
+        + """
+ Context 4
+"""
+        + " "  # This is on purpose to preserve the space from overly eager stripping.
+        + """
+"""
+    )
+
+    expected = """feat: some commit message
+# Please enter the commit message for your changes. Lines starting
+# with '#' will be ignored, and an empty message aborts the commit.
+#
+# On branch main
+# Your branch is up to date with 'origin/main'.
+#
+# Changes to be committed:
+#	modified:   README.md
+#
+# Changes not staged for commit:
+#	modified:   README.md
+#
+"""
+
+    result = format.strip_verbose_commit_ignored(input)
+    assert result == expected
+
+
+@pytest.mark.parametrize("type", format.DEFAULT_TYPES)
+def test_is_conventional__default_type(type):
+    input = f"{type}: message"
+
+    assert format.is_conventional(input)
+
+
+@pytest.mark.parametrize("type", format.CONVENTIONAL_TYPES)
+def test_is_conventional__conventional_type(type):
+    input = f"{type}: message"
+
+    assert format.is_conventional(input)
+
+
+@pytest.mark.parametrize("type", CUSTOM_TYPES)
+def test_is_conventional__custom_type(type):
+    input = f"{type}: message"
+
+    assert format.is_conventional(input, CUSTOM_TYPES)
+
+
+@pytest.mark.parametrize("type", format.CONVENTIONAL_TYPES)
+def test_is_conventional__conventional_custom_type(type):
+    input = f"{type}: message"
+
+    assert format.is_conventional(input, CUSTOM_TYPES)
+
+
+def test_is_conventional__breaking_change():
+    input = "fix!: message"
+
+    assert format.is_conventional(input)
+
+
+def test_is_conventional__with_scope():
+    input = "feat(scope): message"
+
+    assert format.is_conventional(input)
+
+
+def test_is_conventional__body_multiline_body_bad_type():
+    input = """wrong: message
+
+    more_message
+    """
+
+    assert not format.is_conventional(input)
+
+
+def test_is_conventional__bad_body_multiline():
+    input = """feat(scope): message
+    more message
+    """
+
+    assert not format.is_conventional(input)
+
+
+def test_is_conventional__body_multiline():
+    input = """feat(scope): message
+
+    more message
+    """
+
+    assert format.is_conventional(input)
+
+
+def test_is_conventional__bad_body_multiline_paragraphs():
+    input = """feat(scope): message
+    more message
+
+    more body message
+    """
+
+    assert not format.is_conventional(input)
+
+
+def test_is_conventional__comment():
+    input = """feat(scope): message
+# Please enter the commit message for your changes.
+# These are comments usually added by editors, f.ex. with export EDITOR=vim
+"""
+    assert format.is_conventional(input)
+
+
+@pytest.mark.parametrize("char", ['"', "'", "`", "#", "&"])
+def test_is_conventional__body_special_char(char):
+    input = f"feat: message with {char}"
+
+    assert format.is_conventional(input)
+
+
+def test_is_conventional__wrong_type():
+    input = "wrong: message"
+
+    assert not format.is_conventional(input)
+
+
+def test_is_conventional__scope_special_chars():
+    input = "feat(%&*@()): message"
+
+    assert not format.is_conventional(input)
+
+
+def test_is_conventional__space_scope():
+    input = "feat (scope): message"
+
+    assert not format.is_conventional(input)
+
+
+def test_is_conventional__scope_space():
+    input = "feat(scope) : message"
+
+    assert not format.is_conventional(input)
+
+
+def test_is_conventional__scope_not_optional():
+    input = "feat: message"
+
+    assert not format.is_conventional(input, optional_scope=False)
+
+
+def test_is_conventional__scope_not_optional_empty_parenthesis():
+    input = "feat(): message"
+
+    assert not format.is_conventional(input, optional_scope=False)
+
+
+def test_is_conventional__missing_delimiter():
+    input = "feat message"
+
+    assert not format.is_conventional(input)
+
+
+@pytest.mark.parametrize(
+    "input,has_prefix",
+    [
+        ("amend! ", True),
+        ("fixup! ", True),
+        ("squash! ", True),
+        ("squash! whatever .. $12 #", True),
+        ("squash!", False),
+        (" squash! ", False),
+        ("squash!:", False),
+        ("feat(foo):", False),
+    ],
+)
+def test_has_autosquash_prefix(input, has_prefix):
+    assert format.has_autosquash_prefix(input) == has_prefix

{conventional_pre_commit-3.2.0 → conventional_pre_commit-3.4.0}/tests/test_hook.py

@@ -142,6 +142,16 @@ def test_subprocess_success__conventional_with_scope(cmd, conventional_commit_wi
     assert result == RESULT_SUCCESS
 
 
+def test_subprocess_success__conventional_with_multiple_scopes(cmd, conventional_commit_with_multiple_scopes_path):
+    result = subprocess.call((cmd, "--scopes", "api,client", conventional_commit_with_multiple_scopes_path))
+    assert result == RESULT_SUCCESS
+
+
+def test_subprocess_fail__conventional_with_multiple_scopes(cmd, conventional_commit_with_multiple_scopes_path):
+    result = subprocess.call((cmd, "--scopes", "api", conventional_commit_with_multiple_scopes_path))
+    assert result == RESULT_FAIL
+
+
 def test_subprocess_success__fixup_commit(cmd, fixup_commit_path):
     result = subprocess.call((cmd, fixup_commit_path))
 

conventional_pre_commit-3.2.0/tests/test_format.py

@@ -1,368 +0,0 @@
-import re
-
-import pytest
-
-from conventional_pre_commit import format
-
-CUSTOM_TYPES = ["one", "two"]
-
-
-def test_r_types():
-    result = format.r_types(CUSTOM_TYPES)
-    regex = re.compile(result)
-
-    assert regex.match("one")
-    assert regex.match("two")
-
-
-def test_r_scope__optional():
-    result = format.r_scope()
-    regex = re.compile(result)
-
-    assert regex.match("")
-
-
-def test_r_scope__not_optional():
-    result = format.r_scope(optional=False)
-    regex = re.compile(result)
-
-    # Assert not optional anymore
-    assert not regex.match("")
-
-
-def test_r_scope__parenthesis_required():
-    result = format.r_scope()
-    regex = re.compile(result)
-
-    # without parens produces a match object with a 0 span
-    # since the (scope) is optional
-    without_parens = regex.match("something")
-    assert without_parens.span() == (0, 0)
-
-    # with parens produces a match object with a span
-    # that covers the input string
-    with_parens = regex.match("(something)")
-    assert with_parens.span() == (0, 11)
-
-
-def test_r_scope__alphanumeric():
-    result = format.r_scope()
-    regex = re.compile(result)
-
-    assert regex.match("(50m3t41N6)")
-
-
-def test_r_scope__special_chars():
-    result = format.r_scope()
-    regex = re.compile(result)
-
-    assert regex.match("(some-thing)")
-    assert regex.match("(some_thing)")
-    assert regex.match("(some/thing)")
-    assert regex.match("(some thing)")
-    assert regex.match("(some:thing)")
-    assert regex.match("(some,thing)")
-
-
-def test_r_delim():
-    result = format.r_delim()
-    regex = re.compile(result)
-
-    assert regex.match(":")
-
-
-def test_r_delim__optional_breaking_indicator():
-    result = format.r_delim()
-    regex = re.compile(result)
-
-    assert regex.match("!:")
-
-
-def test_r_subject__starts_with_space():
-    result = format.r_subject()
-    regex = re.compile(result)
-
-    assert not regex.match("something")
-    assert regex.match(" something")
-
-
-def test_r_subject__alphanumeric():
-    result = format.r_subject()
-    regex = re.compile(result)
-
-    assert regex.match(" 50m3t41N6")
-
-
-def test_r_subject__special_chars():
-    result = format.r_subject()
-    regex = re.compile(result)
-
-    assert regex.match(" some-thing")
-    assert regex.match(" some_thing")
-    assert regex.match(" some/thing")
-    assert regex.match(" some thing")
-
-
-def test_r_autosquash_prefixes():
-    result = format.r_autosquash_prefixes()
-    regex = re.compile(result)
-
-    for prefix in format.AUTOSQUASH_PREFIXES:
-        assert regex.match(prefix)
-
-
-def test_conventional_types__default():
-    result = format.conventional_types()
-
-    assert result == format.CONVENTIONAL_TYPES
-
-
-def test_conventional_types__custom():
-    result = format.conventional_types(["custom"])
-
-    assert set(["custom", *format.CONVENTIONAL_TYPES]) == set(result)
-
-
-def test_r_comment_single():
-    regex = re.compile(format.r_comment())
-    assert regex.match("# Some comment")
-    assert not regex.match("Some comment")
-    assert not regex.match(" # Some comment")
-
-
-def test_strip_comments__consecutive():
-    input = """feat(scope): message
-# Please enter the commit message for your changes.
-# These are comments usually added by editors, f.ex. with export EDITOR=vim
-    """
-    result = format.strip_comments(input)
-    assert result.count("\n") == 1
-    assert result.strip() == "feat(scope): message"
-
-
-def test_strip_comments__spaced():
-    input = """feat(scope): message
-# Please enter the commit message for your changes.
-
-# These are comments usually added by editors, f.ex. with export EDITOR=vim
-    """
-    result = format.strip_comments(input)
-    assert result.count("\n") == 2
-    assert result.strip() == "feat(scope): message"
-
-
-def test_r_verbose_diff__has_diff():
-    regex = re.compile(format.r_verbose_diff(), re.MULTILINE)
-    input = """# ----------- >8 -----------
-# Some comment
-# Some comment
-diff --git a/file b/file
-"""
-
-    assert regex.match(input)
-
-
-def test_r_verbose_diff__no_diff():
-    regex = re.compile(format.r_verbose_diff(), re.MULTILINE)
-    input = """# ----------- >8 -----------
-# Some comment
-# Some comment
-"""
-
-    assert not regex.match(input)
-
-
-def test_r_verbose_diff__no_extra_comments():
-    regex = re.compile(format.r_verbose_diff(), re.MULTILINE)
-    input = """# ----------- >8 -----------
-diff --git a/file b/file
-"""
-
-    assert not regex.match(input)
-
-
-def test_strip_verbose_diff__has_diff():
-    input = """feat(scope): message
-# Please enter the commit message for your changes.
-
-# These are comments usually added by editors, f.ex. with export EDITOR=vim
-# ----------- >8 -----------
-# Some comment
-# Some comment
-diff --git a/file b/file
-"""
-
-    result = format.strip_verbose_diff(input)
-    assert result.count("\n") == 4
-    assert (
-        result
-        == """feat(scope): message
-# Please enter the commit message for your changes.
-
-# These are comments usually added by editors, f.ex. with export EDITOR=vim
-"""
-    )
-
-
-def test_strip_verbose_diff__no_diff():
-    input = """feat(scope): message
-# Please enter the commit message for your changes.
-
-# These are comments usually added by editors, f.ex. with export EDITOR=vim
-# ----------- >8 -----------
-# Some comment
-# Some comment
-"""
-
-    result = format.strip_verbose_diff(input)
-    assert result == input
-
-
-@pytest.mark.parametrize("type", format.DEFAULT_TYPES)
-def test_is_conventional__default_type(type):
-    input = f"{type}: message"
-
-    assert format.is_conventional(input)
-
-
-@pytest.mark.parametrize("type", format.CONVENTIONAL_TYPES)
-def test_is_conventional__conventional_type(type):
-    input = f"{type}: message"
-
-    assert format.is_conventional(input)
-
-
-@pytest.mark.parametrize("type", CUSTOM_TYPES)
-def test_is_conventional__custom_type(type):
-    input = f"{type}: message"
-
-    assert format.is_conventional(input, CUSTOM_TYPES)
-
-
-@pytest.mark.parametrize("type", format.CONVENTIONAL_TYPES)
-def test_is_conventional__conventional_custom_type(type):
-    input = f"{type}: message"
-
-    assert format.is_conventional(input, CUSTOM_TYPES)
-
-
-def test_is_conventional__breaking_change():
-    input = "fix!: message"
-
-    assert format.is_conventional(input)
-
-
-def test_is_conventional__with_scope():
-    input = "feat(scope): message"
-
-    assert format.is_conventional(input)
-
-
-def test_is_conventional__body_multiline_body_bad_type():
-    input = """wrong: message
-
-    more_message
-    """
-
-    assert not format.is_conventional(input)
-
-
-def test_is_conventional__bad_body_multiline():
-    input = """feat(scope): message
-    more message
-    """
-
-    assert not format.is_conventional(input)
-
-
-def test_is_conventional__body_multiline():
-    input = """feat(scope): message
-
-    more message
-    """
-
-    assert format.is_conventional(input)
-
-
-def test_is_conventional__bad_body_multiline_paragraphs():
-    input = """feat(scope): message
-    more message
-
-    more body message
-    """
-
-    assert not format.is_conventional(input)
-
-
-def test_is_conventional__comment():
-    input = """feat(scope): message
-# Please enter the commit message for your changes.
-# These are comments usually added by editors, f.ex. with export EDITOR=vim
-"""
-    assert format.is_conventional(input)
-
-
-@pytest.mark.parametrize("char", ['"', "'", "`", "#", "&"])
-def test_is_conventional__body_special_char(char):
-    input = f"feat: message with {char}"
-
-    assert format.is_conventional(input)
-
-
-def test_is_conventional__wrong_type():
-    input = "wrong: message"
-
-    assert not format.is_conventional(input)
-
-
-def test_is_conventional__scope_special_chars():
-    input = "feat(%&*@()): message"
-
-    assert not format.is_conventional(input)
-
-
-def test_is_conventional__space_scope():
-    input = "feat (scope): message"
-
-    assert not format.is_conventional(input)
-
-
-def test_is_conventional__scope_space():
-    input = "feat(scope) : message"
-
-    assert not format.is_conventional(input)
-
-
-def test_is_conventional__scope_not_optional():
-    input = "feat: message"
-
-    assert not format.is_conventional(input, optional_scope=False)
-
-
-def test_is_conventional__scope_not_optional_empty_parenthesis():
-    input = "feat(): message"
-
-    assert not format.is_conventional(input, optional_scope=False)
-
-
-def test_is_conventional__missing_delimiter():
-    input = "feat message"
-
-    assert not format.is_conventional(input)
-
-
-@pytest.mark.parametrize(
-    "input,has_prefix",
-    [
-        ("amend! ", True),
-        ("fixup! ", True),
-        ("squash! ", True),
-        ("squash! whatever .. $12 #", True),
-        ("squash!", False),
-        (" squash! ", False),
-        ("squash!:", False),
-        ("feat(foo):", False),
-    ],
-)
-def test_has_autosquash_prefix(input, has_prefix):
-    assert format.has_autosquash_prefix(input) == has_prefix