← 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-10 17:55:08 UTC
  • mfrom: (531.2.2 bzrtools)
  • Revision ID: aaron.bentley@utoronto.ca-20070610175508-gex1oxvmfv0qoagi
Merge whitespace cleanups

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
1
 
#!/usr/bin/python
 
1
# Copyright (C) 2005, 2006, 2007 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
 
2
19
"""\
3
20
Various useful plugins for working with bzr.
4
21
"""
5
 
import rspush
6
 
from errors import CommandError
 
22
 
 
23
import bzrlib
 
24
 
 
25
 
 
26
__version__ = '0.17.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
 
 
68
from bzrlib.lazy_import import lazy_import
 
69
lazy_import(globals(), """
 
70
from bzrlib import help
 
71
import shelf
 
72
""")
 
73
 
 
74
from errors import CommandError, NoPyBaz
7
75
from patchsource import BzrPatchSource
8
 
from shelf import Shelf
9
 
from switch import cmd_switch
10
76
import sys
11
77
import os.path
12
78
 
13
 
from bzrlib import DEFAULT_IGNORE
14
79
import bzrlib.builtins
15
 
import bzrlib.branch
16
80
import bzrlib.commands
17
81
from bzrlib.commands import get_cmd_object
18
82
from bzrlib.errors import BzrCommandError
19
 
from bzrlib.help import command_usage
 
83
import bzrlib.ignores
20
84
from bzrlib.option import Option
21
 
sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__), 
 
85
sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__),
22
86
                                                 "external")))
23
87
 
 
88
import show_paths
24
89
 
25
 
DEFAULT_IGNORE.append('./.shelf')
26
 
DEFAULT_IGNORE.append('./.bzr-shelf*')
 
90
bzrlib.ignores.add_runtime_ignores(['./.shelf'])
27
91
 
28
92
 
29
93
class cmd_clean_tree(bzrlib.commands.Command):
30
94
    """Remove unwanted files from working tree.
31
 
    Normally, ignored files are left alone.
 
95
 
 
96
    By default, only unknown files, not ignored files, are deleted.  Versioned
 
97
    files are never deleted.
 
98
 
 
99
    Another class is 'detritus', which includes files emitted by bzr during
 
100
    normal operations and selftests.  (The value of these files decreases with
 
101
    time.)
 
102
 
 
103
    If no options are specified, unknown files are deleted.  Otherwise, option
 
104
    flags are respected, and may be combined.
 
105
 
 
106
    To check what clean-tree will do, use --dry-run.
32
107
    """
33
 
    takes_options = [Option('ignored', help='delete all ignored files.'), 
34
 
                     Option('detritus', help='delete conflict files merge'
35
 
                            ' backups, and failed selftest dirs.  (*.THIS, '
36
 
                            '*.BASE, *.OTHER, *~, *.tmp)'), 
 
108
    takes_options = [Option('ignored', help='delete all ignored files.'),
 
109
                     Option('detritus', help='delete conflict files, merge'
 
110
                            ' backups, and failed selftest dirs.'),
 
111
                     Option('unknown',
 
112
                            help='delete files unknown to bzr.  (default)'),
37
113
                     Option('dry-run', help='show files to delete instead of'
38
114
                            ' deleting them.')]
39
 
    def run(self, ignored=False, detritus=False, dry_run=False):
 
115
    def run(self, unknown=False, ignored=False, detritus=False, dry_run=False):
40
116
        from clean_tree import clean_tree
41
 
        clean_tree('.', ignored=ignored, detritus=detritus, dry_run=dry_run)
 
117
        if not (unknown or ignored or detritus):
 
118
            unknown = True
 
119
        clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus, 
 
120
                   dry_run=dry_run)
 
121
 
42
122
 
43
123
class cmd_graph_ancestry(bzrlib.commands.Command):
44
124
    """Produce ancestry graphs using dot.
52
132
    with the last 5 characters of their revision identifier are used instead.
53
133
 
54
134
    The value starting with d is "(maximum) distance from the null revision".
55
 
    
 
135
 
56
136
    If --merge-branch is specified, the two branches are compared and a merge
57
137
    base is selected.
58
 
    
 
138
 
59
139
    Legend:
60
140
    white    normal revision
61
141
    yellow   THIS  history
76
156
    be disabled with --no-antialias.
77
157
    """
78
158
    takes_args = ['branch', 'file']
79
 
    takes_options = [Option('no-collapse', help="Do not skip simple nodes"), 
 
159
    takes_options = [Option('no-collapse', help="Do not skip simple nodes"),
80
160
                     Option('no-antialias',
81
 
                     help="Do not use rsvg to produce antialiased output"), 
82
 
                     Option('merge-branch', type=str, 
83
 
                     help="Use this branch to calcuate a merge base"), 
84
 
                     Option('cluster', help="Use clustered output.")]
 
161
                     help="Do not use rsvg to produce antialiased output"),
 
162
                     Option('merge-branch', type=str,
 
163
                     help="Use this branch to calcuate a merge base"),
 
164
                     Option('cluster', help="Use clustered output."),
 
165
                     Option('max-distance', help="Show no nodes farther than this",
 
166
                            type=int)]
85
167
    def run(self, branch, file, no_collapse=False, no_antialias=False,
86
 
        merge_branch=None, cluster=False):
 
168
        merge_branch=None, cluster=False, max_distance=None):
87
169
        import graph
88
170
        if cluster:
89
171
            ranking = "cluster"
90
172
        else:
91
173
            ranking = "forced"
92
 
        graph.write_ancestry_file(branch, file, not no_collapse, 
93
 
                                  not no_antialias, merge_branch, ranking)
 
174
        graph.write_ancestry_file(branch, file, not no_collapse,
 
175
                                  not no_antialias, merge_branch, ranking,
 
176
                                  max_distance=max_distance)
 
177
 
94
178
 
95
179
class cmd_fetch_ghosts(bzrlib.commands.Command):
96
180
    """Attempt to retrieve ghosts from another branch.
105
189
 
106
190
strip_help="""Strip the smallest prefix containing num leading slashes  from \
107
191
each file name found in the patch file."""
108
 
Option.OPTIONS['bzrdiff'] = Option('bzrdiff',type=None,
109
 
                                help="""Handle extra bzr tags""")
 
192
 
 
193
 
110
194
class cmd_patch(bzrlib.commands.Command):
111
195
    """Apply a named patch to the current tree.
112
196
    """
113
197
    takes_args = ['filename?']
114
 
    takes_options = [Option('strip', type=int, help=strip_help)]
115
 
    def run(self, filename=None, strip=-1, bzrdiff=0):
 
198
    takes_options = [Option('strip', type=int, help=strip_help),
 
199
                     Option('silent', help='Suppress chatter')]
 
200
    def run(self, filename=None, strip=None, silent=False):
116
201
        from patch import patch
117
202
        from bzrlib.workingtree import WorkingTree
118
203
        wt = WorkingTree.open_containing('.')[0]
119
 
        if strip == -1:
120
 
            if bzrdiff: strip = 0
121
 
            else:       strip = 0
 
204
        if strip is None:
 
205
            strip = 0
 
206
        return patch(wt, filename, strip, silent)
122
207
 
123
 
        return patch(wt, filename, strip, legacy= not bzrdiff)
124
208
 
125
209
class cmd_shelve(bzrlib.commands.Command):
126
210
    """Temporarily set aside some changes from the current tree.
147
231
    you can also unshelve changes in a different order by explicitly
148
232
    specifiying which changes to unshelve. This works best when the changes
149
233
    don't depend on each other.
 
234
 
 
235
    While you have patches on the shelf you can view and manipulate them with
 
236
    the 'shelf' command. Run 'bzr shelf -h' for more info.
150
237
    """
151
238
 
152
239
    takes_args = ['file*']
153
240
    takes_options = ['message', 'revision',
154
 
            Option('all', help='Shelve all changes without prompting')]
 
241
            Option('all', help='Shelve all changes without prompting'),
 
242
            Option('no-color', help='Never display changes in color')]
155
243
 
156
 
    def run(self, all=False, file_list=None, message=None, revision=None):
 
244
    def run(self, all=False, file_list=None, message=None, revision=None,
 
245
            no_color=False):
157
246
        if revision is not None and revision:
158
247
            if len(revision) == 1:
159
248
                revision = revision[0]
162
251
                                  "parameter.")
163
252
 
164
253
        source = BzrPatchSource(revision, file_list)
165
 
        s = Shelf(source.base)
166
 
        s.shelve(source, all, message)
 
254
        s = shelf.Shelf(source.base)
 
255
        s.shelve(source, all, message, no_color)
167
256
        return 0
168
257
 
169
258
 
190
279
    aliases = ['switch']
191
280
    takes_args = ['othershelf']
192
281
    def run(self, othershelf):
193
 
        s = Shelf(self.shelf.base, othershelf)
 
282
        s = shelf.Shelf(self.shelf.base, othershelf)
194
283
        s.make_default()
195
284
 
196
285
 
219
308
    def run(self, subcommand, args_list):
220
309
        import sys
221
310
 
 
311
        if args_list is None:
 
312
            args_list = []
222
313
        cmd = self._get_cmd_object(subcommand)
223
314
        source = BzrPatchSource()
224
 
        s = Shelf(source.base)
 
315
        s = shelf.Shelf(source.base)
225
316
        cmd.shelf = s
 
317
 
 
318
        if args_list is None:
 
319
            args_list = []
226
320
        return cmd.run_argv_aliases(args_list)
227
321
 
228
322
    def _get_cmd_object(self, cmd_name):
245
339
        cmd_obj = cmd_class()
246
340
        indent = 2 * ' '
247
341
 
248
 
        usage = command_usage(cmd_obj)
 
342
        usage = cmd_obj._usage()
249
343
        usage = usage.replace('bzr shelf-', '')
250
344
        text.append('%s%s\n' % (indent, usage))
251
345
 
270
364
        return text
271
365
 
272
366
 
273
 
 
274
367
class cmd_unshelve(bzrlib.commands.Command):
275
368
    """Restore shelved changes.
276
369
 
282
375
    takes_options = [
283
376
            Option('all', help='Unshelve all changes without prompting'),
284
377
            Option('force', help='Force unshelving even if errors occur'),
285
 
    ]
 
378
            Option('no-color', help='Never display changes in color')
 
379
        ]
286
380
    takes_args = ['patch?']
287
 
    def run(self, patch=None, all=False, force=False):
 
381
    def run(self, patch=None, all=False, force=False, no_color=False):
288
382
        source = BzrPatchSource()
289
 
        s = Shelf(source.base)
290
 
        s.unshelve(source, patch, all, force)
 
383
        s = shelf.Shelf(source.base)
 
384
        s.unshelve(source, patch, all, force, no_color)
291
385
        return 0
292
386
 
293
387
 
313
407
        import shell
314
408
        return shell.run_shell()
315
409
 
 
410
 
316
411
class cmd_branch_history(bzrlib.commands.Command):
317
412
    """\
318
413
    Display the development history of a branch.
323
418
    """
324
419
    takes_args = ["branch?"]
325
420
    def run(self, branch=None):
326
 
        from branchhistory import branch_history 
 
421
        from branchhistory import branch_history
327
422
        return branch_history(branch)
328
423
 
329
424
 
349
444
class cmd_cbranch(bzrlib.commands.Command):
350
445
    """
351
446
    Create a new checkout, associated with a new repository branch.
352
 
    
353
 
    When you cbranch, bzr looks up the repository associated with your current
354
 
    directory in branches.conf.  It creates a new branch in that repository
355
 
    with the same name and relative path as the checkout you request.
356
 
 
357
 
    The branches.conf parameter is "cbranch_root".  So if you want 
358
 
    cbranch operations in /home/jrandom/bigproject to produce branches in 
359
 
    /home/jrandom/bigproject/repository, you'd add this:
360
 
 
361
 
    [/home/jrandom/bigproject]
362
 
    cbranch_root = /home/jrandom/bigproject/repository
363
 
 
364
 
    Note that if "/home/jrandom/bigproject/repository" isn't a repository,
365
 
    standalone branches will be produced.  Standalone branches will also
366
 
    be produced if the source branch is in 0.7 format (or earlier).
 
447
 
 
448
    When you cbranch, bzr looks up a target location in locations.conf, and
 
449
    creates the branch there.
 
450
 
 
451
    In your locations.conf, add the following lines:
 
452
    [/working_directory_root]
 
453
    cbranch_target = /branch_root
 
454
    cbranch_target:policy = appendpath
 
455
 
 
456
    This will mean that if you run "bzr cbranch foo/bar foo/baz" in the
 
457
    working directory root, the branch will be created in
 
458
    "/branch_root/foo/baz"
 
459
 
 
460
    NOTE: cbranch also supports "cbranch_root", but that behaviour is
 
461
    deprecated.
367
462
    """
368
 
    takes_options = [Option("lightweight", 
369
 
                            help="Create a lightweight checkout")]
 
463
    takes_options = [Option("lightweight",
 
464
                            help="Create a lightweight checkout"), 'revision']
370
465
    takes_args = ["source", "target?"]
371
 
    def run(self, source, target=None, lightweight=False):
 
466
    def run(self, source, target=None, lightweight=False, revision=None):
372
467
        from cbranch import cbranch
373
 
        return cbranch(source, target, lightweight=lightweight)
 
468
        return cbranch(source, target, lightweight=lightweight,
 
469
                       revision=revision)
374
470
 
375
471
 
376
472
class cmd_branches(bzrlib.commands.Command):
383
479
 
384
480
class cmd_multi_pull(bzrlib.commands.Command):
385
481
    """Pull all the branches under a location, e.g. a repository.
386
 
    
 
482
 
387
483
    Both branches present in the directory and the branches of checkouts are
388
484
    pulled.
389
485
    """
438
534
        from branch_mark import branch_mark
439
535
        branch_mark(mark, branch, delete)
440
536
 
 
537
 
441
538
class cmd_import(bzrlib.commands.Command):
442
 
    """Import sources from a tarball
443
 
    
444
 
    This command will import a tarball into a bzr tree, replacing any versioned
445
 
    files already present.  If a directory is specified, it is used as the
446
 
    target.  If the directory does not exist, or is not versioned, it is
447
 
    created.
 
539
    """Import sources from a directory, tarball or zip file
 
540
 
 
541
    This command will import a directory, tarball or zip file into a bzr
 
542
    tree, replacing any versioned files already present.  If a directory is
 
543
    specified, it is used as the target.  If the directory does not exist, or
 
544
    is not versioned, it is created.
448
545
 
449
546
    Tarballs may be gzip or bzip2 compressed.  This is autodetected.
450
547
 
451
 
    If the tarball has a single root directory, that directory is stripped
452
 
    when extracting the tarball.
 
548
    If the tarball or zip has a single root directory, that directory is
 
549
    stripped when extracting the tarball.  This is not done for directories.
453
550
    """
454
 
    
 
551
 
455
552
    takes_args = ['source', 'tree?']
456
553
    def run(self, source, tree=None):
457
554
        from upstream_import import do_import
458
555
        do_import(source, tree)
459
556
 
460
 
class cmd_shove(bzrlib.commands.Command):
461
 
    """Apply uncommitted changes to another tree
462
 
    
463
 
    This is useful when you start to make changes in one tree, then realize
464
 
    they should really be done in a different tree.
465
 
 
466
 
    Shove is implemented using merge, so:
467
 
     - All changes, including renames and adds, will be applied.
468
 
     - No changes that have already been applied will be applied.
469
 
     - If the target is significantly different from the source, conflicts may
470
 
       be produced.
471
 
    """
472
 
 
473
 
    takes_args = ['target', 'source?']
474
 
    def run(self, target, source='.'):
475
 
        from shove import do_shove
476
 
        do_shove(source, target)
477
557
 
478
558
class cmd_cdiff(bzrlib.commands.Command):
479
559
    """A color version of bzr's diff"""
480
560
    takes_args = property(lambda x: get_cmd_object('diff').takes_args)
481
 
    takes_options = property(lambda x: get_cmd_object('diff').takes_options)
482
 
    def run(*args, **kwargs):
 
561
 
 
562
    def _takes_options(self):
 
563
        options = list(get_cmd_object('diff').takes_options)
 
564
        options.append(Option('check-style',
 
565
            help='Warn if trailing whitespace or spurious changes have been'
 
566
                 ' added.'))
 
567
        return options
 
568
 
 
569
    takes_options = property(_takes_options)
 
570
 
 
571
    def run(self, check_style=False, *args, **kwargs):
483
572
        from colordiff import colordiff
484
 
        colordiff(*args, **kwargs)
485
 
 
486
 
commands = [cmd_shelve, cmd_unshelve, cmd_shelf, cmd_clean_tree,
487
 
            cmd_graph_ancestry, cmd_fetch_ghosts, cmd_patch, cmd_shell,
488
 
            cmd_branch_history, cmd_zap, cmd_cbranch, cmd_branches, 
489
 
            cmd_multi_pull, cmd_switch, cmd_branch_mark, cmd_import, cmd_shove,
490
 
            cmd_cdiff]
491
 
 
492
 
 
493
 
commands.append(rspush.cmd_rspush)
494
 
 
495
 
from errors import NoPyBaz
496
 
try:
497
 
    import baz_import
498
 
    commands.append(baz_import.cmd_baz_import_branch)
499
 
    commands.append(baz_import.cmd_baz_import)
500
 
 
501
 
except NoPyBaz:
502
 
    class cmd_baz_import_branch(bzrlib.commands.Command):
503
 
        """Disabled. (Requires PyBaz)"""
504
 
        takes_args = ['to_location?', 'from_branch?', 'reuse_history*']
505
 
        takes_options = ['verbose', Option('max-count', type=int)]
506
 
        def run(self, to_location=None, from_branch=None, fast=False, 
507
 
                max_count=None, verbose=False, dry_run=False,
508
 
                reuse_history_list=[]):
509
 
            print "This command is disabled.  Please install PyBaz."
510
 
 
511
 
 
512
 
    class cmd_baz_import(bzrlib.commands.Command):
513
 
        """Disabled. (Requires PyBaz)"""
514
 
        takes_args = ['to_root_dir?', 'from_archive?', 'reuse_history*']
515
 
        takes_options = ['verbose', Option('prefixes', type=str,
516
 
                         help="Prefixes of branches to import")]
517
 
        def run(self, to_root_dir=None, from_archive=None, verbose=False,
518
 
                reuse_history_list=[], prefixes=None):
519
 
                print "This command is disabled.  Please install PyBaz."
520
 
    commands.extend((cmd_baz_import_branch, cmd_baz_import))
 
573
        colordiff(check_style, *args, **kwargs)
 
574
 
 
575
 
 
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):
 
647
    """Upload this branch to another location using rsync.
 
648
 
 
649
    If no location is specified, the last-used location will be used.  To
 
650
    prevent dirty trees from being uploaded, rspush will error out if there are
 
651
    unknown files or local changes.  It will also error out if the upstream
 
652
    directory is non-empty and not an earlier version of the branch.
 
653
    """
 
654
    takes_args = ['location?']
 
655
    takes_options = [Option('overwrite', help='Ignore differences between'
 
656
                            ' branches and overwrite unconditionally'),
 
657
                     Option('no-tree', help='Do not push the working tree,'
 
658
                            ' just the .bzr.')]
 
659
 
 
660
    def run(self, location=None, overwrite=False, no_tree=False):
 
661
        from bzrlib import workingtree
 
662
        import bzrtools
 
663
        cur_branch = workingtree.WorkingTree.open_containing(".")[0]
 
664
        bzrtools.rspush(cur_branch, location, overwrite=overwrite,
 
665
                      working_tree=not no_tree)
 
666
 
 
667
 
 
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
 
 
678
commands = [
 
679
            cmd_baz_import,
 
680
            cmd_baz_import_branch,
 
681
            cmd_branches,
 
682
            cmd_branch_history,
 
683
            cmd_branch_mark,
 
684
            cmd_cbranch,
 
685
            cmd_cdiff,
 
686
            cmd_clean_tree,
 
687
            cmd_fetch_ghosts,
 
688
            cmd_graph_ancestry,
 
689
            cmd_import,
 
690
            cmd_multi_pull,
 
691
            cmd_patch,
 
692
            cmd_rspush,
 
693
            cmd_shelf,
 
694
            cmd_shell,
 
695
            cmd_shelve,
 
696
            cmd_switch,
 
697
            cmd_unshelve,
 
698
            cmd_zap,
 
699
            ]
521
700
 
522
701
 
523
702
if hasattr(bzrlib.commands, 'register_command'):
530
709
    import tests
531
710
    from doctest import DocTestSuite, ELLIPSIS
532
711
    from unittest import TestSuite
 
712
    import bzrtools
533
713
    import tests.clean_tree
534
 
    import upstream_import
 
714
    import tests.is_clean
 
715
    import tests.upstream_import
535
716
    import zap
536
717
    import tests.blackbox
537
718
    import tests.shelf_tests
546
727
    result.addTest(tests.test_suite())
547
728
    result.addTest(TestLoader().loadTestsFromModule(tests.shelf_tests))
548
729
    result.addTest(tests.blackbox.test_suite())
549
 
    result.addTest(upstream_import.test_suite())
 
730
    result.addTest(tests.upstream_import.test_suite())
550
731
    result.addTest(zap.test_suite())
 
732
    result.addTest(TestLoader().loadTestsFromModule(tests.is_clean))
551
733
    return result