← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to __init__.py

  • Committer: Aaron Bentley
  • Date: 2007-06-12 22:09:44 UTC
  • mfrom: (540.1.2 bzrtools-0.17)
  • Revision ID: aaron.bentley@utoronto.ca-20070612220944-5zw4hlzp1ctq6mkl
Merge fixes from 0.17

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
1
 
# Copyright (C) 2005, 2006, 2007 Aaron Bentley <aaron@aaronbentley.com>
 
1
# Copyright (C) 2005, 2006, 2007 Aaron Bentley <aaron.bentley@utoronto.ca>
2
2
# Copyright (C) 2005, 2006 Canonical Limited.
3
3
# Copyright (C) 2006 Michael Ellerman.
4
4
#
22
22
 
23
23
import bzrlib
24
24
 
 
25
 
 
26
__version__ = '0.18.0'
 
27
 
 
28
 
 
29
version_info = tuple(int(n) for n in __version__.split('.'))
 
30
 
 
31
 
 
32
def check_bzrlib_version(desired):
 
33
    """Check that bzrlib is compatible.
 
34
 
 
35
    If version is < bzrtools version, assume incompatible.
 
36
    If version == bzrtools version, assume completely compatible
 
37
    If version == bzrtools version + 1, assume compatible, with deprecations
 
38
    Otherwise, assume incompatible.
 
39
    """
 
40
    desired_plus = (desired[0], desired[1]+1)
 
41
    bzrlib_version = bzrlib.version_info[:2]
 
42
    if bzrlib_version == desired or (bzrlib_version == desired_plus and
 
43
                                     bzrlib.version_info[3] == 'dev'):
 
44
        return
 
45
    try:
 
46
        from bzrlib.trace import warning
 
47
    except ImportError:
 
48
        # get the message out any way we can
 
49
        from warnings import warn as warning
 
50
    if bzrlib_version < desired:
 
51
        warning('Installed Bazaar version %s is too old to be used with'
 
52
                ' plugin \n'
 
53
                '"Bzrtools" %s.' % (bzrlib.__version__, __version__))
 
54
        # Not using BzrNewError, because it may not exist.
 
55
        raise Exception, ('Version mismatch', version_info)
 
56
    else:
 
57
        warning('Plugin "Bzrtools" is not up to date with installed Bazaar'
 
58
                ' version %s.\n'
 
59
                ' There should be a newer version of Bzrtools available, e.g.'
 
60
                ' %i.%i.'
 
61
                % (bzrlib.__version__, bzrlib_version[0], bzrlib_version[1]))
 
62
        if bzrlib_version != desired_plus:
 
63
            raise Exception, 'Version mismatch'
 
64
 
 
65
 
 
66
check_bzrlib_version(version_info[:2])
 
67
 
25
68
from bzrlib.lazy_import import lazy_import
26
69
lazy_import(globals(), """
27
 
from bzrlib import help, urlutils
 
70
from bzrlib import help
28
71
import shelf
29
72
""")
30
73
 
31
 
from version import version_info, __version__
32
 
from command import BzrToolsCommand
33
 
from errors import CommandError
 
74
from errors import CommandError, NoPyBaz
34
75
from patchsource import BzrPatchSource
35
76
import sys
36
77
import os.path
37
78
 
38
79
import bzrlib.builtins
39
80
import bzrlib.commands
40
 
from bzrlib.branch import Branch
41
 
from bzrlib.bzrdir import BzrDir
42
81
from bzrlib.commands import get_cmd_object
43
82
from bzrlib.errors import BzrCommandError
44
83
import bzrlib.ignores
45
 
from bzrlib.trace import note
46
84
from bzrlib.option import Option
47
85
sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__),
48
86
                                                 "external")))
49
87
 
50
88
import show_paths
51
 
from command import BzrToolsCommand
52
89
 
53
90
bzrlib.ignores.add_runtime_ignores(['./.shelf'])
54
91
 
55
92
 
56
 
class cmd_clean_tree(BzrToolsCommand):
 
93
class cmd_clean_tree(bzrlib.commands.Command):
57
94
    """Remove unwanted files from working tree.
58
95
 
59
96
    By default, only unknown files, not ignored files, are deleted.  Versioned
68
105
 
69
106
    To check what clean-tree will do, use --dry-run.
70
107
    """
71
 
    takes_options = [Option('ignored', help='Delete all ignored files.'),
72
 
                     Option('detritus', help='Delete conflict files, merge'
 
108
    takes_options = [Option('ignored', help='delete all ignored files.'),
 
109
                     Option('detritus', help='delete conflict files, merge'
73
110
                            ' backups, and failed selftest dirs.'),
74
111
                     Option('unknown',
75
 
                            help='Delete files unknown to bzr (default).'),
76
 
                     Option('dry-run', help='Show files to delete instead of'
 
112
                            help='delete files unknown to bzr.  (default)'),
 
113
                     Option('dry-run', help='show files to delete instead of'
77
114
                            ' deleting them.')]
78
115
    def run(self, unknown=False, ignored=False, detritus=False, dry_run=False):
79
116
        from clean_tree import clean_tree
83
120
                   dry_run=dry_run)
84
121
 
85
122
 
86
 
class cmd_graph_ancestry(BzrToolsCommand):
 
123
class cmd_graph_ancestry(bzrlib.commands.Command):
87
124
    """Produce ancestry graphs using dot.
88
125
    
89
126
    Output format is detected according to file extension.  Some of the more
118
155
    If available, rsvg is used to antialias PNG and JPEG output, but this can
119
156
    be disabled with --no-antialias.
120
157
    """
121
 
    takes_args = ['file', 'merge_branch?']
122
 
    takes_options = [Option('no-collapse', help="Do not skip simple nodes."),
 
158
    takes_args = ['branch', 'file']
 
159
    takes_options = [Option('no-collapse', help="Do not skip simple nodes"),
123
160
                     Option('no-antialias',
124
 
                     help="Do not use rsvg to produce antialiased output."),
 
161
                     help="Do not use rsvg to produce antialiased output"),
125
162
                     Option('merge-branch', type=str,
126
 
                     help="Use this branch to calcuate a merge base."),
 
163
                     help="Use this branch to calcuate a merge base"),
127
164
                     Option('cluster', help="Use clustered output."),
128
 
                     Option('max-distance',
129
 
                            help="Show no nodes farther than this.", type=int),
130
 
                     Option('directory',
131
 
                            help='Source branch to use (default is current'
132
 
                            ' directory).',
133
 
                            short_name='d',
134
 
                            type=unicode),
135
 
                    ]
136
 
    def run(self, file, merge_branch=None, no_collapse=False,
137
 
            no_antialias=False, cluster=False, max_distance=100,
138
 
            directory='.'):
139
 
        if max_distance == -1:
140
 
            max_distance = None
 
165
                     Option('max-distance', help="Show no nodes farther than this",
 
166
                            type=int)]
 
167
    def run(self, branch, file, no_collapse=False, no_antialias=False,
 
168
        merge_branch=None, cluster=False, max_distance=None):
141
169
        import graph
142
170
        if cluster:
143
171
            ranking = "cluster"
144
172
        else:
145
173
            ranking = "forced"
146
 
        graph.write_ancestry_file(directory, file, not no_collapse,
 
174
        graph.write_ancestry_file(branch, file, not no_collapse,
147
175
                                  not no_antialias, merge_branch, ranking,
148
176
                                  max_distance=max_distance)
149
177
 
150
178
 
151
 
class cmd_fetch_ghosts(BzrToolsCommand):
 
179
class cmd_fetch_ghosts(bzrlib.commands.Command):
152
180
    """Attempt to retrieve ghosts from another branch.
153
181
    If the other branch is not supplied, the last-pulled branch is used.
154
182
    """
155
183
    aliases = ['fetch-missing']
156
184
    takes_args = ['branch?']
157
 
    takes_options = [Option('no-fix', help="Skip additional synchonization.")]
 
185
    takes_options = [Option('no-fix')]
158
186
    def run(self, branch=None, no_fix=False):
159
187
        from fetch_ghosts import fetch_ghosts
160
188
        fetch_ghosts(branch, no_fix)
163
191
each file name found in the patch file."""
164
192
 
165
193
 
166
 
class cmd_patch(BzrToolsCommand):
 
194
class cmd_patch(bzrlib.commands.Command):
167
195
    """Apply a named patch to the current tree.
168
196
    """
169
197
    takes_args = ['filename?']
170
198
    takes_options = [Option('strip', type=int, help=strip_help),
171
 
                     Option('silent', help='Suppress chatter.')]
 
199
                     Option('silent', help='Suppress chatter')]
172
200
    def run(self, filename=None, strip=None, silent=False):
173
201
        from patch import patch
174
202
        from bzrlib.workingtree import WorkingTree
178
206
        return patch(wt, filename, strip, silent)
179
207
 
180
208
 
181
 
class cmd_shelve(BzrToolsCommand):
 
209
class cmd_shelve(bzrlib.commands.Command):
182
210
    """Temporarily set aside some changes from the current tree.
183
211
 
184
212
    Shelve allows you to temporarily put changes you've made "on the shelf",
209
237
    """
210
238
 
211
239
    takes_args = ['file*']
212
 
    takes_options = [Option('message',
213
 
            help='A message to associate with the shelved changes.',
214
 
            short_name='m', type=unicode),
215
 
            'revision',
216
 
            Option('all', help='Shelve all changes without prompting.'),
217
 
            Option('no-color', help='Never display changes in color.')]
 
240
    takes_options = ['message', 'revision',
 
241
            Option('all', help='Shelve all changes without prompting'),
 
242
            Option('no-color', help='Never display changes in color')]
218
243
 
219
244
    def run(self, all=False, file_list=None, message=None, revision=None,
220
245
            no_color=False):
273
298
        self.shelf.upgrade()
274
299
 
275
300
 
276
 
class cmd_shelf(BzrToolsCommand):
 
301
class cmd_shelf(bzrlib.commands.Command):
277
302
    """Perform various operations on your shelved patches. See also shelve."""
278
303
    takes_args = ['subcommand', 'args*']
279
304
 
339
364
        return text
340
365
 
341
366
 
342
 
class cmd_unshelve(BzrToolsCommand):
 
367
class cmd_unshelve(bzrlib.commands.Command):
343
368
    """Restore shelved changes.
344
369
 
345
370
    By default the most recently shelved changes are restored. However if you
348
373
    See 'shelve' for more information.
349
374
    """
350
375
    takes_options = [
351
 
            Option('all', help='Unshelve all changes without prompting.'),
352
 
            Option('force', help='Force unshelving even if errors occur.'),
353
 
            Option('no-color', help='Never display changes in color.')
 
376
            Option('all', help='Unshelve all changes without prompting'),
 
377
            Option('force', help='Force unshelving even if errors occur'),
 
378
            Option('no-color', help='Never display changes in color')
354
379
        ]
355
380
    takes_args = ['patch?']
356
381
    def run(self, patch=None, all=False, force=False, no_color=False):
360
385
        return 0
361
386
 
362
387
 
363
 
class cmd_shell(BzrToolsCommand):
 
388
class cmd_shell(bzrlib.commands.Command):
364
389
    """Begin an interactive shell tailored for bzr.
365
390
    Bzr commands can be used without typing bzr first, and will be run natively
366
391
    when possible.  Tab completion is tailored for bzr.  The shell prompt shows
383
408
        return shell.run_shell()
384
409
 
385
410
 
386
 
class cmd_branch_history(BzrToolsCommand):
 
411
class cmd_branch_history(bzrlib.commands.Command):
387
412
    """\
388
413
    Display the development history of a branch.
389
414
 
397
422
        return branch_history(branch)
398
423
 
399
424
 
400
 
class cmd_zap(BzrToolsCommand):
 
425
class cmd_zap(bzrlib.commands.Command):
401
426
    """\
402
427
    Remove a lightweight checkout, if it can be done safely.
403
428
 
408
433
    If --branch is specified, the branch will be deleted too, but only if the
409
434
    the branch has no new commits (relative to its parent).
410
435
    """
411
 
    takes_options = [Option("branch", help="Remove associated branch from"
412
 
                                           " repository."),
413
 
                     Option('force', help='Delete tree even if contents are'
414
 
                     ' modified.')]
 
436
    takes_options = [Option("branch", help="Remove associtated branch from"
 
437
                                           " repository")]
415
438
    takes_args = ["checkout"]
416
 
    def run(self, checkout, branch=False, force=False):
 
439
    def run(self, checkout, branch=False):
417
440
        from zap import zap
418
 
        return zap(checkout, remove_branch=branch, allow_modified=force)
419
 
 
420
 
 
421
 
class cmd_cbranch(BzrToolsCommand):
 
441
        return zap(checkout, remove_branch=branch)
 
442
 
 
443
 
 
444
class cmd_cbranch(bzrlib.commands.Command):
422
445
    """
423
446
    Create a new checkout, associated with a new repository branch.
424
447
 
438
461
    deprecated.
439
462
    """
440
463
    takes_options = [Option("lightweight",
441
 
                            help="Create a lightweight checkout."), 'revision',
442
 
                     Option('files-from', type=unicode,
443
 
                            help='Accelerate checkout using files from this'
444
 
                                 ' tree.'),
445
 
                     Option('hardlink',
446
 
                            help='Hard-link files from source/files-from tree'
447
 
                            ' where posible.')]
 
464
                            help="Create a lightweight checkout"), 'revision']
448
465
    takes_args = ["source", "target?"]
449
 
    def run(self, source, target=None, lightweight=False, revision=None,
450
 
            files_from=None, hardlink=False):
 
466
    def run(self, source, target=None, lightweight=False, revision=None):
451
467
        from cbranch import cbranch
452
468
        return cbranch(source, target, lightweight=lightweight,
453
 
                       revision=revision, files_from=files_from,
454
 
                       hardlink=hardlink)
455
 
 
456
 
 
457
 
class cmd_branches(BzrToolsCommand):
 
469
                       revision=revision)
 
470
 
 
471
 
 
472
class cmd_branches(bzrlib.commands.Command):
458
473
    """Scan a location for branches"""
459
474
    takes_args = ["location?"]
460
475
    def run(self, location=None):
461
476
        from branches import branches
462
477
        return branches(location)
463
478
 
464
 
class cmd_trees(BzrToolsCommand):
465
 
    """Scan a location for trees"""
466
 
    takes_args = ['location?']
467
 
    def run(self, location='.'):
468
 
        from bzrlib.workingtree import WorkingTree
469
 
        from bzrlib.transport import get_transport
470
 
        t = get_transport(location)
471
 
        for tree in WorkingTree.find_trees(location):
472
 
            self.outf.write('%s\n' % t.relpath(
473
 
                tree.bzrdir.root_transport.base))
474
479
 
475
 
class cmd_multi_pull(BzrToolsCommand):
 
480
class cmd_multi_pull(bzrlib.commands.Command):
476
481
    """Pull all the branches under a location, e.g. a repository.
477
482
 
478
483
    Both branches present in the directory and the branches of checkouts are
480
485
    """
481
486
    takes_args = ["location?"]
482
487
    def run(self, location=None):
 
488
        from bzrlib.branch import Branch
483
489
        from bzrlib.transport import get_transport
484
490
        from bzrtools import iter_branch_tree
485
491
        if location is None:
486
492
            location = '.'
487
493
        t = get_transport(location)
488
 
        possible_transports = []
489
494
        if not t.listable():
490
495
            print "Can't list this type of location."
491
496
            return 3
507
512
                relpath = base
508
513
            print "Pulling %s from %s" % (relpath, parent)
509
514
            try:
510
 
                branch_t = get_transport(parent, possible_transports)
511
 
                pullable.pull(Branch.open_from_transport(branch_t))
 
515
                pullable.pull(Branch.open(parent))
512
516
            except Exception, e:
513
517
                print e
514
518
 
515
519
 
516
 
 
517
 
class cmd_import(BzrToolsCommand):
 
520
class cmd_branch_mark(bzrlib.commands.Command):
 
521
    """
 
522
    Add, view or list branch markers <EXPERIMENTAL>
 
523
 
 
524
    To add a mark, do 'bzr branch-mark MARK'.
 
525
    To list marks, do 'bzr branch-mark' (this lists all marks for the branch's
 
526
    repository).
 
527
    To delete a mark, do 'bzr branch-mark --delete MARK'
 
528
 
 
529
    These marks can be used to track a branch's status.
 
530
    """
 
531
    takes_args = ['mark?', 'branch?']
 
532
    takes_options = [Option('delete', help='Delete this mark')]
 
533
    def run(self, mark=None, branch=None, delete=False):
 
534
        from branch_mark import branch_mark
 
535
        branch_mark(mark, branch, delete)
 
536
 
 
537
 
 
538
class cmd_import(bzrlib.commands.Command):
518
539
    """Import sources from a directory, tarball or zip file
519
540
 
520
541
    This command will import a directory, tarball or zip file into a bzr
534
555
        do_import(source, tree)
535
556
 
536
557
 
537
 
class cmd_cdiff(BzrToolsCommand):
 
558
class cmd_cdiff(bzrlib.commands.Command):
538
559
    """A color version of bzr's diff"""
539
560
    takes_args = property(lambda x: get_cmd_object('diff').takes_args)
540
 
    takes_options = list(get_cmd_object('diff').takes_options) + [
541
 
        Option('check-style',
 
561
 
 
562
    def _takes_options(self):
 
563
        options = list(get_cmd_object('diff').takes_options)
 
564
        options.append(Option('check-style',
542
565
            help='Warn if trailing whitespace or spurious changes have been'
543
 
                 ' added.')]
 
566
                 ' added.'))
 
567
        return options
 
568
 
 
569
    takes_options = property(_takes_options)
544
570
 
545
571
    def run(self, check_style=False, *args, **kwargs):
546
572
        from colordiff import colordiff
547
573
        colordiff(check_style, *args, **kwargs)
548
574
 
549
575
 
550
 
class cmd_rspush(BzrToolsCommand):
 
576
class cmd_baz_import(bzrlib.commands.Command):
 
577
    """Import an Arch or Baz archive into a bzr repository.
 
578
 
 
579
    This command should be used on local archives (or mirrors) only.  It is
 
580
    quite slow on remote archives.
 
581
 
 
582
    reuse_history allows you to specify any previous imports you
 
583
    have done of different archives, which this archive has branches
 
584
    tagged from. This will dramatically reduce the time to convert
 
585
    the archive as it will not have to convert the history already
 
586
    converted in that other branch.
 
587
 
 
588
    If you specify prefixes, only branches whose names start with that prefix
 
589
    will be imported.  Skipped branches will be listed, so you can import any
 
590
    branches you missed by accident.  Here's an example of doing a partial
 
591
    import from thelove@canonical.com:
 
592
    bzr baz-import thelove thelove@canonical.com --prefixes dists:talloc-except
 
593
 
 
594
    WARNING: Encoding should not be specified unless necessary, because if you
 
595
    specify an encoding, your converted branch will not interoperate with
 
596
    independently-converted branches, unless the other branches were converted
 
597
    with exactly the same encoding.  Any encoding recognized by Python may
 
598
    be specified.  Aliases are not detected, so 'utf_8', 'U8', 'UTF' and 'utf8'
 
599
    are incompatible.
 
600
    """
 
601
    takes_args = ['to_root_dir', 'from_archive', 'reuse_history*']
 
602
    takes_options = ['verbose', Option('prefixes', type=str,
 
603
                     help="Prefixes of branches to import, colon-separated"),
 
604
                     Option('encoding', type=str,
 
605
                     help='Force encoding to specified value.  See WARNING.')]
 
606
 
 
607
    def run(self, to_root_dir, from_archive, encoding=None, verbose=False,
 
608
            reuse_history_list=[], prefixes=None):
 
609
        from errors import NoPyBaz
 
610
        try:
 
611
            import baz_import
 
612
            baz_import.baz_import(to_root_dir, from_archive, encoding,
 
613
                                  verbose, reuse_history_list, prefixes)
 
614
        except NoPyBaz:
 
615
            print "This command is disabled.  Please install PyBaz."
 
616
 
 
617
 
 
618
class cmd_baz_import_branch(bzrlib.commands.Command):
 
619
    """Import an Arch or Baz branch into a bzr branch.
 
620
 
 
621
    WARNING: Encoding should not be specified unless necessary, because if you
 
622
    specify an encoding, your converted branch will not interoperate with
 
623
    independently-converted branches, unless the other branches were converted
 
624
    with exactly the same encoding.  Any encoding recognized by Python may
 
625
    be specified.  Aliases are not detected, so 'utf_8', 'U8', 'UTF' and 'utf8'
 
626
    are incompatible.
 
627
    """
 
628
    takes_args = ['to_location', 'from_branch?', 'reuse_history*']
 
629
    takes_options = ['verbose', Option('max-count', type=int),
 
630
                     Option('encoding', type=str,
 
631
                     help='Force encoding to specified value.  See WARNING.')]
 
632
 
 
633
    def run(self, to_location, from_branch=None, fast=False, max_count=None,
 
634
            encoding=None, verbose=False, dry_run=False,
 
635
            reuse_history_list=[]):
 
636
        from errors import NoPyBaz
 
637
        try:
 
638
            import baz_import
 
639
            baz_import.baz_import_branch(to_location, from_branch, fast,
 
640
                                         max_count, verbose, encoding, dry_run,
 
641
                                         reuse_history_list)
 
642
        except NoPyBaz:
 
643
            print "This command is disabled.  Please install PyBaz."
 
644
 
 
645
 
 
646
class cmd_rspush(bzrlib.commands.Command):
551
647
    """Upload this branch to another location using rsync.
552
648
 
553
649
    If no location is specified, the last-used location will be used.  To
557
653
    """
558
654
    takes_args = ['location?']
559
655
    takes_options = [Option('overwrite', help='Ignore differences between'
560
 
                            ' branches and overwrite unconditionally.'),
 
656
                            ' branches and overwrite unconditionally'),
561
657
                     Option('no-tree', help='Do not push the working tree,'
562
658
                            ' just the .bzr.')]
563
659
 
569
665
                      working_tree=not no_tree)
570
666
 
571
667
 
572
 
class cmd_link_tree(BzrToolsCommand):
573
 
    """Hardlink matching files to another tree.
574
 
 
575
 
    Only files with identical content and execute bit will be linked.
576
 
    """
577
 
    takes_args = ['location']
578
 
 
579
 
    def run(self, location):
580
 
        from bzrlib import workingtree
581
 
        from bzrlib.plugins.bzrtools.link_tree import link_tree
582
 
        target_tree = workingtree.WorkingTree.open_containing(".")[0]
583
 
        source_tree = workingtree.WorkingTree.open(location)
584
 
        target_tree.lock_write()
585
 
        try:
586
 
            source_tree.lock_read()
587
 
            try:
588
 
                link_tree(target_tree, source_tree)
589
 
            finally:
590
 
                source_tree.unlock()
591
 
        finally:
592
 
            target_tree.unlock()
593
 
 
594
 
from heads import cmd_heads
 
668
class cmd_switch(bzrlib.commands.Command):
 
669
    """Set the branch of a lightweight checkout and update."""
 
670
 
 
671
    takes_args = ['to_location']
 
672
 
 
673
    def run(self, to_location):
 
674
        from switch import cmd_switch
 
675
        cmd_switch().run(to_location)
 
676
 
 
677
 
595
678
commands = [
 
679
            cmd_baz_import,
 
680
            cmd_baz_import_branch,
596
681
            cmd_branches,
597
682
            cmd_branch_history,
 
683
            cmd_branch_mark,
598
684
            cmd_cbranch,
599
685
            cmd_cdiff,
600
686
            cmd_clean_tree,
601
687
            cmd_fetch_ghosts,
602
688
            cmd_graph_ancestry,
603
 
            cmd_heads,
604
689
            cmd_import,
605
 
            cmd_link_tree,
606
690
            cmd_multi_pull,
607
691
            cmd_patch,
608
692
            cmd_rspush,
609
693
            cmd_shelf,
610
694
            cmd_shell,
611
695
            cmd_shelve,
612
 
            cmd_trees,
 
696
            cmd_switch,
613
697
            cmd_unshelve,
614
698
            cmd_zap,
615
699
            ]
627
711
    from unittest import TestSuite
628
712
    import bzrtools
629
713
    import tests.clean_tree
630
 
    import tests.test_dotgraph
631
714
    import tests.is_clean
632
 
    import tests.test_cbranch
633
 
    import tests.test_link_tree
634
 
    import tests.test_patch
635
 
    import tests.test_rspush
636
715
    import tests.upstream_import
637
716
    import zap
638
717
    import tests.blackbox
640
719
    result = TestSuite()
641
720
    result.addTest(DocTestSuite(bzrtools, optionflags=ELLIPSIS))
642
721
    result.addTest(tests.clean_tree.test_suite())
 
722
    try:
 
723
        import baz_import
 
724
        result.addTest(DocTestSuite(baz_import))
 
725
    except NoPyBaz:
 
726
        pass
643
727
    result.addTest(tests.test_suite())
644
728
    result.addTest(TestLoader().loadTestsFromModule(tests.shelf_tests))
645
729
    result.addTest(tests.blackbox.test_suite())
646
730
    result.addTest(tests.upstream_import.test_suite())
647
731
    result.addTest(zap.test_suite())
648
 
    result.addTest(TestLoader().loadTestsFromModule(tests.test_dotgraph))
649
732
    result.addTest(TestLoader().loadTestsFromModule(tests.is_clean))
650
 
    result.addTest(TestLoader().loadTestsFromModule(tests.test_link_tree))
651
 
    result.addTest(TestLoader().loadTestsFromModule(tests.test_patch))
652
 
    result.addTest(TestLoader().loadTestsFromModule(tests.test_rspush))
653
 
    result.addTest(TestLoader().loadTestsFromModule(tests.test_cbranch))
654
733
    return result