/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/plugins/launchpad/lp_propose.py

  • Committer: Vincent Ladeuil
  • Date: 2010-01-25 15:55:48 UTC
  • mto: (4985.1.4 add-attr-cleanup)
  • mto: This revision was merged to the branch mainline in revision 4988.
  • Revision ID: v.ladeuil+lp@free.fr-20100125155548-0l352pujvt5bzl5e
Deploy addAttrCleanup on the whole test suite.

Several use case worth mentioning:

- setting a module or any other object attribute is the majority
by far. In some cases the setting itself is deferred but most of
the time we want to set at the same time we add the cleanup.

- there multiple occurrences of protecting hooks or ui factory
which are now useless (the test framework takes care of that now),

- there was some lambda uses that can now be avoided.

That first cleanup already simplifies things a lot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2010 Canonical Ltd
2
 
#
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
 
18
 
import urlparse
19
 
import webbrowser
20
 
 
21
 
from bzrlib import (
22
 
    errors,
23
 
    hooks,
24
 
    msgeditor,
25
 
)
26
 
from bzrlib.plugins.launchpad import (
27
 
    lp_api,
28
 
    lp_registration,
29
 
)
30
 
 
31
 
from lazr.restfulclient import errors as restful_errors
32
 
 
33
 
 
34
 
class ProposeMergeHooks(hooks.Hooks):
35
 
    """Hooks for proposing a merge on Launchpad."""
36
 
 
37
 
    def __init__(self):
38
 
        hooks.Hooks.__init__(self)
39
 
        self.create_hook(
40
 
            hooks.HookPoint(
41
 
                'get_prerequisite',
42
 
                "Return the prerequisite branch for proposing as merge.",
43
 
                (2, 1), None),
44
 
        )
45
 
        self.create_hook(
46
 
            hooks.HookPoint(
47
 
                'merge_proposal_body',
48
 
                "Return an initial body for the merge proposal message.",
49
 
                (2, 1), None),
50
 
        )
51
 
 
52
 
 
53
 
class Proposer(object):
54
 
 
55
 
    hooks = ProposeMergeHooks()
56
 
 
57
 
    def __init__(self, tree, source_branch, target_branch, message, reviews,
58
 
                 staging=False):
59
 
        """Constructor.
60
 
 
61
 
        :param tree: The working tree for the source branch.
62
 
        :param source_branch: The branch to propose for merging.
63
 
        :param target_branch: The branch to merge into.
64
 
        :param message: The commit message to use.  (May be None.)
65
 
        :param reviews: A list of tuples of reviewer, review type.
66
 
        :param staging: If True, propose the merge against staging instead of
67
 
            production.
68
 
        """
69
 
        self.tree = tree
70
 
        if staging:
71
 
            lp_instance = 'staging'
72
 
        else:
73
 
            lp_instance = 'edge'
74
 
        service = lp_registration.LaunchpadService(lp_instance=lp_instance)
75
 
        self.launchpad = lp_api.login(service)
76
 
        self.source_branch = lp_api.LaunchpadBranch.from_bzr(
77
 
            self.launchpad, source_branch)
78
 
        if target_branch is None:
79
 
            self.target_branch = self.source_branch.get_dev_focus()
80
 
        else:
81
 
            self.target_branch = lp_api.LaunchpadBranch.from_bzr(
82
 
                self.launchpad, target_branch)
83
 
        self.commit_message = message
84
 
        if reviews == []:
85
 
            target_reviewer = self.target_branch.lp.reviewer
86
 
            if target_reviewer is None:
87
 
                raise errors.BzrCommandError('No reviewer specified')
88
 
            self.reviews = [(target_reviewer, '')]
89
 
        else:
90
 
            self.reviews = [(self.launchpad.people[reviewer], review_type)
91
 
                            for reviewer, review_type in
92
 
                            reviews]
93
 
 
94
 
    def get_comment(self, prerequisite_branch):
95
 
        """Determine the initial comment for the merge proposal."""
96
 
        info = ["Source: %s\n" % self.source_branch.lp.bzr_identity]
97
 
        info.append("Target: %s\n" % self.target_branch.lp.bzr_identity)
98
 
        if prerequisite_branch is not None:
99
 
            info.append("Prereq: %s\n" % prerequisite_branch.lp.bzr_identity)
100
 
        for rdata in self.reviews:
101
 
            uniquename = "%s (%s)" % (rdata[0].display_name, rdata[0].name)
102
 
            info.append('Reviewer: %s, type "%s"\n' % (uniquename, rdata[1]))
103
 
        self.source_branch.bzr.lock_read()
104
 
        try:
105
 
            self.target_branch.bzr.lock_read()
106
 
            try:
107
 
                body = self.get_initial_body()
108
 
            finally:
109
 
                self.target_branch.bzr.unlock()
110
 
        finally:
111
 
            self.source_branch.bzr.unlock()
112
 
        initial_comment = msgeditor.edit_commit_message(''.join(info),
113
 
                                                        start_message=body)
114
 
        return initial_comment.strip().encode('utf-8')
115
 
 
116
 
    def get_initial_body(self):
117
 
        """Get a body for the proposal for the user to modify.
118
 
 
119
 
        :return: a str or None.
120
 
        """
121
 
        def list_modified_files():
122
 
            lca_tree = self.source_branch.find_lca_tree(
123
 
                self.target_branch)
124
 
            source_tree = self.source_branch.bzr.basis_tree()
125
 
            files = modified_files(lca_tree, source_tree)
126
 
            return list(files)
127
 
        target_loc = ('bzr+ssh://bazaar.launchpad.net/%s' %
128
 
                       self.target_branch.lp.unique_name)
129
 
        body = None
130
 
        for hook in self.hooks['merge_proposal_body']:
131
 
            body = hook({
132
 
                'tree': self.tree,
133
 
                'target_branch': target_loc,
134
 
                'modified_files_callback': list_modified_files,
135
 
                'old_body': body,
136
 
            })
137
 
        return body
138
 
 
139
 
    def check_proposal(self):
140
 
        """Check that the submission is sensible."""
141
 
        if self.source_branch.lp.self_link == self.target_branch.lp.self_link:
142
 
            raise errors.BzrCommandError(
143
 
                'Source and target branches must be different.')
144
 
        for mp in self.source_branch.lp.landing_targets:
145
 
            if mp.queue_status in ('Merged', 'Rejected'):
146
 
                continue
147
 
            if mp.target_branch.self_link == self.target_branch.lp.self_link:
148
 
                raise errors.BzrCommandError(
149
 
                    'There is already a branch merge proposal: %s' %
150
 
                    canonical_url(mp))
151
 
 
152
 
    def _get_prerequisite_branch(self):
153
 
        hooks = self.hooks['get_prerequisite']
154
 
        prerequisite_branch = None
155
 
        for hook in hooks:
156
 
            prerequisite_branch = hook(
157
 
                {'launchpad': self.launchpad,
158
 
                 'source_branch': self.source_branch,
159
 
                 'target_branch': self.target_branch,
160
 
                 'prerequisite_branch': prerequisite_branch})
161
 
        return prerequisite_branch
162
 
 
163
 
    def create_proposal(self):
164
 
        """Perform the submission."""
165
 
        prerequisite_branch = self._get_prerequisite_branch()
166
 
        if prerequisite_branch is None:
167
 
            prereq = None
168
 
        else:
169
 
            prereq = prerequisite_branch.lp
170
 
            prerequisite_branch.update_lp()
171
 
        self.source_branch.update_lp()
172
 
        reviewers = []
173
 
        review_types = []
174
 
        for reviewer, review_type in self.reviews:
175
 
            review_types.append(review_type)
176
 
            reviewers.append(reviewer.self_link)
177
 
        initial_comment = self.get_comment(prerequisite_branch)
178
 
        try:
179
 
            mp = self.source_branch.lp.createMergeProposal(
180
 
                target_branch=self.target_branch.lp,
181
 
                prerequisite_branch=prereq,
182
 
                initial_comment=initial_comment,
183
 
                commit_message=self.commit_message, reviewers=reviewers,
184
 
                review_types=review_types)
185
 
        except restful_errors.HTTPError, e:
186
 
            error_lines = []
187
 
            for line in e.content.splitlines():
188
 
                if line.startswith('Traceback (most recent call last):'):
189
 
                    break
190
 
                error_lines.append(line)
191
 
            raise Exception(''.join(error_lines))
192
 
        else:
193
 
            webbrowser.open(canonical_url(mp))
194
 
 
195
 
 
196
 
def modified_files(old_tree, new_tree):
197
 
    """Return a list of paths in the new tree with modified contents."""
198
 
    for f, (op, path), c, v, p, n, (ok, k), e in new_tree.iter_changes(
199
 
        old_tree):
200
 
        if c and k == 'file':
201
 
            yield str(path)
202
 
 
203
 
 
204
 
def canonical_url(object):
205
 
    """Return the canonical URL for a branch."""
206
 
    scheme, netloc, path, params, query, fragment = urlparse.urlparse(
207
 
        str(object.self_link))
208
 
    path = '/'.join(path.split('/')[2:])
209
 
    netloc = netloc.replace('api.', 'code.')
210
 
    return urlparse.urlunparse((scheme, netloc, path, params, query,
211
 
                                fragment))