/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/bugtracker.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/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 bzrlib import registry
18
 
from bzrlib.lazy_import import lazy_import
 
17
from __future__ import absolute_import
 
18
 
 
19
from . import (
 
20
    errors,
 
21
    registry,
 
22
    )
 
23
from .lazy_import import lazy_import
19
24
lazy_import(globals(), """
20
 
from bzrlib import errors, urlutils
 
25
from breezy import urlutils
21
26
""")
22
27
 
23
28
 
37
42
"""
38
43
 
39
44
 
40
 
_bugs_help = \
41
 
"""When making a commit, metadata about bugs fixed by that change can be
 
45
_bugs_help = """\
 
46
When making a commit, metadata about bugs fixed by that change can be
42
47
recorded by using the ``--fixes`` option. For each bug marked as fixed, an
43
48
entry is included in the 'bugs' revision property stating '<url> <status>'.
44
49
(The only ``status`` value currently supported is ``fixed.``)
48
53
 
49
54
    bzr commit --fixes <tracker>:<id>
50
55
 
 
56
or::
 
57
 
 
58
    bzr commit --fixes <id>
 
59
 
51
60
where "<tracker>" is an identifier for the bug tracker, and "<id>" is the
52
61
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.
53
64
 
54
65
Bazaar knows about a few bug trackers that have many users. If
55
66
you use one of these bug trackers then there is no setup required to
73
84
 
74
85
If you use Bugzilla or Trac, then you only need to set a configuration
75
86
variable which contains the base URL of the bug tracker. These options
76
 
can go into ``bazaar.conf``, ``branch.conf`` or into a branch-specific
 
87
can go into ``breezy.conf``, ``branch.conf`` or into a branch-specific
77
88
configuration section in ``locations.conf``.  You can set up these values
78
89
for each of the projects you work on.
79
90
 
93
104
--fixes`` to mark bugs in that tracker as being fixed by that commit. For
94
105
example::
95
106
 
96
 
    bugzilla_squid_url = http://www.squid-cache.org/bugs
 
107
    bugzilla_squid_url = http://bugs.squid-cache.org
97
108
 
98
109
would allow ``bzr commit --fixes squid:1234`` to mark Squid's bug 1234 as
99
110
fixed.
127
138
 
128
139
    bugtracker_cpan_url = http://rt.cpan.org/Public/Bug/Display.html?id={id}
129
140
 
130
 
for CPAN's RT bug tracker.
 
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.
131
148
"""
132
149
 
133
150
 
 
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
 
134
205
def get_bug_url(abbreviated_bugtracker_name, branch, bug_id):
135
206
    """Return a URL pointing to the canonical web page of the bug identified by
136
207
    'bug_id'.
153
224
            tracker = tracker_type.get(abbreviated_bugtracker_name, branch)
154
225
            if tracker is not None:
155
226
                return tracker
156
 
        raise errors.UnknownBugTrackerAbbreviation(abbreviated_bugtracker_name,
157
 
                                                   branch)
 
227
        raise UnknownBugTrackerAbbreviation(
 
228
            abbreviated_bugtracker_name, branch)
158
229
 
159
230
    def help_topic(self, topic):
160
231
        return _bugs_help
189
260
        try:
190
261
            int(bug_id)
191
262
        except ValueError:
192
 
            raise errors.MalformedBugIdentifier(bug_id, "Must be an integer")
 
263
            raise MalformedBugIdentifier(bug_id, "Must be an integer")
193
264
 
194
265
 
195
266
class UniqueIntegerBugTracker(IntegerBugTracker):
205
276
        self.base_url = base_url
206
277
 
207
278
    def get(self, abbreviated_bugtracker_name, branch):
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
 
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))
217
328
 
218
329
 
219
330
tracker_registry.register(
224
335
    'debian', UniqueIntegerBugTracker('deb', 'http://bugs.debian.org/'))
225
336
 
226
337
 
227
 
tracker_registry.register('gnome',
228
 
    UniqueIntegerBugTracker('gnome', 'http://bugzilla.gnome.org/show_bug.cgi?id='))
229
 
 
230
 
 
231
 
class URLParametrizedIntegerBugTracker(IntegerBugTracker):
 
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):
232
349
    """A type of bug tracker that can be found on a variety of different sites,
233
350
    and thus needs to have the base URL configured.
234
351
 
235
352
    Looks for a config setting in the form '<type_name>_<abbreviation>_url'.
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').
 
353
    `type_name` is the name of the type of tracker and `abbreviation`
 
354
    is a short name for the particular instance.
239
355
    """
240
356
 
241
357
    def get(self, abbreviation, branch):
242
358
        config = branch.get_config()
243
359
        url = config.get_user_option(
244
 
            "%s_%s_url" % (self.type_name, abbreviation))
 
360
            "%s_%s_url" % (self.type_name, abbreviation), expand=False)
245
361
        if url is None:
246
362
            return None
247
363
        self._base_url = url
256
372
        return urlutils.join(self._base_url, self._bug_area) + str(bug_id)
257
373
 
258
374
 
 
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
 
259
389
tracker_registry.register(
260
390
    'trac', URLParametrizedIntegerBugTracker('trac', 'ticket/'))
261
391
 
264
394
    URLParametrizedIntegerBugTracker('bugzilla', 'show_bug.cgi?id='))
265
395
 
266
396
 
267
 
class GenericBugTracker(URLParametrizedIntegerBugTracker):
 
397
class GenericBugTracker(URLParametrizedBugTracker):
268
398
    """Generic bug tracker specified by an URL template."""
269
399
 
270
400
    def __init__(self):
277
407
    def _get_bug_url(self, bug_id):
278
408
        """Given a validated bug_id, return the bug's web page's URL."""
279
409
        if '{id}' not in self._base_url:
280
 
            raise errors.InvalidBugTrackerURL(self._abbreviation,
281
 
                                              self._base_url)
 
410
            raise InvalidBugTrackerURL(self._abbreviation, self._base_url)
282
411
        return self._base_url.replace('{id}', str(bug_id))
283
412
 
284
413
 
286
415
 
287
416
 
288
417
FIXED = 'fixed'
 
418
RELATED = 'related'
289
419
 
290
 
ALLOWED_BUG_STATUSES = set([FIXED])
 
420
ALLOWED_BUG_STATUSES = {FIXED, RELATED}
291
421
 
292
422
 
293
423
def encode_fixes_bug_urls(bug_urls):
294
424
    """Get the revision property value for a commit that fixes bugs.
295
425
 
296
 
    :param bug_urls: An iterable of escaped URLs to bugs. These normally
 
426
    :param bug_urls: An iterable of (escaped URL, tag) tuples. These normally
297
427
        come from `get_bug_url`.
298
428
    :return: A string that will be set as the 'bugs' property of a revision
299
429
        as part of a commit.
300
430
    """
301
 
    return '\n'.join(('%s %s' % (url, FIXED)) for url in bug_urls)
 
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