~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to __init__.py

  • Committer: Aaron Bentley
  • Date: 2008-02-25 07:19:24 UTC
  • mfrom: (605.1.1 bzrtools.mongrel)
  • Revision ID: aaron@aaronbentley.com-20080225071924-2gskmt4ixo6n0nuo
Add support for hard-link in cbranch

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006 Aaron Bentley <aaron.bentley@utoronto.ca>
 
1
# Copyright (C) 2005, 2006, 2007 Aaron Bentley <aaron@aaronbentley.com>
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.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
 
 
 
25
from bzrlib.lazy_import import lazy_import
 
26
lazy_import(globals(), """
 
27
from bzrlib import help, urlutils
 
28
import shelf
 
29
""")
 
30
 
 
31
from version import version_info, __version__
 
32
from command import BzrToolsCommand
65
33
from errors import CommandError, NoPyBaz
66
34
from patchsource import BzrPatchSource
67
 
from shelf import Shelf
68
35
import sys
69
36
import os.path
70
37
 
71
38
import bzrlib.builtins
72
39
import bzrlib.commands
 
40
from bzrlib.branch import Branch
 
41
from bzrlib.bzrdir import BzrDir
73
42
from bzrlib.commands import get_cmd_object
74
43
from bzrlib.errors import BzrCommandError
75
 
from bzrlib.help import command_usage
76
44
import bzrlib.ignores
 
45
from bzrlib.trace import note
77
46
from bzrlib.option import Option
78
 
sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__), 
 
47
sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__),
79
48
                                                 "external")))
80
49
 
81
50
import show_paths
 
51
from command import BzrToolsCommand
82
52
 
83
53
bzrlib.ignores.add_runtime_ignores(['./.shelf'])
84
54
 
85
55
 
86
 
class cmd_clean_tree(bzrlib.commands.Command):
 
56
class cmd_clean_tree(BzrToolsCommand):
87
57
    """Remove unwanted files from working tree.
88
58
 
89
59
    By default, only unknown files, not ignored files, are deleted.  Versioned
98
68
 
99
69
    To check what clean-tree will do, use --dry-run.
100
70
    """
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'
 
71
    takes_options = [Option('ignored', help='Delete all ignored files.'),
 
72
                     Option('detritus', help='Delete conflict files, merge'
 
73
                            ' backups, and failed selftest dirs.'),
 
74
                     Option('unknown',
 
75
                            help='Delete files unknown to bzr (default).'),
 
76
                     Option('dry-run', help='Show files to delete instead of'
107
77
                            ' deleting them.')]
108
78
    def run(self, unknown=False, ignored=False, detritus=False, dry_run=False):
109
79
        from clean_tree import clean_tree
113
83
                   dry_run=dry_run)
114
84
 
115
85
 
116
 
class cmd_graph_ancestry(bzrlib.commands.Command):
 
86
class cmd_graph_ancestry(BzrToolsCommand):
117
87
    """Produce ancestry graphs using dot.
118
88
    
119
89
    Output format is detected according to file extension.  Some of the more
125
95
    with the last 5 characters of their revision identifier are used instead.
126
96
 
127
97
    The value starting with d is "(maximum) distance from the null revision".
128
 
    
 
98
 
129
99
    If --merge-branch is specified, the two branches are compared and a merge
130
100
    base is selected.
131
 
    
 
101
 
132
102
    Legend:
133
103
    white    normal revision
134
104
    yellow   THIS  history
148
118
    If available, rsvg is used to antialias PNG and JPEG output, but this can
149
119
    be disabled with --no-antialias.
150
120
    """
151
 
    takes_args = ['branch', 'file']
152
 
    takes_options = [Option('no-collapse', help="Do not skip simple nodes"), 
 
121
    takes_args = ['file', 'merge_branch?']
 
122
    takes_options = [Option('no-collapse', help="Do not skip simple nodes."),
153
123
                     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):
 
124
                     help="Do not use rsvg to produce antialiased output."),
 
125
                     Option('merge-branch', type=str,
 
126
                     help="Use this branch to calcuate a merge base."),
 
127
                     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
160
141
        import graph
161
142
        if cluster:
162
143
            ranking = "cluster"
163
144
        else:
164
145
            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):
 
146
        graph.write_ancestry_file(directory, file, not no_collapse,
 
147
                                  not no_antialias, merge_branch, ranking,
 
148
                                  max_distance=max_distance)
 
149
 
 
150
 
 
151
class cmd_fetch_ghosts(BzrToolsCommand):
170
152
    """Attempt to retrieve ghosts from another branch.
171
153
    If the other branch is not supplied, the last-pulled branch is used.
172
154
    """
173
155
    aliases = ['fetch-missing']
174
156
    takes_args = ['branch?']
175
 
    takes_options = [Option('no-fix')]
 
157
    takes_options = [Option('no-fix', help="Skip additional synchonization.")]
176
158
    def run(self, branch=None, no_fix=False):
177
159
        from fetch_ghosts import fetch_ghosts
178
160
        fetch_ghosts(branch, no_fix)
179
161
 
180
162
strip_help="""Strip the smallest prefix containing num leading slashes  from \
181
163
each file name found in the patch file."""
182
 
Option.OPTIONS['bzrdiff'] = Option('bzrdiff',type=None,
183
 
                                help="""Handle extra bzr tags""")
184
 
 
185
 
 
186
 
class cmd_patch(bzrlib.commands.Command):
 
164
 
 
165
 
 
166
class cmd_patch(BzrToolsCommand):
187
167
    """Apply a named patch to the current tree.
188
168
    """
189
169
    takes_args = ['filename?']
190
 
    takes_options = [Option('strip', type=int, help=strip_help)]
191
 
    def run(self, filename=None, strip=-1, bzrdiff=0):
 
170
    takes_options = [Option('strip', type=int, help=strip_help),
 
171
                     Option('silent', help='Suppress chatter.')]
 
172
    def run(self, filename=None, strip=None, silent=False):
192
173
        from patch import patch
193
174
        from bzrlib.workingtree import WorkingTree
194
175
        wt = WorkingTree.open_containing('.')[0]
195
 
        if strip == -1:
196
 
            if bzrdiff: strip = 0
197
 
            else:       strip = 0
198
 
 
199
 
        return patch(wt, filename, strip, legacy= not bzrdiff)
200
 
 
201
 
 
202
 
class cmd_shelve(bzrlib.commands.Command):
 
176
        if strip is None:
 
177
            strip = 0
 
178
        return patch(wt, filename, strip, silent)
 
179
 
 
180
 
 
181
class cmd_shelve(BzrToolsCommand):
203
182
    """Temporarily set aside some changes from the current tree.
204
183
 
205
184
    Shelve allows you to temporarily put changes you've made "on the shelf",
230
209
    """
231
210
 
232
211
    takes_args = ['file*']
233
 
    takes_options = ['message', 'revision',
234
 
            Option('all', help='Shelve all changes without prompting'), 
235
 
            Option('no-color', help='Never display changes in color')]
 
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.')]
236
218
 
237
219
    def run(self, all=False, file_list=None, message=None, revision=None,
238
220
            no_color=False):
244
226
                                  "parameter.")
245
227
 
246
228
        source = BzrPatchSource(revision, file_list)
247
 
        s = Shelf(source.base)
 
229
        s = shelf.Shelf(source.base)
248
230
        s.shelve(source, all, message, no_color)
249
231
        return 0
250
232
 
272
254
    aliases = ['switch']
273
255
    takes_args = ['othershelf']
274
256
    def run(self, othershelf):
275
 
        s = Shelf(self.shelf.base, othershelf)
 
257
        s = shelf.Shelf(self.shelf.base, othershelf)
276
258
        s.make_default()
277
259
 
278
260
 
291
273
        self.shelf.upgrade()
292
274
 
293
275
 
294
 
class cmd_shelf(bzrlib.commands.Command):
 
276
class cmd_shelf(BzrToolsCommand):
295
277
    """Perform various operations on your shelved patches. See also shelve."""
296
278
    takes_args = ['subcommand', 'args*']
297
279
 
305
287
            args_list = []
306
288
        cmd = self._get_cmd_object(subcommand)
307
289
        source = BzrPatchSource()
308
 
        s = Shelf(source.base)
 
290
        s = shelf.Shelf(source.base)
309
291
        cmd.shelf = s
 
292
 
 
293
        if args_list is None:
 
294
            args_list = []
310
295
        return cmd.run_argv_aliases(args_list)
311
296
 
312
297
    def _get_cmd_object(self, cmd_name):
329
314
        cmd_obj = cmd_class()
330
315
        indent = 2 * ' '
331
316
 
332
 
        usage = command_usage(cmd_obj)
 
317
        usage = cmd_obj._usage()
333
318
        usage = usage.replace('bzr shelf-', '')
334
319
        text.append('%s%s\n' % (indent, usage))
335
320
 
354
339
        return text
355
340
 
356
341
 
357
 
class cmd_unshelve(bzrlib.commands.Command):
 
342
class cmd_unshelve(BzrToolsCommand):
358
343
    """Restore shelved changes.
359
344
 
360
345
    By default the most recently shelved changes are restored. However if you
363
348
    See 'shelve' for more information.
364
349
    """
365
350
    takes_options = [
366
 
            Option('all', help='Unshelve all changes without prompting'),
367
 
            Option('force', help='Force unshelving even if errors occur'),
368
 
            Option('no-color', help='Never display changes in color')
 
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.')
369
354
        ]
370
355
    takes_args = ['patch?']
371
356
    def run(self, patch=None, all=False, force=False, no_color=False):
372
357
        source = BzrPatchSource()
373
 
        s = Shelf(source.base)
 
358
        s = shelf.Shelf(source.base)
374
359
        s.unshelve(source, patch, all, force, no_color)
375
360
        return 0
376
361
 
377
362
 
378
 
class cmd_shell(bzrlib.commands.Command):
 
363
class cmd_shell(BzrToolsCommand):
379
364
    """Begin an interactive shell tailored for bzr.
380
365
    Bzr commands can be used without typing bzr first, and will be run natively
381
366
    when possible.  Tab completion is tailored for bzr.  The shell prompt shows
398
383
        return shell.run_shell()
399
384
 
400
385
 
401
 
class cmd_branch_history(bzrlib.commands.Command):
 
386
class cmd_branch_history(BzrToolsCommand):
402
387
    """\
403
388
    Display the development history of a branch.
404
389
 
408
393
    """
409
394
    takes_args = ["branch?"]
410
395
    def run(self, branch=None):
411
 
        from branchhistory import branch_history 
 
396
        from branchhistory import branch_history
412
397
        return branch_history(branch)
413
398
 
414
399
 
415
 
class cmd_zap(bzrlib.commands.Command):
 
400
class cmd_zap(BzrToolsCommand):
416
401
    """\
417
402
    Remove a lightweight checkout, if it can be done safely.
418
403
 
423
408
    If --branch is specified, the branch will be deleted too, but only if the
424
409
    the branch has no new commits (relative to its parent).
425
410
    """
426
 
    takes_options = [Option("branch", help="Remove associtated branch from"
427
 
                                           " repository")]
 
411
    takes_options = [Option("branch", help="Remove associated branch from"
 
412
                                           " repository."),
 
413
                     Option('force', help='Delete tree even if contents are'
 
414
                     ' modified.')]
428
415
    takes_args = ["checkout"]
429
 
    def run(self, checkout, branch=False):
 
416
    def run(self, checkout, branch=False, force=False):
430
417
        from zap import zap
431
 
        return zap(checkout, remove_branch=branch)
432
 
 
433
 
 
434
 
class cmd_cbranch(bzrlib.commands.Command):
 
418
        return zap(checkout, remove_branch=branch, allow_modified=force)
 
419
 
 
420
 
 
421
class cmd_cbranch(BzrToolsCommand):
435
422
    """
436
423
    Create a new checkout, associated with a new repository branch.
437
 
    
438
 
    When you cbranch, bzr looks up the repository associated with your current
439
 
    directory in locations.conf.  It creates a new branch in that repository
440
 
    with the same name and relative path as the checkout you request.
441
 
 
442
 
    The locations.conf parameter is "cbranch_root".  So if you want 
443
 
    cbranch operations in /home/jrandom/bigproject to produce branches in 
444
 
    /home/jrandom/bigproject/repository, you'd add this:
445
 
 
446
 
    [/home/jrandom/bigproject]
447
 
    cbranch_root = /home/jrandom/bigproject/repository
448
 
 
449
 
    Note that if "/home/jrandom/bigproject/repository" isn't a repository,
450
 
    standalone branches will be produced.  Standalone branches will also
451
 
    be produced if the source branch is in 0.7 format (or earlier).
 
424
 
 
425
    When you cbranch, bzr looks up a target location in locations.conf, and
 
426
    creates the branch there.
 
427
 
 
428
    In your locations.conf, add the following lines:
 
429
    [/working_directory_root]
 
430
    cbranch_target = /branch_root
 
431
    cbranch_target:policy = appendpath
 
432
 
 
433
    This will mean that if you run "bzr cbranch foo/bar foo/baz" in the
 
434
    working directory root, the branch will be created in
 
435
    "/branch_root/foo/baz"
 
436
 
 
437
    NOTE: cbranch also supports "cbranch_root", but that behaviour is
 
438
    deprecated.
452
439
    """
453
 
    takes_options = [Option("lightweight", 
454
 
                            help="Create a lightweight checkout"), 'revision']
 
440
    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.')]
455
448
    takes_args = ["source", "target?"]
456
 
    def run(self, source, target=None, lightweight=False, revision=None):
 
449
    def run(self, source, target=None, lightweight=False, revision=None,
 
450
            files_from=None, hardlink=False):
457
451
        from cbranch import cbranch
458
 
        return cbranch(source, target, lightweight=lightweight, 
459
 
                       revision=revision)
460
 
 
461
 
 
462
 
class cmd_branches(bzrlib.commands.Command):
 
452
        return cbranch(source, target, lightweight=lightweight,
 
453
                       revision=revision, files_from=files_from,
 
454
                       hardlink=hardlink)
 
455
 
 
456
 
 
457
class cmd_branches(BzrToolsCommand):
463
458
    """Scan a location for branches"""
464
459
    takes_args = ["location?"]
465
460
    def run(self, location=None):
466
461
        from branches import branches
467
462
        return branches(location)
468
463
 
 
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))
469
474
 
470
 
class cmd_multi_pull(bzrlib.commands.Command):
 
475
class cmd_multi_pull(BzrToolsCommand):
471
476
    """Pull all the branches under a location, e.g. a repository.
472
 
    
 
477
 
473
478
    Both branches present in the directory and the branches of checkouts are
474
479
    pulled.
475
480
    """
476
481
    takes_args = ["location?"]
477
482
    def run(self, location=None):
478
 
        from bzrlib.branch import Branch
479
483
        from bzrlib.transport import get_transport
480
484
        from bzrtools import iter_branch_tree
481
485
        if location is None:
482
486
            location = '.'
483
487
        t = get_transport(location)
 
488
        possible_transports = []
484
489
        if not t.listable():
485
490
            print "Can't list this type of location."
486
491
            return 3
502
507
                relpath = base
503
508
            print "Pulling %s from %s" % (relpath, parent)
504
509
            try:
505
 
                pullable.pull(Branch.open(parent))
 
510
                branch_t = get_transport(parent, possible_transports)
 
511
                pullable.pull(Branch.open_from_transport(branch_t))
506
512
            except Exception, e:
507
513
                print e
508
514
 
509
515
 
510
 
class cmd_branch_mark(bzrlib.commands.Command):
511
 
    """
512
 
    Add, view or list branch markers <EXPERIMENTAL>
513
 
 
514
 
    To add a mark, do 'bzr branch-mark MARK'.
515
 
    To list marks, do 'bzr branch-mark' (this lists all marks for the branch's
516
 
    repository).
517
 
    To delete a mark, do 'bzr branch-mark --delete MARK'
518
 
 
519
 
    These marks can be used to track a branch's status.
520
 
    """
521
 
    takes_args = ['mark?', 'branch?']
522
 
    takes_options = [Option('delete', help='Delete this mark')]
523
 
    def run(self, mark=None, branch=None, delete=False):
524
 
        from branch_mark import branch_mark
525
 
        branch_mark(mark, branch, delete)
526
 
 
527
 
 
528
 
class cmd_import(bzrlib.commands.Command):
529
 
    """Import sources from a tarball
530
 
    
531
 
    This command will import a tarball into a bzr tree, replacing any versioned
532
 
    files already present.  If a directory is specified, it is used as the
533
 
    target.  If the directory does not exist, or is not versioned, it is
534
 
    created.
 
516
 
 
517
class cmd_import(BzrToolsCommand):
 
518
    """Import sources from a directory, tarball or zip file
 
519
 
 
520
    This command will import a directory, tarball or zip file into a bzr
 
521
    tree, replacing any versioned files already present.  If a directory is
 
522
    specified, it is used as the target.  If the directory does not exist, or
 
523
    is not versioned, it is created.
535
524
 
536
525
    Tarballs may be gzip or bzip2 compressed.  This is autodetected.
537
526
 
538
 
    If the tarball has a single root directory, that directory is stripped
539
 
    when extracting the tarball.
 
527
    If the tarball or zip has a single root directory, that directory is
 
528
    stripped when extracting the tarball.  This is not done for directories.
540
529
    """
541
 
    
 
530
 
542
531
    takes_args = ['source', 'tree?']
543
532
    def run(self, source, tree=None):
544
533
        from upstream_import import do_import
545
534
        do_import(source, tree)
546
535
 
547
536
 
548
 
class cmd_cdiff(bzrlib.commands.Command):
 
537
class cmd_cdiff(BzrToolsCommand):
549
538
    """A color version of bzr's diff"""
550
539
    takes_args = property(lambda x: get_cmd_object('diff').takes_args)
551
 
    takes_options = property(lambda x: get_cmd_object('diff').takes_options)
552
 
    def run(*args, **kwargs):
 
540
    takes_options = list(get_cmd_object('diff').takes_options) + [
 
541
        Option('check-style',
 
542
            help='Warn if trailing whitespace or spurious changes have been'
 
543
                 ' added.')]
 
544
 
 
545
    def run(self, check_style=False, *args, **kwargs):
553
546
        from colordiff import colordiff
554
 
        colordiff(*args, **kwargs)
555
 
 
556
 
 
557
 
class cmd_baz_import(bzrlib.commands.Command):
 
547
        colordiff(check_style, *args, **kwargs)
 
548
 
 
549
 
 
550
class cmd_baz_import(BzrToolsCommand):
558
551
    """Import an Arch or Baz archive into a bzr repository.
559
552
 
560
553
    This command should be used on local archives (or mirrors) only.  It is
561
554
    quite slow on remote archives.
562
 
    
563
 
    reuse_history allows you to specify any previous imports you 
 
555
 
 
556
    reuse_history allows you to specify any previous imports you
564
557
    have done of different archives, which this archive has branches
565
 
    tagged from. This will dramatically reduce the time to convert 
 
558
    tagged from. This will dramatically reduce the time to convert
566
559
    the archive as it will not have to convert the history already
567
560
    converted in that other branch.
568
561
 
581
574
    """
582
575
    takes_args = ['to_root_dir', 'from_archive', 'reuse_history*']
583
576
    takes_options = ['verbose', Option('prefixes', type=str,
584
 
                     help="Prefixes of branches to import, colon-separated"),
585
 
                     Option('encoding', type=str, 
 
577
                     help="Prefixes of branches to import, colon-separated."),
 
578
                     Option('encoding', type=str,
586
579
                     help='Force encoding to specified value.  See WARNING.')]
587
580
 
588
581
    def run(self, to_root_dir, from_archive, encoding=None, verbose=False,
596
589
            print "This command is disabled.  Please install PyBaz."
597
590
 
598
591
 
599
 
class cmd_baz_import_branch(bzrlib.commands.Command):
 
592
class cmd_baz_import_branch(BzrToolsCommand):
600
593
    """Import an Arch or Baz branch into a bzr branch.
601
594
 
602
595
    WARNING: Encoding should not be specified unless necessary, because if you
607
600
    are incompatible.
608
601
    """
609
602
    takes_args = ['to_location', 'from_branch?', 'reuse_history*']
610
 
    takes_options = ['verbose', Option('max-count', type=int),
611
 
                     Option('encoding', type=str, 
 
603
    takes_options = ['verbose', 
 
604
                     Option('max-count', type=int, 
 
605
                     help='Maximim revisions to import at once.'),
 
606
                     Option('encoding', type=str,
612
607
                     help='Force encoding to specified value.  See WARNING.')]
613
608
 
614
609
    def run(self, to_location, from_branch=None, fast=False, max_count=None,
617
612
        from errors import NoPyBaz
618
613
        try:
619
614
            import baz_import
620
 
            baz_import.baz_import_branch(to_location, from_branch, fast, 
 
615
            baz_import.baz_import_branch(to_location, from_branch, fast,
621
616
                                         max_count, verbose, encoding, dry_run,
622
617
                                         reuse_history_list)
623
618
        except NoPyBaz:
624
619
            print "This command is disabled.  Please install PyBaz."
625
620
 
626
621
 
627
 
class cmd_rspush(bzrlib.commands.Command):
 
622
class cmd_rspush(BzrToolsCommand):
628
623
    """Upload this branch to another location using rsync.
629
624
 
630
 
    If no location is specified, the last-used location will be used.  To 
631
 
    prevent dirty trees from being uploaded, rspush will error out if there are 
632
 
    unknown files or local changes.  It will also error out if the upstream 
633
 
    directory is non-empty and not an earlier version of the branch. 
 
625
    If no location is specified, the last-used location will be used.  To
 
626
    prevent dirty trees from being uploaded, rspush will error out if there are
 
627
    unknown files or local changes.  It will also error out if the upstream
 
628
    directory is non-empty and not an earlier version of the branch.
634
629
    """
635
630
    takes_args = ['location?']
636
631
    takes_options = [Option('overwrite', help='Ignore differences between'
637
 
                            ' branches and overwrite unconditionally'),
 
632
                            ' branches and overwrite unconditionally.'),
638
633
                     Option('no-tree', help='Do not push the working tree,'
639
634
                            ' just the .bzr.')]
640
635
 
642
637
        from bzrlib import workingtree
643
638
        import bzrtools
644
639
        cur_branch = workingtree.WorkingTree.open_containing(".")[0]
645
 
        bzrtools.rspush(cur_branch, location, overwrite=overwrite, 
 
640
        bzrtools.rspush(cur_branch, location, overwrite=overwrite,
646
641
                      working_tree=not no_tree)
647
642
 
648
643
 
649
 
class cmd_switch(bzrlib.commands.Command):
650
 
    """Set the branch of a lightweight checkout and update."""
651
 
 
652
 
    takes_args = ['to_location']
653
 
 
654
 
    def run(self, to_location):
655
 
        from switch import cmd_switch
656
 
        cmd_switch().run(to_location)
657
 
 
658
 
 
659
644
commands = [
660
645
            cmd_baz_import,
661
646
            cmd_baz_import_branch,
662
647
            cmd_branches,
 
648
            cmd_trees,
663
649
            cmd_branch_history,
664
 
            cmd_branch_mark,
665
 
            cmd_cbranch,  
 
650
            cmd_cbranch,
666
651
            cmd_cdiff,
667
652
            cmd_clean_tree,
668
653
            cmd_fetch_ghosts,
671
656
            cmd_multi_pull,
672
657
            cmd_patch,
673
658
            cmd_rspush,
674
 
            cmd_shelf, 
 
659
            cmd_shelf,
675
660
            cmd_shell,
676
 
            cmd_shelve, 
677
 
            cmd_switch,
678
 
            cmd_unshelve, 
679
 
            cmd_zap,            
 
661
            cmd_shelve,
 
662
            cmd_unshelve,
 
663
            cmd_zap,
680
664
            ]
681
665
 
682
666
 
692
676
    from unittest import TestSuite
693
677
    import bzrtools
694
678
    import tests.clean_tree
695
 
    import upstream_import
 
679
    import tests.is_clean
 
680
    import tests.test_patch
 
681
    import tests.test_rspush
 
682
    import tests.upstream_import
696
683
    import zap
697
684
    import tests.blackbox
698
685
    import tests.shelf_tests
707
694
    result.addTest(tests.test_suite())
708
695
    result.addTest(TestLoader().loadTestsFromModule(tests.shelf_tests))
709
696
    result.addTest(tests.blackbox.test_suite())
710
 
    result.addTest(upstream_import.test_suite())
 
697
    result.addTest(tests.upstream_import.test_suite())
711
698
    result.addTest(zap.test_suite())
 
699
    result.addTest(TestLoader().loadTestsFromModule(tests.is_clean))
 
700
    result.addTest(TestLoader().loadTestsFromModule(tests.test_patch))
 
701
    result.addTest(TestLoader().loadTestsFromModule(tests.test_rspush))
712
702
    return result