← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Andrew Bennetts
  • Date: 2010-01-12 03:53:21 UTC
  • mfrom: (4948 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4964.
  • Revision ID: andrew.bennetts@canonical.com-20100112035321-hofpz5p10224ryj3
Merge lp:bzr, resolving conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/plugins/launchpad/__init__.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Launchpad.net integration plugin for Bazaar."""
18
18
 
21
21
 
22
22
# see http://bazaar-vcs.org/Specs/BranchRegistrationTool
23
23
 
24
 
from bzrlib.branch import Branch
 
24
# Since we are a built-in plugin we share the bzrlib version
 
25
from bzrlib import version_info
 
26
 
 
27
from bzrlib.lazy_import import lazy_import
 
28
lazy_import(globals(), """
 
29
from bzrlib import (
 
30
    branch as _mod_branch,
 
31
    trace,
 
32
    )
 
33
""")
 
34
 
25
35
from bzrlib.commands import Command, Option, register_command
26
36
from bzrlib.directory_service import directories
27
 
from bzrlib.errors import BzrCommandError, NoPublicBranch, NotBranchError
 
37
from bzrlib.errors import (
 
38
    BzrCommandError,
 
39
    DependencyNotPresent,
 
40
    InvalidURL,
 
41
    NoPublicBranch,
 
42
    NotBranchError,
 
43
    )
28
44
from bzrlib.help_topics import topic_registry
29
45
 
30
46
 
34
50
    This command lists a bzr branch in the directory of branches on
35
51
    launchpad.net.  Registration allows the branch to be associated with
36
52
    bugs or specifications.
37
 
    
38
 
    Before using this command you must register the product to which the
 
53
 
 
54
    Before using this command you must register the project to which the
39
55
    branch belongs, and create an account for yourself on launchpad.net.
40
56
 
41
57
    arguments:
48
64
                    otherwise error.
49
65
 
50
66
    example:
51
 
        bzr register-branch http://foo.com/bzr/fooproduct.mine \\
52
 
                --product fooproduct
 
67
        bzr register-branch http://foo.com/bzr/fooproject.mine \\
 
68
                --project fooproject
53
69
    """
54
70
    takes_args = ['public_url?']
55
71
    takes_options = [
 
72
         Option('project',
 
73
                'Launchpad project short name to associate with the branch.',
 
74
                unicode),
56
75
         Option('product',
57
 
                'Launchpad product short name to associate with the branch.',
58
 
                unicode),
 
76
                'Launchpad product short name to associate with the branch.', 
 
77
                unicode,
 
78
                hidden=True),
59
79
         Option('branch-name',
60
80
                'Short name for the branch; '
61
81
                'by default taken from the last component of the url.',
79
99
 
80
100
    def run(self,
81
101
            public_url=None,
82
 
            product='',
 
102
            project='',
 
103
            product=None,
83
104
            branch_name='',
84
105
            branch_title='',
85
106
            branch_description='',
87
108
            link_bug=None,
88
109
            dry_run=False):
89
110
        from bzrlib.plugins.launchpad.lp_registration import (
90
 
            LaunchpadService, BranchRegistrationRequest, BranchBugLinkRequest,
91
 
            DryRunLaunchpadService)
 
111
            BranchRegistrationRequest, BranchBugLinkRequest,
 
112
            DryRunLaunchpadService, LaunchpadService)
92
113
        if public_url is None:
93
114
            try:
94
 
                b = Branch.open_containing('.')[0]
 
115
                b = _mod_branch.Branch.open_containing('.')[0]
95
116
            except NotBranchError:
96
117
                raise BzrCommandError('register-branch requires a public '
97
118
                    'branch url - see bzr help register-branch.')
98
119
            public_url = b.get_public_branch()
99
120
            if public_url is None:
100
121
                raise NoPublicBranch(b)
 
122
        if product is not None:
 
123
            project = product
 
124
            trace.note('--product is deprecated; please use --project.')
 
125
 
101
126
 
102
127
        rego = BranchRegistrationRequest(branch_url=public_url,
103
128
                                         branch_name=branch_name,
104
129
                                         branch_title=branch_title,
105
130
                                         branch_description=branch_description,
106
 
                                         product_name=product,
 
131
                                         product_name=project,
107
132
                                         author_email=author,
108
133
                                         )
109
134
        linko = BranchBugLinkRequest(branch_url=public_url,
119
144
            # Run on service entirely in memory
120
145
            service = DryRunLaunchpadService()
121
146
        service.gather_user_credentials()
122
 
        branch_object_url = rego.submit(service)
 
147
        rego.submit(service)
123
148
        if link_bug:
124
 
            link_bug_url = linko.submit(service)
 
149
            linko.submit(service)
125
150
        print 'Branch registered.'
126
151
 
127
152
register_command(cmd_register_branch)
128
153
 
129
154
 
130
 
# XXX: Make notes to test this.
131
155
class cmd_launchpad_open(Command):
132
156
    """Open a Launchpad branch page in your web browser."""
133
157
 
139
163
        ]
140
164
    takes_args = ['location?']
141
165
 
 
166
    def _possible_locations(self, location):
 
167
        """Yield possible external locations for the branch at 'location'."""
 
168
        yield location
 
169
        try:
 
170
            branch = _mod_branch.Branch.open_containing(location)[0]
 
171
        except NotBranchError:
 
172
            return
 
173
        branch_url = branch.get_public_branch()
 
174
        if branch_url is not None:
 
175
            yield branch_url
 
176
        branch_url = branch.get_push_location()
 
177
        if branch_url is not None:
 
178
            yield branch_url
 
179
 
 
180
    def _get_web_url(self, service, location):
 
181
        from bzrlib.plugins.launchpad.lp_registration import (
 
182
            NotLaunchpadBranch)
 
183
        for branch_url in self._possible_locations(location):
 
184
            try:
 
185
                return service.get_web_url_from_branch_url(branch_url)
 
186
            except (NotLaunchpadBranch, InvalidURL):
 
187
                pass
 
188
        raise NotLaunchpadBranch(branch_url)
 
189
 
142
190
    def run(self, location=None, dry_run=False):
143
 
        from bzrlib.plugins.launchpad.lp_registration import LaunchpadService
144
 
        from bzrlib.trace import note
145
 
        import webbrowser
 
191
        from bzrlib.plugins.launchpad.lp_registration import (
 
192
            LaunchpadService)
146
193
        if location is None:
147
194
            location = u'.'
148
 
        branch = Branch.open(location)
149
 
        branch_url = branch.get_public_branch()
150
 
        if branch_url is None:
151
 
            raise NoPublicBranch(branch)
152
 
        service = LaunchpadService()
153
 
        web_url = service.get_web_url_from_branch_url(branch_url)
154
 
        note('Opening %s in web browser' % web_url)
 
195
        web_url = self._get_web_url(LaunchpadService(), location)
 
196
        trace.note('Opening %s in web browser' % web_url)
155
197
        if not dry_run:
 
198
            import webbrowser   # this import should not be lazy
 
199
                                # otherwise bzr.exe lacks this module
156
200
            webbrowser.open(web_url)
157
201
 
158
202
register_command(cmd_launchpad_open)
177
221
    aliases = ['lp-login']
178
222
    takes_args = ['name?']
179
223
    takes_options = [
 
224
        'verbose',
180
225
        Option('no-check',
181
226
               "Don't check that the user name is valid."),
182
227
        ]
183
228
 
184
 
    def run(self, name=None, no_check=False):
 
229
    def run(self, name=None, no_check=False, verbose=False):
 
230
        # This is totally separate from any launchpadlib login system.
185
231
        from bzrlib.plugins.launchpad import account
186
232
        check_account = not no_check
187
233
 
190
236
            if username:
191
237
                if check_account:
192
238
                    account.check_lp_login(username)
 
239
                    if verbose:
 
240
                        self.outf.write(
 
241
                            "Launchpad user ID exists and has SSH keys.\n")
193
242
                self.outf.write(username + '\n')
194
243
            else:
195
244
                self.outf.write('No Launchpad user ID configured.\n')
196
245
                return 1
197
246
        else:
 
247
            name = name.lower()
198
248
            if check_account:
199
249
                account.check_lp_login(name)
 
250
                if verbose:
 
251
                    self.outf.write(
 
252
                        "Launchpad user ID exists and has SSH keys.\n")
200
253
            account.set_lp_login(name)
 
254
            if verbose:
 
255
                self.outf.write("Launchpad user ID set to '%s'.\n" % (name,))
201
256
 
202
257
register_command(cmd_launchpad_login)
203
258
 
204
259
 
 
260
# XXX: cmd_launchpad_mirror is untested
 
261
class cmd_launchpad_mirror(Command):
 
262
    """Ask Launchpad to mirror a branch now."""
 
263
 
 
264
    aliases = ['lp-mirror']
 
265
    takes_args = ['location?']
 
266
 
 
267
    def run(self, location='.'):
 
268
        from bzrlib.plugins.launchpad import lp_api
 
269
        from bzrlib.plugins.launchpad.lp_registration import LaunchpadService
 
270
        branch = _mod_branch.Branch.open(location)
 
271
        service = LaunchpadService()
 
272
        launchpad = lp_api.login(service)
 
273
        lp_branch = lp_api.load_branch(launchpad, branch)
 
274
        lp_branch.requestMirror()
 
275
 
 
276
 
 
277
register_command(cmd_launchpad_mirror)
 
278
 
 
279
 
205
280
def _register_directory():
206
281
    directories.register_lazy('lp:', 'bzrlib.plugins.launchpad.lp_directory',
207
282
                              'LaunchpadDirectory',
209
284
_register_directory()
210
285
 
211
286
 
212
 
def test_suite():
213
 
    """Called by bzrlib to fetch tests for this plugin"""
214
 
    from unittest import TestSuite, TestLoader
215
 
    from bzrlib.plugins.launchpad import (
216
 
        test_account,
217
 
        test_lp_directory,
218
 
        test_lp_open,
219
 
        test_lp_service,
220
 
        test_register,
221
 
        )
 
287
def load_tests(basic_tests, module, loader):
 
288
    testmod_names = [
 
289
        'test_account',
 
290
        'test_register',
 
291
        'test_lp_api',
 
292
        'test_lp_directory',
 
293
        'test_lp_login',
 
294
        'test_lp_open',
 
295
        'test_lp_service',
 
296
        ]
 
297
    basic_tests.addTest(loader.loadTestsFromModuleNames(
 
298
            ["%s.%s" % (__name__, tmn) for tmn in testmod_names]))
 
299
    return basic_tests
222
300
 
223
 
    loader = TestLoader()
224
 
    suite = TestSuite()
225
 
    for module in [
226
 
        test_account,
227
 
        test_register,
228
 
        test_lp_directory,
229
 
        test_lp_open,
230
 
        test_lp_service,
231
 
        ]:
232
 
        suite.addTests(loader.loadTestsFromModule(module))
233
 
    return suite
234
301
 
235
302
_launchpad_help = """Integration with Launchpad.net
236
303
 
244
311
      is then used by the 'lp:' transport to download your branches using
245
312
      bzr+ssh://.
246
313
 
 
314
    * The 'lp:' transport uses Launchpad as a directory service: for example
 
315
      'lp:bzr' and 'lp:python' refer to the main branches of the relevant
 
316
      projects and may be branched, logged, etc. You can also use the 'lp:'
 
317
      transport to refer to specific branches, e.g. lp:~bzr/bzr/trunk.
 
318
 
 
319
    * The 'lp:' bug tracker alias can expand launchpad bug numbers to their
 
320
      URLs for use with 'bzr commit --fixes', e.g. 'bzr commit --fixes lp:12345'
 
321
      will record a revision property that marks that revision as fixing
 
322
      Launchpad bug 12345. When you push that branch to Launchpad it will
 
323
      automatically be linked to the bug report.
 
324
 
247
325
    * The register-branch command tells Launchpad about the url of a
248
326
      public branch.  Launchpad will then mirror the branch, display
249
327
      its contents and allow it to be attached to bugs and other
250
328
      objects.
251
329
 
252
 
    * The 'lp:' transport uses Launchpad as a directory service: for example
253
 
      'lp:bzr' and 'lp:python' refer to the main branches of the relevant
254
 
      projects and may be branched, logged, etc. You can also use the 'lp:'
255
 
      transport to refer to specific branches, e.g. lp:///~bzr/bzr/trunk.
256
 
 
257
330
For more information see http://help.launchpad.net/
258
331
"""
259
332
topic_registry.register('launchpad',