~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to __init__.py

  • Committer: Aaron Bentley
  • Date: 2008-10-08 13:55:13 UTC
  • Revision ID: aaron@aaronbentley.com-20081008135513-wjxlb9sgh9ua0edb
Publish getchar

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
 
 
65
 
from errors import CommandError, NoPyBaz
 
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
 
33
from errors import CommandError
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__), 
79
 
                                                 "external")))
80
47
 
81
 
import show_paths
 
48
from command import BzrToolsCommand
82
49
 
83
50
bzrlib.ignores.add_runtime_ignores(['./.shelf'])
84
51
 
85
52
 
86
 
class cmd_clean_tree(bzrlib.commands.Command):
 
53
class cmd_clean_tree(BzrToolsCommand):
87
54
    """Remove unwanted files from working tree.
88
55
 
89
56
    By default, only unknown files, not ignored files, are deleted.  Versioned
98
65
 
99
66
    To check what clean-tree will do, use --dry-run.
100
67
    """
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'
 
68
    takes_options = [Option('ignored', help='Delete all ignored files.'),
 
69
                     Option('detritus', help='Delete conflict files, merge'
 
70
                            ' backups, and failed selftest dirs.'),
 
71
                     Option('unknown',
 
72
                            help='Delete files unknown to bzr (default).'),
 
73
                     Option('dry-run', help='Show files to delete instead of'
107
74
                            ' deleting them.')]
108
75
    def run(self, unknown=False, ignored=False, detritus=False, dry_run=False):
109
76
        from clean_tree import clean_tree
113
80
                   dry_run=dry_run)
114
81
 
115
82
 
116
 
class cmd_graph_ancestry(bzrlib.commands.Command):
 
83
class cmd_graph_ancestry(BzrToolsCommand):
117
84
    """Produce ancestry graphs using dot.
118
85
    
119
86
    Output format is detected according to file extension.  Some of the more
125
92
    with the last 5 characters of their revision identifier are used instead.
126
93
 
127
94
    The value starting with d is "(maximum) distance from the null revision".
128
 
    
 
95
 
129
96
    If --merge-branch is specified, the two branches are compared and a merge
130
97
    base is selected.
131
 
    
 
98
 
132
99
    Legend:
133
100
    white    normal revision
134
101
    yellow   THIS  history
148
115
    If available, rsvg is used to antialias PNG and JPEG output, but this can
149
116
    be disabled with --no-antialias.
150
117
    """
151
 
    takes_args = ['branch', 'file']
152
 
    takes_options = [Option('no-collapse', help="Do not skip simple nodes"), 
 
118
    takes_args = ['file', 'merge_branch?']
 
119
    takes_options = [Option('no-collapse', help="Do not skip simple nodes."),
153
120
                     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):
 
121
                     help="Do not use rsvg to produce antialiased output."),
 
122
                     Option('merge-branch', type=str,
 
123
                     help="Use this branch to calcuate a merge base."),
 
124
                     Option('cluster', help="Use clustered output."),
 
125
                     Option('max-distance',
 
126
                            help="Show no nodes farther than this.", type=int),
 
127
                     Option('directory',
 
128
                            help='Source branch to use (default is current'
 
129
                            ' directory).',
 
130
                            short_name='d',
 
131
                            type=unicode),
 
132
                    ]
 
133
    def run(self, file, merge_branch=None, no_collapse=False,
 
134
            no_antialias=False, cluster=False, max_distance=100,
 
135
            directory='.'):
 
136
        if max_distance == -1:
 
137
            max_distance = None
160
138
        import graph
161
139
        if cluster:
162
140
            ranking = "cluster"
163
141
        else:
164
142
            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):
 
143
        graph.write_ancestry_file(directory, file, not no_collapse,
 
144
                                  not no_antialias, merge_branch, ranking,
 
145
                                  max_distance=max_distance)
 
146
 
 
147
 
 
148
class cmd_fetch_ghosts(BzrToolsCommand):
170
149
    """Attempt to retrieve ghosts from another branch.
171
150
    If the other branch is not supplied, the last-pulled branch is used.
172
151
    """
173
152
    aliases = ['fetch-missing']
174
153
    takes_args = ['branch?']
175
 
    takes_options = [Option('no-fix')]
 
154
    takes_options = [Option('no-fix', help="Skip additional synchonization.")]
176
155
    def run(self, branch=None, no_fix=False):
177
156
        from fetch_ghosts import fetch_ghosts
178
157
        fetch_ghosts(branch, no_fix)
181
160
each file name found in the patch file."""
182
161
 
183
162
 
184
 
class cmd_patch(bzrlib.commands.Command):
 
163
class cmd_patch(BzrToolsCommand):
185
164
    """Apply a named patch to the current tree.
186
165
    """
187
166
    takes_args = ['filename?']
188
 
    takes_options = [Option('strip', type=int, help=strip_help)]
189
 
    def run(self, filename=None, strip=None):
 
167
    takes_options = [Option('strip', type=int, help=strip_help),
 
168
                     Option('silent', help='Suppress chatter.')]
 
169
    def run(self, filename=None, strip=None, silent=False):
190
170
        from patch import patch
191
171
        from bzrlib.workingtree import WorkingTree
192
172
        wt = WorkingTree.open_containing('.')[0]
193
173
        if strip is None:
194
174
            strip = 0
195
 
        return patch(wt, filename, strip)
196
 
 
197
 
 
198
 
class cmd_shelve(bzrlib.commands.Command):
 
175
        return patch(wt, filename, strip, silent)
 
176
 
 
177
 
 
178
class cmd_shelve(BzrToolsCommand):
199
179
    """Temporarily set aside some changes from the current tree.
200
180
 
201
181
    Shelve allows you to temporarily put changes you've made "on the shelf",
226
206
    """
227
207
 
228
208
    takes_args = ['file*']
229
 
    takes_options = ['message', 'revision',
230
 
            Option('all', help='Shelve all changes without prompting'), 
231
 
            Option('no-color', help='Never display changes in color')]
 
209
    takes_options = [Option('message',
 
210
            help='A message to associate with the shelved changes.',
 
211
            short_name='m', type=unicode),
 
212
            'revision',
 
213
            Option('all', help='Shelve all changes without prompting.'),
 
214
            Option('no-color', help='Never display changes in color.')]
232
215
 
233
216
    def run(self, all=False, file_list=None, message=None, revision=None,
234
217
            no_color=False):
240
223
                                  "parameter.")
241
224
 
242
225
        source = BzrPatchSource(revision, file_list)
243
 
        s = Shelf(source.base)
 
226
        s = shelf.Shelf(source.base)
244
227
        s.shelve(source, all, message, no_color)
245
228
        return 0
246
229
 
268
251
    aliases = ['switch']
269
252
    takes_args = ['othershelf']
270
253
    def run(self, othershelf):
271
 
        s = Shelf(self.shelf.base, othershelf)
 
254
        s = shelf.Shelf(self.shelf.base, othershelf)
272
255
        s.make_default()
273
256
 
274
257
 
287
270
        self.shelf.upgrade()
288
271
 
289
272
 
290
 
class cmd_shelf(bzrlib.commands.Command):
 
273
class cmd_shelf(BzrToolsCommand):
291
274
    """Perform various operations on your shelved patches. See also shelve."""
292
275
    takes_args = ['subcommand', 'args*']
293
276
 
301
284
            args_list = []
302
285
        cmd = self._get_cmd_object(subcommand)
303
286
        source = BzrPatchSource()
304
 
        s = Shelf(source.base)
 
287
        s = shelf.Shelf(source.base)
305
288
        cmd.shelf = s
 
289
 
 
290
        if args_list is None:
 
291
            args_list = []
306
292
        return cmd.run_argv_aliases(args_list)
307
293
 
308
294
    def _get_cmd_object(self, cmd_name):
325
311
        cmd_obj = cmd_class()
326
312
        indent = 2 * ' '
327
313
 
328
 
        usage = command_usage(cmd_obj)
 
314
        usage = cmd_obj._usage()
329
315
        usage = usage.replace('bzr shelf-', '')
330
316
        text.append('%s%s\n' % (indent, usage))
331
317
 
350
336
        return text
351
337
 
352
338
 
353
 
class cmd_unshelve(bzrlib.commands.Command):
 
339
class cmd_unshelve(BzrToolsCommand):
354
340
    """Restore shelved changes.
355
341
 
356
342
    By default the most recently shelved changes are restored. However if you
359
345
    See 'shelve' for more information.
360
346
    """
361
347
    takes_options = [
362
 
            Option('all', help='Unshelve all changes without prompting'),
363
 
            Option('force', help='Force unshelving even if errors occur'),
364
 
            Option('no-color', help='Never display changes in color')
 
348
            Option('all', help='Unshelve all changes without prompting.'),
 
349
            Option('force', help='Force unshelving even if errors occur.'),
 
350
            Option('no-color', help='Never display changes in color.')
365
351
        ]
366
352
    takes_args = ['patch?']
367
353
    def run(self, patch=None, all=False, force=False, no_color=False):
368
354
        source = BzrPatchSource()
369
 
        s = Shelf(source.base)
 
355
        s = shelf.Shelf(source.base)
370
356
        s.unshelve(source, patch, all, force, no_color)
371
357
        return 0
372
358
 
373
359
 
374
 
class cmd_shell(bzrlib.commands.Command):
 
360
class cmd_shell(BzrToolsCommand):
375
361
    """Begin an interactive shell tailored for bzr.
376
362
    Bzr commands can be used without typing bzr first, and will be run natively
377
363
    when possible.  Tab completion is tailored for bzr.  The shell prompt shows
394
380
        return shell.run_shell()
395
381
 
396
382
 
397
 
class cmd_branch_history(bzrlib.commands.Command):
 
383
class cmd_branch_history(BzrToolsCommand):
398
384
    """\
399
385
    Display the development history of a branch.
400
386
 
404
390
    """
405
391
    takes_args = ["branch?"]
406
392
    def run(self, branch=None):
407
 
        from branchhistory import branch_history 
 
393
        from branchhistory import branch_history
408
394
        return branch_history(branch)
409
395
 
410
396
 
411
 
class cmd_zap(bzrlib.commands.Command):
 
397
class cmd_zap(BzrToolsCommand):
412
398
    """\
413
399
    Remove a lightweight checkout, if it can be done safely.
414
400
 
419
405
    If --branch is specified, the branch will be deleted too, but only if the
420
406
    the branch has no new commits (relative to its parent).
421
407
    """
422
 
    takes_options = [Option("branch", help="Remove associtated branch from"
423
 
                                           " repository")]
 
408
    takes_options = [Option("branch", help="Remove associated branch from"
 
409
                                           " repository."),
 
410
                     Option('force', help='Delete tree even if contents are'
 
411
                     ' modified.')]
424
412
    takes_args = ["checkout"]
425
 
    def run(self, checkout, branch=False):
 
413
    def run(self, checkout, branch=False, force=False):
426
414
        from zap import zap
427
 
        return zap(checkout, remove_branch=branch)
428
 
 
429
 
 
430
 
class cmd_cbranch(bzrlib.commands.Command):
 
415
        return zap(checkout, remove_branch=branch, allow_modified=force)
 
416
 
 
417
 
 
418
class cmd_cbranch(BzrToolsCommand):
431
419
    """
432
420
    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).
 
421
 
 
422
    When you cbranch, bzr looks up a target location in locations.conf, and
 
423
    creates the branch there.
 
424
 
 
425
    In your locations.conf, add the following lines:
 
426
    [/working_directory_root]
 
427
    cbranch_target = /branch_root
 
428
    cbranch_target:policy = appendpath
 
429
 
 
430
    This will mean that if you run "bzr cbranch foo/bar foo/baz" in the
 
431
    working directory root, the branch will be created in
 
432
    "/branch_root/foo/baz"
 
433
 
 
434
    NOTE: cbranch also supports "cbranch_root", but that behaviour is
 
435
    deprecated.
448
436
    """
449
 
    takes_options = [Option("lightweight", 
450
 
                            help="Create a lightweight checkout"), 'revision']
 
437
    takes_options = [Option("lightweight",
 
438
                            help="Create a lightweight checkout."), 'revision',
 
439
                     Option('files-from', type=unicode,
 
440
                            help='Accelerate checkout using files from this'
 
441
                                 ' tree.'),
 
442
                     Option('hardlink',
 
443
                            help='Hard-link files from source/files-from tree'
 
444
                            ' where posible.')]
451
445
    takes_args = ["source", "target?"]
452
 
    def run(self, source, target=None, lightweight=False, revision=None):
 
446
    def run(self, source, target=None, lightweight=False, revision=None,
 
447
            files_from=None, hardlink=False):
453
448
        from cbranch import cbranch
454
 
        return cbranch(source, target, lightweight=lightweight, 
455
 
                       revision=revision)
456
 
 
457
 
 
458
 
class cmd_branches(bzrlib.commands.Command):
 
449
        return cbranch(source, target, lightweight=lightweight,
 
450
                       revision=revision, files_from=files_from,
 
451
                       hardlink=hardlink)
 
452
 
 
453
 
 
454
class cmd_branches(BzrToolsCommand):
459
455
    """Scan a location for branches"""
460
456
    takes_args = ["location?"]
461
457
    def run(self, location=None):
462
458
        from branches import branches
463
459
        return branches(location)
464
460
 
 
461
class cmd_trees(BzrToolsCommand):
 
462
    """Scan a location for trees"""
 
463
    takes_args = ['location?']
 
464
    def run(self, location='.'):
 
465
        from bzrlib.workingtree import WorkingTree
 
466
        from bzrlib.transport import get_transport
 
467
        t = get_transport(location)
 
468
        for tree in WorkingTree.find_trees(location):
 
469
            self.outf.write('%s\n' % t.relpath(
 
470
                tree.bzrdir.root_transport.base))
465
471
 
466
 
class cmd_multi_pull(bzrlib.commands.Command):
 
472
class cmd_multi_pull(BzrToolsCommand):
467
473
    """Pull all the branches under a location, e.g. a repository.
468
 
    
 
474
 
469
475
    Both branches present in the directory and the branches of checkouts are
470
476
    pulled.
471
477
    """
472
478
    takes_args = ["location?"]
473
479
    def run(self, location=None):
474
 
        from bzrlib.branch import Branch
475
480
        from bzrlib.transport import get_transport
476
481
        from bzrtools import iter_branch_tree
477
482
        if location is None:
478
483
            location = '.'
479
484
        t = get_transport(location)
 
485
        possible_transports = []
480
486
        if not t.listable():
481
487
            print "Can't list this type of location."
482
488
            return 3
498
504
                relpath = base
499
505
            print "Pulling %s from %s" % (relpath, parent)
500
506
            try:
501
 
                pullable.pull(Branch.open(parent))
 
507
                branch_t = get_transport(parent, possible_transports)
 
508
                pullable.pull(Branch.open_from_transport(branch_t))
502
509
            except Exception, e:
503
510
                print e
504
511
 
505
512
 
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.
 
513
 
 
514
class cmd_import(BzrToolsCommand):
 
515
    """Import sources from a directory, tarball or zip file
 
516
 
 
517
    This command will import a directory, tarball or zip file into a bzr
 
518
    tree, replacing any versioned files already present.  If a directory is
 
519
    specified, it is used as the target.  If the directory does not exist, or
 
520
    is not versioned, it is created.
531
521
 
532
522
    Tarballs may be gzip or bzip2 compressed.  This is autodetected.
533
523
 
534
 
    If the tarball has a single root directory, that directory is stripped
535
 
    when extracting the tarball.
 
524
    If the tarball or zip has a single root directory, that directory is
 
525
    stripped when extracting the tarball.  This is not done for directories.
536
526
    """
537
 
    
 
527
 
538
528
    takes_args = ['source', 'tree?']
539
529
    def run(self, source, tree=None):
540
530
        from upstream_import import do_import
541
531
        do_import(source, tree)
542
532
 
543
533
 
544
 
class cmd_cdiff(bzrlib.commands.Command):
 
534
class cmd_cdiff(BzrToolsCommand):
545
535
    """A color version of bzr's diff"""
546
536
    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):
 
537
    takes_options = list(get_cmd_object('diff').takes_options) + [
 
538
        Option('check-style',
 
539
            help='Warn if trailing whitespace or spurious changes have been'
 
540
                 ' added.')]
 
541
 
 
542
    def run(self, check_style=False, *args, **kwargs):
549
543
        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):
 
544
        colordiff(check_style, *args, **kwargs)
 
545
 
 
546
 
 
547
class cmd_rspush(BzrToolsCommand):
624
548
    """Upload this branch to another location using rsync.
625
549
 
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. 
 
550
    If no location is specified, the last-used location will be used.  To
 
551
    prevent dirty trees from being uploaded, rspush will error out if there are
 
552
    unknown files or local changes.  It will also error out if the upstream
 
553
    directory is non-empty and not an earlier version of the branch.
630
554
    """
631
555
    takes_args = ['location?']
632
556
    takes_options = [Option('overwrite', help='Ignore differences between'
633
 
                            ' branches and overwrite unconditionally'),
 
557
                            ' branches and overwrite unconditionally.'),
634
558
                     Option('no-tree', help='Do not push the working tree,'
635
559
                            ' just the .bzr.')]
636
560
 
638
562
        from bzrlib import workingtree
639
563
        import bzrtools
640
564
        cur_branch = workingtree.WorkingTree.open_containing(".")[0]
641
 
        bzrtools.rspush(cur_branch, location, overwrite=overwrite, 
 
565
        bzrtools.rspush(cur_branch, location, overwrite=overwrite,
642
566
                      working_tree=not no_tree)
643
567
 
644
568
 
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
 
 
 
569
class cmd_link_tree(BzrToolsCommand):
 
570
    """Hardlink matching files to another tree.
 
571
 
 
572
    Only files with identical content and execute bit will be linked.
 
573
    """
 
574
    takes_args = ['location']
 
575
 
 
576
    def run(self, location):
 
577
        from bzrlib import workingtree
 
578
        from bzrlib.plugins.bzrtools.link_tree import link_tree
 
579
        target_tree = workingtree.WorkingTree.open_containing(".")[0]
 
580
        source_tree = workingtree.WorkingTree.open(location)
 
581
        target_tree.lock_write()
 
582
        try:
 
583
            source_tree.lock_read()
 
584
            try:
 
585
                link_tree(target_tree, source_tree)
 
586
            finally:
 
587
                source_tree.unlock()
 
588
        finally:
 
589
            target_tree.unlock()
 
590
 
 
591
from heads import cmd_heads
655
592
commands = [
656
 
            cmd_baz_import,
657
 
            cmd_baz_import_branch,
658
593
            cmd_branches,
659
594
            cmd_branch_history,
660
 
            cmd_branch_mark,
661
 
            cmd_cbranch,  
 
595
            cmd_cbranch,
662
596
            cmd_cdiff,
663
597
            cmd_clean_tree,
664
598
            cmd_fetch_ghosts,
665
599
            cmd_graph_ancestry,
 
600
            cmd_heads,
666
601
            cmd_import,
 
602
            cmd_link_tree,
667
603
            cmd_multi_pull,
668
604
            cmd_patch,
669
605
            cmd_rspush,
670
 
            cmd_shelf, 
 
606
            cmd_shelf,
671
607
            cmd_shell,
672
 
            cmd_shelve, 
673
 
            cmd_switch,
674
 
            cmd_unshelve, 
675
 
            cmd_zap,            
 
608
            cmd_shelve,
 
609
            cmd_trees,
 
610
            cmd_unshelve,
 
611
            cmd_zap,
676
612
            ]
677
613
 
678
614
 
688
624
    from unittest import TestSuite
689
625
    import bzrtools
690
626
    import tests.clean_tree
691
 
    import upstream_import
 
627
    import tests.test_dotgraph
 
628
    import tests.is_clean
 
629
    import tests.test_cbranch
 
630
    import tests.test_link_tree
 
631
    import tests.test_patch
 
632
    import tests.test_rspush
 
633
    import tests.upstream_import
692
634
    import zap
693
635
    import tests.blackbox
694
636
    import tests.shelf_tests
695
637
    result = TestSuite()
696
638
    result.addTest(DocTestSuite(bzrtools, optionflags=ELLIPSIS))
697
639
    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
640
    result.addTest(tests.test_suite())
704
641
    result.addTest(TestLoader().loadTestsFromModule(tests.shelf_tests))
705
642
    result.addTest(tests.blackbox.test_suite())
706
 
    result.addTest(upstream_import.test_suite())
 
643
    result.addTest(tests.upstream_import.test_suite())
707
644
    result.addTest(zap.test_suite())
 
645
    result.addTest(TestLoader().loadTestsFromModule(tests.test_dotgraph))
 
646
    result.addTest(TestLoader().loadTestsFromModule(tests.is_clean))
 
647
    result.addTest(TestLoader().loadTestsFromModule(tests.test_link_tree))
 
648
    result.addTest(TestLoader().loadTestsFromModule(tests.test_patch))
 
649
    result.addTest(TestLoader().loadTestsFromModule(tests.test_rspush))
 
650
    result.addTest(TestLoader().loadTestsFromModule(tests.test_cbranch))
708
651
    return result