feat(changelog): adds a tag parser to filter tags (--tag-parser; tag_parser)

The git tag parser is used to filter out undesired git tags from changelog. regex default is .* (all).

Author: bhelgs

commitizen/changelog.py

@@ -29,7 +29,7 @@
 import re
 from collections import OrderedDict, defaultdict
 from datetime import date
-from typing import Callable, Dict, Iterable, List, Optional, Tuple
+from typing import Callable, Dict, Iterable, List, Optional, Pattern, Tuple
 
 from jinja2 import Environment, PackageLoader
 
@@ -74,6 +74,7 @@ def generate_tree_from_commits(
     unreleased_version: Optional[str] = None,
     change_type_map: Optional[Dict[str, str]] = None,
     changelog_message_builder_hook: Optional[Callable] = None,
+    tag_pattern: Pattern = re.compile(".*"),
 ) -> Iterable[Dict]:
     pat = re.compile(changelog_pattern)
     map_pat = re.compile(commit_parser, re.MULTILINE)
@@ -87,24 +88,35 @@ def generate_tree_from_commits(
     current_tag_date: str = ""
     if unreleased_version is not None:
         current_tag_date = date.today().isoformat()
-    if current_tag is not None and current_tag.name:
+    if (
+        current_tag is not None
+        and current_tag.name
+        and tag_pattern.fullmatch(current_tag.name)
+    ):
         current_tag_name = current_tag.name
         current_tag_date = current_tag.date
 
     changes: Dict = defaultdict(list)
     used_tags: List = [current_tag]
     for commit in commits:
-        commit_tag = get_commit_tag(commit, tags)
 
-        if commit_tag is not None and commit_tag not in used_tags:
+        # determine if we found a new matching tag
+        commit_tag = get_commit_tag(commit, tags)
+        is_tag_match = False
+        if commit_tag:
+            matches = tag_pattern.fullmatch(commit_tag.name)
+            if matches and (commit_tag not in used_tags):
+                is_tag_match = True
+
+        # new node if we have a tag match
+        if is_tag_match:
             used_tags.append(commit_tag)
             yield {
                 "version": current_tag_name,
                 "date": current_tag_date,
                 "changes": changes,
             }
-            # TODO: Check if tag matches the version pattern, otherwise skip it.
-            # This in order to prevent tags that are not versions.
+            assert commit_tag is not None  # for mypy
             current_tag_name = commit_tag.name
             current_tag_date = commit_tag.date
             changes = defaultdict(list)

commitizen/cli.py

@@ -220,6 +220,13 @@
                             "If not set, it will generate changelog from the start"
                         ),
                     },
+                    {
+                        "name": "--tag-parser",
+                        "help": (
+                            "regex match for tags represented "
+                            "within the changelog. default: '.*'"
+                        ),
+                    },
                 ],
             },
             {

commitizen/commands/changelog.py

@@ -1,4 +1,5 @@
 import os.path
+import re
 from difflib import SequenceMatcher
 from operator import itemgetter
 from typing import Callable, Dict, List, Optional
@@ -51,6 +52,10 @@ def __init__(self, config: BaseConfig, args):
         self.tag_format = args.get("tag_format") or self.config.settings.get(
             "tag_format"
         )
+        tag_parser = args.get("tag_parser")
+        if tag_parser is None:
+            tag_parser = self.config.settings.get("tag_parser", r".*")
+        self.tag_pattern = re.compile(tag_parser)
 
     def _find_incremental_rev(self, latest_version: str, tags: List[GitTag]) -> str:
         """Try to find the 'start_rev'.
@@ -154,6 +159,7 @@ def __call__(self):
             unreleased_version,
             change_type_map=change_type_map,
             changelog_message_builder_hook=changelog_message_builder_hook,
+            tag_pattern=self.tag_pattern,
         )
         if self.change_type_order:
             tree = changelog.order_changelog_tree(tree, self.change_type_order)

commitizen/cz/customize/customize.py

@@ -50,6 +50,10 @@ def __init__(self, config: BaseConfig):
         if change_type_map:
             self.change_type_map = change_type_map
 
+        tag_parser = self.custom_settings.get("tag_pattern")
+        if tag_parser:
+            self.tag_parser = str(tag_parser)
+
     def questions(self) -> Questions:
         return self.custom_settings.get("questions", [{}])
 

docs/changelog.md

@@ -161,6 +161,24 @@ cz changelog --start-rev="v0.2.0"
 changelog_start_rev = "v0.2.0"
 ```
 
+### `tag-parser`
+
+This value can be set in the `toml` file with the key `tag_parser` under `tools.commitizen`
+
+The default the changelog will capture all git tags (e.g. regex `.*`).
+The user may specify a regex pattern of their own display only
+specific tags within the changelog.
+
+```bash
+cz changelog --tag-parser=".*"
+```
+
+```toml
+[tools.commitizen]
+# ...
+tag_parser = "v[0-9]*\\.[0-9]*\\.[0-9]*"
+```
+
 ## Hooks
 
 Supported hook methods:

docs/config.md

@@ -128,6 +128,7 @@ commitizen:
 | `version`                  | `str`  | `None`                      | Current version. Example: "0.1.2"                                                                                                                                                               |
 | `version_files`            | `list` | `[ ]`                       | Files were the version will be updated. A pattern to match a line, can also be specified, separated by `:` [See more][version_files]                                                            |
 | `tag_format`               | `str`  | `None`                      | Format for the git tag, useful for old projects, that use a convention like `"v1.2.1"`. [See more][tag_format]                                                                                  |
+| `tag_parser `              | `str`  | `.*`                        | Generate changelog using only tags matching the regex pattern (e.g. `"v([0-9.])*"`). [See more][tag_parser]                                                                                  |
 | `update_changelog_on_bump` | `bool` | `false`                     | Create changelog when running `cz bump`                                                                                                                                                         |
 | `annotated_tag`            | `bool` | `false`                     | Use annotated tags instead of lightweight tags. [See difference][annotated-tags-vs-lightweight]                                                                                                 |
 | `bump_message`             | `str`  | `None`                      | Create custom commit message, useful to skip ci. [See more][bump_message]                                                                                                                       |
@@ -142,6 +143,7 @@ commitizen:
 [version_files]: bump.md#version_files
 [tag_format]: bump.md#tag_format
 [bump_message]: bump.md#bump_message
+[tag_parser]: changelog.md#tag_parser
 [allow_abort]: check.md#allow-abort
 [additional-features]: https://github.com/tmbo/questionary#additional-features
 [customization]: customization.md

tests/commands/test_changelog_command.py

@@ -872,3 +872,50 @@ def test_changelog_from_rev_latest_version_dry_run(
     out, _ = capsys.readouterr()
 
     file_regression.check(out, extension=".md")
+
+
+@pytest.mark.usefixtures("tmp_commitizen_project")
+@pytest.mark.freeze_time("2022-02-13")
+@pytest.mark.parametrize(
+    "cli_args, line, filtered",
+    [
+        ([], r'tag_parser = "v[0-9]*\\.[0-9]*\\.[0-9]*"', True),  # version filter
+        (["--tag-parser", r"v[0-9]*\.[0-9]*\.[0-9]*"], "", True),  # cli arg filter
+        ([], "", False),  # default tag_parser
+    ],
+)
+def test_changelog_tag_parser_config(
+    mocker, config_path, changelog_path, cli_args, line, filtered
+):
+    mocker.patch("commitizen.git.GitTag.date", "2022-02-13")
+
+    with open(config_path, "a") as f:
+        # f.write('tag_format = "$version"\n')
+        f.write(line)
+
+    # create a valid start tag
+    create_file_and_commit("feat: initial")
+    git.tag("v1.0.0")
+
+    # create a tag for this test
+    create_file_and_commit("feat: add new")
+    git.tag("v1.1.0-beta")
+
+    # create a valid end tag
+    create_file_and_commit("feat: add more")
+    git.tag("v1.1.0")
+
+    # call CLI
+    command = ["cz", "changelog"]
+    command.extend(cli_args)
+    mocker.patch.object(sys, "argv", command)
+    cli.main()
+
+    # open CLI output
+    with open(changelog_path, "r") as f:
+        out = f.read()
+
+    # test if cli is handling tag_format
+    assert "v1.0.0" in out
+    assert ("v1.1.0-beta" in out) is not filtered
+    assert "v1.1.0" in out

tests/test_changelog.py

@@ -1,3 +1,6 @@
+import re
+from typing import Dict, Iterable, List, Pattern
+
 import pytest
 
 from commitizen import changelog, defaults, git
@@ -790,6 +793,26 @@ def test_get_commit_tag_is_None(gitcommits, tags):
 )
 
 
+def _filter_tree(tag_pattern: Pattern, tree: Iterable[Dict]) -> List[Dict[str, str]]:
+    """filters the tree. commits with invalid tags are kept within the current node"""
+
+    current = None
+    out = []
+    for node in tree:
+        if not current or tag_pattern.fullmatch(node["version"]) or not out:
+            current = node.copy()
+            out.append(current)
+        else:
+            changes = current["changes"]
+            for key, value in node["changes"].items():
+                if key in changes:
+                    changes[key].extend(value)
+                else:
+                    changes[key] = value
+
+    return out
+
+
 def test_generate_tree_from_commits(gitcommits, tags):
     parser = defaults.commit_parser
     changelog_pattern = defaults.bump_pattern
@@ -800,6 +823,23 @@ def test_generate_tree_from_commits(gitcommits, tags):
     assert tuple(tree) == COMMITS_TREE
 
 
+def test_generate_tree_from_commits_release_filter(gitcommits, tags):
+    parser = defaults.commit_parser
+    changelog_pattern = defaults.bump_pattern
+
+    # match release tags only
+    tag_parser = r"v([0-9]+)\.([0-9]+)\.([0-9]+)"
+    tag_pattern = re.compile(tag_parser)
+
+    tree = changelog.generate_tree_from_commits(
+        gitcommits, tags, parser, changelog_pattern, tag_pattern=tag_pattern
+    )
+
+    expected_tree = _filter_tree(tag_pattern, COMMITS_TREE)
+
+    assert list(tree) == expected_tree
+
+
 @pytest.mark.parametrize(
     "change_type_order, expected_reordering",
     (