/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 breezy/plugins/propose/cmds.py

  • Committer: Jelmer Vernooij
  • Date: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/plugins/propose/cmds.py
 
1
# Copyright (C) 2018 Jelmer Vernooij <jelmer@jelmer.uk>
 
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
"""Propose command implementations."""
 
18
 
 
19
from __future__ import absolute_import
 
20
 
 
21
from io import StringIO
 
22
 
 
23
from ... import (
 
24
    branch as _mod_branch,
 
25
    controldir,
 
26
    errors,
 
27
    log as _mod_log,
 
28
    missing as _mod_missing,
 
29
    msgeditor,
 
30
    urlutils,
 
31
    )
 
32
from ...i18n import gettext
 
33
from ...commands import Command
 
34
from ...option import (
 
35
    ListOption,
 
36
    Option,
 
37
    RegistryOption,
 
38
    )
 
39
from ...sixish import text_type
 
40
from ...trace import note
 
41
from ... import (
 
42
    propose as _mod_propose,
 
43
    )
 
44
 
 
45
 
 
46
def branch_name(branch):
 
47
    if branch.name:
 
48
        return branch.name
 
49
    return urlutils.basename(branch.user_url)
 
50
 
 
51
 
 
52
class cmd_publish_derived(Command):
 
53
    __doc__ = """Publish a derived branch.
 
54
 
 
55
    Try to create a public copy of a local branch on a hosting site,
 
56
    derived from the specified base branch.
 
57
 
 
58
    Reasonable defaults are picked for owner name, branch name and project
 
59
    name, but they can also be overridden from the command-line.
 
60
    """
 
61
 
 
62
    takes_options = [
 
63
        'directory',
 
64
        Option('owner', help='Owner of the new remote branch.', type=str),
 
65
        Option('project', help='Project name for the new remote branch.',
 
66
               type=str),
 
67
        Option('name', help='Name of the new remote branch.', type=str),
 
68
        Option('no-allow-lossy',
 
69
               help='Allow fallback to lossy push, if necessary.'),
 
70
        Option('overwrite', help="Overwrite existing commits."),
 
71
        ]
 
72
    takes_args = ['submit_branch?']
 
73
 
 
74
    def run(self, submit_branch=None, owner=None, name=None, project=None,
 
75
            no_allow_lossy=False, overwrite=False, directory='.'):
 
76
        local_branch = _mod_branch.Branch.open_containing(directory)[0]
 
77
        self.add_cleanup(local_branch.lock_write().unlock)
 
78
        if submit_branch is None:
 
79
            submit_branch = local_branch.get_submit_branch()
 
80
            note(gettext('Using submit branch %s') % submit_branch)
 
81
        if submit_branch is None:
 
82
            submit_branch = local_branch.get_parent()
 
83
            note(gettext('Using parent branch %s') % submit_branch)
 
84
        submit_branch = _mod_branch.Branch.open(submit_branch)
 
85
        if name is None:
 
86
            name = branch_name(local_branch)
 
87
        hoster = _mod_propose.get_hoster(submit_branch)
 
88
        remote_branch, public_url = hoster.publish_derived(
 
89
            local_branch, submit_branch, name=name, project=project,
 
90
            owner=owner, allow_lossy=not no_allow_lossy,
 
91
            overwrite=overwrite)
 
92
        local_branch.set_push_location(remote_branch.user_url)
 
93
        local_branch.set_public_branch(public_url)
 
94
        local_branch.set_submit_branch(submit_branch.user_url)
 
95
        note(gettext("Pushed to %s") % public_url)
 
96
 
 
97
 
 
98
def summarize_unmerged(local_branch, remote_branch, target,
 
99
                       prerequisite_branch=None):
 
100
    """Generate a text description of the unmerged revisions in branch.
 
101
 
 
102
    :param branch: The proposed branch
 
103
    :param target: Target branch
 
104
    :param prerequisite_branch: Optional prerequisite branch
 
105
    :return: A string
 
106
    """
 
107
    log_format = _mod_log.log_formatter_registry.get_default(local_branch)
 
108
    to_file = StringIO()
 
109
    lf = log_format(to_file=to_file, show_ids=False, show_timezone='original')
 
110
    if prerequisite_branch:
 
111
        local_extra = _mod_missing.find_unmerged(
 
112
            remote_branch, prerequisite_branch, restrict='local')[0]
 
113
    else:
 
114
        local_extra = _mod_missing.find_unmerged(
 
115
            remote_branch, target, restrict='local')[0]
 
116
 
 
117
    if remote_branch.supports_tags():
 
118
        rev_tag_dict = remote_branch.tags.get_reverse_tag_dict()
 
119
    else:
 
120
        rev_tag_dict = {}
 
121
 
 
122
    for revision in _mod_missing.iter_log_revisions(
 
123
            local_extra, local_branch.repository, False, rev_tag_dict):
 
124
        lf.log_revision(revision)
 
125
    return to_file.getvalue()
 
126
 
 
127
 
 
128
class cmd_propose_merge(Command):
 
129
    __doc__ = """Propose a branch for merging.
 
130
 
 
131
    This command creates a merge proposal for the local
 
132
    branch to the target branch. The format of the merge
 
133
    proposal depends on the submit branch.
 
134
    """
 
135
 
 
136
    takes_options = [
 
137
        'directory',
 
138
        RegistryOption(
 
139
            'hoster',
 
140
            help='Use the hoster.',
 
141
            lazy_registry=('breezy.plugins.propose.propose', 'hosters')),
 
142
        ListOption('reviewers', short_name='R', type=text_type,
 
143
                   help='Requested reviewers.'),
 
144
        Option('name', help='Name of the new remote branch.', type=str),
 
145
        Option('description', help='Description of the change.', type=str),
 
146
        Option('prerequisite', help='Prerequisite branch.', type=str),
 
147
        Option('wip', help='Mark merge request as work-in-progress'),
 
148
        Option(
 
149
            'commit-message',
 
150
            help='Set commit message for merge, if supported', type=str),
 
151
        ListOption('labels', short_name='l', type=text_type,
 
152
                   help='Labels to apply.'),
 
153
        Option('no-allow-lossy',
 
154
               help='Allow fallback to lossy push, if necessary.'),
 
155
        Option('allow-collaboration',
 
156
               help='Allow collaboration from target branch maintainer(s)'),
 
157
        ]
 
158
    takes_args = ['submit_branch?']
 
159
 
 
160
    aliases = ['propose']
 
161
 
 
162
    def run(self, submit_branch=None, directory='.', hoster=None,
 
163
            reviewers=None, name=None, no_allow_lossy=False, description=None,
 
164
            labels=None, prerequisite=None, commit_message=None, wip=False,
 
165
            allow_collaboration=False):
 
166
        tree, branch, relpath = (
 
167
            controldir.ControlDir.open_containing_tree_or_branch(directory))
 
168
        if submit_branch is None:
 
169
            submit_branch = branch.get_submit_branch()
 
170
        if submit_branch is None:
 
171
            submit_branch = branch.get_parent()
 
172
        if submit_branch is None:
 
173
            raise errors.BzrCommandError(
 
174
                gettext("No target location specified or remembered"))
 
175
        else:
 
176
            target = _mod_branch.Branch.open(submit_branch)
 
177
        if hoster is None:
 
178
            hoster = _mod_propose.get_hoster(target)
 
179
        else:
 
180
            hoster = hoster.probe(target)
 
181
        if name is None:
 
182
            name = branch_name(branch)
 
183
        remote_branch, public_branch_url = hoster.publish_derived(
 
184
            branch, target, name=name, allow_lossy=not no_allow_lossy)
 
185
        branch.set_push_location(remote_branch.user_url)
 
186
        branch.set_submit_branch(target.user_url)
 
187
        note(gettext('Published branch to %s') % public_branch_url)
 
188
        if prerequisite is not None:
 
189
            prerequisite_branch = _mod_branch.Branch.open(prerequisite)
 
190
        else:
 
191
            prerequisite_branch = None
 
192
        proposal_builder = hoster.get_proposer(remote_branch, target)
 
193
        if description is None:
 
194
            body = proposal_builder.get_initial_body()
 
195
            info = proposal_builder.get_infotext()
 
196
            info += "\n\n" + summarize_unmerged(
 
197
                branch, remote_branch, target, prerequisite_branch)
 
198
            description = msgeditor.edit_commit_message(
 
199
                info, start_message=body)
 
200
        try:
 
201
            proposal = proposal_builder.create_proposal(
 
202
                description=description, reviewers=reviewers,
 
203
                prerequisite_branch=prerequisite_branch, labels=labels,
 
204
                commit_message=commit_message,
 
205
                work_in_progress=wip, allow_collaboration=allow_collaboration)
 
206
        except _mod_propose.MergeProposalExists as e:
 
207
            note(gettext('There is already a branch merge proposal: %s'), e.url)
 
208
        else:
 
209
            note(gettext('Merge proposal created: %s') % proposal.url)
 
210
 
 
211
 
 
212
class cmd_find_merge_proposal(Command):
 
213
    __doc__ = """Find a merge proposal.
 
214
 
 
215
    """
 
216
 
 
217
    takes_options = ['directory']
 
218
    takes_args = ['submit_branch?']
 
219
    aliases = ['find-proposal']
 
220
 
 
221
    def run(self, directory='.', submit_branch=None):
 
222
        tree, branch, relpath = controldir.ControlDir.open_containing_tree_or_branch(
 
223
            directory)
 
224
        public_location = branch.get_public_branch()
 
225
        if public_location:
 
226
            branch = _mod_branch.Branch.open(public_location)
 
227
        if submit_branch is None:
 
228
            submit_branch = branch.get_submit_branch()
 
229
        if submit_branch is None:
 
230
            submit_branch = branch.get_parent()
 
231
        if submit_branch is None:
 
232
            raise errors.BzrCommandError(
 
233
                gettext("No target location specified or remembered"))
 
234
        else:
 
235
            target = _mod_branch.Branch.open(submit_branch)
 
236
        hoster = _mod_propose.get_hoster(branch)
 
237
        for mp in hoster.iter_proposals(branch, target):
 
238
            self.outf.write(gettext('Merge proposal: %s\n') % mp.url)
 
239
 
 
240
 
 
241
class cmd_github_login(Command):
 
242
    __doc__ = """Log into GitHub.
 
243
 
 
244
    When communicating with GitHub, some commands need to authenticate to
 
245
    GitHub.
 
246
    """
 
247
 
 
248
    takes_args = ['username?']
 
249
 
 
250
    def run(self, username=None):
 
251
        from github import Github, GithubException
 
252
        from breezy.config import AuthenticationConfig
 
253
        authconfig = AuthenticationConfig()
 
254
        if username is None:
 
255
            username = authconfig.get_user(
 
256
                'https', 'github.com', prompt=u'GitHub username', ask=True)
 
257
        password = authconfig.get_password('https', 'github.com', username)
 
258
        client = Github(username, password)
 
259
        user = client.get_user()
 
260
        try:
 
261
            authorization = user.create_authorization(
 
262
                scopes=['user', 'repo', 'delete_repo'], note='Breezy',
 
263
                note_url='https://github.com/breezy-team/breezy')
 
264
        except GithubException as e:
 
265
            errs = e.data.get('errors', [])
 
266
            if errs:
 
267
                err_code = errs[0].get('code')
 
268
                if err_code == u'already_exists':
 
269
                    raise errors.BzrCommandError('token already exists')
 
270
            raise errors.BzrCommandError(e.data['message'])
 
271
        # TODO(jelmer): This should really use something in
 
272
        # AuthenticationConfig
 
273
        from .github import store_github_token
 
274
        store_github_token(scheme='https', host='github.com',
 
275
                           token=authorization.token)
 
276
 
 
277
 
 
278
class cmd_gitlab_login(Command):
 
279
    __doc__ = """Log into a GitLab instance.
 
280
 
 
281
    This command takes a GitLab instance URL (e.g. https://gitlab.com)
 
282
    as well as an optional private token. Private tokens can be created via the
 
283
    web UI.
 
284
 
 
285
    :Examples:
 
286
 
 
287
      Log into GNOME's GitLab (prompts for a token):
 
288
 
 
289
         brz gitlab-login https://gitlab.gnome.org/
 
290
 
 
291
      Log into Debian's salsa, using a token created earlier:
 
292
 
 
293
         brz gitlab-login https://salsa.debian.org if4Theis6Eich7aef0zo
 
294
    """
 
295
 
 
296
    takes_args = ['url', 'private_token?']
 
297
 
 
298
    takes_options = [
 
299
        Option('name', help='Name for GitLab site in configuration.',
 
300
               type=str),
 
301
        Option('no-check',
 
302
               "Don't check that the token is valid."),
 
303
        ]
 
304
 
 
305
    def run(self, url, private_token=None, name=None, no_check=False):
 
306
        from breezy import ui
 
307
        from .gitlabs import store_gitlab_token
 
308
        if name is None:
 
309
            try:
 
310
                name = urlutils.parse_url(url)[3].split('.')[-2]
 
311
            except (ValueError, IndexError):
 
312
                raise errors.BzrCommandError(
 
313
                    'please specify a site name with --name')
 
314
        if private_token is None:
 
315
            note("Please visit %s to obtain a private token.",
 
316
                 urlutils.join(url, "profile/personal_access_tokens"))
 
317
            private_token = ui.ui_factory.get_password(u'Private token')
 
318
        if not no_check:
 
319
            from breezy.transport import get_transport
 
320
            from .gitlabs import GitLab
 
321
            GitLab(get_transport(url), private_token=private_token)
 
322
        store_gitlab_token(name=name, url=url, private_token=private_token)
 
323
 
 
324
 
 
325
class cmd_my_merge_proposals(Command):
 
326
    __doc__ = """List all merge proposals owned by the logged-in user.
 
327
 
 
328
    """
 
329
 
 
330
    hidden = True
 
331
 
 
332
    takes_options = [
 
333
        'verbose',
 
334
        RegistryOption.from_kwargs(
 
335
            'status',
 
336
            title='Proposal Status',
 
337
            help='Only include proposals with specified status.',
 
338
            value_switches=True,
 
339
            enum_switch=True,
 
340
            all='All merge proposals',
 
341
            open='Open merge proposals',
 
342
            merged='Merged merge proposals',
 
343
            closed='Closed merge proposals')]
 
344
 
 
345
    def run(self, status='open', verbose=False):
 
346
        for name, hoster_cls in _mod_propose.hosters.items():
 
347
            for instance in hoster_cls.iter_instances():
 
348
                for mp in instance.iter_my_proposals(status=status):
 
349
                    self.outf.write('%s\n' % mp.url)
 
350
                    if verbose:
 
351
                        self.outf.write(
 
352
                            '(Merging %s into %s)\n' %
 
353
                            (mp.get_source_branch_url(),
 
354
                             mp.get_target_branch_url()))
 
355
                        description = mp.get_description()
 
356
                        if description:
 
357
                            self.outf.writelines(
 
358
                                ['\t%s\n' % l
 
359
                                 for l in description.splitlines()])
 
360
                        self.outf.write('\n')
 
361
 
 
362
 
 
363
class cmd_land_merge_proposal(Command):
 
364
    __doc__ = """Land a merge proposal."""
 
365
 
 
366
    takes_args = ['url']
 
367
    takes_options = [
 
368
        Option('message', help='Commit message to use.', type=str)]
 
369
 
 
370
    def run(self, url, message=None):
 
371
        proposal = _mod_propose.get_proposal_by_url(url)
 
372
        proposal.merge(commit_message=message)