def publish()

in bot/code_review_bot/report/phabricator.py [0:0]

• 72 lines of code
• 26 McCabe index (conditional complexity)

    def publish(self, issues, revision, task_failures, notices, reviewers):
        """
        Publish issues on Phabricator:
        * publishable issues use lint results
        * build errors are displayed as unit test results
        """

        # Add extra reviewers groups to the revision
        if reviewers:
            phids = []
            for reviewers_group in reviewers:
                data = self.api.search_projects(slugs=[reviewers_group])
                if not data or "phid" not in data[0]:
                    logger.warning(
                        f'Unable to find the PHID of the reviewers group identified by the slug "{reviewers_group}"'
                    )
                    continue

                phids.append(data[0]["phid"])

            if phids:
                self.api.edit_revision(
                    revision.phabricator_id,
                    [
                        {
                            "type": "reviewers.add",
                            "value": phids,
                        }
                    ],
                )

        # Use only new and publishable issues and patches
        # Avoid publishing a patch from a de-activated analyzer
        publishable_issues = [
            issue
            for issue in issues
            if issue.is_publishable()
            and issue.analyzer.name not in self.analyzers_skipped
        ]
        patches = [
            patch
            for patch in revision.improvement_patches
            if patch.analyzer.name not in self.analyzers_skipped
        ]

        if publishable_issues:
            # Publish detected patch's issues on Harbormaster, all at once, as lint issues
            self.publish_harbormaster(revision, publishable_issues)

        # Retrieve all diffs for the current revision
        rev_diffs = self.api.search_diffs(revision_phid=revision.phabricator_phid)

        if any(diff["id"] > revision.diff_id for diff in rev_diffs):
            logger.warning(
                "A newer diff exists on this patch, skipping the comment publication"
            )
            return publishable_issues, patches

        # Compare issues that are not known on the repository to a previous diff
        older_diff_ids = [
            diff["id"] for diff in rev_diffs if diff["id"] < revision.diff_id
        ]
        former_diff_id = sorted(older_diff_ids)[-1] if older_diff_ids else None
        unresolved_issues, closed_issues = self.compare_issues(
            former_diff_id, publishable_issues
        )

        if (
            len(unresolved_issues) == len(publishable_issues)
            and not closed_issues
            and not task_failures
            and not notices
        ):
            # Nothing changed, no issue have been opened or closed
            logger.info(
                "No new issues nor failures/notices were detected. "
                "Skipping comment publication (some issues are unresolved)",
                unresolved_count=len(unresolved_issues),
            )
            return publishable_issues, patches

        # Publish comment summarizing detected, unresolved and closed issues
        self.publish_summary(
            revision,
            publishable_issues,
            patches,
            task_failures,
            notices,
            former_diff_id=former_diff_id,
            unresolved_count=len(unresolved_issues),
            closed_count=len(closed_issues),
        )

        # Publish statistics
        stats.add_metric("report.phabricator.issues", len(issues))
        stats.add_metric("report.phabricator")

        return publishable_issues, patches