Fixed problem with multilevel issues.

Author: miroslavpojer

release_notes_generator/chapters/custom_chapters.py

@@ -68,7 +68,7 @@ def populate(self, records: dict[str, Record]) -> None:
 
                 for record_label in records[record_id].labels:  # iterate all labels of the record (issue, or 1st PR)
                     if record_label in ch.labels and pulls_count > 0:
-                        if not records[record_id].is_present_in_chapters:
+                        if not records[record_id].is_present_in_chapters and records[record_id].contains_change_increment():
                             ch.add_row(record_id, records[record_id].to_chapter_row(True))
                             self.populated_record_numbers_list.append(record_id)
 

release_notes_generator/filter.py

@@ -107,6 +107,27 @@ def filter(self, data: MinedData) -> MinedData:
             md.pull_requests = deepcopy(data.pull_requests)
             md.commits = deepcopy(data.commits)
 
+        print("debug filtering")
+        print(f"XXX md issues before {len(md.issues)}")
+
+        for issue in data.issues:
+            # if issue.number not in [3689,3688,3687,3686,3674,3620,3580,2960,3606,248,198,199,200,201,202,203]:
+            if issue.number not in [3689,3688,3687,3686,3674,3620,3580,2960,3606]:
+                if issue in md.issues:
+                    md.issues.remove(issue)
+
+        print(f"XXX md issues after {len(md.issues)}")
+
+        md.pull_requests = []
+        for pull in data.pull_requests:
+            if pull.number == 3616:
+                md.pull_requests.append(pull)
+
+        # for commit in data.commits:
+        #     if commit.sha in []:
+        #         md.commits.remove(commit)
+        md.commits = []
+
         return md
 
     def _filter_issues(self, data: MinedData) -> list:

release_notes_generator/model/commit_record.py

@@ -65,6 +65,9 @@ def to_chapter_row(self, add_into_chapters: bool = True) -> str:
 
         return row
 
+    def contains_change_increment(self) -> bool:
+        return True
+
     def get_rls_notes(self, line_marks: Optional[list[str]] = None) -> str:
         # Hint: direct commits does not support release notes
         return ""

release_notes_generator/model/hierarchy_issue_record.py

@@ -120,7 +120,8 @@ def to_chapter_row(self, add_into_chapters: bool = True) -> str:
 
         # add sub-hierarchy issues
         for sub_hierarchy_issue in self._sub_hierarchy_issues.values():
-            row = f"{row}\n{sub_hierarchy_issue.to_chapter_row()}"
+            if sub_hierarchy_issue.contains_change_increment():
+                row = f"{row}\n{sub_hierarchy_issue.to_chapter_row()}"
 
         # add sub-issues
         if len(self._sub_issues) > 0:
@@ -129,6 +130,9 @@ def to_chapter_row(self, add_into_chapters: bool = True) -> str:
                 if sub_issue.is_open:
                     continue  # only closed issues are reported in release notes
 
+                if not sub_issue.contains_change_increment():
+                    continue  # skip sub-issues without change increment
+
                 sub_issue_block = "- " + sub_issue.to_chapter_row()
                 ind_child_block = "\n".join(
                     f"{sub_indent}{line}" if line else "" for line in sub_issue_block.splitlines()

release_notes_generator/model/issue_record.py

@@ -122,6 +122,9 @@ def to_chapter_row(self, add_into_chapters: bool = True) -> str:
 
         return row
 
+    def contains_change_increment(self) -> bool:
+        return self.pull_requests_count() > 0
+
     def get_rls_notes(self, line_marks: Optional[list[str]] = None) -> str:
         release_notes = ""
         detection_pattern = ActionInputs.get_release_notes_title()

release_notes_generator/model/pull_request_record.py

@@ -128,6 +128,9 @@ def to_chapter_row(self, add_into_chapters: bool = True) -> str:
             row = f"{row}\n{self.get_rls_notes()}"
         return row
 
+    def contains_change_increment(self) -> bool:
+        return True
+
     def get_rls_notes(self, line_marks: Optional[list[str]] = None) -> str:
         release_notes = ""
         detection_pattern = ActionInputs.get_release_notes_title()

release_notes_generator/model/record.py

@@ -117,6 +117,15 @@ def to_chapter_row(self, add_into_chapters: bool = True) -> str:
             str: The string representation of the record in a chapter row.
         """
 
+    @abstractmethod
+    def contains_change_increment(self) -> bool:
+        """
+        Checks if the record contains a change increment.
+
+        Returns:
+            bool: True if the record contains a change increment, False otherwise.
+        """
+
     @abstractmethod
     def get_labels(self) -> list[str]:
         """

release_notes_generator/record/factory/default_record_factory.py

@@ -19,7 +19,7 @@
 """
 
 import logging
-from functools import singledispatchmethod
+from functools import singledispatchmethod, lru_cache
 from typing import cast, Optional
 
 from github import Github
@@ -68,7 +68,13 @@ def get_id(self, obj) -> str:
 
     @get_id.register
     def _(self, issue: Issue) -> str:
-        return f"{issue.repository.full_name}#{issue.number}"
+        # delegate to a cached, hashable-only helper
+        return self._issue_id(issue.repository.full_name, issue.number)
+
+    @staticmethod
+    @lru_cache(maxsize=2048)
+    def _issue_id(repo_full_name: str, number: int) -> str:
+        return f"{repo_full_name.lower()}#{number}"
 
     @get_id.register
     def _(self, pull_request: PullRequest) -> str:

release_notes_generator/record/factory/issue_hierarchy_record_factory.py

@@ -19,7 +19,6 @@
 """
 
 import logging
-from datetime import datetime
 from typing import cast, Optional
 
 from github import Github
@@ -52,7 +51,9 @@ def __init__(self, github: Github) -> None:
         self.__registered_issues: set[str] = set()
         self.__sub_issue_parents: dict[str, str] = {}
         self.__registered_commits: set[str] = set()
+
         self.__external_sub_issues: list[SubIssue] = []
+        self.__local_sub_issues_checked: list[str] = []
 
     def generate(self, data: MinedData) -> dict[str, Record]:
         """
@@ -64,15 +65,38 @@ def generate(self, data: MinedData) -> dict[str, Record]:
         """
         logger.debug("Creation of records started...")
         # First register all issues with sub-issues
+        issues_expansion: list[SubIssue] = []
         for issue in data.issues:
             if self.get_id(issue) in self.__registered_issues:
                 continue
 
-            self._create_issue_record_using_sub_issues_existence(issue, data.since)
+            issues_expansion.extend(self._create_issue_record_using_sub_issues_existence(issue, data))
+
+        data.issues.extend(issues_expansion)
+
+        # Second register all hierarchy issues from sub-issues
+        registered_before = -1
+        while registered_before < len(self.__registered_issues):
+            registered_before = len(self.__registered_issues)
+            logger.debug(f"Looking for hierarchical issue among sub-issues...")
+
+            issues_expansion = []
+            for issue in data.issues:
+                iid = self.get_id(issue)
+                if iid in self.__registered_issues:
+                    continue
 
-        # Second register all external sub-issues
-        # TODO decide if added as issue or sub-issue
+                if iid in self.__sub_issue_parents.keys() and iid not in self.__local_sub_issues_checked:
+                    issues_expansion.extend(self._create_issue_record_using_sub_issues_existence(issue, data))
+                    self.__local_sub_issues_checked.append(iid)
+
+            data.issues.extend(issues_expansion)
+
+        # Third register all external sub-issues
         for ext_sub_issue in self.__external_sub_issues:
+            if self.get_id(ext_sub_issue) in self.__registered_issues:
+                continue
+
             self._create_record_for_sub_issue(ext_sub_issue)
 
         # Now register all issues without sub-issues
@@ -132,7 +156,7 @@ def _register_pull_and_its_commits_to_issue(self, pull: PullRequest, data: Mined
                     issue_number = int(issue_id.split("#")[1])
                     parent_issue = self._safe_call(data.repository.get_issue)(issue_number) if data.repository else None
                     if parent_issue is not None:
-                        self._create_issue_record_using_sub_issues_existence(parent_issue)
+                        self._create_issue_record_using_sub_issues_existence(parent_issue, data)
 
                 if issue_id in self._records and isinstance(
                     self._records[issue_id], (SubIssueRecord, HierarchyIssueRecord, IssueRecord)
@@ -154,19 +178,22 @@ def _register_pull_and_its_commits_to_issue(self, pull: PullRequest, data: Mined
             self._records[str(pull.number)] = pr_rec
             logger.debug("Created record for PR %d: %s", pull.number, pull.title)
 
-    def _create_issue_record_using_sub_issues_existence(self, issue: Issue, since: Optional[datetime] = None) -> None:
+    def _create_issue_record_using_sub_issues_existence(self, issue: Issue, data: MinedData) -> list[SubIssue]:
         # use presence of sub-issues as a hint for hierarchy issue or non hierarchy issue
         sub_issues = list(issue.get_sub_issues())
+        logger.debug(f"Found {len(sub_issues)} sub-issues for {issue.number}")
+        new_local_issues: list[SubIssue] = []
 
         if len(sub_issues) > 0:
             self._create_record_for_hierarchy_issue(issue)
             for si in sub_issues:
+                siid = self.get_id(si)
+
                 # check if sub-issue is from current repository
                 if si.repository.full_name != issue.repository.full_name:
                     # register sub-issue and its parent for later hierarchy building
-                    self.__sub_issue_parents[self.get_id(si)] = self.get_id(
-                        issue
-                    )  # Note: GitHub now allows only 1 parent
+                    # Note: GitHub now allows only 1 parent
+                    self.__sub_issue_parents[siid] = self.get_id(issue)
 
                     self.__external_sub_issues.append(si)
                     logger.debug(
@@ -177,21 +204,33 @@ def _create_issue_record_using_sub_issues_existence(self, issue: Issue, since: O
                     )
 
                 else:
-                    self.__sub_issue_parents[self.get_id(si)] = self.get_id(
-                        issue
-                    )  # Note: GitHub now allows only 1 parent
-                    if since and si.state == IssueRecord.ISSUE_STATE_CLOSED and si.closed_at and since > si.closed_at:
-                        logger.debug("Detected sub-issue %d closed in previous release - skipping", si.number)
-                        continue
-
-                    if si.state == IssueRecord.ISSUE_STATE_OPEN:
-                        logger.debug("Detected sub-issue %d is still open - skipping", si.number)
-                        continue
-
-                    if si.state == IssueRecord.ISSUE_STATE_CLOSED:  # issue is valid
-                        continue
-
-                logger.warning("Detected unexpected sub-issue %d with parent %d", si.number, issue.number)
+                    use_issue = False
+                    if data.since and si.state == IssueRecord.ISSUE_STATE_CLOSED and si.closed_at and data.since > si.closed_at:
+                        logger.debug("Detected sub-issue %d closed in previous release.", si.number)
+                        if len(list(si.get_sub_issues())) > 0:
+                            use_issue = True
+                        else:
+                            self.__registered_issues.add(siid)
+
+                    elif si.state == IssueRecord.ISSUE_STATE_OPEN:
+                        logger.debug("Detected sub-issue %d is still open.", si.number)
+                        if len(list(si.get_sub_issues())) > 0:
+                            use_issue = True
+                        else:
+                            self.__registered_issues.add(siid)
+
+                    elif si.state == IssueRecord.ISSUE_STATE_CLOSED:  # issue is valid
+                        use_issue = True
+
+                    else:
+                        logger.warning("Detected unexpected sub-issue %d with parent %d", si.number, issue.number)
+
+                    if use_issue:
+                        self.__sub_issue_parents[siid] = self.get_id(issue)
+                        if si not in data.issues:
+                            new_local_issues.append(si)
+
+        return new_local_issues
 
     def _create_issue_record_using_sub_issues_not_existence(self, issue: Issue) -> None:
         # Expected to run after all issue with sub-issues are registered
@@ -249,6 +288,8 @@ def _create_record_for_sub_issue(self, issue: Issue, issue_labels: Optional[list
         self._records[iid] = SubIssueRecord(issue, issue_labels, skip_record)
 
     def _re_register_hierarchy_issues(self):
+        logger.debug("Re-registering hierarchy issues ...")
+
         sub_issues_ids: list[str] = list(self.__sub_issue_parents.keys())
 
         made_progress = False

tests/conftest.py

@@ -834,7 +834,7 @@ def mined_data_isolated_record_types_with_labels_with_type_defined(mocker, mined
     t_epic = mocker.Mock(spec=IssueType)
     t_epic.name = "Epic"
     t_feature = mocker.Mock(spec=IssueType)
-    t_feature.name = "feature"
+    t_feature.name = "Feature"
     t_task = mocker.Mock(spec=IssueType)
     t_task.name = "Task"
     t_bug = mocker.Mock(spec=IssueType)