/b-gtk/fix-viz

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/b-gtk/fix-viz

« back to all changes in this revision

Viewing changes to __init__.py

  • Committer: Jasper Groenewegen
  • Date: 2008-07-27 11:37:31 UTC
  • mto: (577.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 579.
  • Revision ID: colbrac@xs4all.nl-20080727113731-p2krsw6o3m57ctu6
Add PointlessMerge error
Merge dialog title change
Merge dialog icon
Tweak logic

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
22
22
gconflicts        GTK+ conflicts. 
23
23
gdiff             Show differences in working tree in a GTK+ Window. 
24
24
ginit             Initialise a new branch.
25
 
ginfo             GTK+ branch info dialog
26
 
gloom             GTK+ loom browse dialog
27
25
gmerge            GTK+ merge dialog
28
26
gmissing          GTK+ missing revisions dialog. 
29
27
gpreferences      GTK+ preferences dialog. 
34
32
visualise         Graphically visualise this branch. 
35
33
"""
36
34
 
37
 
import os
38
35
import sys
39
36
 
40
 
if getattr(sys, "frozen", None) is not None: # we run bzr.exe
41
 
 
42
 
    # FIXME: Unless a better packaging solution is found, the following
43
 
    # provides a workaround for https://bugs.launchpad.net/bzr/+bug/388790 Also
44
 
    # see https://code.edge.launchpad.net/~vila/bzr-gtk/388790-windows-setup
45
 
    # for more details about while it's needed.
46
 
 
47
 
    # NOTE: _lib must be ahead of bzrlib or sax.saxutils (in olive) fails
48
 
    here = os.path.dirname(__file__)
49
 
    sys.path.insert(0, os.path.join(here, '_lib'))
50
 
    sys.path.append(os.path.join(here, '_lib/gtk-2.0'))
51
 
 
52
 
 
53
37
import bzrlib
54
 
import bzrlib.api
55
 
from bzrlib import (
56
 
    branch,
57
 
    config,
58
 
    errors,
59
 
    )
60
 
from bzrlib.commands import plugin_cmds
61
 
 
62
 
 
63
 
version_info = (0, 99, 0, 'dev', 1)
 
38
 
 
39
version_info = (0, 95, 0, 'dev', 1)
64
40
 
65
41
if version_info[3] == 'final':
66
42
    version_string = '%d.%d.%d' % version_info[:3]
68
44
    version_string = '%d.%d.%d%s%d' % version_info
69
45
__version__ = version_string
70
46
 
71
 
COMPATIBLE_BZR_VERSIONS = [(1, 6, 0), (1, 7, 0), (1, 8, 0), (1, 9, 0),
72
 
                           (1, 10, 0), (1, 11, 0), (1, 12, 0), (1, 13, 0),
73
 
                           (1, 15, 0),
74
 
                           (1, 17, 0),
75
 
                           (2, 1, 0),
76
 
                           (2, 2, 0),
77
 
                           ]
78
 
 
79
 
bzrlib.api.require_any_api(bzrlib, COMPATIBLE_BZR_VERSIONS)
80
 
 
 
47
required_bzrlib = (1, 3)
 
48
 
 
49
def check_bzrlib_version(desired):
 
50
    """Check that bzrlib is compatible.
 
51
 
 
52
    If version is < bzr-gtk version, assume incompatible.
 
53
    """
 
54
    bzrlib_version = bzrlib.version_info[:2]
 
55
    try:
 
56
        from bzrlib.trace import warning
 
57
    except ImportError:
 
58
        # get the message out any way we can
 
59
        from warnings import warn as warning
 
60
    if bzrlib_version < desired:
 
61
        from bzrlib.errors import BzrError
 
62
        warning('Installed Bazaar version %s is too old to be used with bzr-gtk'
 
63
                ' %s.' % (bzrlib.__version__, __version__))
 
64
        raise BzrError('Version mismatch: %r, %r' % (version_info, bzrlib.version_info) )
 
65
 
 
66
 
 
67
if version_info[2] == "final":
 
68
    check_bzrlib_version(required_bzrlib)
 
69
 
 
70
from bzrlib.trace import warning
81
71
if __name__ != 'bzrlib.plugins.gtk':
82
 
    from bzrlib.trace import warning
83
72
    warning("Not running as bzrlib.plugins.gtk, things may break.")
84
73
 
 
74
from bzrlib.lazy_import import lazy_import
 
75
lazy_import(globals(), """
 
76
from bzrlib import (
 
77
    branch,
 
78
    builtins,
 
79
    errors,
 
80
    merge_directive,
 
81
    workingtree,
 
82
    )
 
83
""")
 
84
 
 
85
from bzrlib.commands import Command, register_command, display_command
 
86
from bzrlib.errors import NotVersionedError, BzrCommandError, NoSuchFile
 
87
from bzrlib.option import Option
 
88
 
 
89
import os.path
 
90
 
85
91
def import_pygtk():
86
92
    try:
87
93
        import pygtk
125
131
            raise NoDisplayError
126
132
    set_ui_factory()
127
133
    return gtk
128
 
 
129
 
 
130
 
commands = {
131
 
    "gannotate": ["gblame", "gpraise"],
132
 
    "gbranch": [],
133
 
    "gcheckout": [],
134
 
    "gcommit": ["gci"],
135
 
    "gconflicts": [],
136
 
    "gdiff": [],
137
 
    "ginit": [],
138
 
    "ginfo": [],
139
 
    "gmerge": [],
140
 
    "gmissing": [],
141
 
    "gpreferences": [],
142
 
    "gpush": [],
143
 
    "gselftest": [],
144
 
    "gsend": [],
145
 
    "gstatus": ["gst"],
146
 
    "gtags": [],
147
 
    "visualise": ["visualize", "vis", "viz", 'glog'],
148
 
    }
149
 
 
150
 
try:
151
 
    from bzrlib.plugins import loom
152
 
except ImportError:
153
 
    pass # Loom plugin doesn't appear to be present
154
 
else:
155
 
    commands["gloom"] = []
156
 
 
157
 
for cmd, aliases in commands.iteritems():
158
 
    plugin_cmds.register_lazy("cmd_%s" % cmd, aliases,
159
 
                              "bzrlib.plugins.gtk.commands")
160
 
 
161
 
def save_commit_messages(*args):
162
 
    from bzrlib.plugins.gtk import commit
163
 
    commit.save_commit_messages(*args)
164
 
 
165
 
branch.Branch.hooks.install_named_hook('post_uncommit',
166
 
                                       save_commit_messages,
167
 
                                       "Saving commit messages for gcommit")
 
134
 
 
135
 
 
136
class GTKCommand(Command):
 
137
    """Abstract class providing GTK specific run commands."""
 
138
 
 
139
    def run(self):
 
140
        open_display()
 
141
        dialog = self.get_gtk_dialog(os.path.abspath('.'))
 
142
        dialog.run()
 
143
 
 
144
 
 
145
class cmd_gbranch(GTKCommand):
 
146
    """GTK+ branching.
 
147
    
 
148
    """
 
149
 
 
150
    def get_gtk_dialog(self, path):
 
151
        from bzrlib.plugins.gtk.branch import BranchDialog
 
152
        return BranchDialog(path)
 
153
 
 
154
 
 
155
class cmd_gcheckout(GTKCommand):
 
156
    """ GTK+ checkout.
 
157
    
 
158
    """
 
159
    
 
160
    def get_gtk_dialog(self, path):
 
161
        from bzrlib.plugins.gtk.checkout import CheckoutDialog
 
162
        return CheckoutDialog(path)
 
163
 
 
164
 
 
165
 
 
166
class cmd_gpush(GTKCommand):
 
167
    """ GTK+ push.
 
168
    
 
169
    """
 
170
    takes_args = [ "location?" ]
 
171
 
 
172
    def run(self, location="."):
 
173
        (br, path) = branch.Branch.open_containing(location)
 
174
        open_display()
 
175
        from push import PushDialog
 
176
        dialog = PushDialog(br.repository, br.last_revision(), br)
 
177
        dialog.run()
 
178
 
 
179
 
 
180
 
 
181
class cmd_gdiff(GTKCommand):
 
182
    """Show differences in working tree in a GTK+ Window.
 
183
    
 
184
    Otherwise, all changes for the tree are listed.
 
185
    """
 
186
    takes_args = ['filename?']
 
187
    takes_options = ['revision']
 
188
 
 
189
    @display_command
 
190
    def run(self, revision=None, filename=None):
 
191
        set_ui_factory()
 
192
        wt = workingtree.WorkingTree.open_containing(".")[0]
 
193
        wt.lock_read()
 
194
        try:
 
195
            branch = wt.branch
 
196
            if revision is not None:
 
197
                if len(revision) == 1:
 
198
                    tree1 = wt
 
199
                    revision_id = revision[0].as_revision_id(tree1.branch)
 
200
                    tree2 = branch.repository.revision_tree(revision_id)
 
201
                elif len(revision) == 2:
 
202
                    revision_id_0 = revision[0].as_revision_id(branch)
 
203
                    tree2 = branch.repository.revision_tree(revision_id_0)
 
204
                    revision_id_1 = revision[1].as_revision_id(branch)
 
205
                    tree1 = branch.repository.revision_tree(revision_id_1)
 
206
            else:
 
207
                tree1 = wt
 
208
                tree2 = tree1.basis_tree()
 
209
 
 
210
            from diff import DiffWindow
 
211
            import gtk
 
212
            window = DiffWindow()
 
213
            window.connect("destroy", gtk.main_quit)
 
214
            window.set_diff("Working Tree", tree1, tree2)
 
215
            if filename is not None:
 
216
                tree_filename = wt.relpath(filename)
 
217
                try:
 
218
                    window.set_file(tree_filename)
 
219
                except NoSuchFile:
 
220
                    if (tree1.path2id(tree_filename) is None and 
 
221
                        tree2.path2id(tree_filename) is None):
 
222
                        raise NotVersionedError(filename)
 
223
                    raise BzrCommandError('No changes found for file "%s"' % 
 
224
                                          filename)
 
225
            window.show()
 
226
 
 
227
            gtk.main()
 
228
        finally:
 
229
            wt.unlock()
 
230
 
 
231
 
 
232
def start_viz_window(branch, revisions, limit=None):
 
233
    """Start viz on branch with revision revision.
 
234
    
 
235
    :return: The viz window object.
 
236
    """
 
237
    from viz import BranchWindow
 
238
    return BranchWindow(branch, revisions, limit)
 
239
 
 
240
 
 
241
class cmd_visualise(Command):
 
242
    """Graphically visualise this branch.
 
243
 
 
244
    Opens a graphical window to allow you to see the history of the branch
 
245
    and relationships between revisions in a visual manner,
 
246
 
 
247
    The default starting point is latest revision on the branch, you can
 
248
    specify a starting point with -r revision.
 
249
    """
 
250
    takes_options = [
 
251
        "revision",
 
252
        Option('limit', "Maximum number of revisions to display.",
 
253
               int, 'count')]
 
254
    takes_args = [ "locations*" ]
 
255
    aliases = [ "visualize", "vis", "viz" ]
 
256
 
 
257
    def run(self, locations_list, revision=None, limit=None):
 
258
        set_ui_factory()
 
259
        if locations_list is None:
 
260
            locations_list = ["."]
 
261
        revids = []
 
262
        for location in locations_list:
 
263
            (br, path) = branch.Branch.open_containing(location)
 
264
            if revision is None:
 
265
                revids.append(br.last_revision())
 
266
            else:
 
267
                revids.append(revision[0].as_revision_id(br))
 
268
        import gtk
 
269
        pp = start_viz_window(br, revids, limit)
 
270
        pp.connect("destroy", lambda w: gtk.main_quit())
 
271
        pp.show()
 
272
        gtk.main()
 
273
 
 
274
 
 
275
class cmd_gannotate(GTKCommand):
 
276
    """GTK+ annotate.
 
277
    
 
278
    Browse changes to FILENAME line by line in a GTK+ window.
 
279
    """
 
280
 
 
281
    takes_args = ["filename", "line?"]
 
282
    takes_options = [
 
283
        Option("all", help="Show annotations on all lines."),
 
284
        Option("plain", help="Don't highlight annotation lines."),
 
285
        Option("line", type=int, argname="lineno",
 
286
               help="Jump to specified line number."),
 
287
        "revision",
 
288
    ]
 
289
    aliases = ["gblame", "gpraise"]
 
290
    
 
291
    def run(self, filename, all=False, plain=False, line='1', revision=None):
 
292
        gtk = open_display()
 
293
 
 
294
        try:
 
295
            line = int(line)
 
296
        except ValueError:
 
297
            raise BzrCommandError('Line argument ("%s") is not a number.' % 
 
298
                                  line)
 
299
 
 
300
        from annotate.gannotate import GAnnotateWindow
 
301
        from annotate.config import GAnnotateConfig
 
302
        from bzrlib.bzrdir import BzrDir
 
303
 
 
304
        wt, br, path = BzrDir.open_containing_tree_or_branch(filename)
 
305
        if wt is not None:
 
306
            tree = wt
 
307
        else:
 
308
            tree = br.basis_tree()
 
309
 
 
310
        file_id = tree.path2id(path)
 
311
 
 
312
        if file_id is None:
 
313
            raise NotVersionedError(filename)
 
314
        if revision is not None:
 
315
            if len(revision) != 1:
 
316
                raise BzrCommandError("Only 1 revion may be specified.")
 
317
            revision_id = revision[0].as_revision_id(br)
 
318
            tree = br.repository.revision_tree(revision_id)
 
319
        else:
 
320
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
 
321
 
 
322
        window = GAnnotateWindow(all, plain, branch=br)
 
323
        window.connect("destroy", lambda w: gtk.main_quit())
 
324
        config = GAnnotateConfig(window)
 
325
        window.show()
 
326
        br.lock_read()
 
327
        if wt is not None:
 
328
            wt.lock_read()
 
329
        try:
 
330
            window.annotate(tree, br, file_id)
 
331
            window.jump_to_line(line)
 
332
            gtk.main()
 
333
        finally:
 
334
            br.unlock()
 
335
            if wt is not None:
 
336
                wt.unlock()
 
337
 
 
338
 
 
339
 
 
340
class cmd_gcommit(GTKCommand):
 
341
    """GTK+ commit dialog
 
342
 
 
343
    Graphical user interface for committing revisions"""
 
344
 
 
345
    aliases = [ "gci" ]
 
346
    takes_args = []
 
347
    takes_options = []
 
348
 
 
349
    def run(self, filename=None):
 
350
        import os
 
351
        open_display()
 
352
        from commit import CommitDialog
 
353
        from bzrlib.errors import (BzrCommandError,
 
354
                                   NotBranchError,
 
355
                                   NoWorkingTree)
 
356
 
 
357
        wt = None
 
358
        br = None
 
359
        try:
 
360
            (wt, path) = workingtree.WorkingTree.open_containing(filename)
 
361
            br = wt.branch
 
362
        except NoWorkingTree, e:
 
363
            from dialog import error_dialog
 
364
            error_dialog(_i18n('Directory does not have a working tree'),
 
365
                         _i18n('Operation aborted.'))
 
366
            return 1 # should this be retval=3?
 
367
 
 
368
        # It is a good habit to keep things locked for the duration, but it
 
369
        # could cause difficulties if someone wants to do things in another
 
370
        # window... We could lock_read() until we actually go to commit
 
371
        # changes... Just a thought.
 
372
        wt.lock_write()
 
373
        try:
 
374
            dlg = CommitDialog(wt)
 
375
            return dlg.run()
 
376
        finally:
 
377
            wt.unlock()
 
378
 
 
379
 
 
380
class cmd_gstatus(GTKCommand):
 
381
    """GTK+ status dialog
 
382
 
 
383
    Graphical user interface for showing status 
 
384
    information."""
 
385
    
 
386
    aliases = [ "gst" ]
 
387
    takes_args = ['PATH?']
 
388
    takes_options = ['revision']
 
389
 
 
390
    def run(self, path='.', revision=None):
 
391
        import os
 
392
        gtk = open_display()
 
393
        from status import StatusDialog
 
394
        (wt, wt_path) = workingtree.WorkingTree.open_containing(path)
 
395
        
 
396
        if revision is not None:
 
397
            try:
 
398
                revision_id = revision[0].as_revision_id(wt.branch)
 
399
            except:
 
400
                from bzrlib.errors import BzrError
 
401
                raise BzrError('Revision %r doesn\'t exist' % revision[0].user_spec )
 
402
        else:
 
403
            revision_id = None
 
404
 
 
405
        status = StatusDialog(wt, wt_path, revision_id)
 
406
        status.connect("destroy", gtk.main_quit)
 
407
        status.run()
 
408
 
 
409
 
 
410
class cmd_gsend(GTKCommand):
 
411
    """GTK+ send merge directive.
 
412
 
 
413
    """
 
414
    def run(self):
 
415
        (br, path) = branch.Branch.open_containing(".")
 
416
        gtk = open_display()
 
417
        from bzrlib.plugins.gtk.mergedirective import SendMergeDirectiveDialog
 
418
        from StringIO import StringIO
 
419
        dialog = SendMergeDirectiveDialog(br)
 
420
        if dialog.run() == gtk.RESPONSE_OK:
 
421
            outf = StringIO()
 
422
            outf.writelines(dialog.get_merge_directive().to_lines())
 
423
            mail_client = br.get_config().get_mail_client()
 
424
            mail_client.compose_merge_request(dialog.get_mail_to(), "[MERGE]", 
 
425
                outf.getvalue())
 
426
 
 
427
            
 
428
 
 
429
 
 
430
class cmd_gconflicts(GTKCommand):
 
431
    """GTK+ conflicts.
 
432
    
 
433
    Select files from the list of conflicts and run an external utility to
 
434
    resolve them.
 
435
    """
 
436
    def run(self):
 
437
        (wt, path) = workingtree.WorkingTree.open_containing('.')
 
438
        open_display()
 
439
        from bzrlib.plugins.gtk.conflicts import ConflictsDialog
 
440
        dialog = ConflictsDialog(wt)
 
441
        dialog.run()
 
442
 
 
443
 
 
444
class cmd_gpreferences(GTKCommand):
 
445
    """ GTK+ preferences dialog.
 
446
 
 
447
    """
 
448
    def run(self):
 
449
        open_display()
 
450
        from bzrlib.plugins.gtk.preferences import PreferencesWindow
 
451
        dialog = PreferencesWindow()
 
452
        dialog.run()
 
453
 
 
454
 
 
455
class cmd_gmerge(Command):
 
456
    """ GTK+ merge dialog
 
457
    
 
458
    """
 
459
    takes_args = ["merge_from_path?"]
 
460
    def run(self, merge_from_path=None):
 
461
        from bzrlib import workingtree
 
462
        from bzrlib.plugins.gtk.dialog import error_dialog
 
463
        from bzrlib.plugins.gtk.merge import MergeDialog
 
464
        
 
465
        (wt, path) = workingtree.WorkingTree.open_containing('.')
 
466
        old_tree = wt.branch.repository.revision_tree(wt.branch.last_revision())
 
467
        delta = wt.changes_from(old_tree)
 
468
        if len(delta.added) or len(delta.removed) or len(delta.renamed) or len(delta.modified):
 
469
            error_dialog(_i18n('There are local changes in the branch'),
 
470
                         _i18n('Please commit or revert the changes before merging.'))
 
471
        else:
 
472
            parent_branch_path = wt.branch.get_parent()
 
473
            merge = MergeDialog(wt, path, parent_branch_path)
 
474
            response = merge.run()
 
475
            merge.destroy()
 
476
 
 
477
 
 
478
class cmd_gmissing(Command):
 
479
    """ GTK+ missing revisions dialog.
 
480
 
 
481
    """
 
482
    takes_args = ["other_branch?"]
 
483
    def run(self, other_branch=None):
 
484
        pygtk = import_pygtk()
 
485
        try:
 
486
            import gtk
 
487
        except RuntimeError, e:
 
488
            if str(e) == "could not open display":
 
489
                raise NoDisplayError
 
490
 
 
491
        from bzrlib.plugins.gtk.missing import MissingWindow
 
492
        from bzrlib.branch import Branch
 
493
 
 
494
        local_branch = Branch.open_containing(".")[0]
 
495
        if other_branch is None:
 
496
            other_branch = local_branch.get_parent()
 
497
            
 
498
            if other_branch is None:
 
499
                raise errors.BzrCommandError("No peer location known or specified.")
 
500
        remote_branch = Branch.open_containing(other_branch)[0]
 
501
        set_ui_factory()
 
502
        local_branch.lock_read()
 
503
        try:
 
504
            remote_branch.lock_read()
 
505
            try:
 
506
                dialog = MissingWindow(local_branch, remote_branch)
 
507
                dialog.run()
 
508
            finally:
 
509
                remote_branch.unlock()
 
510
        finally:
 
511
            local_branch.unlock()
 
512
 
 
513
 
 
514
class cmd_ginit(GTKCommand):
 
515
    def run(self):
 
516
        open_display()
 
517
        from initialize import InitDialog
 
518
        dialog = InitDialog(os.path.abspath(os.path.curdir))
 
519
        dialog.run()
 
520
 
 
521
 
 
522
class cmd_gtags(GTKCommand):
 
523
    def run(self):
 
524
        br = branch.Branch.open_containing('.')[0]
 
525
        
 
526
        gtk = open_display()
 
527
        from tags import TagsWindow
 
528
        window = TagsWindow(br)
 
529
        window.show()
 
530
        gtk.main()
 
531
 
 
532
 
 
533
commands = [
 
534
    cmd_gannotate, 
 
535
    cmd_gbranch,
 
536
    cmd_gcheckout, 
 
537
    cmd_gcommit, 
 
538
    cmd_gconflicts, 
 
539
    cmd_gdiff,
 
540
    cmd_ginit,
 
541
    cmd_gmerge,
 
542
    cmd_gmissing, 
 
543
    cmd_gpreferences, 
 
544
    cmd_gpush, 
 
545
    cmd_gsend,
 
546
    cmd_gstatus,
 
547
    cmd_gtags,
 
548
    cmd_visualise
 
549
    ]
 
550
 
 
551
for cmd in commands:
 
552
    register_command(cmd)
 
553
 
 
554
 
 
555
class cmd_gselftest(GTKCommand):
 
556
    """Version of selftest that displays a notification at the end"""
 
557
 
 
558
    takes_args = builtins.cmd_selftest.takes_args
 
559
    takes_options = builtins.cmd_selftest.takes_options
 
560
    _see_also = ['selftest']
 
561
 
 
562
    def run(self, *args, **kwargs):
 
563
        import cgi
 
564
        import sys
 
565
        default_encoding = sys.getdefaultencoding()
 
566
        # prevent gtk from blowing up later
 
567
        gtk = import_pygtk()
 
568
        # prevent gtk from messing with default encoding
 
569
        import pynotify
 
570
        if sys.getdefaultencoding() != default_encoding:
 
571
            reload(sys)
 
572
            sys.setdefaultencoding(default_encoding)
 
573
        result = builtins.cmd_selftest().run(*args, **kwargs)
 
574
        if result == 0:
 
575
            summary = 'Success'
 
576
            body = 'Selftest succeeded in "%s"' % os.getcwd()
 
577
        if result == 1:
 
578
            summary = 'Failure'
 
579
            body = 'Selftest failed in "%s"' % os.getcwd()
 
580
        pynotify.init("bzr gselftest")
 
581
        note = pynotify.Notification(cgi.escape(summary), cgi.escape(body))
 
582
        note.set_timeout(pynotify.EXPIRES_NEVER)
 
583
        note.show()
 
584
 
 
585
 
 
586
register_command(cmd_gselftest)
 
587
 
 
588
 
 
589
class cmd_test_gtk(GTKCommand):
 
590
    """Version of selftest that just runs the gtk test suite."""
 
591
 
 
592
    takes_options = ['verbose',
 
593
                     Option('one', short_name='1',
 
594
                            help='Stop when one test fails.'),
 
595
                     Option('benchmark', help='Run the benchmarks.'),
 
596
                     Option('lsprof-timed',
 
597
                     help='Generate lsprof output for benchmarked'
 
598
                          ' sections of code.'),
 
599
                     Option('list-only',
 
600
                     help='List the tests instead of running them.'),
 
601
                     Option('randomize', type=str, argname="SEED",
 
602
                     help='Randomize the order of tests using the given'
 
603
                          ' seed or "now" for the current time.'),
 
604
                    ]
 
605
    takes_args = ['testspecs*']
 
606
 
 
607
    def run(self, verbose=None, one=False, benchmark=None,
 
608
            lsprof_timed=None, list_only=False, randomize=None,
 
609
            testspecs_list=None):
 
610
        from bzrlib import __path__ as bzrlib_path
 
611
        from bzrlib.tests import selftest
 
612
 
 
613
        print '%10s: %s' % ('bzrlib', bzrlib_path[0])
 
614
        if benchmark:
 
615
            print 'No benchmarks yet'
 
616
            return 3
 
617
 
 
618
            test_suite_factory = bench_suite
 
619
            if verbose is None:
 
620
                verbose = True
 
621
            # TODO: should possibly lock the history file...
 
622
            benchfile = open(".perf_history", "at", buffering=1)
 
623
        else:
 
624
            test_suite_factory = test_suite
 
625
            if verbose is None:
 
626
                verbose = False
 
627
            benchfile = None
 
628
 
 
629
        if testspecs_list is not None:
 
630
            pattern = '|'.join(testspecs_list)
 
631
        else:
 
632
            pattern = ".*"
 
633
 
 
634
        try:
 
635
            result = selftest(verbose=verbose,
 
636
                              pattern=pattern,
 
637
                              stop_on_failure=one,
 
638
                              test_suite_factory=test_suite_factory,
 
639
                              lsprof_timed=lsprof_timed,
 
640
                              bench_history=benchfile,
 
641
                              list_only=list_only,
 
642
                              random_seed=randomize,
 
643
                             )
 
644
        finally:
 
645
            if benchfile is not None:
 
646
                benchfile.close()
 
647
 
 
648
register_command(cmd_test_gtk)
 
649
 
 
650
 
168
651
 
169
652
import gettext
170
653
gettext.install('olive-gtk')
173
656
# uses of '_' as an anonymous variable (think pdb for one).
174
657
_i18n = gettext.gettext
175
658
 
176
 
class NoDisplayError(errors.BzrCommandError):
 
659
class NoDisplayError(BzrCommandError):
177
660
    """gtk could not find a proper display"""
178
661
 
179
662
    def __str__(self):
180
663
        return "No DISPLAY. Unable to run GTK+ application."
181
664
 
182
665
 
183
 
credential_store_registry = getattr(config, "credential_store_registry", None)
184
 
if credential_store_registry is not None:
185
 
    try:
186
 
        credential_store_registry.register_lazy(
187
 
            "gnome-keyring", "bzrlib.plugins.gtk.keyring", "GnomeKeyringCredentialStore",
188
 
            help="The GNOME Keyring.", fallback=True)
189
 
    except TypeError:
190
 
    # Fallback credentials stores were introduced in Bazaar 1.15
191
 
        credential_store_registry.register_lazy(
192
 
            "gnome-keyring", "bzrlib.plugins.gtk.keyring", "GnomeKeyringCredentialStore",
193
 
            help="The GNOME Keyring.")
194
 
 
195
 
 
196
 
def load_tests(basic_tests, module, loader):
197
 
    testmod_names = [
198
 
        'tests',
199
 
        ]
 
666
def test_suite():
 
667
    from unittest import TestSuite
 
668
    import tests
200
669
    import sys
201
670
    default_encoding = sys.getdefaultencoding()
202
671
    try:
203
 
        result = basic_tests
 
672
        result = TestSuite()
204
673
        try:
205
674
            import_pygtk()
206
675
        except errors.BzrCommandError:
207
 
            return basic_tests
208
 
        basic_tests.addTest(loader.loadTestsFromModuleNames(
209
 
                ["%s.%s" % (__name__, tmn) for tmn in testmod_names]))
 
676
            return result
 
677
        result.addTest(tests.test_suite())
210
678
    finally:
211
679
        if sys.getdefaultencoding() != default_encoding:
212
680
            reload(sys)
213
681
            sys.setdefaultencoding(default_encoding)
214
 
    return basic_tests
 
682
    return result