~launchpad-pqm/launchpad/devel

# Copyright 2009-2011 Canonical Ltd.  This software is licensed under the

# GNU Affero General Public License version 3 (see the file LICENSE).

# pylint: disable-msg=C0322,F0401

"""Views, navigation and actions for BranchMergeProposals."""

__metaclass__ = type

__all__ = [

    'BranchMergeCandidateView',

    'BranchMergeProposalActionNavigationMenu',

    'BranchMergeProposalAddVoteView',

    'BranchMergeProposalChangeStatusView',

    'BranchMergeProposalCommitMessageEditView',

    'BranchMergeProposalContextMenu',

    'BranchMergeProposalDeleteView',

    'BranchMergeProposalDequeueView',

    'BranchMergeProposalDescriptionEditView',

    'BranchMergeProposalEditMenu',

    'BranchMergeProposalEditView',

    'BranchMergeProposalEnqueueView',

    'BranchMergeProposalInlineDequeueView',

    'BranchMergeProposalJumpQueueView',

    'BranchMergeProposalNavigation',

    'BranchMergeProposalMergedView',

    'BranchMergeProposalPrimaryContext',

    'BranchMergeProposalRequestReviewView',

    'BranchMergeProposalResubmitView',

    'BranchMergeProposalSubscribersView',

    'BranchMergeProposalView',

    'BranchMergeProposalVoteView',

    'latest_proposals_for_each_branch',

    ]

from functools import wraps

import operator

from lazr.delegates import delegates

from lazr.restful.interface import copy_field

from lazr.restful.interfaces import (

    IJSONRequestCache,

    IWebServiceClientRequest,

    )

import simplejson

from zope.app.form.browser import TextAreaWidget

from zope.component import (

    adapts,

    getMultiAdapter,

    getUtility,

    )

from zope.formlib import form

from zope.interface import (

    implements,

    Interface,

    )

from zope.schema import (

    Bool,

    Choice,

    Int,

    Text,

    )

from zope.schema.vocabulary import (

    SimpleTerm,

    SimpleVocabulary,

    )

from canonical.config import config

from lp import _

from lp.services.webapp import (

    canonical_url,

    ContextMenu,

    enabled_with_permission,

    LaunchpadView,

    Link,

    Navigation,

    stepthrough,

    stepto,

    )

from lp.services.webapp.authorization import check_permission

from lp.services.webapp.breadcrumb import Breadcrumb

from lp.services.webapp.interfaces import IPrimaryContext

from lp.services.webapp.menu import (

    NavigationMenu,

    structured,

    )

from lp.app.browser.launchpadform import (

    action,

    custom_widget,

    LaunchpadEditFormView,

    LaunchpadFormView,

    )

from lp.app.browser.lazrjs import (

    TextAreaEditorWidget,

    vocabulary_to_choice_edit_items,

    )

from lp.app.browser.tales import DateTimeFormatterAPI

from lp.app.longpoll import subscribe

from lp.code.adapters.branch import BranchMergeProposalNoPreviewDiffDelta

from lp.code.browser.codereviewcomment import CodeReviewDisplayComment

from lp.code.browser.decorations import DecoratedBranch

from lp.code.enums import (

    BranchMergeProposalStatus,

    BranchType,

    CodeReviewNotificationLevel,

    CodeReviewVote,

    )

from lp.code.errors import (

    BranchMergeProposalExists,

    ClaimReviewFailed,

    InvalidBranchMergeProposal,

    WrongBranchMergeProposal,

    )

from lp.code.interfaces.branchmergeproposal import IBranchMergeProposal

from lp.code.interfaces.codereviewcomment import ICodeReviewComment

from lp.code.interfaces.codereviewvote import ICodeReviewVoteReference

from lp.code.interfaces.diff import IPreviewDiff

from lp.registry.interfaces.person import IPersonSet

from lp.services.comments.interfaces.conversation import (

    IComment,

    IConversation,

    )

from lp.services.features import getFeatureFlag

from lp.services.fields import (

    Summary,

    Whiteboard,

    )

from lp.services.messages.interfaces.message import IMessageSet

from lp.services.propertycache import cachedproperty

def latest_proposals_for_each_branch(proposals):

    """Returns the most recent merge proposals for any particular branch.

    Also filters out proposals that the logged in user can't see.

    """

    targets = {}

    for proposal in proposals:

        # Don't show the proposal if the user can't see it.

        if not check_permission('launchpad.View', proposal):

            continue

        # Only show the must recent proposal for any given target.

        date_created = proposal.date_created

        target_id = proposal.target_branch.id

        if target_id not in targets or date_created > targets[target_id][1]:

            targets[target_id] = (proposal, date_created)

    return sorted(

        [proposal for proposal, date_created in targets.itervalues()],

        key=operator.attrgetter('date_created'), reverse=True)

class BranchMergeProposalPrimaryContext:

    """The primary context is the proposal is that of the source branch."""

    implements(IPrimaryContext)

    def __init__(self, branch_merge_proposal):

        self.context = IPrimaryContext(

            branch_merge_proposal.source_branch).context

class BranchMergeProposalBreadcrumb(Breadcrumb):

    """An `IBreadcrumb` for a merge proposal."""

    @property

    def text(self):

        return 'Merge into %s' % self.context.target_branch.name

def notify(func):

    """Decorate a view method to send a notification."""

    @wraps(func)

    def decorator(view, *args, **kwargs):

        with BranchMergeProposalNoPreviewDiffDelta.monitor(view.context):

            return func(view, *args, **kwargs)

    return decorator

def update_and_notify(func):

    """Decorate an action to update from a form and send a notification."""

    @notify

    def decorator(view, action, data):

        result = func(view, action, data)

        form.applyChanges(

            view.context, view.form_fields, data, view.adapters)

        return result

    return decorator

class BranchMergeCandidateView(LaunchpadView):

    """Provides a small fragment of landing targets"""

    def friendly_text(self):

        """Prints friendly text for a branch."""

        friendly_texts = {

            BranchMergeProposalStatus.WORK_IN_PROGRESS: 'On hold',

            BranchMergeProposalStatus.NEEDS_REVIEW: 'Ready for review',

            BranchMergeProposalStatus.CODE_APPROVED: 'Approved',

            BranchMergeProposalStatus.REJECTED: 'Rejected',

            BranchMergeProposalStatus.MERGED: 'Merged',

            BranchMergeProposalStatus.MERGE_FAILED:

                'Approved [Merge Failed]',

            BranchMergeProposalStatus.QUEUED: 'Queued',

            BranchMergeProposalStatus.SUPERSEDED: 'Superseded',

        }

        return friendly_texts[self.context.queue_status]

    @property

    def status_title(self):

        """The title for the status text.

        Only set if the status is approved or rejected.

        """

        result = ''

        if self.context.queue_status in (

            BranchMergeProposalStatus.CODE_APPROVED,

            BranchMergeProposalStatus.REJECTED):

            formatter = DateTimeFormatterAPI(self.context.date_reviewed)

            result = '%s %s' % (

                self.context.reviewer.displayname,

                formatter.displaydate())

        return result

class BranchMergeProposalMenuMixin:

    """Mixin class for merge proposal menus."""

    @enabled_with_permission('launchpad.AnyPerson')

    def add_comment(self):

        return Link('+comment', 'Add a review or comment', icon='add')

    @enabled_with_permission('launchpad.Edit')

    def edit(self):

        text = 'Edit details'

        enabled = self.context.isMergable()

        return Link('+edit', text, icon='edit', enabled=enabled)

    @enabled_with_permission('launchpad.Edit')

    def set_description(self):

        text = 'Set description'

        return Link('+edit-description', text, icon='add')

    @enabled_with_permission('launchpad.Edit')

    def set_commit_message(self):

        text = 'Set commit message'

        enabled = self.context.isMergable()

        return Link('+edit-commit-message', text, icon='add',

                    enabled=enabled)

    @enabled_with_permission('launchpad.Edit')

    def edit_status(self):

        text = 'Change status'

        return Link('+edit-status', text, icon='edit')

    @enabled_with_permission('launchpad.Edit')

    def delete(self):

        text = 'Delete proposal to merge'

        return Link('+delete', text, icon='trash-icon')

    def _enabledForStatus(self, next_state):

        """True if the next_state is a valid transition for the current user.

        Return False if the current state is next_state.

        """

        bmp = self.branch_merge_proposal

        status = bmp.queue_status

        if status == next_state:

            return False

        else:

            return bmp.isValidTransition(next_state, self.user)

    @enabled_with_permission('launchpad.Edit')

    def request_review(self):

        text = 'Request a review'

        enabled = self._enabledForStatus(

            BranchMergeProposalStatus.NEEDS_REVIEW)

        if (self.context.queue_status ==

            BranchMergeProposalStatus.NEEDS_REVIEW):

            enabled = True

            if (self.context.votes.count()) > 0:

                text = 'Request another review'

        return Link('+request-review', text, icon='add', enabled=enabled)

    @enabled_with_permission('launchpad.Edit')

    def merge(self):

        text = 'Mark as merged'

        enabled = self._enabledForStatus(

            BranchMergeProposalStatus.MERGED)

        return Link('+merged', text, enabled=enabled)

    @enabled_with_permission('launchpad.Edit')

    def update_merge_revno(self):

        text = 'Update revision number'

        return Link('+merged', text)

    @enabled_with_permission('launchpad.Edit')

    def enqueue(self):

        text = 'Queue for merging'

        enabled = self._enabledForStatus(

            BranchMergeProposalStatus.QUEUED)

        return Link('+enqueue', text, enabled=enabled)

    @enabled_with_permission('launchpad.Edit')

    def dequeue(self):

        text = 'Remove from queue'

        enabled = (self.context.queue_status ==

                   BranchMergeProposalStatus.QUEUED)

        return Link('+dequeue', text, enabled=enabled)

    @enabled_with_permission('launchpad.Edit')

    def resubmit(self):

        text = 'Resubmit proposal'

        enabled = self._enabledForStatus(

            BranchMergeProposalStatus.SUPERSEDED)

        return Link('+resubmit', text, enabled=enabled, icon='edit')

class BranchMergeProposalEditMenu(NavigationMenu,

                                  BranchMergeProposalMenuMixin):

    """Edit menu for Branch Merge Proposals."""

    usedfor = IBranchMergeProposal

    title = 'Edit Proposal'

    facet = 'branches'

    links = ['resubmit', 'delete']

    @property

    def branch_merge_proposal(self):

        return self.context

class BranchMergeProposalContextMenu(ContextMenu,

                                     BranchMergeProposalMenuMixin):

    """Context menu for merge proposals."""

    usedfor = IBranchMergeProposal

    links = [

        'add_comment',

        'dequeue',

        'set_commit_message',

        'set_description',

        'edit_status',

        'enqueue',

        'merge',

        'request_review',

        'resubmit',

        'update_merge_revno',

        ]

    @property

    def branch_merge_proposal(self):

        return self.context

class IBranchMergeProposalActionMenu(Interface):

    """A marker interface for the global action navigation menu."""

class BranchMergeProposalActionNavigationMenu(NavigationMenu,

                                              BranchMergeProposalMenuMixin):

    """A sub-menu for acting upon a Product."""

    usedfor = IBranchMergeProposalActionMenu

    facet = 'branches'

    links = ('resubmit', 'delete')

    @property

    def branch_merge_proposal(self):

        # This context is the view, the view's context is the bmp.

        return self.context.context

class UnmergedRevisionsMixin:

    """Provides the methods needed to show unmerged revisions."""

    @cachedproperty

    def unlanded_revisions(self):

        """Return the unlanded revisions from the source branch."""

        return self.context.getUnlandedSourceBranchRevisions()

    @property

    def pending_writes(self):

        """Needed to make the branch-revisions metal macro work."""

        return False

    @property

    def codebrowse_url(self):

        """Return the link to codebrowse for this branch."""

        return self.context.source_branch.codebrowse_url()

class BranchMergeProposalRevisionIdMixin:

    """A mixin class to provide access to the revision ids."""

    def _getRevisionNumberForRevisionId(self, revision_id):

        """Find the revision number that corresponds to the revision id.

        If there was no last reviewed revision, None is returned.

        If the reviewed revision is no longer in the revision history of

        the source branch, then a message is returned.

        """

        if revision_id is None:

            return None

        # If the source branch is REMOTE, then there won't be any ids.

        source_branch = self.context.source_branch

        if source_branch.branch_type == BranchType.REMOTE:

            return revision_id

        else:

            branch_revision = source_branch.getBranchRevision(

                revision_id=revision_id)

            if branch_revision is None:

                return "no longer in the source branch."

            elif branch_revision.sequence is None:

                return (

                    "no longer in the revision history of the source branch.")

            else:

                return branch_revision.sequence

    @cachedproperty

    def reviewed_revision_number(self):

        """Return the number of the reviewed revision."""

        return self._getRevisionNumberForRevisionId(

            self.context.reviewed_revision_id)

    @cachedproperty

    def queued_revision_number(self):

        """Return the number of the queued revision."""

        return self._getRevisionNumberForRevisionId(

            self.context.queued_revision_id)

class BranchMergeProposalNavigation(Navigation):

    """Navigation from BranchMergeProposal to CodeReviewComment views."""

    usedfor = IBranchMergeProposal

    @stepthrough('reviews')

    def traverse_review(self, id):

        """Navigate to a CodeReviewVoteReference through its BMP."""

        try:

            id = int(id)

        except ValueError:

            return None

        try:

            return self.context.getVoteReference(id)

        except WrongBranchMergeProposal:

            return None

    @stepthrough('comments')

    def traverse_comment(self, id):

        try:

            id = int(id)

        except ValueError:

            return None

        try:

            return self.context.getComment(id)

        except WrongBranchMergeProposal:

            return None

    @stepto("+preview-diff")

    def preview_diff(self):

        """Step to the preview diff."""

        return self.context.preview_diff

    @stepthrough('+review')

    def review(self, id):

        """Step to the CodeReviewVoteReference."""

        try:

            id = int(id)

        except ValueError:

            return None

        try:

            return self.context.getVoteReference(id)

        except WrongBranchMergeProposal:

            return None

class CodeReviewConversation:

    """A code review conversation."""

    implements(IConversation)

    def __init__(self, comments):

        self.comments = comments

class ClaimButton(Interface):

    """A simple interface to populate the form to enqueue a proposal."""

    review_id = Int(required=True)

class BranchMergeProposalStatusMixin:

    '''A mixin for generating status vocabularies.'''

    def _createStatusVocabulary(self):

        # Create the vocabulary that is used for the status widget.

        possible_next_states = (

            BranchMergeProposalStatus.WORK_IN_PROGRESS,

            BranchMergeProposalStatus.NEEDS_REVIEW,

            BranchMergeProposalStatus.CODE_APPROVED,

            BranchMergeProposalStatus.REJECTED,

            # BranchMergeProposalStatus.QUEUED,

            BranchMergeProposalStatus.MERGED,

            )

        terms = []

        for status in possible_next_states:

            if not self.context.isValidTransition(status, self.user):

                continue

            else:

                title = status.title

            terms.append(SimpleTerm(status, status.name, title))

        return SimpleVocabulary(terms)

class DiffRenderingMixin:

    """A mixin class for handling diff text."""

    @cachedproperty

    def preview_diff_text(self):

        """Return a (hopefully) intelligently encoded review diff."""

        preview_diff = self.preview_diff

        if preview_diff is None:

            return None

        try:

            diff = preview_diff.text.decode('utf-8')

        except UnicodeDecodeError:

            diff = preview_diff.text.decode('windows-1252', 'replace')

        # Strip off the trailing carriage returns.

        return diff.rstrip('\n')

    @cachedproperty

    def diff_oversized(self):

        """Return True if the preview_diff is over the configured size limit.

        The diff can be over the limit in two ways.  If the diff is oversized

        in bytes it will be cut off at the Diff.text method.  If the number of

        lines is over the max_format_lines, then it is cut off at the fmt:diff

        processing.

        """

        preview_diff = self.preview_diff

        if preview_diff is None:

            return False

        diff_text = self.preview_diff_text

        return diff_text.count('\n') >= config.diff.max_format_lines

class ICodeReviewNewRevisions(IComment):

    """Marker interface used to register views for CodeReviewNewRevisions."""

class CodeReviewNewRevisions:

    """Represents a logical grouping of revisions.

    Each object instance represents a number of revisions scanned at a

    particular time.

    """

    implements(ICodeReviewNewRevisions)

    def __init__(self, revisions, date, branch, diff):

        self.revisions = revisions

        self.branch = branch

        self.has_body = False

        self.has_footer = True

        # The date attribute is used to sort the comments in the conversation.

        self.date = date

        self.diff = diff

        # Other standard IComment attributes are not used.

        self.extra_css_class = None

        self.comment_author = None

        self.body_text = None

        self.comment_date = None

        self.display_attachments = False

class CodeReviewNewRevisionsView(LaunchpadView):

    """The view for rendering the new revisions."""

    @property

    def codebrowse_url(self):

        """Return the link to codebrowse for this branch."""

        return self.context.branch.codebrowse_url()

class BranchMergeProposalView(LaunchpadFormView, UnmergedRevisionsMixin,

                              BranchMergeProposalRevisionIdMixin,

                              BranchMergeProposalStatusMixin,

                              DiffRenderingMixin):

    """A basic view used for the index page."""

    implements(IBranchMergeProposalActionMenu)

    schema = ClaimButton

    def initialize(self):

        super(BranchMergeProposalView, self).initialize()

        cache = IJSONRequestCache(self.request)

        cache.objects.update({

            'branch_diff_link':

                'https://%s/+loggerhead/%s/diff/' % (

                    config.launchpad.code_domain,

                    self.context.source_branch.unique_name),

            })

        if getFeatureFlag("longpoll.merge_proposals.enabled"):

            cache.objects['merge_proposal_event_key'] = (

                subscribe(self.context).event_key)

    @action('Claim', name='claim')

    def claim_action(self, action, data):

        """Claim this proposal."""

        request = self.context.getVoteReference(data['review_id'])

        if request is not None:

            try:

                request.claimReview(self.user)

            except ClaimReviewFailed as e:

                self.request.response.addErrorNotification(unicode(e))

        self.next_url = canonical_url(self.context)

    @property

    def comment_location(self):

        """Location of page for commenting on this proposal."""

        return canonical_url(self.context, view_name='+comment')

    @cachedproperty

    def conversation(self):

        """Return a conversation that is to be rendered."""

        # Sort the comments by date order.

        merge_proposal = self.context

        groups = list(merge_proposal.getRevisionsSinceReviewStart())

        source = DecoratedBranch(merge_proposal.source_branch)

        comments = []

        if getFeatureFlag('code.incremental_diffs.enabled'):

            ranges = [

                (revisions[0].revision.getLefthandParent(),

                 revisions[-1].revision)

                for revisions in groups]

            diffs = merge_proposal.getIncrementalDiffs(ranges)

        else:

            diffs = [None] * len(groups)

        for revisions, diff in zip(groups, diffs):

            newrevs = CodeReviewNewRevisions(

                revisions, revisions[-1].revision.date_created, source, diff)

            comments.append(newrevs)

        while merge_proposal is not None:

            from_superseded = merge_proposal != self.context

            comments.extend(

                CodeReviewDisplayComment(comment, from_superseded)

                for comment in merge_proposal.all_comments)

            merge_proposal = merge_proposal.supersedes

        comments = sorted(comments, key=operator.attrgetter('date'))

        return CodeReviewConversation(comments)

    @property

    def comments(self):

        """Return comments associated with this proposal, plus styling info.

        Comments are in threaded order, and the style indicates indenting

        for use with threads.

        """

        message_to_comment = {}

        messages = []

        for comment in self.context.all_comments:

            message_to_comment[comment.message] = comment

            messages.append(comment.message)

        message_set = getUtility(IMessageSet)

        threads = message_set.threadMessages(messages)

        result = []

        for depth, message in message_set.flattenThreads(threads):

            comment = message_to_comment[message]

            style = 'margin-left: %dem;' % (2 * depth)

            result.append(dict(style=style, comment=comment))

        return result

    @property

    def label(self):

        return "Merge %s into %s" % (

            self.context.source_branch.bzr_identity,

            self.context.target_branch.bzr_identity)

    @property

    def pending_diff(self):

        return (

            self.context.next_preview_diff_job is not None or

            self.context.source_branch.pending_writes)

    @cachedproperty

    def preview_diff(self):

        """Return a `Diff` of the preview.

        If no preview is available, try using the review diff.

        """