/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: Jelmer Vernooij
  • Date: 2008-06-29 19:18:34 UTC
  • mto: This revision was merged to the branch mainline in revision 515.
  • Revision ID: jelmer@samba.org-20080629191834-ha2ecpv5szt96nge
Make sure signed testament matches repository data.

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
1
 
#
2
 
#
3
1
# This program is free software; you can redistribute it and/or modify
4
2
# it under the terms of the GNU General Public License as published by
5
3
# the Free Software Foundation; either version 2 of the License, or
21
19
gannotate         GTK+ annotate. 
22
20
gbranch           GTK+ branching. 
23
21
gcheckout         GTK+ checkout. 
24
 
gcommit           GTK+ commit dialog 
25
 
gconflicts        GTK+ push. 
 
22
gcommit           GTK+ commit dialog.
 
23
gconflicts        GTK+ conflicts. 
26
24
gdiff             Show differences in working tree in a GTK+ Window. 
27
25
ginit             Initialise a new branch.
28
26
gmissing          GTK+ missing revisions dialog. 
29
27
gpreferences      GTK+ preferences dialog. 
30
 
gpush             GTK+ push. 
31
 
gstatus           GTK+ status dialog 
 
28
gpush             GTK+ push.
 
29
gsend             GTK+ send merge directive.
 
30
gstatus           GTK+ status dialog.
32
31
gtags             Manage branch tags.
33
32
visualise         Graphically visualise this branch. 
34
33
"""
35
34
 
 
35
import sys
 
36
 
36
37
import bzrlib
37
38
 
38
 
__version__ = '0.18.0'
39
 
version_info = tuple(int(n) for n in __version__.split('.'))
40
 
 
 
39
version_info = (0, 95, 0, 'dev', 1)
 
40
 
 
41
if version_info[3] == 'final':
 
42
    version_string = '%d.%d.%d' % version_info[:3]
 
43
else:
 
44
    version_string = '%d.%d.%d%s%d' % version_info
 
45
__version__ = version_string
 
46
 
 
47
required_bzrlib = (1, 3)
41
48
 
42
49
def check_bzrlib_version(desired):
43
50
    """Check that bzrlib is compatible.
44
51
 
45
52
    If version is < bzr-gtk version, assume incompatible.
46
 
    If version == bzr-gtk version, assume completely compatible
47
 
    If version == bzr-gtk version + 1, assume compatible, with deprecations
48
 
    Otherwise, assume incompatible.
49
53
    """
50
 
    desired_plus = (desired[0], desired[1]+1)
51
54
    bzrlib_version = bzrlib.version_info[:2]
52
 
    if bzrlib_version == desired or (bzrlib_version == desired_plus and
53
 
                                     bzrlib.version_info[3] == 'dev'):
54
 
        return
55
55
    try:
56
56
        from bzrlib.trace import warning
57
57
    except ImportError:
59
59
        from warnings import warn as warning
60
60
    if bzrlib_version < desired:
61
61
        from bzrlib.errors import BzrError
62
 
        warning('Installed bzr version %s is too old to be used with bzr-gtk'
 
62
        warning('Installed Bazaar version %s is too old to be used with bzr-gtk'
63
63
                ' %s.' % (bzrlib.__version__, __version__))
64
 
        raise BzrError('Version mismatch: %r' % version_info)
65
 
    else:
66
 
        warning('bzr-gtk is not up to date with installed bzr version %s.'
67
 
                ' \nThere should be a newer version available, e.g. %i.%i.' 
68
 
                % (bzrlib.__version__, bzrlib_version[0], bzrlib_version[1]))
69
 
 
70
 
 
71
 
check_bzrlib_version(version_info[:2])
 
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)
72
69
 
73
70
from bzrlib.trace import warning
74
71
if __name__ != 'bzrlib.plugins.gtk':
78
75
lazy_import(globals(), """
79
76
from bzrlib import (
80
77
    branch,
 
78
    builtins,
81
79
    errors,
 
80
    merge_directive,
82
81
    workingtree,
83
82
    )
84
83
""")
105
104
    bzrlib.ui.ui_factory = GtkUIFactory()
106
105
 
107
106
 
 
107
def data_path():
 
108
    return os.path.dirname(__file__)
 
109
 
 
110
 
 
111
def icon_path(*args):
 
112
    basedirs = [os.path.join(data_path()),
 
113
             "/usr/share/bzr-gtk", 
 
114
             "/usr/local/share/bzr-gtk"]
 
115
    for basedir in basedirs:
 
116
        path = os.path.join(basedir, 'icons', *args)
 
117
        if os.path.exists(path):
 
118
            return path
 
119
    return None
 
120
 
 
121
 
 
122
def open_display():
 
123
    pygtk = import_pygtk()
 
124
    try:
 
125
        import gtk
 
126
    except RuntimeError, e:
 
127
        if str(e) == "could not open display":
 
128
            raise NoDisplayError
 
129
    set_ui_factory()
 
130
    return gtk
 
131
 
 
132
 
108
133
class GTKCommand(Command):
109
134
    """Abstract class providing GTK specific run commands."""
110
135
 
111
 
    def open_display(self):
112
 
        pygtk = import_pygtk()
113
 
        try:
114
 
            import gtk
115
 
        except RuntimeError, e:
116
 
            if str(e) == "could not open display":
117
 
                raise NoDisplayError
118
 
        set_ui_factory()
119
 
        return gtk
120
 
 
121
136
    def run(self):
122
 
        self.open_display()
 
137
        open_display()
123
138
        dialog = self.get_gtk_dialog(os.path.abspath('.'))
124
139
        dialog.run()
125
140
 
153
168
 
154
169
    def run(self, location="."):
155
170
        (br, path) = branch.Branch.open_containing(location)
156
 
        self.open_display()
 
171
        open_display()
157
172
        from push import PushDialog
158
 
        dialog = PushDialog(br)
 
173
        dialog = PushDialog(br.repository, br.last_revision(), br)
159
174
        dialog.run()
160
175
 
161
176
 
178
193
            if revision is not None:
179
194
                if len(revision) == 1:
180
195
                    tree1 = wt
181
 
                    revision_id = revision[0].in_history(branch).rev_id
 
196
                    revision_id = revision[0].as_revision_id(tree1.branch)
182
197
                    tree2 = branch.repository.revision_tree(revision_id)
183
198
                elif len(revision) == 2:
184
 
                    revision_id_0 = revision[0].in_history(branch).rev_id
 
199
                    revision_id_0 = revision[0].as_revision_id(branch)
185
200
                    tree2 = branch.repository.revision_tree(revision_id_0)
186
 
                    revision_id_1 = revision[1].in_history(branch).rev_id
 
201
                    revision_id_1 = revision[1].as_revision_id(branch)
187
202
                    tree1 = branch.repository.revision_tree(revision_id_1)
188
203
            else:
189
204
                tree1 = wt
211
226
            wt.unlock()
212
227
 
213
228
 
214
 
def start_viz_window(branch, revision, limit=None):
 
229
def start_viz_window(branch, revisions, limit=None):
215
230
    """Start viz on branch with revision revision.
216
231
    
217
232
    :return: The viz window object.
218
233
    """
219
 
    from viz.branchwin import BranchWindow
220
 
    branch.lock_read()
221
 
    pp = BranchWindow()
222
 
    pp.set_branch(branch, revision, limit)
223
 
    # cleanup locks when the window is closed
224
 
    pp.connect("destroy", lambda w: branch.unlock())
225
 
    return pp
 
234
    from viz import BranchWindow
 
235
    return BranchWindow(branch, revisions, limit)
226
236
 
227
237
 
228
238
class cmd_visualise(Command):
238
248
        "revision",
239
249
        Option('limit', "Maximum number of revisions to display.",
240
250
               int, 'count')]
241
 
    takes_args = [ "location?" ]
 
251
    takes_args = [ "locations*" ]
242
252
    aliases = [ "visualize", "vis", "viz" ]
243
253
 
244
 
    def run(self, location=".", revision=None, limit=None):
 
254
    def run(self, locations_list, revision=None, limit=None):
245
255
        set_ui_factory()
246
 
        (br, path) = branch.Branch.open_containing(location)
247
 
        br.lock_read()
248
 
        try:
 
256
        if locations_list is None:
 
257
            locations_list = ["."]
 
258
        revids = []
 
259
        for location in locations_list:
 
260
            (br, path) = branch.Branch.open_containing(location)
249
261
            if revision is None:
250
 
                revid = br.last_revision()
251
 
                if revid is None:
252
 
                    return
 
262
                revids.append(br.last_revision())
253
263
            else:
254
 
                (revno, revid) = revision[0].in_history(br)
255
 
 
256
 
            import gtk
257
 
            pp = start_viz_window(br, revid, limit)
258
 
            pp.connect("destroy", lambda w: gtk.main_quit())
259
 
            pp.show()
260
 
            gtk.main()
261
 
        finally:
262
 
            br.unlock()
 
264
                revids.append(revision[0].as_revision_id(br))
 
265
        import gtk
 
266
        pp = start_viz_window(br, revids, limit)
 
267
        pp.connect("destroy", lambda w: gtk.main_quit())
 
268
        pp.show()
 
269
        gtk.main()
263
270
 
264
271
 
265
272
class cmd_gannotate(GTKCommand):
279
286
    aliases = ["gblame", "gpraise"]
280
287
    
281
288
    def run(self, filename, all=False, plain=False, line='1', revision=None):
282
 
        gtk = self.open_display()
 
289
        gtk = open_display()
283
290
 
284
291
        try:
285
292
            line = int(line)
304
311
        if revision is not None:
305
312
            if len(revision) != 1:
306
313
                raise BzrCommandError("Only 1 revion may be specified.")
307
 
            revision_id = revision[0].in_history(br).rev_id
 
314
            revision_id = revision[0].as_revision_id(br)
308
315
            tree = br.repository.revision_tree(revision_id)
309
316
        else:
310
317
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
311
318
 
312
 
        window = GAnnotateWindow(all, plain)
 
319
        window = GAnnotateWindow(all, plain, branch=br)
313
320
        window.connect("destroy", lambda w: gtk.main_quit())
314
 
        window.set_title(path + " - gannotate")
315
321
        config = GAnnotateConfig(window)
316
322
        window.show()
317
323
        br.lock_read()
332
338
    """GTK+ commit dialog
333
339
 
334
340
    Graphical user interface for committing revisions"""
335
 
    
 
341
 
336
342
    aliases = [ "gci" ]
337
343
    takes_args = []
338
344
    takes_options = []
339
345
 
340
346
    def run(self, filename=None):
341
347
        import os
342
 
        self.open_display()
 
348
        open_display()
343
349
        from commit import CommitDialog
344
350
        from bzrlib.errors import (BzrCommandError,
345
351
                                   NotBranchError,
351
357
            (wt, path) = workingtree.WorkingTree.open_containing(filename)
352
358
            br = wt.branch
353
359
        except NoWorkingTree, e:
354
 
            path = e.base
355
 
            (br, path) = branch.Branch.open_containing(path)
356
 
 
357
 
        commit = CommitDialog(wt, path, not br)
358
 
        commit.run()
359
 
 
 
360
            from dialog import error_dialog
 
361
            error_dialog(_i18n('Directory does not have a working tree'),
 
362
                         _i18n('Operation aborted.'))
 
363
            return 1 # should this be retval=3?
 
364
 
 
365
        # It is a good habit to keep things locked for the duration, but it
 
366
        # could cause difficulties if someone wants to do things in another
 
367
        # window... We could lock_read() until we actually go to commit
 
368
        # changes... Just a thought.
 
369
        wt.lock_write()
 
370
        try:
 
371
            dlg = CommitDialog(wt)
 
372
            return dlg.run()
 
373
        finally:
 
374
            wt.unlock()
360
375
 
361
376
 
362
377
class cmd_gstatus(GTKCommand):
367
382
    
368
383
    aliases = [ "gst" ]
369
384
    takes_args = ['PATH?']
370
 
    takes_options = []
 
385
    takes_options = ['revision']
371
386
 
372
 
    def run(self, path='.'):
 
387
    def run(self, path='.', revision=None):
373
388
        import os
374
 
        gtk = self.open_display()
 
389
        gtk = open_display()
375
390
        from status import StatusDialog
376
391
        (wt, wt_path) = workingtree.WorkingTree.open_containing(path)
377
 
        status = StatusDialog(wt, wt_path)
 
392
        
 
393
        if revision is not None:
 
394
            try:
 
395
                revision_id = revision[0].as_revision_id(wt.branch)
 
396
            except:
 
397
                from bzrlib.errors import BzrError
 
398
                raise BzrError('Revision %r doesn\'t exist' % revision[0].user_spec )
 
399
        else:
 
400
            revision_id = None
 
401
 
 
402
        status = StatusDialog(wt, wt_path, revision_id)
378
403
        status.connect("destroy", gtk.main_quit)
379
404
        status.run()
380
405
 
381
406
 
 
407
class cmd_gsend(GTKCommand):
 
408
    """GTK+ send merge directive.
 
409
 
 
410
    """
 
411
    def run(self):
 
412
        (br, path) = branch.Branch.open_containing(".")
 
413
        gtk = open_display()
 
414
        from bzrlib.plugins.gtk.mergedirective import SendMergeDirectiveDialog
 
415
        from StringIO import StringIO
 
416
        dialog = SendMergeDirectiveDialog(br)
 
417
        if dialog.run() == gtk.RESPONSE_OK:
 
418
            outf = StringIO()
 
419
            outf.writelines(dialog.get_merge_directive().to_lines())
 
420
            mail_client = br.get_config().get_mail_client()
 
421
            mail_client.compose_merge_request(dialog.get_mail_to(), "[MERGE]", 
 
422
                outf.getvalue())
 
423
 
 
424
            
 
425
 
382
426
 
383
427
class cmd_gconflicts(GTKCommand):
384
 
    """ GTK+ push.
 
428
    """GTK+ conflicts.
385
429
    
 
430
    Select files from the list of conflicts and run an external utility to
 
431
    resolve them.
386
432
    """
387
433
    def run(self):
388
434
        (wt, path) = workingtree.WorkingTree.open_containing('.')
389
 
        self.open_display()
 
435
        open_display()
390
436
        from bzrlib.plugins.gtk.conflicts import ConflictsDialog
391
437
        dialog = ConflictsDialog(wt)
392
438
        dialog.run()
393
439
 
394
440
 
395
 
 
396
441
class cmd_gpreferences(GTKCommand):
397
442
    """ GTK+ preferences dialog.
398
443
 
399
444
    """
400
445
    def run(self):
401
 
        self.open_display()
 
446
        open_display()
402
447
        from bzrlib.plugins.gtk.preferences import PreferencesWindow
403
448
        dialog = PreferencesWindow()
404
449
        dialog.run()
405
450
 
406
451
 
407
 
 
408
452
class cmd_gmissing(Command):
409
453
    """ GTK+ missing revisions dialog.
410
454
 
443
487
 
444
488
class cmd_ginit(GTKCommand):
445
489
    def run(self):
446
 
        self.open_display()
 
490
        open_display()
447
491
        from initialize import InitDialog
448
492
        dialog = InitDialog(os.path.abspath(os.path.curdir))
449
493
        dialog.run()
453
497
    def run(self):
454
498
        br = branch.Branch.open_containing('.')[0]
455
499
        
456
 
        gtk = self.open_display()
 
500
        gtk = open_display()
457
501
        from tags import TagsWindow
458
502
        window = TagsWindow(br)
459
503
        window.show()
461
505
 
462
506
 
463
507
commands = [
 
508
    cmd_gannotate, 
 
509
    cmd_gbranch,
 
510
    cmd_gcheckout, 
 
511
    cmd_gcommit, 
 
512
    cmd_gconflicts, 
 
513
    cmd_gdiff,
 
514
    cmd_ginit,
464
515
    cmd_gmissing, 
465
516
    cmd_gpreferences, 
466
 
    cmd_gconflicts, 
 
517
    cmd_gpush, 
 
518
    cmd_gsend,
467
519
    cmd_gstatus,
468
 
    cmd_gcommit, 
469
 
    cmd_gannotate, 
470
 
    cmd_visualise, 
471
 
    cmd_gdiff,
472
 
    cmd_gpush, 
473
 
    cmd_gcheckout, 
474
 
    cmd_gbranch,
475
 
    cmd_ginit,
476
 
    cmd_gtags
 
520
    cmd_gtags,
 
521
    cmd_visualise
477
522
    ]
478
523
 
479
524
for cmd in commands:
489
534
 
490
535
    def run(self):
491
536
        from notify import NotifyPopupMenu
492
 
        gtk = self.open_display()
 
537
        gtk = open_display()
493
538
        menu = NotifyPopupMenu()
494
 
        icon = gtk.status_icon_new_from_file("bzr-icon-64.png")
 
539
        icon = gtk.status_icon_new_from_file(icon_path("bzr-icon-64.png"))
495
540
        icon.connect('popup-menu', menu.display)
496
541
 
497
542
        import cgi
504
549
        from bzrlib.transport import get_transport
505
550
        if getattr(dbus, 'version', (0,0,0)) >= (0,41,0):
506
551
            import dbus.glib
507
 
        from bzrlib.plugins.dbus import activity
 
552
        BROADCAST_INTERFACE = "org.bazaarvcs.plugins.dbus.Broadcast"
508
553
        bus = dbus.SessionBus()
509
 
        # get the object so we can subscribe to callbacks from it.
510
 
        broadcast_service = bus.get_object(
511
 
            activity.Broadcast.DBUS_NAME,
512
 
            activity.Broadcast.DBUS_PATH)
513
554
 
514
555
        def catch_branch(revision_id, urls):
515
556
            # TODO: show all the urls, or perhaps choose the 'best'.
546
587
            except Exception, e:
547
588
                print e
548
589
                raise
549
 
        broadcast_service.connect_to_signal("Revision", catch_branch,
550
 
            dbus_interface=activity.Broadcast.DBUS_INTERFACE)
 
590
        bus.add_signal_receiver(catch_branch,
 
591
                                dbus_interface=BROADCAST_INTERFACE,
 
592
                                signal_name="Revision")
551
593
        pynotify.init("bzr commit-notify")
552
594
        gtk.main()
553
595
 
554
596
register_command(cmd_commit_notify)
555
597
 
556
598
 
 
599
class cmd_gselftest(GTKCommand):
 
600
    """Version of selftest that displays a notification at the end"""
 
601
 
 
602
    takes_args = builtins.cmd_selftest.takes_args
 
603
    takes_options = builtins.cmd_selftest.takes_options
 
604
    _see_also = ['selftest']
 
605
 
 
606
    def run(self, *args, **kwargs):
 
607
        import cgi
 
608
        import sys
 
609
        default_encoding = sys.getdefaultencoding()
 
610
        # prevent gtk from blowing up later
 
611
        gtk = import_pygtk()
 
612
        # prevent gtk from messing with default encoding
 
613
        import pynotify
 
614
        if sys.getdefaultencoding() != default_encoding:
 
615
            reload(sys)
 
616
            sys.setdefaultencoding(default_encoding)
 
617
        result = builtins.cmd_selftest().run(*args, **kwargs)
 
618
        if result == 0:
 
619
            summary = 'Success'
 
620
            body = 'Selftest succeeded in "%s"' % os.getcwd()
 
621
        if result == 1:
 
622
            summary = 'Failure'
 
623
            body = 'Selftest failed in "%s"' % os.getcwd()
 
624
        pynotify.init("bzr gselftest")
 
625
        note = pynotify.Notification(cgi.escape(summary), cgi.escape(body))
 
626
        note.set_timeout(pynotify.EXPIRES_NEVER)
 
627
        note.show()
 
628
 
 
629
 
 
630
register_command(cmd_gselftest)
 
631
 
 
632
 
 
633
class cmd_test_gtk(GTKCommand):
 
634
    """Version of selftest that just runs the gtk test suite."""
 
635
 
 
636
    takes_options = ['verbose',
 
637
                     Option('one', short_name='1',
 
638
                            help='Stop when one test fails.'),
 
639
                     Option('benchmark', help='Run the benchmarks.'),
 
640
                     Option('lsprof-timed',
 
641
                     help='Generate lsprof output for benchmarked'
 
642
                          ' sections of code.'),
 
643
                     Option('list-only',
 
644
                     help='List the tests instead of running them.'),
 
645
                     Option('randomize', type=str, argname="SEED",
 
646
                     help='Randomize the order of tests using the given'
 
647
                          ' seed or "now" for the current time.'),
 
648
                    ]
 
649
    takes_args = ['testspecs*']
 
650
 
 
651
    def run(self, verbose=None, one=False, benchmark=None,
 
652
            lsprof_timed=None, list_only=False, randomize=None,
 
653
            testspecs_list=None):
 
654
        from bzrlib import __path__ as bzrlib_path
 
655
        from bzrlib.tests import selftest
 
656
 
 
657
        print '%10s: %s' % ('bzrlib', bzrlib_path[0])
 
658
        if benchmark:
 
659
            print 'No benchmarks yet'
 
660
            return 3
 
661
 
 
662
            test_suite_factory = bench_suite
 
663
            if verbose is None:
 
664
                verbose = True
 
665
            # TODO: should possibly lock the history file...
 
666
            benchfile = open(".perf_history", "at", buffering=1)
 
667
        else:
 
668
            test_suite_factory = test_suite
 
669
            if verbose is None:
 
670
                verbose = False
 
671
            benchfile = None
 
672
 
 
673
        if testspecs_list is not None:
 
674
            pattern = '|'.join(testspecs_list)
 
675
        else:
 
676
            pattern = ".*"
 
677
 
 
678
        try:
 
679
            result = selftest(verbose=verbose,
 
680
                              pattern=pattern,
 
681
                              stop_on_failure=one,
 
682
                              test_suite_factory=test_suite_factory,
 
683
                              lsprof_timed=lsprof_timed,
 
684
                              bench_history=benchfile,
 
685
                              list_only=list_only,
 
686
                              random_seed=randomize,
 
687
                             )
 
688
        finally:
 
689
            if benchfile is not None:
 
690
                benchfile.close()
 
691
 
 
692
register_command(cmd_test_gtk)
 
693
 
 
694
 
 
695
 
557
696
import gettext
558
697
gettext.install('olive-gtk')
559
698
 
 
699
# Let's create a specialized alias to protect '_' from being erased by other
 
700
# uses of '_' as an anonymous variable (think pdb for one).
 
701
_i18n = gettext.gettext
560
702
 
561
703
class NoDisplayError(BzrCommandError):
562
704
    """gtk could not find a proper display"""
572
714
    default_encoding = sys.getdefaultencoding()
573
715
    try:
574
716
        result = TestSuite()
 
717
        try:
 
718
            import_pygtk()
 
719
        except errors.BzrCommandError:
 
720
            return result
575
721
        result.addTest(tests.test_suite())
576
722
    finally:
577
723
        if sys.getdefaultencoding() != default_encoding: