cumulusci-plus 5.0.0__py3-none-any.whl

cumulusci/vcs/github/release_notes/generator.py

@@ -0,0 +1,219 @@
+import github3.exceptions
+
+from cumulusci.core.github import (
+    get_pull_requests_with_base_branch,
+    is_pull_request_merged,
+)
+from cumulusci.core.utils import import_global
+from cumulusci.tasks.release_notes.exceptions import CumulusCIException
+from cumulusci.tasks.release_notes.generator import (
+    BaseReleaseNotesGenerator,
+    render_empty_pr_section,
+)
+from cumulusci.vcs.github.release_notes.parser import GithubLinesParser, parser_configs
+from cumulusci.vcs.github.release_notes.provider import GithubChangeNotesProvider
+
+
+class ParentPullRequestNotesGenerator(BaseReleaseNotesGenerator):
+    """Aggregates notes from child pull requests in to a parent pull request"""
+
+    # Header where unaggregated child pull requests are linked to
+    UNAGGREGATED_SECTION_HEADER = "\r\n\r\n# Unaggregated Pull Requests"
+
+    def __init__(self, github, repo, project_config):
+
+        self.repo = repo
+        self.github = github
+        self.github_info = {
+            "github_owner": project_config.repo_owner,
+            "github_repo": project_config.repo_name,
+            "prefix_beta": project_config.project__git__prefix_beta,
+            "prefix_prod": project_config.project__git__prefix_release,
+        }
+        self.link_pr = True  # create links to pr on parsed change notes
+        self.has_issues = True  # need for parsers
+        self.do_publish = True  # need for parsers
+        self.parser_config = parser_configs(project_config)
+        super(ParentPullRequestNotesGenerator, self).__init__()
+
+    def _init_parsers(self):
+        """Invoked from Super Class"""
+        for cfg in self.parser_config:
+            if cfg["class_path"] is not None:
+                parser_class = import_global(cfg["class_path"])
+                self.parsers.append(parser_class(self, cfg["title"]))
+
+        # Additional parser to collect developer notes above tracked headers
+        self.parsers.append(GithubLinesParser(self, title=None))
+        self.parsers[-1]._in_section = True
+
+    def aggregate_child_change_notes(self, pull_request):
+        """Given a pull request, aggregate all change notes from child pull requests.
+        Child pull requests are pull requests that have a base branch
+        equal to the the given pull request's head."""
+        self.change_notes = get_pull_requests_with_base_branch(
+            self.repo, pull_request.head.ref, state="all"
+        )
+        self.change_notes = [
+            note
+            for note in self.change_notes
+            if is_pull_request_merged(note)
+            and note.head.ref != self.repo.default_branch
+        ]
+        if len(self.change_notes) == 0:
+            return
+
+        for change_note in self.change_notes:
+            self._parse_change_note(change_note)
+
+        body = []
+        for parser in self.parsers:
+            if parser.title is None:
+                parser.title = "Notes From Child PRs"
+            parser_content = parser.render()
+            if parser_content:
+                body.append(parser_content)
+
+        if self.empty_change_notes:
+            body.extend(render_empty_pr_section(self.empty_change_notes))
+        new_body = "\r\n".join(body)
+
+        if not pull_request.update(body=new_body):
+            raise CumulusCIException(
+                "Update of pull request #{} failed.".format(pull_request.number)
+            )
+
+
+class GithubReleaseNotesGenerator(BaseReleaseNotesGenerator):
+    def __init__(
+        self,
+        github,
+        github_info,
+        parser_config,
+        current_tag,
+        last_tag=None,
+        link_pr=False,
+        publish=False,
+        has_issues=True,
+        include_empty=False,
+        version_id=None,
+        trial_info=False,
+        sandbox_date=None,
+        production_date=None,
+    ):
+        self.github = github
+        self.github_info = github_info
+        self.parser_config = parser_config
+        self.current_tag = current_tag
+        self.last_tag = last_tag
+        self.link_pr = link_pr
+        self.do_publish = publish
+        self.has_issues = has_issues
+        self.include_empty_pull_requests = include_empty
+        self.lines_parser_class = None
+        self.issues_parser_class = None
+        super(GithubReleaseNotesGenerator, self).__init__()
+        self.version_id = version_id
+        self.trial_info = trial_info
+        self.sandbox_date = sandbox_date
+        self.production_date = production_date
+
+    def __call__(self):
+        release = self._get_release()
+        content = super(GithubReleaseNotesGenerator, self).__call__()
+        content = self._update_release_content(release, content)
+        if self.do_publish:
+            release.edit(body=content)
+        return content
+
+    def _init_parsers(self):
+        for cfg in self.parser_config:
+            if cfg["class_path"] is None:
+                continue
+            parser_class = import_global(cfg["class_path"])
+            self.parsers.append(parser_class(self, cfg["title"]))
+
+    def _init_change_notes(self):
+        return GithubChangeNotesProvider(self, self.current_tag, self.last_tag)
+
+    def _get_release(self):
+        repo = self.get_repo()
+        try:
+            return repo.release_from_tag(self.current_tag)
+        except github3.exceptions.NotFoundError:
+            raise CumulusCIException(
+                "Release not found for tag: {}".format(self.current_tag)
+            )
+
+    def _update_release_content(self, release, content):
+        """Merge existing and new release content."""
+        new_body = []
+        if release.body:
+            current_parser = None
+            current_lines = []
+            is_start_line = False
+            for parser in self.parsers:
+                parser.replaced = False
+
+            # update existing sections
+            for line in release.body.splitlines():
+
+                if current_parser:
+                    if current_parser._is_end_line(current_parser._process_line(line)):
+                        parser_content = current_parser.render(
+                            "\r\n".join(current_lines)
+                        )
+                        if parser_content:
+                            # replace existing section with new content
+                            new_body.append(parser_content + "\r\n")
+                        current_parser = None
+                        current_lines = []
+
+                for parser in self.parsers:
+                    if (
+                        parser._render_header().strip()
+                        == parser._process_line(line).strip()
+                    ):
+                        parser.replaced = True
+                        current_parser = parser
+                        current_lines = []
+                        is_start_line = True
+                        break
+                    else:
+                        is_start_line = False
+
+                current_lines.append(line)
+                if is_start_line:
+                    continue
+                if current_parser:
+                    continue
+                else:
+                    # preserve existing sections
+                    new_body.append(line.strip())
+
+            # catch section without end line
+            if current_parser:
+                parser_content = current_parser.render("\r\n".join(current_lines))
+                new_body.append(parser_content)
+
+            # add new sections at bottom
+            for parser in self.parsers:
+                if not parser.replaced:
+                    parser_content = parser.render("")
+                    if parser_content:
+                        new_body.append(parser_content + "\r\n")
+
+        else:  # no release.body
+            new_body.append(content)
+
+        # add empty PR section
+        if self.include_empty_pull_requests:
+            new_body.extend(render_empty_pr_section(self.empty_change_notes))
+
+        content = "\r\n".join(new_body)
+        return content
+
+    def get_repo(self):
+        return self.github.repository(
+            self.github_info["github_owner"], self.github_info["github_repo"]
+        )

cumulusci/vcs/github/release_notes/parser.py

@@ -0,0 +1,151 @@
+import logging
+import re
+from typing import Dict
+
+import github3.exceptions
+
+from cumulusci.core.config import BaseProjectConfig
+from cumulusci.core.exceptions import GithubApiNotFoundError
+from cumulusci.core.versions import PackageVersionNumber
+from cumulusci.tasks.release_notes.parser import ChangeNotesLinesParser, IssuesParser
+from cumulusci.utils.yaml.cumulusci_yml import ReleaseNotesParser
+
+
+def parser_configs(project_config: BaseProjectConfig) -> Dict[int, ReleaseNotesParser]:
+    configs = (
+        project_config.project__git__release_notes__parsers__github.values()
+        if project_config.project__git__release_notes__parsers__github
+        else {}
+    )
+    configs = (
+        project_config.project__git__release_notes__parsers.values()
+        if not configs and project_config.project__git__release_notes__parsers
+        else configs
+    )
+    return configs
+
+
+class GithubLinesParser(ChangeNotesLinesParser):
+    def __init__(self, release_notes_generator, title):
+        super(GithubLinesParser, self).__init__(release_notes_generator, title)
+        self.link_pr = release_notes_generator.link_pr
+        self.pr_number = None
+        self.pr_url = None
+
+    def _process_change_note(self, pull_request):
+        self.pr_number = pull_request.number
+        self.pr_url = pull_request.html_url
+        return pull_request.body
+
+    def _add_link(self, line):
+        if self.link_pr:
+            line += " [[PR{}]({})]".format(self.pr_number, self.pr_url)
+        return line
+
+
+class GithubIssuesParser(IssuesParser):
+    ISSUE_COMMENT = {
+        "beta": "Included in beta release",
+        "prod": "Included in production release",
+    }
+
+    def __new__(cls, release_notes_generator, title, issue_regex=None):
+        if not release_notes_generator.has_issues:
+            logging.getLogger(__file__).warning(
+                "Issues are disabled for this repository. Falling back to change notes parser."
+            )
+            return GithubLinesParser(release_notes_generator, title)
+
+        return super().__new__(cls)
+
+    def __init__(self, release_notes_generator, title, issue_regex=None):
+        super().__init__(release_notes_generator, title, issue_regex)
+        self.link_pr = release_notes_generator.link_pr
+        self.pr_number = None
+        self.pr_url = None
+        self.publish = release_notes_generator.do_publish
+        self.github = release_notes_generator.github
+
+    def _add_line(self, line):
+        # find issue numbers per line
+        issue_numbers = re.findall(self.issue_regex, line, flags=re.IGNORECASE)
+        for issue_number in issue_numbers:
+            self.content.append(
+                {
+                    "issue_number": int(issue_number),
+                    "pr_number": self.pr_number,
+                    "pr_url": self.pr_url,
+                }
+            )
+
+    def _get_default_regex(self):
+        keywords = (
+            "close",
+            "closes",
+            "closed",
+            "fix",
+            "fixes",
+            "fixed",
+            "resolve",
+            "resolves",
+            "resolved",
+        )
+        return r"(?:{})\s\[?#(\d+)\]?".format("|".join(keywords))
+
+    def _render_content(self):
+        content = []
+        for item in sorted(self.content, key=lambda k: k["issue_number"]):
+            issue = self._get_issue(item["issue_number"])
+            txt = "#{}: {}".format(item["issue_number"], issue.title)
+            if self.link_pr:
+                txt += " [[PR{}]({})]".format(item["pr_number"], item["pr_url"])
+            content.append(txt)
+            if self.publish:
+                self._add_issue_comment(issue)
+        return "\r\n".join(content)
+
+    def _get_issue(self, issue_number):
+        try:
+            issue = self.github.issue(
+                self.release_notes_generator.github_info["github_owner"],
+                self.release_notes_generator.github_info["github_repo"],
+                issue_number,
+            )
+        except github3.exceptions.NotFoundError:
+            raise GithubApiNotFoundError("Issue #{} not found".format(issue_number))
+        return issue
+
+    def _process_change_note(self, pull_request):
+        self.pr_number = pull_request.number
+        self.pr_url = pull_request.html_url
+        return pull_request.body
+
+    def _add_issue_comment(self, issue):
+        # Ensure all issues have a comment on which release they were fixed
+        prefix_beta = self.release_notes_generator.github_info["prefix_beta"]
+        prefix_prod = self.release_notes_generator.github_info["prefix_prod"]
+
+        # ParentPullRequestNotesGenerator doesn't utilize a current_tag
+        if not hasattr(self.release_notes_generator, "current_tag"):
+            return
+        elif self.release_notes_generator.current_tag.startswith(prefix_beta):
+            is_beta = True
+        elif self.release_notes_generator.current_tag.startswith(prefix_prod):
+            is_beta = False
+        else:
+            # not production or beta tag, don't comment
+            return
+        if is_beta:
+            comment_prefix = self.ISSUE_COMMENT["beta"]
+        else:
+            comment_prefix = self.ISSUE_COMMENT["prod"]
+        version_str = PackageVersionNumber.parse_tag(
+            self.release_notes_generator.current_tag, prefix_beta, prefix_prod
+        ).format()
+        has_comment = False
+        for comment in issue.comments():
+            if comment.body.startswith(comment_prefix):
+                has_comment = True
+                break
+        if not has_comment:
+            issue.create_comment("{} {}".format(comment_prefix, version_str))

cumulusci/vcs/github/release_notes/provider.py

@@ -0,0 +1,143 @@
+import time
+from datetime import datetime
+
+import pytz
+
+from cumulusci.core.github import get_tag_by_name
+from cumulusci.tasks.release_notes.provider import BaseChangeNotesProvider
+from cumulusci.utils.version_strings import LooseVersion
+
+
+class GithubChangeNotesProvider(BaseChangeNotesProvider):
+    """Provides changes notes by finding all merged pull requests to
+    the default branch between two tags.
+
+    Expects the passed release_notes_generator instance to have a github_info
+    property that contains a dictionary of settings for accessing Github:
+
+        - github_repo
+        - github_owner
+        - github_username
+        - github_password
+        - default_branch
+        - prefix_prod: Tag prefix for production release tags. Defaults to 'prod/'
+    """
+
+    def __init__(self, release_notes_generator, current_tag, last_tag=None):
+        super(GithubChangeNotesProvider, self).__init__(release_notes_generator)
+        self.current_tag = current_tag
+        self._last_tag = last_tag
+        self._start_date = None
+        self._end_date = None
+        self.repo = release_notes_generator.get_repo()
+        self.github_info = release_notes_generator.github_info
+
+    def __call__(self):
+        for pull_request in self._get_pull_requests():
+            yield pull_request
+
+    @property
+    def last_tag(self):
+        if not self._last_tag:
+            self._last_tag = self._get_last_tag()
+        return self._last_tag
+
+    @property
+    def current_tag_info(self):
+        if not hasattr(self, "_current_tag_info"):
+            tag = get_tag_by_name(self.repo, self.current_tag)
+            self._current_tag_info = {"tag": tag, "commit": self._get_commit_info(tag)}
+        return self._current_tag_info
+
+    @property
+    def last_tag_info(self):
+        if not hasattr(self, "_last_tag_info"):
+            if self.last_tag:
+                tag = get_tag_by_name(self.repo, self.last_tag)
+                self._last_tag_info = {"tag": tag, "commit": self._get_commit_info(tag)}
+            else:
+                self._last_tag_info = None
+        return self._last_tag_info
+
+    def _get_commit_info(self, tag):
+        return self.repo.git_commit(tag.object.sha)
+
+    @property
+    def start_date(self):
+        return self._get_commit_date(self.current_tag_info["commit"])
+
+    @property
+    def end_date(self):
+        if self.last_tag_info:
+            return self._get_commit_date(self.last_tag_info["commit"])
+
+    def _get_commit_date(self, commit):
+        t = time.strptime(commit.author["date"], "%Y-%m-%dT%H:%M:%SZ")
+        return datetime(t[0], t[1], t[2], t[3], t[4], t[5], t[6], pytz.UTC)
+
+    def _get_version_from_tag(self, tag):
+        if tag.startswith(self.github_info["prefix_prod"]):
+            return tag.replace(self.github_info["prefix_prod"], "")
+        elif tag.startswith(self.github_info["prefix_beta"]):
+            return tag.replace(self.github_info["prefix_beta"], "")
+        raise ValueError("Could not determine version number from tag {}".format(tag))
+
+    def _get_last_tag(self):
+        """Gets the last release tag before self.current_tag"""
+
+        current_version = LooseVersion(
+            self._get_version_from_tag(self.release_notes_generator.current_tag)
+        )
+
+        versions = []
+        for tag in self.repo.tags():
+            if not tag.name.startswith(self.github_info["prefix_prod"]):
+                continue
+            version = LooseVersion(self._get_version_from_tag(tag.name))
+            if version >= current_version:
+                continue
+            versions.append(version)
+        if versions:
+            versions.sort()
+            return "{}{}".format(self.github_info["prefix_prod"], versions[-1])
+
+    def _get_pull_requests(self):
+        """Gets all pull requests from the repo since we can't do a filtered
+        date merged search"""
+        for pull in self.repo.pull_requests(
+            state="closed", base=self.github_info["default_branch"], direction="asc"
+        ):
+            if self._include_pull_request(pull):
+                yield pull
+
+    def _include_pull_request(self, pull_request):
+        """Checks if the given pull_request was merged to the default branch
+        between self.start_date and self.end_date"""
+
+        merged_date = pull_request.merged_at
+        if not merged_date:
+            return False
+        if self.last_tag:
+            last_tag_sha = self.last_tag_info["commit"].sha
+            if pull_request.merge_commit_sha == last_tag_sha:
+                # Github commit dates can be different from the merged_at date
+                return False
+
+        current_tag_sha = self.current_tag_info["commit"].sha
+        if pull_request.merge_commit_sha == current_tag_sha:
+            return True
+
+        # include PRs before current tag
+        if merged_date <= self.start_date:
+            if self.end_date:
+                # include PRs after last tag
+                if (
+                    merged_date > self.end_date
+                    and pull_request.merge_commit_sha != last_tag_sha
+                ):
+                    return True
+            else:
+                # no last tag, include all PRs before current tag
+                return True
+
+        return False