← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to __init__.py

  • Committer: Michael Ellerman
  • Date: 2006-06-05 15:11:57 UTC
  • mto: (0.3.1 shelf-dev)
  • mto: This revision was merged to the branch mainline in revision 393.
  • Revision ID: michael@ellerman.id.au-20060605151157-76bb35698cc25a51
Update README.

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
1
 
# Copyright (C) 2005, 2006 Aaron Bentley <aaron.bentley@utoronto.ca>
2
 
# Copyright (C) 2005, 2006 Canonical Limited.
3
 
# Copyright (C) 2006 Michael Ellerman.
4
 
#
5
 
#    This program is free software; you can redistribute it and/or modify
6
 
#    it under the terms of the GNU General Public License as published by
7
 
#    the Free Software Foundation; either version 2 of the License, or
8
 
#    (at your option) any later version.
9
 
#
10
 
#    This program is distributed in the hope that it will be useful,
11
 
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
#    GNU General Public License for more details.
14
 
#
15
 
#    You should have received a copy of the GNU General Public License
16
 
#    along with this program; if not, write to the Free Software
17
 
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 
 
19
 
"""\
20
 
Various useful plugins for working with bzr.
21
 
"""
22
 
 
23
 
import bzrlib
24
 
 
25
 
 
26
 
__version__ = '0.14.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:
43
 
        return
44
 
    try:
45
 
        from bzrlib.trace import warning
46
 
    except ImportError:
47
 
        # get the message out any way we can
48
 
        from warnings import warn as warning
49
 
    if bzrlib_version < desired:
50
 
        warning('Installed bzr version %s is too old to be used with bzrtools'
51
 
                ' %s.' % (bzrlib.__version__, __version__))
52
 
        # Not using BzrNewError, because it may not exist.
53
 
        raise Exception, ('Version mismatch', version_info)
54
 
    else:
55
 
        warning('Bzrtools is not up to date with installed bzr version %s.'
56
 
                ' \nThere should be a newer version available, e.g. %i.%i.' 
57
 
                % (bzrlib.__version__, bzrlib_version[0], bzrlib_version[1]))
58
 
        if bzrlib_version != desired_plus:
59
 
            raise Exception, 'Version mismatch'
60
 
 
61
 
 
62
 
check_bzrlib_version(version_info[:2])
63
 
 
64
 
 
65
 
from errors import CommandError, NoPyBaz
 
1
#!/usr/bin/python
 
2
"""Shelf - temporarily set aside changes, then bring them back."""
 
3
 
 
4
import bzrlib.commands
 
5
from errors import CommandError
 
6
from bzrlib.option import Option
66
7
from patchsource import BzrPatchSource
67
8
from shelf import Shelf
68
 
import sys
69
 
import os.path
70
 
 
71
 
import bzrlib.builtins
72
 
import bzrlib.commands
73
 
from bzrlib.commands import get_cmd_object
74
 
from bzrlib.errors import BzrCommandError
 
9
from bzrlib import DEFAULT_IGNORE
75
10
from bzrlib.help import command_usage
76
 
import bzrlib.ignores
77
 
from bzrlib.option import Option
78
 
sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__), 
79
 
                                                 "external")))
80
 
 
81
 
import show_paths
82
 
 
83
 
bzrlib.ignores.add_runtime_ignores(['./.shelf'])
84
 
 
85
 
 
86
 
class cmd_clean_tree(bzrlib.commands.Command):
87
 
    """Remove unwanted files from working tree.
88
 
 
89
 
    By default, only unknown files, not ignored files, are deleted.  Versioned
90
 
    files are never deleted.
91
 
 
92
 
    Another class is 'detritus', which includes files emitted by bzr during
93
 
    normal operations and selftests.  (The value of these files decreases with
94
 
    time.)
95
 
 
96
 
    If no options are specified, unknown files are deleted.  Otherwise, option
97
 
    flags are respected, and may be combined.
98
 
 
99
 
    To check what clean-tree will do, use --dry-run.
100
 
    """
101
 
    takes_options = [Option('ignored', help='delete all ignored files.'), 
102
 
                     Option('detritus', help='delete conflict files, merge'
103
 
                            ' backups, and failed selftest dirs.'), 
104
 
                     Option('unknown', 
105
 
                            help='delete files unknown to bzr.  (default)'),
106
 
                     Option('dry-run', help='show files to delete instead of'
107
 
                            ' deleting them.')]
108
 
    def run(self, unknown=False, ignored=False, detritus=False, dry_run=False):
109
 
        from clean_tree import clean_tree
110
 
        if not (unknown or ignored or detritus):
111
 
            unknown = True
112
 
        clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus, 
113
 
                   dry_run=dry_run)
114
 
 
115
 
 
116
 
class cmd_graph_ancestry(bzrlib.commands.Command):
117
 
    """Produce ancestry graphs using dot.
118
 
    
119
 
    Output format is detected according to file extension.  Some of the more
120
 
    common output formats are html, png, gif, svg, ps.  An extension of '.dot'
121
 
    will cause a dot graph file to be produced.  HTML output has mouseovers
122
 
    that show the commit message.
123
 
 
124
 
    Branches are labeled r?, where ? is the revno.  If they have no revno,
125
 
    with the last 5 characters of their revision identifier are used instead.
126
 
 
127
 
    The value starting with d is "(maximum) distance from the null revision".
128
 
    
129
 
    If --merge-branch is specified, the two branches are compared and a merge
130
 
    base is selected.
131
 
    
132
 
    Legend:
133
 
    white    normal revision
134
 
    yellow   THIS  history
135
 
    red      OTHER history
136
 
    orange   COMMON history
137
 
    blue     COMMON non-history ancestor
138
 
    green    Merge base (COMMON ancestor farthest from the null revision)
139
 
    dotted   Ghost revision (missing from branch storage)
140
 
 
141
 
    Ancestry is usually collapsed by skipping revisions with a single parent
142
 
    and descendant.  The number of skipped revisions is shown on the arrow.
143
 
    This feature can be disabled with --no-collapse.
144
 
 
145
 
    By default, revisions are ordered by distance from root, but they can be
146
 
    clustered instead using --cluster.
147
 
 
148
 
    If available, rsvg is used to antialias PNG and JPEG output, but this can
149
 
    be disabled with --no-antialias.
150
 
    """
151
 
    takes_args = ['branch', 'file']
152
 
    takes_options = [Option('no-collapse', help="Do not skip simple nodes"), 
153
 
                     Option('no-antialias',
154
 
                     help="Do not use rsvg to produce antialiased output"), 
155
 
                     Option('merge-branch', type=str, 
156
 
                     help="Use this branch to calcuate a merge base"), 
157
 
                     Option('cluster', help="Use clustered output.")]
158
 
    def run(self, branch, file, no_collapse=False, no_antialias=False,
159
 
        merge_branch=None, cluster=False):
160
 
        import graph
161
 
        if cluster:
162
 
            ranking = "cluster"
163
 
        else:
164
 
            ranking = "forced"
165
 
        graph.write_ancestry_file(branch, file, not no_collapse, 
166
 
                                  not no_antialias, merge_branch, ranking)
167
 
 
168
 
 
169
 
class cmd_fetch_ghosts(bzrlib.commands.Command):
170
 
    """Attempt to retrieve ghosts from another branch.
171
 
    If the other branch is not supplied, the last-pulled branch is used.
172
 
    """
173
 
    aliases = ['fetch-missing']
174
 
    takes_args = ['branch?']
175
 
    takes_options = [Option('no-fix')]
176
 
    def run(self, branch=None, no_fix=False):
177
 
        from fetch_ghosts import fetch_ghosts
178
 
        fetch_ghosts(branch, no_fix)
179
 
 
180
 
strip_help="""Strip the smallest prefix containing num leading slashes  from \
181
 
each file name found in the patch file."""
182
 
 
183
 
 
184
 
class cmd_patch(bzrlib.commands.Command):
185
 
    """Apply a named patch to the current tree.
186
 
    """
187
 
    takes_args = ['filename?']
188
 
    takes_options = [Option('strip', type=int, help=strip_help)]
189
 
    def run(self, filename=None, strip=None):
190
 
        from patch import patch
191
 
        from bzrlib.workingtree import WorkingTree
192
 
        wt = WorkingTree.open_containing('.')[0]
193
 
        if strip is None:
194
 
            strip = 0
195
 
        return patch(wt, filename, strip)
196
 
 
 
11
 
 
12
DEFAULT_IGNORE.append('./.shelf')
 
13
DEFAULT_IGNORE.append('./.bzr-shelf*')
197
14
 
198
15
class cmd_shelve(bzrlib.commands.Command):
199
16
    """Temporarily set aside some changes from the current tree.
205
22
    Shelve is intended to help separate several sets of text changes that have
206
23
    been inappropriately mingled.  If you just want to get rid of all changes
207
24
    (text and otherwise) and you don't need to restore them later, use revert.
208
 
    If you want to shelve all text changes at once, use shelve --all.
209
25
 
210
26
    By default shelve asks you what you want to shelve, press '?' at the
211
27
    prompt to get help. To shelve everything run shelve --all.
220
36
    you can also unshelve changes in a different order by explicitly
221
37
    specifiying which changes to unshelve. This works best when the changes
222
38
    don't depend on each other.
223
 
 
224
 
    While you have patches on the shelf you can view and manipulate them with
225
 
    the 'shelf' command. Run 'bzr shelf -h' for more info.
226
39
    """
227
40
 
228
41
    takes_args = ['file*']
229
42
    takes_options = ['message', 'revision',
230
 
            Option('all', help='Shelve all changes without prompting'), 
231
 
            Option('no-color', help='Never display changes in color')]
 
43
            Option('all', help='Shelve all changes without prompting')]
232
44
 
233
 
    def run(self, all=False, file_list=None, message=None, revision=None,
234
 
            no_color=False):
 
45
    def run(self, all=False, file_list=None, message=None, revision=None):
235
46
        if revision is not None and revision:
236
47
            if len(revision) == 1:
237
48
                revision = revision[0]
241
52
 
242
53
        source = BzrPatchSource(revision, file_list)
243
54
        s = Shelf(source.base)
244
 
        s.shelve(source, all, message, no_color)
 
55
        s.shelve(source, all, message)
245
56
        return 0
246
57
 
247
58
 
266
77
class cmd_shelf_switch(bzrlib.commands.Command):
267
78
    """Switch to the other shelf, create it if necessary."""
268
79
    aliases = ['switch']
269
 
    takes_args = ['othershelf']
270
 
    def run(self, othershelf):
271
 
        s = Shelf(self.shelf.base, othershelf)
 
80
    takes_args = ['other-shelf']
 
81
    def run(self, other_shelf):
 
82
        s = Shelf(self.shelf.base, other_shelf)
272
83
        s.make_default()
273
84
 
274
85
 
297
108
    def run(self, subcommand, args_list):
298
109
        import sys
299
110
 
300
 
        if args_list is None:
301
 
            args_list = []
302
111
        cmd = self._get_cmd_object(subcommand)
303
112
        source = BzrPatchSource()
304
113
        s = Shelf(source.base)
361
170
    takes_options = [
362
171
            Option('all', help='Unshelve all changes without prompting'),
363
172
            Option('force', help='Force unshelving even if errors occur'),
364
 
            Option('no-color', help='Never display changes in color')
365
 
        ]
 
173
    ]
366
174
    takes_args = ['patch?']
367
 
    def run(self, patch=None, all=False, force=False, no_color=False):
 
175
    def run(self, patch=None, all=False, force=False):
368
176
        source = BzrPatchSource()
369
177
        s = Shelf(source.base)
370
 
        s.unshelve(source, patch, all, force, no_color)
 
178
        s.unshelve(source, patch, all, force)
371
179
        return 0
372
180
 
373
 
 
374
 
class cmd_shell(bzrlib.commands.Command):
375
 
    """Begin an interactive shell tailored for bzr.
376
 
    Bzr commands can be used without typing bzr first, and will be run natively
377
 
    when possible.  Tab completion is tailored for bzr.  The shell prompt shows
378
 
    the branch nick, revno, and path.
379
 
 
380
 
    If it encounters any moderately complicated shell command, it will punt to
381
 
    the system shell.
382
 
 
383
 
    Example:
384
 
    $ bzr shell
385
 
    bzr bzrtools:287/> status
386
 
    modified:
387
 
      __init__.py
388
 
    bzr bzrtools:287/> status --[TAB][TAB]
389
 
    --all        --help       --revision   --show-ids
390
 
    bzr bzrtools:287/> status --
391
 
    """
392
 
    def run(self):
393
 
        import shell
394
 
        return shell.run_shell()
395
 
 
396
 
 
397
 
class cmd_branch_history(bzrlib.commands.Command):
398
 
    """\
399
 
    Display the development history of a branch.
400
 
 
401
 
    Each different committer or branch nick is considered a different line of
402
 
    development.  Committers are treated as the same if they have the same
403
 
    name, or if they have the same email address.
404
 
    """
405
 
    takes_args = ["branch?"]
406
 
    def run(self, branch=None):
407
 
        from branchhistory import branch_history 
408
 
        return branch_history(branch)
409
 
 
410
 
 
411
 
class cmd_zap(bzrlib.commands.Command):
412
 
    """\
413
 
    Remove a lightweight checkout, if it can be done safely.
414
 
 
415
 
    This command will remove a lightweight checkout without losing data.  That
416
 
    means it only removes lightweight checkouts, and only if they have no
417
 
    uncommitted changes.
418
 
 
419
 
    If --branch is specified, the branch will be deleted too, but only if the
420
 
    the branch has no new commits (relative to its parent).
421
 
    """
422
 
    takes_options = [Option("branch", help="Remove associtated branch from"
423
 
                                           " repository")]
424
 
    takes_args = ["checkout"]
425
 
    def run(self, checkout, branch=False):
426
 
        from zap import zap
427
 
        return zap(checkout, remove_branch=branch)
428
 
 
429
 
 
430
 
class cmd_cbranch(bzrlib.commands.Command):
431
 
    """
432
 
    Create a new checkout, associated with a new repository branch.
433
 
    
434
 
    When you cbranch, bzr looks up the repository associated with your current
435
 
    directory in locations.conf.  It creates a new branch in that repository
436
 
    with the same name and relative path as the checkout you request.
437
 
 
438
 
    The locations.conf parameter is "cbranch_root".  So if you want 
439
 
    cbranch operations in /home/jrandom/bigproject to produce branches in 
440
 
    /home/jrandom/bigproject/repository, you'd add this:
441
 
 
442
 
    [/home/jrandom/bigproject]
443
 
    cbranch_root = /home/jrandom/bigproject/repository
444
 
 
445
 
    Note that if "/home/jrandom/bigproject/repository" isn't a repository,
446
 
    standalone branches will be produced.  Standalone branches will also
447
 
    be produced if the source branch is in 0.7 format (or earlier).
448
 
    """
449
 
    takes_options = [Option("lightweight", 
450
 
                            help="Create a lightweight checkout"), 'revision']
451
 
    takes_args = ["source", "target?"]
452
 
    def run(self, source, target=None, lightweight=False, revision=None):
453
 
        from cbranch import cbranch
454
 
        return cbranch(source, target, lightweight=lightweight, 
455
 
                       revision=revision)
456
 
 
457
 
 
458
 
class cmd_branches(bzrlib.commands.Command):
459
 
    """Scan a location for branches"""
460
 
    takes_args = ["location?"]
461
 
    def run(self, location=None):
462
 
        from branches import branches
463
 
        return branches(location)
464
 
 
465
 
 
466
 
class cmd_multi_pull(bzrlib.commands.Command):
467
 
    """Pull all the branches under a location, e.g. a repository.
468
 
    
469
 
    Both branches present in the directory and the branches of checkouts are
470
 
    pulled.
471
 
    """
472
 
    takes_args = ["location?"]
473
 
    def run(self, location=None):
474
 
        from bzrlib.branch import Branch
475
 
        from bzrlib.transport import get_transport
476
 
        from bzrtools import iter_branch_tree
477
 
        if location is None:
478
 
            location = '.'
479
 
        t = get_transport(location)
480
 
        if not t.listable():
481
 
            print "Can't list this type of location."
482
 
            return 3
483
 
        for branch, wt in iter_branch_tree(t):
484
 
            if wt is None:
485
 
                pullable = branch
486
 
            else:
487
 
                pullable = wt
488
 
            parent = branch.get_parent()
489
 
            if parent is None:
490
 
                continue
491
 
            if wt is not None:
492
 
                base = wt.basedir
493
 
            else:
494
 
                base = branch.base
495
 
            if base.startswith(t.base):
496
 
                relpath = base[len(t.base):].rstrip('/')
497
 
            else:
498
 
                relpath = base
499
 
            print "Pulling %s from %s" % (relpath, parent)
500
 
            try:
501
 
                pullable.pull(Branch.open(parent))
502
 
            except Exception, e:
503
 
                print e
504
 
 
505
 
 
506
 
class cmd_branch_mark(bzrlib.commands.Command):
507
 
    """
508
 
    Add, view or list branch markers <EXPERIMENTAL>
509
 
 
510
 
    To add a mark, do 'bzr branch-mark MARK'.
511
 
    To list marks, do 'bzr branch-mark' (this lists all marks for the branch's
512
 
    repository).
513
 
    To delete a mark, do 'bzr branch-mark --delete MARK'
514
 
 
515
 
    These marks can be used to track a branch's status.
516
 
    """
517
 
    takes_args = ['mark?', 'branch?']
518
 
    takes_options = [Option('delete', help='Delete this mark')]
519
 
    def run(self, mark=None, branch=None, delete=False):
520
 
        from branch_mark import branch_mark
521
 
        branch_mark(mark, branch, delete)
522
 
 
523
 
 
524
 
class cmd_import(bzrlib.commands.Command):
525
 
    """Import sources from a tarball
526
 
    
527
 
    This command will import a tarball into a bzr tree, replacing any versioned
528
 
    files already present.  If a directory is specified, it is used as the
529
 
    target.  If the directory does not exist, or is not versioned, it is
530
 
    created.
531
 
 
532
 
    Tarballs may be gzip or bzip2 compressed.  This is autodetected.
533
 
 
534
 
    If the tarball has a single root directory, that directory is stripped
535
 
    when extracting the tarball.
536
 
    """
537
 
    
538
 
    takes_args = ['source', 'tree?']
539
 
    def run(self, source, tree=None):
540
 
        from upstream_import import do_import
541
 
        do_import(source, tree)
542
 
 
543
 
 
544
 
class cmd_cdiff(bzrlib.commands.Command):
545
 
    """A color version of bzr's diff"""
546
 
    takes_args = property(lambda x: get_cmd_object('diff').takes_args)
547
 
    takes_options = property(lambda x: get_cmd_object('diff').takes_options)
548
 
    def run(*args, **kwargs):
549
 
        from colordiff import colordiff
550
 
        colordiff(*args, **kwargs)
551
 
 
552
 
 
553
 
class cmd_baz_import(bzrlib.commands.Command):
554
 
    """Import an Arch or Baz archive into a bzr repository.
555
 
 
556
 
    This command should be used on local archives (or mirrors) only.  It is
557
 
    quite slow on remote archives.
558
 
    
559
 
    reuse_history allows you to specify any previous imports you 
560
 
    have done of different archives, which this archive has branches
561
 
    tagged from. This will dramatically reduce the time to convert 
562
 
    the archive as it will not have to convert the history already
563
 
    converted in that other branch.
564
 
 
565
 
    If you specify prefixes, only branches whose names start with that prefix
566
 
    will be imported.  Skipped branches will be listed, so you can import any
567
 
    branches you missed by accident.  Here's an example of doing a partial
568
 
    import from thelove@canonical.com:
569
 
    bzr baz-import thelove thelove@canonical.com --prefixes dists:talloc-except
570
 
 
571
 
    WARNING: Encoding should not be specified unless necessary, because if you
572
 
    specify an encoding, your converted branch will not interoperate with
573
 
    independently-converted branches, unless the other branches were converted
574
 
    with exactly the same encoding.  Any encoding recognized by Python may
575
 
    be specified.  Aliases are not detected, so 'utf_8', 'U8', 'UTF' and 'utf8'
576
 
    are incompatible.
577
 
    """
578
 
    takes_args = ['to_root_dir', 'from_archive', 'reuse_history*']
579
 
    takes_options = ['verbose', Option('prefixes', type=str,
580
 
                     help="Prefixes of branches to import, colon-separated"),
581
 
                     Option('encoding', type=str, 
582
 
                     help='Force encoding to specified value.  See WARNING.')]
583
 
 
584
 
    def run(self, to_root_dir, from_archive, encoding=None, verbose=False,
585
 
            reuse_history_list=[], prefixes=None):
586
 
        from errors import NoPyBaz
587
 
        try:
588
 
            import baz_import
589
 
            baz_import.baz_import(to_root_dir, from_archive, encoding,
590
 
                                  verbose, reuse_history_list, prefixes)
591
 
        except NoPyBaz:
592
 
            print "This command is disabled.  Please install PyBaz."
593
 
 
594
 
 
595
 
class cmd_baz_import_branch(bzrlib.commands.Command):
596
 
    """Import an Arch or Baz branch into a bzr branch.
597
 
 
598
 
    WARNING: Encoding should not be specified unless necessary, because if you
599
 
    specify an encoding, your converted branch will not interoperate with
600
 
    independently-converted branches, unless the other branches were converted
601
 
    with exactly the same encoding.  Any encoding recognized by Python may
602
 
    be specified.  Aliases are not detected, so 'utf_8', 'U8', 'UTF' and 'utf8'
603
 
    are incompatible.
604
 
    """
605
 
    takes_args = ['to_location', 'from_branch?', 'reuse_history*']
606
 
    takes_options = ['verbose', Option('max-count', type=int),
607
 
                     Option('encoding', type=str, 
608
 
                     help='Force encoding to specified value.  See WARNING.')]
609
 
 
610
 
    def run(self, to_location, from_branch=None, fast=False, max_count=None,
611
 
            encoding=None, verbose=False, dry_run=False,
612
 
            reuse_history_list=[]):
613
 
        from errors import NoPyBaz
614
 
        try:
615
 
            import baz_import
616
 
            baz_import.baz_import_branch(to_location, from_branch, fast, 
617
 
                                         max_count, verbose, encoding, dry_run,
618
 
                                         reuse_history_list)
619
 
        except NoPyBaz:
620
 
            print "This command is disabled.  Please install PyBaz."
621
 
 
622
 
 
623
 
class cmd_rspush(bzrlib.commands.Command):
624
 
    """Upload this branch to another location using rsync.
625
 
 
626
 
    If no location is specified, the last-used location will be used.  To 
627
 
    prevent dirty trees from being uploaded, rspush will error out if there are 
628
 
    unknown files or local changes.  It will also error out if the upstream 
629
 
    directory is non-empty and not an earlier version of the branch. 
630
 
    """
631
 
    takes_args = ['location?']
632
 
    takes_options = [Option('overwrite', help='Ignore differences between'
633
 
                            ' branches and overwrite unconditionally'),
634
 
                     Option('no-tree', help='Do not push the working tree,'
635
 
                            ' just the .bzr.')]
636
 
 
637
 
    def run(self, location=None, overwrite=False, no_tree=False):
638
 
        from bzrlib import workingtree
639
 
        import bzrtools
640
 
        cur_branch = workingtree.WorkingTree.open_containing(".")[0]
641
 
        bzrtools.rspush(cur_branch, location, overwrite=overwrite, 
642
 
                      working_tree=not no_tree)
643
 
 
644
 
 
645
 
class cmd_switch(bzrlib.commands.Command):
646
 
    """Set the branch of a lightweight checkout and update."""
647
 
 
648
 
    takes_args = ['to_location']
649
 
 
650
 
    def run(self, to_location):
651
 
        from switch import cmd_switch
652
 
        cmd_switch().run(to_location)
653
 
 
654
 
 
655
 
commands = [
656
 
            cmd_baz_import,
657
 
            cmd_baz_import_branch,
658
 
            cmd_branches,
659
 
            cmd_branch_history,
660
 
            cmd_branch_mark,
661
 
            cmd_cbranch,  
662
 
            cmd_cdiff,
663
 
            cmd_clean_tree,
664
 
            cmd_fetch_ghosts,
665
 
            cmd_graph_ancestry,
666
 
            cmd_import,
667
 
            cmd_multi_pull,
668
 
            cmd_patch,
669
 
            cmd_rspush,
670
 
            cmd_shelf, 
671
 
            cmd_shell,
672
 
            cmd_shelve, 
673
 
            cmd_switch,
674
 
            cmd_unshelve, 
675
 
            cmd_zap,            
676
 
            ]
677
 
 
678
 
 
679
 
if hasattr(bzrlib.commands, 'register_command'):
680
 
    for command in commands:
681
 
        bzrlib.commands.register_command(command)
682
 
 
 
181
bzrlib.commands.register_command(cmd_shelf)
 
182
bzrlib.commands.register_command(cmd_shelve)
 
183
bzrlib.commands.register_command(cmd_unshelve)
683
184
 
684
185
def test_suite():
685
186
    from bzrlib.tests.TestUtil import TestLoader
686
187
    import tests
687
 
    from doctest import DocTestSuite, ELLIPSIS
688
 
    from unittest import TestSuite
689
 
    import bzrtools
690
 
    import tests.clean_tree
691
 
    import upstream_import
692
 
    import zap
693
 
    import tests.blackbox
694
 
    import tests.shelf_tests
695
 
    result = TestSuite()
696
 
    result.addTest(DocTestSuite(bzrtools, optionflags=ELLIPSIS))
697
 
    result.addTest(tests.clean_tree.test_suite())
698
 
    try:
699
 
        import baz_import
700
 
        result.addTest(DocTestSuite(baz_import))
701
 
    except NoPyBaz:
702
 
        pass
703
 
    result.addTest(tests.test_suite())
704
 
    result.addTest(TestLoader().loadTestsFromModule(tests.shelf_tests))
705
 
    result.addTest(tests.blackbox.test_suite())
706
 
    result.addTest(upstream_import.test_suite())
707
 
    result.addTest(zap.test_suite())
708
 
    return result
 
188
    return TestLoader().loadTestsFromModule(tests)