refactor(changelog): use functions from changelog.py

Author: woile

CHANGELOG.md

@@ -13,17 +13,31 @@
 1. get commits between versions
 2. filter commits with the current cz rules
 3. parse commit information
-4. generate tree
+4. yield tree nodes
+5. format tree nodes
+6. produce full tree
+7. generate changelog
 
-Options:
+Extra:
 - Generate full or partial changelog
+- Include in tree from file all the extra comments added manually
 """
 import re
-from typing import Dict, Generator, Iterable, List
+from collections import OrderedDict, defaultdict
+from typing import Dict, Generator, Iterable, List, Optional, Type
+
+import pkg_resources
+from jinja2 import Template
+from typing_extensions import Protocol
+
+from commitizen import defaults
+from commitizen.git import GitCommit, GitObject, GitProtocol, GitTag
 
 MD_VERSION_RE = r"^##\s(?P<version>[a-zA-Z0-9.+]+)\s?\(?(?P<date>[0-9-]+)?\)?"
 MD_CHANGE_TYPE_RE = r"^###\s(?P<change_type>[a-zA-Z0-9.+\s]+)"
-MD_MESSAGE_RE = r"^-\s(\*{2}(?P<scope>[a-zA-Z0-9]+)\*{2}:\s)?(?P<message>.+)"
+MD_MESSAGE_RE = (
+    r"^-\s(\*{2}(?P<scope>[a-zA-Z0-9]+)\*{2}:\s)?(?P<message>.+)(?P<breaking>!)?"
+)
 md_version_c = re.compile(MD_VERSION_RE)
 md_change_type_c = re.compile(MD_CHANGE_TYPE_RE)
 md_message_c = re.compile(MD_MESSAGE_RE)
@@ -50,11 +64,11 @@ def find_version_blocks(filepath: str) -> Generator:
     ```
     ## 1.2.1 (2019-07-20)
 
-    ## Bug fixes
+    ### Fix
 
     - username validation not working
 
-    ## Features
+    ### Feat
 
     - new login system
 
@@ -98,6 +112,8 @@ def parse_md_message(md_message: str) -> Dict:
 
 
 def transform_change_type(change_type: str) -> str:
+    # TODO: Use again to parse, for this we have to wait until the maps get
+    # defined again.
     _change_type_lower = change_type.lower()
     for match_value, output in CATEGORIES:
         if re.search(match_value, _change_type_lower):
@@ -107,22 +123,27 @@ def transform_change_type(change_type: str) -> str:
 
 
 def generate_block_tree(block: List[str]) -> Dict:
-    tree: Dict = {"commits": []}
+    # tree: Dict = {"commits": []}
+    changes: Dict = defaultdict(list)
+    tree: Dict = {"changes": changes}
+
     change_type = None
     for line in block:
         if line.startswith("## "):
+            # version identified
             change_type = None
             tree = {**tree, **parse_md_version(line)}
         elif line.startswith("### "):
+            # change_type identified
             result = parse_md_change_type(line)
             if not result:
                 continue
-            change_type = transform_change_type(result.get("change_type", ""))
+            change_type = result.get("change_type", "").lower()
 
         elif line.startswith("- "):
+            # message identified
             commit = parse_md_message(line)
-            commit["change_type"] = change_type
-            tree["commits"].append(commit)
+            changes[change_type].append(commit)
         else:
             print("it's something else: ", line)
     return tree
@@ -131,3 +152,82 @@ def generate_block_tree(block: List[str]) -> Dict:
 def generate_full_tree(blocks: Iterable) -> Iterable[Dict]:
     for block in blocks:
         yield generate_block_tree(block)
+
+
+def get_commit_tag(commit: GitProtocol, tags: List[GitProtocol]) -> Optional[GitTag]:
+    """"""
+    try:
+        tag_index = tags.index(commit)
+    except ValueError:
+        return None
+    else:
+        tag = tags[tag_index]
+        # if hasattr(tag, "name"):
+        return tag
+
+
+def generate_tree_from_commits(
+    commits: List[GitCommit],
+    tags: List[GitTag],
+    commit_parser: str,
+    changelog_pattern: str = defaults.bump_pattern,
+) -> Iterable[Dict]:
+    pat = re.compile(changelog_pattern)
+    map_pat = re.compile(commit_parser)
+    # Check if the latest commit is not tagged
+    latest_commit = commits[0]
+    current_tag: Optional[GitTag] = get_commit_tag(latest_commit, tags)
+
+    current_tag_name: str = "Unreleased"
+    current_tag_date: str = ""
+    if current_tag is not None and 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:
+            used_tags.append(commit_tag)
+            yield {
+                "version": current_tag_name,
+                "date": current_tag_date,
+                "changes": changes,
+            }
+            # TODO: Check if tag matches the version pattern, otherwie skip it.
+            # This in order to prevent tags that are not versions.
+            current_tag_name = commit_tag.name
+            current_tag_date = commit_tag.date
+            changes = defaultdict(list)
+
+        matches = pat.match(commit.message)
+        if not matches:
+            continue
+
+        message = map_pat.match(commit.message)
+        message_body = map_pat.match(commit.body)
+        if message:
+            parsed_message: Dict = message.groupdict()
+            change_type = parsed_message.pop("change_type")
+            changes[change_type].append(parsed_message)
+        if message_body:
+            parsed_message_body: Dict = message_body.groupdict()
+            change_type = parsed_message_body.pop("change_type")
+            changes[change_type].append(parsed_message_body)
+
+    yield {
+        "version": current_tag_name,
+        "date": current_tag_date,
+        "changes": changes,
+    }
+
+
+def render_changelog(tree: Iterable) -> str:
+    template_file = pkg_resources.resource_string(
+        __name__, "templates/keep_a_changelog_template.j2"
+    ).decode("utf-8")
+    jinja_template = Template(template_file, trim_blocks=True)
+    changelog: str = jinja_template.render(tree=tree)
+    return changelog

commitizen/changelog.py

@@ -4,9 +4,9 @@
 import pkg_resources
 from jinja2 import Template
 
-from commitizen import factory, git, out
+from commitizen import factory, git, out, changelog
 from commitizen.config import BaseConfig
-from commitizen.error_codes import NO_COMMITS_FOUND, NO_PATTERN_MAP
+from commitizen.error_codes import NO_COMMITS_FOUND, NO_PATTERN_MAP, TAG_FAILED
 
 
 class Changelog:
@@ -21,59 +21,68 @@ def __init__(self, config: BaseConfig, args):
         self.start_rev = args["start_rev"]
 
     def __call__(self):
-        changelog_map = self.cz.changelog_map
+        # changelog_map = self.cz.changelog_map
+        commit_parser = self.cz.commit_parser
         changelog_pattern = self.cz.changelog_pattern
-        if not changelog_map or not changelog_pattern:
+
+        if not changelog_pattern or not commit_parser:
             out.error(
                 f"'{self.config.settings['name']}' rule does not support changelog"
             )
             raise SystemExit(NO_PATTERN_MAP)
-
-        pat = re.compile(changelog_pattern)
+        # pat = re.compile(changelog_pattern)
 
         commits = git.get_commits(start=self.start_rev)
         if not commits:
             out.error("No commits found")
             raise SystemExit(NO_COMMITS_FOUND)
 
-        tag_map = {tag.rev: tag.name for tag in git.get_tags()}
-
-        entries = OrderedDict()
-        # The latest commit is not tagged
-        latest_commit = commits[0]
-        if latest_commit.rev not in tag_map:
-            current_key = "Unreleased"
-            entries[current_key] = OrderedDict(
-                {value: [] for value in changelog_map.values()}
-            )
-        else:
-            current_key = tag_map[latest_commit.rev]
-
-        for commit in commits:
-            if commit.rev in tag_map:
-                current_key = tag_map[commit.rev]
-                entries[current_key] = OrderedDict(
-                    {value: [] for value in changelog_map.values()}
-                )
-
-            matches = pat.match(commit.message)
-            if not matches:
-                continue
-
-            processed_commit = self.cz.process_commit(commit.message)
-            for group_name, commit_type in changelog_map.items():
-                if matches.group(group_name):
-                    entries[current_key][commit_type].append(processed_commit)
-                    break
-
-        template_file = pkg_resources.resource_string(
-            __name__, "../templates/keep_a_changelog_template.j2"
-        ).decode("utf-8")
-        jinja_template = Template(template_file)
-        changelog_str = jinja_template.render(entries=entries)
+        tags = git.get_tags()
+        if not tags:
+            tags = []
+
+        tree = changelog.generate_tree_from_commits(
+            commits, tags, commit_parser, changelog_pattern
+        )
+        changelog_out = changelog.render_changelog(tree)
+        # tag_map = {tag.rev: tag.name for tag in git.get_tags()}
+
+        # entries = OrderedDict()
+        # # The latest commit is not tagged
+        # latest_commit = commits[0]
+        # if latest_commit.rev not in tag_map:
+        #     current_key = "Unreleased"
+        #     entries[current_key] = OrderedDict(
+        #         {value: [] for value in changelog_map.values()}
+        #     )
+        # else:
+        #     current_key = tag_map[latest_commit.rev]
+
+        # for commit in commits:
+        #     if commit.rev in tag_map:
+        #         current_key = tag_map[commit.rev]
+        #         entries[current_key] = OrderedDict(
+        #             {value: [] for value in changelog_map.values()}
+        #         )
+
+        #     matches = pat.match(commit.message)
+        #     if not matches:
+        #         continue
+
+        #     processed_commit = self.cz.process_commit(commit.message)
+        #     for group_name, commit_type in changelog_map.items():
+        #         if matches.group(group_name):
+        #             entries[current_key][commit_type].append(processed_commit)
+        #             break
+
+        # template_file = pkg_resources.resource_string(
+        #     __name__, "../templates/keep_a_changelog_template.j2"
+        # ).decode("utf-8")
+        # jinja_template = Template(template_file)
+        # changelog_str = jinja_template.render(entries=entries)
         if self.dry_run:
-            out.write(changelog_str)
+            out.write(changelog_out)
             raise SystemExit(0)
 
         with open(self.file_name, "w") as changelog_file:
-            changelog_file.write(changelog_str)
+            changelog_file.write(changelog_out)

commitizen/commands/changelog.py

@@ -23,6 +23,7 @@ class BaseCommitizen(metaclass=ABCMeta):
         ("text", ""),
         ("disabled", "fg:#858585 italic"),
     ]
+    commit_parser: Optional[str] = None
 
     def __init__(self, config: BaseConfig):
         self.config = config

commitizen/cz/base.py

@@ -1,6 +1,5 @@
 import os
 import re
-from collections import OrderedDict
 from typing import Any, Dict, List
 
 from commitizen import defaults
@@ -31,10 +30,8 @@ def parse_subject(text):
 class ConventionalCommitsCz(BaseCommitizen):
     bump_pattern = defaults.bump_pattern
     bump_map = defaults.bump_map
-    changelog_pattern = (
-        r"(?P<break>.*\n\nBREAKING CHANGE)|(?P<feat>^feat)|(?P<fix>^fix)"
-    )
-    changelog_map = OrderedDict({"break": "breaking", "feat": "feat", "fix": "fix"})
+    commit_parser = defaults.commit_parser
+    changelog_pattern = defaults.bump_pattern
 
     def questions(self) -> List[Dict[str, Any]]:
         questions: List[Dict[str, Any]] = [
@@ -194,5 +191,5 @@ def process_commit(self, commit: str) -> str:
         pat = re.compile(self.schema_pattern())
         m = re.match(pat, commit)
         if m is None:
-            return ''
+            return ""
         return m.group(3).strip()

commitizen/cz/conventional_commits/conventional_commits.py

@@ -32,3 +32,5 @@
     )
 )
 bump_message = "bump: version $current_version → $new_version"
+
+commit_parser = r"^(?P<change_type>feat|fix|refactor|perf|BREAKING CHANGE)(?:\((?P<scope>[^()\r\n]*)\)|\()?(?P<breaking>!)?:\s(?P<message>.*)?"  # noqa

commitizen/defaults.py

@@ -2,13 +2,20 @@
 from pathlib import Path
 from tempfile import NamedTemporaryFile
 from typing import List, Optional
-
+from typing_extensions import Protocol
 from commitizen import cmd
 
 
+class GitProtocol(Protocol):
+    rev: str
+    name: str
+
+
 class GitObject:
-    def __eq__(self, other):
-        if not isinstance(other, GitObject):
+    rev: str
+
+    def __eq__(self, other) -> bool:
+        if not hasattr(other, "rev"):
             return False
         return self.rev == other.rev
 
@@ -34,7 +41,7 @@ def __init__(self, name, rev, date):
         self.date = date.strip()
 
     def __repr__(self):
-        return f"{self.name} ({self.rev})"
+        return f"GitTag('{self.name}', '{self.rev}', '{self.date}')"
 
 
 def tag(tag: str):

commitizen/git.py

@@ -1,13 +1,17 @@
-# CHANGELOG
-
-{% for entry_key, entry_value in entries.items() -%}
-## {{entry_key}}
-{% for type, commits in entry_value.items() -%}
-{%- if commits -%}
-### {{type}}
-{% for commit in commits-%}
-- {{commit}}
-{% endfor %}
+{% for entry in tree %}
+
+## {{ entry.version }} {% if entry.date %}({{ entry.date }}){% endif %}
+
+{% for change_key, changes in entry.changes.items() %}
+
+### {{ change_key|title }}
+
+{% for change in changes %}
+{% if change.scope %}
+- **{{ change.scope }}**: {{ change.message }}
+{% else %}
+- {{ change.message }}
 {% endif %}
-{%- endfor %}
-{%- endfor %}
+{% endfor %}
+{% endfor %}
+{% endfor %}