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

  • Committer: Robert Collins
  • Date: 2010-05-06 23:41:35 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506234135-yivbzczw1sejxnxc
Lock methods on ``Tree``, ``Branch`` and ``Repository`` are now
expected to return an object which can be used to unlock them. This reduces
duplicate code when using cleanups. The previous 'tokens's returned by
``Branch.lock_write`` and ``Repository.lock_write`` are now attributes
on the result of the lock_write. ``repository.RepositoryWriteLockResult``
and ``branch.BranchWriteLockResult`` document this. (Robert Collins)

``log._get_info_for_log_files`` now takes an add_cleanup callable.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bugtracker.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
from __future__ import absolute_import
18
 
 
19
 
from . import (
20
 
    errors,
21
 
    registry,
22
 
    )
23
 
from .lazy_import import lazy_import
 
17
from bzrlib import registry
 
18
from bzrlib.lazy_import import lazy_import
24
19
lazy_import(globals(), """
25
 
from breezy import urlutils
 
20
from bzrlib import errors, urlutils
26
21
""")
27
22
 
28
23
 
42
37
"""
43
38
 
44
39
 
45
 
_bugs_help = """\
46
 
When making a commit, metadata about bugs fixed by that change can be
 
40
_bugs_help = \
 
41
"""When making a commit, metadata about bugs fixed by that change can be
47
42
recorded by using the ``--fixes`` option. For each bug marked as fixed, an
48
43
entry is included in the 'bugs' revision property stating '<url> <status>'.
49
44
(The only ``status`` value currently supported is ``fixed.``)
53
48
 
54
49
    bzr commit --fixes <tracker>:<id>
55
50
 
56
 
or::
57
 
 
58
 
    bzr commit --fixes <id>
59
 
 
60
51
where "<tracker>" is an identifier for the bug tracker, and "<id>" is the
61
52
identifier for that bug within the bugtracker, usually the bug number.
62
 
If "<tracker>" is not specified the ``bugtracker`` set in the branch
63
 
or global configuration is used.
64
53
 
65
54
Bazaar knows about a few bug trackers that have many users. If
66
55
you use one of these bug trackers then there is no setup required to
84
73
 
85
74
If you use Bugzilla or Trac, then you only need to set a configuration
86
75
variable which contains the base URL of the bug tracker. These options
87
 
can go into ``breezy.conf``, ``branch.conf`` or into a branch-specific
 
76
can go into ``bazaar.conf``, ``branch.conf`` or into a branch-specific
88
77
configuration section in ``locations.conf``.  You can set up these values
89
78
for each of the projects you work on.
90
79
 
104
93
--fixes`` to mark bugs in that tracker as being fixed by that commit. For
105
94
example::
106
95
 
107
 
    bugzilla_squid_url = http://bugs.squid-cache.org
 
96
    bugzilla_squid_url = http://www.squid-cache.org/bugs
108
97
 
109
98
would allow ``bzr commit --fixes squid:1234`` to mark Squid's bug 1234 as
110
99
fixed.
138
127
 
139
128
    bugtracker_cpan_url = http://rt.cpan.org/Public/Bug/Display.html?id={id}
140
129
 
141
 
would allow ``bzr commit --fixes cpan:1234`` to mark bug 1234 in CPAN's
142
 
RT bug tracker as fixed, or::
143
 
 
144
 
    bugtracker_hudson_url = http://issues.hudson-ci.org/browse/{id}
145
 
 
146
 
would allow ``bzr commit --fixes hudson:HUDSON-1234`` to mark bug HUDSON-1234
147
 
in Hudson's JIRA bug tracker as fixed.
 
130
for CPAN's RT bug tracker.
148
131
"""
149
132
 
150
133
 
151
 
class MalformedBugIdentifier(errors.BzrError):
152
 
 
153
 
    _fmt = ('Did not understand bug identifier %(bug_id)s: %(reason)s. '
154
 
            'See "brz help bugs" for more information on this feature.')
155
 
 
156
 
    def __init__(self, bug_id, reason):
157
 
        self.bug_id = bug_id
158
 
        self.reason = reason
159
 
 
160
 
 
161
 
class InvalidBugTrackerURL(errors.BzrError):
162
 
 
163
 
    _fmt = ("The URL for bug tracker \"%(abbreviation)s\" doesn't "
164
 
            "contain {id}: %(url)s")
165
 
 
166
 
    def __init__(self, abbreviation, url):
167
 
        self.abbreviation = abbreviation
168
 
        self.url = url
169
 
 
170
 
 
171
 
class UnknownBugTrackerAbbreviation(errors.BzrError):
172
 
 
173
 
    _fmt = ("Cannot find registered bug tracker called %(abbreviation)s "
174
 
            "on %(branch)s")
175
 
 
176
 
    def __init__(self, abbreviation, branch):
177
 
        self.abbreviation = abbreviation
178
 
        self.branch = branch
179
 
 
180
 
 
181
 
class InvalidLineInBugsProperty(errors.BzrError):
182
 
 
183
 
    _fmt = ("Invalid line in bugs property: '%(line)s'")
184
 
 
185
 
    def __init__(self, line):
186
 
        self.line = line
187
 
 
188
 
 
189
 
class InvalidBugUrl(errors.BzrError):
190
 
 
191
 
    _fmt = "Invalid bug URL: %(url)s"
192
 
 
193
 
    def __init__(self, url):
194
 
        self.url = url
195
 
 
196
 
 
197
 
class InvalidBugStatus(errors.BzrError):
198
 
 
199
 
    _fmt = ("Invalid bug status: '%(status)s'")
200
 
 
201
 
    def __init__(self, status):
202
 
        self.status = status
203
 
 
204
 
 
205
134
def get_bug_url(abbreviated_bugtracker_name, branch, bug_id):
206
135
    """Return a URL pointing to the canonical web page of the bug identified by
207
136
    'bug_id'.
224
153
            tracker = tracker_type.get(abbreviated_bugtracker_name, branch)
225
154
            if tracker is not None:
226
155
                return tracker
227
 
        raise UnknownBugTrackerAbbreviation(
228
 
            abbreviated_bugtracker_name, branch)
 
156
        raise errors.UnknownBugTrackerAbbreviation(abbreviated_bugtracker_name,
 
157
                                                   branch)
229
158
 
230
159
    def help_topic(self, topic):
231
160
        return _bugs_help
260
189
        try:
261
190
            int(bug_id)
262
191
        except ValueError:
263
 
            raise MalformedBugIdentifier(bug_id, "Must be an integer")
 
192
            raise errors.MalformedBugIdentifier(bug_id, "Must be an integer")
264
193
 
265
194
 
266
195
class UniqueIntegerBugTracker(IntegerBugTracker):
276
205
        self.base_url = base_url
277
206
 
278
207
    def get(self, abbreviated_bugtracker_name, branch):
279
 
        """Returns the tracker if the abbreviation matches, otherwise ``None``.
280
 
        """
281
 
        if abbreviated_bugtracker_name != self.abbreviation:
282
 
            return None
283
 
        return self
284
 
 
285
 
    def _get_bug_url(self, bug_id):
286
 
        """Return the URL for bug_id."""
287
 
        return self.base_url + str(bug_id)
288
 
 
289
 
 
290
 
class ProjectIntegerBugTracker(IntegerBugTracker):
291
 
    """A bug tracker that exists in one place only with per-project ids.
292
 
 
293
 
    If you have one of these trackers then register an instance passing in an
294
 
    abbreviated name for the bug tracker and a base URL. The bug ids are
295
 
    appended directly to the URL.
296
 
    """
297
 
 
298
 
    def __init__(self, abbreviated_bugtracker_name, base_url):
299
 
        self.abbreviation = abbreviated_bugtracker_name
300
 
        self._base_url = base_url
301
 
 
302
 
    def get(self, abbreviated_bugtracker_name, branch):
303
 
        """Returns the tracker if the abbreviation matches, otherwise ``None``.
304
 
        """
305
 
        if abbreviated_bugtracker_name != self.abbreviation:
306
 
            return None
307
 
        return self
308
 
 
309
 
    def check_bug_id(self, bug_id):
310
 
        try:
311
 
            (project, bug_id) = bug_id.rsplit('/', 1)
312
 
        except ValueError:
313
 
            raise MalformedBugIdentifier(bug_id, "Expected format: project/id")
314
 
        try:
315
 
            int(bug_id)
316
 
        except ValueError:
317
 
            raise MalformedBugIdentifier(bug_id, "Bug id must be an integer")
318
 
 
319
 
    def _get_bug_url(self, bug_id):
320
 
        (project, bug_id) = bug_id.rsplit('/', 1)
321
 
        """Return the URL for bug_id."""
322
 
        if '{id}' not in self._base_url:
323
 
            raise InvalidBugTrackerURL(self._abbreviation, self._base_url)
324
 
        if '{project}' not in self._base_url:
325
 
            raise InvalidBugTrackerURL(self._abbreviation, self._base_url)
326
 
        return self._base_url.replace(
327
 
            '{project}', project).replace('{id}', str(bug_id))
 
208
        """Returns the tracker if the abbreviation matches. Returns None
 
209
        otherwise."""
 
210
        if abbreviated_bugtracker_name != self.abbreviation:
 
211
            return None
 
212
        return self
 
213
 
 
214
    def _get_bug_url(self, bug_id):
 
215
        """Return the URL for bug_id."""
 
216
        return self.base_url + bug_id
328
217
 
329
218
 
330
219
tracker_registry.register(
335
224
    'debian', UniqueIntegerBugTracker('deb', 'http://bugs.debian.org/'))
336
225
 
337
226
 
338
 
tracker_registry.register(
339
 
    'gnome', UniqueIntegerBugTracker(
340
 
        'gnome', 'http://bugzilla.gnome.org/show_bug.cgi?id='))
341
 
 
342
 
 
343
 
tracker_registry.register(
344
 
    'github', ProjectIntegerBugTracker(
345
 
        'github', 'https://github.com/{project}/issues/{id}'))
346
 
 
347
 
 
348
 
class URLParametrizedBugTracker(BugTracker):
 
227
tracker_registry.register('gnome',
 
228
    UniqueIntegerBugTracker('gnome', 'http://bugzilla.gnome.org/show_bug.cgi?id='))
 
229
 
 
230
 
 
231
class URLParametrizedIntegerBugTracker(IntegerBugTracker):
349
232
    """A type of bug tracker that can be found on a variety of different sites,
350
233
    and thus needs to have the base URL configured.
351
234
 
352
235
    Looks for a config setting in the form '<type_name>_<abbreviation>_url'.
353
 
    `type_name` is the name of the type of tracker and `abbreviation`
354
 
    is a short name for the particular instance.
 
236
    `type_name` is the name of the type of tracker (e.g. 'bugzilla' or 'trac')
 
237
    and `abbreviation` is a short name for the particular instance (e.g.
 
238
    'squid' or 'apache').
355
239
    """
356
240
 
357
241
    def get(self, abbreviation, branch):
358
242
        config = branch.get_config()
359
243
        url = config.get_user_option(
360
 
            "%s_%s_url" % (self.type_name, abbreviation), expand=False)
 
244
            "%s_%s_url" % (self.type_name, abbreviation))
361
245
        if url is None:
362
246
            return None
363
247
        self._base_url = url
372
256
        return urlutils.join(self._base_url, self._bug_area) + str(bug_id)
373
257
 
374
258
 
375
 
class URLParametrizedIntegerBugTracker(IntegerBugTracker,
376
 
                                       URLParametrizedBugTracker):
377
 
    """A type of bug tracker that  only allows integer bug IDs.
378
 
 
379
 
    This can be found on a variety of different sites, and thus needs to have
380
 
    the base URL configured.
381
 
 
382
 
    Looks for a config setting in the form '<type_name>_<abbreviation>_url'.
383
 
    `type_name` is the name of the type of tracker (e.g. 'bugzilla' or 'trac')
384
 
    and `abbreviation` is a short name for the particular instance (e.g.
385
 
    'squid' or 'apache').
386
 
    """
387
 
 
388
 
 
389
259
tracker_registry.register(
390
260
    'trac', URLParametrizedIntegerBugTracker('trac', 'ticket/'))
391
261
 
394
264
    URLParametrizedIntegerBugTracker('bugzilla', 'show_bug.cgi?id='))
395
265
 
396
266
 
397
 
class GenericBugTracker(URLParametrizedBugTracker):
 
267
class GenericBugTracker(URLParametrizedIntegerBugTracker):
398
268
    """Generic bug tracker specified by an URL template."""
399
269
 
400
270
    def __init__(self):
407
277
    def _get_bug_url(self, bug_id):
408
278
        """Given a validated bug_id, return the bug's web page's URL."""
409
279
        if '{id}' not in self._base_url:
410
 
            raise InvalidBugTrackerURL(self._abbreviation, self._base_url)
 
280
            raise errors.InvalidBugTrackerURL(self._abbreviation,
 
281
                                              self._base_url)
411
282
        return self._base_url.replace('{id}', str(bug_id))
412
283
 
413
284
 
415
286
 
416
287
 
417
288
FIXED = 'fixed'
418
 
RELATED = 'related'
419
289
 
420
 
ALLOWED_BUG_STATUSES = {FIXED, RELATED}
 
290
ALLOWED_BUG_STATUSES = set([FIXED])
421
291
 
422
292
 
423
293
def encode_fixes_bug_urls(bug_urls):
424
294
    """Get the revision property value for a commit that fixes bugs.
425
295
 
426
 
    :param bug_urls: An iterable of (escaped URL, tag) tuples. These normally
 
296
    :param bug_urls: An iterable of escaped URLs to bugs. These normally
427
297
        come from `get_bug_url`.
428
298
    :return: A string that will be set as the 'bugs' property of a revision
429
299
        as part of a commit.
430
300
    """
431
 
    lines = []
432
 
    for (url, tag) in bug_urls:
433
 
        if ' ' in url:
434
 
            raise InvalidBugUrl(url)
435
 
        lines.append('%s %s' % (url, tag))
436
 
    return '\n'.join(lines)
437
 
 
438
 
 
439
 
def decode_bug_urls(bug_text):
440
 
    """Decode a bug property text.
441
 
 
442
 
    :param bug_text: Contents of a bugs property
443
 
    :return: iterator over (url, status) tuples
444
 
    """
445
 
    for line in bug_text.splitlines():
446
 
        try:
447
 
            url, status = line.split(None, 2)
448
 
        except ValueError:
449
 
            raise InvalidLineInBugsProperty(line)
450
 
        if status not in ALLOWED_BUG_STATUSES:
451
 
            raise InvalidBugStatus(status)
452
 
        yield url, status
 
301
    return '\n'.join(('%s %s' % (url, FIXED)) for url in bug_urls)