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

  • Committer: Richard Wilbur
  • Date: 2016-02-04 19:07:28 UTC
  • mto: This revision was merged to the branch mainline in revision 6618.
  • Revision ID: richard.wilbur@gmail.com-20160204190728-p0zvfii6zase0fw7
Update COPYING.txt from the original http://www.gnu.org/licenses/gpl-2.0.txt  (Only differences were in whitespace.)  Thanks to Petr Stodulka for pointing out the discrepancy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/plugins/launchpad/cmds.py
1
 
# Copyright (C) 2006-2017 Canonical Ltd
 
1
# Copyright (C) 2006-2012 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
18
18
 
19
19
from __future__ import absolute_import
20
20
 
21
 
from ... import (
 
21
from bzrlib import (
22
22
    branch as _mod_branch,
23
23
    controldir,
24
24
    trace,
25
25
    )
26
 
from ...commands import (
 
26
from bzrlib.commands import (
27
27
    Command,
28
28
    )
29
 
from ...errors import (
 
29
from bzrlib.errors import (
30
30
    BzrCommandError,
 
31
    InvalidURL,
 
32
    NoPublicBranch,
31
33
    NotBranchError,
32
34
    )
33
 
from ...i18n import gettext
34
 
from ...option import (
 
35
from bzrlib.i18n import gettext
 
36
from bzrlib.option import (
35
37
    Option,
36
38
    ListOption,
37
39
    )
38
 
from ...sixish import (
39
 
    text_type,
40
 
    )
 
40
 
 
41
 
 
42
class cmd_register_branch(Command):
 
43
    __doc__ = """Register a branch with launchpad.net.
 
44
 
 
45
    This command lists a bzr branch in the directory of branches on
 
46
    launchpad.net.  Registration allows the branch to be associated with
 
47
    bugs or specifications.
 
48
 
 
49
    Before using this command you must register the project to which the
 
50
    branch belongs, and create an account for yourself on launchpad.net.
 
51
 
 
52
    arguments:
 
53
        public_url: The publicly visible url for the branch to register.
 
54
                    This must be an http or https url (which Launchpad can read
 
55
                    from to access the branch). Local file urls, SFTP urls, and
 
56
                    bzr+ssh urls will not work.
 
57
                    If no public_url is provided, bzr will use the configured
 
58
                    public_url if there is one for the current branch, and
 
59
                    otherwise error.
 
60
 
 
61
    example:
 
62
        bzr register-branch http://foo.com/bzr/fooproject.mine \\
 
63
                --project fooproject
 
64
    """
 
65
    takes_args = ['public_url?']
 
66
    takes_options = [
 
67
         Option('project',
 
68
                'Launchpad project short name to associate with the branch.',
 
69
                unicode),
 
70
         Option('product',
 
71
                'Launchpad product short name to associate with the branch.',
 
72
                unicode,
 
73
                hidden=True),
 
74
         Option('branch-name',
 
75
                'Short name for the branch; '
 
76
                'by default taken from the last component of the url.',
 
77
                unicode),
 
78
         Option('branch-title',
 
79
                'One-sentence description of the branch.',
 
80
                unicode),
 
81
         Option('branch-description',
 
82
                'Longer description of the purpose or contents of the branch.',
 
83
                unicode),
 
84
         Option('author',
 
85
                "Branch author's email address, if not yourself.",
 
86
                unicode),
 
87
         Option('link-bug',
 
88
                'The bug this branch fixes.',
 
89
                int),
 
90
         Option('dry-run',
 
91
                'Prepare the request but don\'t actually send it.')
 
92
        ]
 
93
 
 
94
 
 
95
    def run(self,
 
96
            public_url=None,
 
97
            project='',
 
98
            product=None,
 
99
            branch_name='',
 
100
            branch_title='',
 
101
            branch_description='',
 
102
            author='',
 
103
            link_bug=None,
 
104
            dry_run=False):
 
105
        from bzrlib.plugins.launchpad.lp_registration import (
 
106
            BranchRegistrationRequest, BranchBugLinkRequest,
 
107
            DryRunLaunchpadService, LaunchpadService)
 
108
        if public_url is None:
 
109
            try:
 
110
                b = _mod_branch.Branch.open_containing('.')[0]
 
111
            except NotBranchError:
 
112
                raise BzrCommandError(gettext(
 
113
                            'register-branch requires a public '
 
114
                            'branch url - see bzr help register-branch.'))
 
115
            public_url = b.get_public_branch()
 
116
            if public_url is None:
 
117
                raise NoPublicBranch(b)
 
118
        if product is not None:
 
119
            project = product
 
120
            trace.note(gettext(
 
121
                '--product is deprecated; please use --project.'))
 
122
 
 
123
 
 
124
        rego = BranchRegistrationRequest(branch_url=public_url,
 
125
                                         branch_name=branch_name,
 
126
                                         branch_title=branch_title,
 
127
                                         branch_description=branch_description,
 
128
                                         product_name=project,
 
129
                                         author_email=author,
 
130
                                         )
 
131
        linko = BranchBugLinkRequest(branch_url=public_url,
 
132
                                     bug_id=link_bug)
 
133
        if not dry_run:
 
134
            service = LaunchpadService()
 
135
            # This gives back the xmlrpc url that can be used for future
 
136
            # operations on the branch.  It's not so useful to print to the
 
137
            # user since they can't do anything with it from a web browser; it
 
138
            # might be nice for the server to tell us about an html url as
 
139
            # well.
 
140
        else:
 
141
            # Run on service entirely in memory
 
142
            service = DryRunLaunchpadService()
 
143
        service.gather_user_credentials()
 
144
        rego.submit(service)
 
145
        if link_bug:
 
146
            linko.submit(service)
 
147
        self.outf.write('Branch registered.\n')
41
148
 
42
149
 
43
150
class cmd_launchpad_open(Command):
66
173
            yield branch_url
67
174
 
68
175
    def _get_web_url(self, service, location):
69
 
        from .lp_registration import (
70
 
            InvalidURL,
 
176
        from bzrlib.plugins.launchpad.lp_registration import (
71
177
            NotLaunchpadBranch)
72
178
        for branch_url in self._possible_locations(location):
73
179
            try:
77
183
        raise NotLaunchpadBranch(branch_url)
78
184
 
79
185
    def run(self, location=None, dry_run=False):
80
 
        from .lp_registration import (
 
186
        from bzrlib.plugins.launchpad.lp_registration import (
81
187
            LaunchpadService)
82
188
        if location is None:
83
189
            location = u'.'
85
191
        trace.note(gettext('Opening %s in web browser') % web_url)
86
192
        if not dry_run:
87
193
            import webbrowser   # this import should not be lazy
88
 
                                # otherwise brz.exe lacks this module
 
194
                                # otherwise bzr.exe lacks this module
89
195
            webbrowser.open(web_url)
90
196
 
91
197
 
99
205
    :Examples:
100
206
      Show the Launchpad ID of the current user::
101
207
 
102
 
          brz launchpad-login
 
208
          bzr launchpad-login
103
209
 
104
210
      Set the Launchpad ID of the current user to 'bob'::
105
211
 
106
 
          brz launchpad-login bob
 
212
          bzr launchpad-login bob
107
213
    """
108
214
    aliases = ['lp-login']
109
215
    takes_args = ['name?']
115
221
 
116
222
    def run(self, name=None, no_check=False, verbose=False):
117
223
        # This is totally separate from any launchpadlib login system.
118
 
        from . import account
 
224
        from bzrlib.plugins.launchpad import account
119
225
        check_account = not no_check
120
226
 
121
227
        if name is None:
143
249
                                                                        (name,))
144
250
 
145
251
 
146
 
class cmd_launchpad_logout(Command):
147
 
    __doc__ = """Unset the Launchpad user ID.
148
 
 
149
 
    When communicating with Launchpad, some commands need to know your
150
 
    Launchpad user ID.  This command will log you out from Launchpad.
151
 
    This means that communication with Launchpad will happen over
152
 
    HTTPS, and will not require one of your SSH keys to be available.
153
 
    """
154
 
    aliases = ['lp-logout']
155
 
    takes_options = ['verbose']
156
 
 
157
 
    def run(self, verbose=False):
158
 
        from . import account
159
 
        old_username = account.get_lp_login()
160
 
        if old_username is None:
161
 
            self.outf.write(gettext('Not logged into Launchpad.\n'))
162
 
            return 1
163
 
        account.set_lp_login(None)
164
 
        if verbose:
165
 
            self.outf.write(gettext(
166
 
                "Launchpad user ID %s logged out.\n") %
167
 
                old_username)
168
 
 
169
 
 
170
252
# XXX: cmd_launchpad_mirror is untested
171
253
class cmd_launchpad_mirror(Command):
172
254
    __doc__ = """Ask Launchpad to mirror a branch now."""
175
257
    takes_args = ['location?']
176
258
 
177
259
    def run(self, location='.'):
178
 
        from . import lp_api
179
 
        from .lp_registration import LaunchpadService
 
260
        from bzrlib.plugins.launchpad import lp_api
 
261
        from bzrlib.plugins.launchpad.lp_registration import LaunchpadService
180
262
        branch, _ = _mod_branch.Branch.open_containing(location)
181
263
        service = LaunchpadService()
182
264
        launchpad = lp_api.login(service)
200
282
    The parameter the launchpad account name of the desired reviewer.  This
201
283
    may optionally be followed by '=' and the review type.  For example:
202
284
 
203
 
      brz lp-propose-merge --review jrandom --review review-team=qa
 
285
      bzr lp-propose-merge --review jrandom --review review-team=qa
204
286
 
205
287
    This will propose a merge,  request "jrandom" to perform a review of
206
288
    unspecified type, and request "review-team" to perform a "qa" review.
208
290
 
209
291
    takes_options = [Option('staging',
210
292
                            help='Propose the merge on staging.'),
211
 
                     Option('message', short_name='m', type=text_type,
 
293
                     Option('message', short_name='m', type=unicode,
212
294
                            help='Commit message.'),
213
295
                     Option('approve',
214
296
                            help=('Mark the proposal as approved immediately, '
215
297
                                  'setting the approved revision to tip.')),
216
298
                     Option('fixes', 'The bug this proposal fixes.', str),
217
 
                     ListOption('review', short_name='R', type=text_type,
 
299
                     ListOption('review', short_name='R', type=unicode,
218
300
                            help='Requested reviewer and optional type.')]
219
301
 
220
302
    takes_args = ['submit_branch?']
223
305
 
224
306
    def run(self, submit_branch=None, review=None, staging=False,
225
307
            message=None, approve=False, fixes=None):
226
 
        from . import lp_propose
 
308
        from bzrlib.plugins.launchpad import lp_propose
227
309
        tree, branch, relpath = controldir.ControlDir.open_containing_tree_or_branch(
228
310
            '.')
229
311
        if review is None:
261
343
 
262
344
    So, to find the merge proposal that reviewed line 1 of README::
263
345
 
264
 
      brz lp-find-proposal -r mainline:annotate:README:1
 
346
      bzr lp-find-proposal -r mainline:annotate:README:1
265
347
    """
266
348
 
267
349
    takes_options = ['revision']
268
350
 
269
351
    def run(self, revision=None):
270
 
        from ... import ui
271
 
        from . import lp_api
 
352
        from bzrlib import ui
 
353
        from bzrlib.plugins.launchpad import lp_api
272
354
        import webbrowser
273
355
        b = _mod_branch.Branch.open_containing('.')[0]
274
 
        with ui.ui_factory.nested_progress_bar() as pb, b.lock_read():
 
356
        pb = ui.ui_factory.nested_progress_bar()
 
357
        b.lock_read()
 
358
        try:
275
359
            if revision is None:
276
360
                revision_id = b.last_revision()
277
361
            else:
282
366
            trace.note(gettext('%d proposals(s) found.') % len(merged))
283
367
            for mp in merged:
284
368
                webbrowser.open(lp_api.canonical_url(mp))
 
369
        finally:
 
370
            b.unlock()
 
371
            pb.finished()
285
372
 
286
373
    def _find_proposals(self, revision_id, pb):
287
 
        from . import (lp_api, lp_registration)
 
374
        from bzrlib.plugins.launchpad import (lp_api, lp_registration)
288
375
        # "devel" because branches.getMergeProposals is not part of 1.0 API.
289
376
        launchpad = lp_api.login(lp_registration.LaunchpadService(),
290
377
                                 version='devel')