/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: 2007-02-01 15:50:40 UTC
  • Revision ID: jelmer@samba.org-20070201155040-3hq4mfbxs99kzazy
add framework for tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
16
16
 
17
17
import bzrlib
18
18
 
19
 
__version__ = '0.16.0'
 
19
__version__ = '0.15.0'
20
20
version_info = tuple(int(n) for n in __version__.split('.'))
21
21
 
22
22
 
52
52
 
53
53
check_bzrlib_version(version_info[:2])
54
54
 
55
 
from bzrlib.trace import warning
56
 
if __name__ != 'bzrlib.plugins.gtk':
57
 
    warning("Not running as bzrlib.plugins.gtk, things may break.")
58
 
 
59
 
from bzrlib.lazy_import import lazy_import
60
 
lazy_import(globals(), """
61
 
from bzrlib import (
62
 
    branch,
63
 
    errors,
64
 
    workingtree,
65
 
    )
66
 
""")
67
 
 
 
55
from bzrlib import errors
68
56
from bzrlib.commands import Command, register_command, display_command
69
57
from bzrlib.errors import NotVersionedError, BzrCommandError, NoSuchFile
70
58
from bzrlib.commands import Command, register_command
71
59
from bzrlib.option import Option
 
60
from bzrlib.branch import Branch
 
61
from bzrlib.workingtree import WorkingTree
72
62
from bzrlib.bzrdir import BzrDir
73
63
 
74
64
import os.path
84
74
 
85
75
def set_ui_factory():
86
76
    pygtk = import_pygtk()
87
 
    from ui import GtkUIFactory
 
77
    from olive.ui import GtkUIFactory
88
78
    import bzrlib.ui
89
79
    bzrlib.ui.ui_factory = GtkUIFactory()
90
80
 
102
92
            if str(e) == "could not open display":
103
93
                raise NoDisplayError
104
94
 
105
 
        from bzrlib.plugins.gtk.branch import BranchDialog
 
95
        from bzrlib.plugins.gtk.olive.branch import BranchDialog
106
96
 
107
97
        set_ui_factory()
108
98
        dialog = BranchDialog(os.path.abspath('.'))
109
 
        dialog.run()
 
99
        dialog.window.connect("destroy", lambda w: gtk.main_quit())
 
100
        dialog.display()
 
101
        
 
102
        gtk.main()
110
103
 
111
104
register_command(cmd_gbranch)
112
105
 
113
 
class cmd_gcheckout(Command):
114
 
    """ GTK+ checkout.
115
 
    
116
 
    """
117
 
    
118
 
    def run(self):
119
 
        pygtk = import_pygtk()
120
 
        try:
121
 
            import gtk
122
 
        except RuntimeError, e:
123
 
            if str(e) == "could not open display":
124
 
                raise NoDisplayError
125
 
 
126
 
        from bzrlib.plugins.gtk.checkout import CheckoutDialog
127
 
 
128
 
        set_ui_factory()
129
 
        dialog = CheckoutDialog(os.path.abspath('.'))
130
 
        dialog.run()
131
 
 
132
 
register_command(cmd_gcheckout)
133
 
 
134
 
class cmd_gpush(Command):
135
 
    """ GTK+ push.
136
 
    
137
 
    """
138
 
    takes_args = [ "location?" ]
139
 
 
140
 
    def run(self, location="."):
141
 
        (br, path) = branch.Branch.open_containing(location)
142
 
 
143
 
        pygtk = import_pygtk()
144
 
        try:
145
 
            import gtk
146
 
        except RuntimeError, e:
147
 
            if str(e) == "could not open display":
148
 
                raise NoDisplayError
149
 
 
150
 
        from push import PushDialog
151
 
 
152
 
        set_ui_factory()
153
 
        dialog = PushDialog(br)
154
 
        dialog.run()
155
 
 
156
 
register_command(cmd_gpush)
157
 
 
158
106
class cmd_gdiff(Command):
159
107
    """Show differences in working tree in a GTK+ Window.
160
108
    
166
114
    @display_command
167
115
    def run(self, revision=None, filename=None):
168
116
        set_ui_factory()
169
 
        wt = workingtree.WorkingTree.open_containing(".")[0]
170
 
        wt.lock_read()
171
 
        try:
172
 
            branch = wt.branch
173
 
            if revision is not None:
174
 
                if len(revision) == 1:
175
 
                    tree1 = wt
176
 
                    revision_id = revision[0].in_history(branch).rev_id
177
 
                    tree2 = branch.repository.revision_tree(revision_id)
178
 
                elif len(revision) == 2:
179
 
                    revision_id_0 = revision[0].in_history(branch).rev_id
180
 
                    tree2 = branch.repository.revision_tree(revision_id_0)
181
 
                    revision_id_1 = revision[1].in_history(branch).rev_id
182
 
                    tree1 = branch.repository.revision_tree(revision_id_1)
183
 
            else:
 
117
        wt = WorkingTree.open_containing(".")[0]
 
118
        branch = wt.branch
 
119
        if revision is not None:
 
120
            if len(revision) == 1:
184
121
                tree1 = wt
185
 
                tree2 = tree1.basis_tree()
186
 
 
187
 
            from diff import DiffWindow
188
 
            import gtk
189
 
            window = DiffWindow()
190
 
            window.connect("destroy", gtk.main_quit)
191
 
            window.set_diff("Working Tree", tree1, tree2)
192
 
            if filename is not None:
193
 
                tree_filename = wt.relpath(filename)
194
 
                try:
195
 
                    window.set_file(tree_filename)
196
 
                except NoSuchFile:
197
 
                    if (tree1.inventory.path2id(tree_filename) is None and 
198
 
                        tree2.inventory.path2id(tree_filename) is None):
199
 
                        raise NotVersionedError(filename)
200
 
                    raise BzrCommandError('No changes found for file "%s"' % 
201
 
                                          filename)
202
 
            window.show()
203
 
 
204
 
            gtk.main()
205
 
        finally:
206
 
            wt.unlock()
 
122
                revision_id = revision[0].in_history(branch).rev_id
 
123
                tree2 = branch.repository.revision_tree(revision_id)
 
124
            elif len(revision) == 2:
 
125
                revision_id_0 = revision[0].in_history(branch).rev_id
 
126
                tree2 = branch.repository.revision_tree(revision_id_0)
 
127
                revision_id_1 = revision[1].in_history(branch).rev_id
 
128
                tree1 = branch.repository.revision_tree(revision_id_1)
 
129
        else:
 
130
            tree1 = wt
 
131
            tree2 = tree1.basis_tree()
 
132
 
 
133
        from viz.diffwin import DiffWindow
 
134
        import gtk
 
135
        window = DiffWindow()
 
136
        window.connect("destroy", lambda w: gtk.main_quit())
 
137
        window.set_diff("Working Tree", tree1, tree2)
 
138
        if filename is not None:
 
139
            tree_filename = wt.relpath(filename)
 
140
            try:
 
141
                window.set_file(tree_filename)
 
142
            except NoSuchFile:
 
143
                if (tree1.inventory.path2id(tree_filename) is None and 
 
144
                    tree2.inventory.path2id(tree_filename) is None):
 
145
                    raise NotVersionedError(filename)
 
146
                raise BzrCommandError('No changes found for file "%s"' % 
 
147
                                      filename)
 
148
        window.show()
 
149
 
 
150
        gtk.main()
207
151
 
208
152
register_command(cmd_gdiff)
209
153
 
225
169
 
226
170
    def run(self, location=".", revision=None, limit=None):
227
171
        set_ui_factory()
228
 
        (br, path) = branch.Branch.open_containing(location)
229
 
        br.lock_read()
230
 
        br.repository.lock_read()
 
172
        (branch, path) = Branch.open_containing(location)
 
173
        branch.lock_read()
 
174
        branch.repository.lock_read()
231
175
        try:
232
176
            if revision is None:
233
 
                revid = br.last_revision()
 
177
                revid = branch.last_revision()
234
178
                if revid is None:
235
179
                    return
236
180
            else:
237
 
                (revno, revid) = revision[0].in_history(br)
 
181
                (revno, revid) = revision[0].in_history(branch)
238
182
 
239
 
            from viz.branchwin import BranchWindow
240
 
            import gtk
 
183
            from viz.bzrkapp import BzrkApp
241
184
                
242
 
            pp = BranchWindow()
243
 
            pp.set_branch(br, revid, limit)
244
 
            pp.connect("destroy", lambda w: gtk.main_quit())
245
 
            pp.show()
246
 
            gtk.main()
 
185
            app = BzrkApp()
 
186
            app.show(branch, revid, limit)
247
187
        finally:
248
 
            br.repository.unlock()
249
 
            br.unlock()
 
188
            branch.repository.unlock()
 
189
            branch.unlock()
 
190
        app.main()
250
191
 
251
192
 
252
193
register_command(cmd_visualise)
286
227
        from annotate.gannotate import GAnnotateWindow
287
228
        from annotate.config import GAnnotateConfig
288
229
 
289
 
        wt, br, path = BzrDir.open_containing_tree_or_branch(filename)
290
 
        if wt is not None:
291
 
            tree = wt
292
 
        else:
293
 
            tree = br.basis_tree()
 
230
        try:
 
231
            (tree, path) = WorkingTree.open_containing(filename)
 
232
            branch = tree.branch
 
233
        except errors.NoWorkingTree:
 
234
            (branch, path) = Branch.open_containing(filename)
 
235
            tree = branch.basis_tree()
294
236
 
295
237
        file_id = tree.path2id(path)
296
238
 
299
241
        if revision is not None:
300
242
            if len(revision) != 1:
301
243
                raise BzrCommandError("Only 1 revion may be specified.")
302
 
            revision_id = revision[0].in_history(br).rev_id
303
 
            tree = br.repository.revision_tree(revision_id)
 
244
            revision_id = revision[0].in_history(branch).rev_id
 
245
            tree = branch.repository.revision_tree(revision_id)
304
246
        else:
305
247
            revision_id = getattr(tree, 'get_revision_id', lambda: None)()
306
248
 
309
251
        window.set_title(path + " - gannotate")
310
252
        config = GAnnotateConfig(window)
311
253
        window.show()
312
 
        br.lock_read()
313
 
        if wt is not None:
314
 
            wt.lock_read()
 
254
        branch.lock_read()
315
255
        try:
316
 
            window.annotate(tree, br, file_id)
317
 
            window.jump_to_line(line)
318
 
            gtk.main()
 
256
            window.annotate(tree, branch, file_id)
319
257
        finally:
320
 
            br.unlock()
321
 
            if wt is not None:
322
 
                wt.unlock()
 
258
            branch.unlock()
 
259
        window.jump_to_line(line)
 
260
        
 
261
        gtk.main()
323
262
 
324
263
register_command(cmd_gannotate)
325
264
 
328
267
 
329
268
    Graphical user interface for committing revisions"""
330
269
    
331
 
    aliases = [ "gci" ]
332
270
    takes_args = []
333
271
    takes_options = []
334
272
 
343
281
                raise NoDisplayError
344
282
 
345
283
        set_ui_factory()
346
 
        from commit import CommitDialog
 
284
        from olive.commit import CommitDialog
347
285
        from bzrlib.commit import Commit
348
286
        from bzrlib.errors import (BzrCommandError,
349
287
                                   NotBranchError,
353
291
                                   StrictCommitFailed)
354
292
 
355
293
        wt = None
356
 
        br = None
 
294
        branch = None
357
295
        try:
358
 
            (wt, path) = workingtree.WorkingTree.open_containing(filename)
359
 
            br = wt.branch
 
296
            (wt, path) = WorkingTree.open_containing(filename)
 
297
            branch = wt.branch
360
298
        except NotBranchError, e:
361
299
            path = e.path
362
300
        except NoWorkingTree, e:
363
301
            path = e.base
364
302
            try:
365
 
                (br, path) = branch.Branch.open_containing(path)
 
303
                (branch, path) = Branch.open_containing(path)
366
304
            except NotBranchError, e:
367
305
                path = e.path
368
306
 
369
307
 
370
 
        commit = CommitDialog(wt, path, not br)
 
308
        commit = CommitDialog(wt, path, not branch)
371
309
        commit.run()
372
310
 
373
311
register_command(cmd_gcommit)
374
312
 
375
 
class cmd_gstatus(Command):
376
 
    """GTK+ status dialog
377
 
 
378
 
    Graphical user interface for showing status 
379
 
    information."""
380
 
    
381
 
    aliases = [ "gst" ]
382
 
    takes_args = ['PATH?']
383
 
    takes_options = []
384
 
 
385
 
    def run(self, path='.'):
386
 
        import os
387
 
        pygtk = import_pygtk()
388
 
 
389
 
        try:
390
 
            import gtk
391
 
        except RuntimeError, e:
392
 
            if str(e) == "could not open display":
393
 
                raise NoDisplayError
394
 
 
395
 
        set_ui_factory()
396
 
        from status import StatusDialog
397
 
        (wt, wt_path) = workingtree.WorkingTree.open_containing(path)
398
 
        status = StatusDialog(wt, wt_path)
399
 
        status.connect("destroy", gtk.main_quit)
400
 
        status.run()
401
 
 
402
 
register_command(cmd_gstatus)
403
 
 
404
 
class cmd_gconflicts(Command):
405
 
    """ GTK+ push.
406
 
    
407
 
    """
408
 
    def run(self):
409
 
        (wt, path) = workingtree.WorkingTree.open_containing('.')
410
 
        
411
 
        pygtk = import_pygtk()
412
 
        try:
413
 
            import gtk
414
 
        except RuntimeError, e:
415
 
            if str(e) == "could not open display":
416
 
                raise NoDisplayError
417
 
 
418
 
        from bzrlib.plugins.gtk.conflicts import ConflictsDialog
419
 
 
420
 
        set_ui_factory()
421
 
        dialog = ConflictsDialog(wt)
422
 
        dialog.run()
423
 
 
424
 
register_command(cmd_gconflicts)
425
 
 
426
 
import gettext
427
 
gettext.install('olive-gtk')
428
 
 
429
313
class NoDisplayError(BzrCommandError):
430
314
    """gtk could not find a proper display"""
431
315
 
435
319
def test_suite():
436
320
    from unittest import TestSuite
437
321
    import tests
438
 
    import sys
439
 
    default_encoding = sys.getdefaultencoding()
440
 
    try:
441
 
        result = TestSuite()
442
 
        result.addTest(tests.test_suite())
443
 
    finally:
444
 
        reload(sys)
445
 
        sys.setdefaultencoding(default_encoding)
 
322
    result = TestSuite()
 
323
    result.addTest(tests.test_suite())
446
324
    return result
 
325