← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to command_classes.py

  • Committer: Aaron Bentley
  • Date: 2013-08-20 03:02:43 UTC
  • Revision ID: aaron@aaronbentley.com-20130820030243-r8v1xfbcnd8f10p4
Fix zap command for 2.6/7

Show diffs side-by-side

added added

removed removed

Lines of Context:
command_classes.py
1
 
# Copyright (C) 2005, 2006, 2007 Aaron Bentley <aaron.bentley@utoronto.ca>
2
 
# Copyright (C) 2005, 2006 Canonical Limited.
 
1
# Copyright (C) 2005, 2006, 2007, 2011 Aaron Bentley <aaron@aaronbentley.com>
 
2
# Copyright (C) 2005, 2006, 2011 Canonical Limited.
3
3
# Copyright (C) 2006 Michael Ellerman.
4
4
#
5
5
#    This program is free software; you can redistribute it and/or modify
16
16
#    along with this program; if not, write to the Free Software
17
17
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
 
19
 
"""\
20
 
Various useful plugins for working with bzr.
21
 
"""
22
 
 
23
19
import bzrlib
24
20
 
25
 
 
26
 
__version__ = '0.15.3'
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 Bazaar version %s is too old to be used with'
51
 
                ' plugin \n'
52
 
                '"Bzrtools" %s.' % (bzrlib.__version__, __version__))
53
 
        # Not using BzrNewError, because it may not exist.
54
 
        raise Exception, ('Version mismatch', version_info)
55
 
    else:
56
 
        warning('Plugin "Bzrtools" is not up to date with installed Bazaar'
57
 
                ' version %s.\n'
58
 
                ' There should be a newer version of Bzrtools available, e.g.'
59
 
                ' %i.%i.'
60
 
                % (bzrlib.__version__, bzrlib_version[0], bzrlib_version[1]))
61
 
        if bzrlib_version != desired_plus:
62
 
            raise Exception, 'Version mismatch'
63
 
 
64
 
 
65
 
check_bzrlib_version(version_info[:2])
66
 
 
67
21
from bzrlib.lazy_import import lazy_import
68
22
lazy_import(globals(), """
69
 
from bzrlib import help
70
 
import shelf
 
23
from bzrlib import help, urlutils
 
24
from bzrlib.plugins.bzrtools import shelf
71
25
""")
72
26
 
73
 
from errors import CommandError, NoPyBaz
 
27
from bzrlib.plugins import bzrtools
 
28
from command import BzrToolsCommand
 
29
from errors import CommandError
74
30
from patchsource import BzrPatchSource
75
 
import sys
76
 
import os.path
77
31
 
78
 
import bzrlib.builtins
79
32
import bzrlib.commands
 
33
from bzrlib.branch import Branch
80
34
from bzrlib.commands import get_cmd_object
81
35
from bzrlib.errors import BzrCommandError
82
 
import bzrlib.ignores
83
 
from bzrlib.option import Option
84
 
sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__), 
85
 
                                                 "external")))
86
 
 
87
 
import show_paths
88
 
 
89
 
bzrlib.ignores.add_runtime_ignores(['./.shelf'])
90
 
 
91
 
 
92
 
class cmd_clean_tree(bzrlib.commands.Command):
93
 
    """Remove unwanted files from working tree.
94
 
 
95
 
    By default, only unknown files, not ignored files, are deleted.  Versioned
96
 
    files are never deleted.
97
 
 
98
 
    Another class is 'detritus', which includes files emitted by bzr during
99
 
    normal operations and selftests.  (The value of these files decreases with
100
 
    time.)
101
 
 
102
 
    If no options are specified, unknown files are deleted.  Otherwise, option
103
 
    flags are respected, and may be combined.
104
 
 
105
 
    To check what clean-tree will do, use --dry-run.
106
 
    """
107
 
    takes_options = [Option('ignored', help='delete all ignored files.'), 
108
 
                     Option('detritus', help='delete conflict files, merge'
109
 
                            ' backups, and failed selftest dirs.'), 
110
 
                     Option('unknown', 
111
 
                            help='delete files unknown to bzr.  (default)'),
112
 
                     Option('dry-run', help='show files to delete instead of'
113
 
                            ' deleting them.')]
114
 
    def run(self, unknown=False, ignored=False, detritus=False, dry_run=False):
115
 
        from clean_tree import clean_tree
116
 
        if not (unknown or ignored or detritus):
117
 
            unknown = True
118
 
        clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus, 
119
 
                   dry_run=dry_run)
120
 
 
121
 
 
122
 
class cmd_graph_ancestry(bzrlib.commands.Command):
 
36
from bzrlib.option import Option, RegistryOption
 
37
 
 
38
 
 
39
class cmd_graph_ancestry(BzrToolsCommand):
123
40
    """Produce ancestry graphs using dot.
124
 
    
 
41
 
125
42
    Output format is detected according to file extension.  Some of the more
126
43
    common output formats are html, png, gif, svg, ps.  An extension of '.dot'
127
44
    will cause a dot graph file to be produced.  HTML output has mouseovers
131
48
    with the last 5 characters of their revision identifier are used instead.
132
49
 
133
50
    The value starting with d is "(maximum) distance from the null revision".
134
 
    
 
51
 
135
52
    If --merge-branch is specified, the two branches are compared and a merge
136
53
    base is selected.
137
 
    
 
54
 
138
55
    Legend:
139
56
    white    normal revision
140
57
    yellow   THIS  history
154
71
    If available, rsvg is used to antialias PNG and JPEG output, but this can
155
72
    be disabled with --no-antialias.
156
73
    """
157
 
    takes_args = ['branch', 'file']
158
 
    takes_options = [Option('no-collapse', help="Do not skip simple nodes"), 
 
74
    takes_args = ['file', 'merge_branch?']
 
75
    takes_options = [Option('no-collapse', help="Do not skip simple nodes."),
159
76
                     Option('no-antialias',
160
 
                     help="Do not use rsvg to produce antialiased output"), 
161
 
                     Option('merge-branch', type=str, 
162
 
                     help="Use this branch to calcuate a merge base"), 
 
77
                     help="Do not use rsvg to produce antialiased output."),
 
78
                     Option('merge-branch', type=str,
 
79
                     help="Use this branch to calcuate a merge base."),
163
80
                     Option('cluster', help="Use clustered output."),
164
 
                     Option('max-distance', help="Show no nodes farther than this",
165
 
                            type=int)]
166
 
    def run(self, branch, file, no_collapse=False, no_antialias=False,
167
 
        merge_branch=None, cluster=False, max_distance=None):
 
81
                     Option('max-distance',
 
82
                            help="Show no nodes farther than this.", type=int),
 
83
                     Option('directory',
 
84
                            help='Source branch to use (default is current'
 
85
                            ' directory).',
 
86
                            short_name='d',
 
87
                            type=unicode),
 
88
                    ]
 
89
    def run(self, file, merge_branch=None, no_collapse=False,
 
90
            no_antialias=False, cluster=False, max_distance=100,
 
91
            directory='.'):
 
92
        if max_distance == -1:
 
93
            max_distance = None
168
94
        import graph
169
95
        if cluster:
170
96
            ranking = "cluster"
171
97
        else:
172
98
            ranking = "forced"
173
 
        graph.write_ancestry_file(branch, file, not no_collapse, 
174
 
                                  not no_antialias, merge_branch, ranking, 
 
99
        graph.write_ancestry_file(directory, file, not no_collapse,
 
100
                                  not no_antialias, merge_branch, ranking,
175
101
                                  max_distance=max_distance)
176
102
 
177
103
 
178
 
class cmd_fetch_ghosts(bzrlib.commands.Command):
 
104
class cmd_fetch_ghosts(BzrToolsCommand):
179
105
    """Attempt to retrieve ghosts from another branch.
180
106
    If the other branch is not supplied, the last-pulled branch is used.
181
107
    """
182
108
    aliases = ['fetch-missing']
183
109
    takes_args = ['branch?']
184
 
    takes_options = [Option('no-fix')]
 
110
    takes_options = [Option('no-fix', help="Skip additional synchonization.")]
185
111
    def run(self, branch=None, no_fix=False):
186
112
        from fetch_ghosts import fetch_ghosts
187
 
        fetch_ghosts(branch, no_fix)
 
113
        fetch_ghosts(branch, do_reconcile=not no_fix)
188
114
 
189
115
strip_help="""Strip the smallest prefix containing num leading slashes  from \
190
116
each file name found in the patch file."""
191
117
 
192
118
 
193
 
class cmd_patch(bzrlib.commands.Command):
 
119
class cmd_patch(BzrToolsCommand):
194
120
    """Apply a named patch to the current tree.
195
121
    """
196
122
    takes_args = ['filename?']
197
 
    takes_options = [Option('strip', type=int, help=strip_help),
198
 
                     Option('silent', help='Suppress chatter')]
 
123
    takes_options = [Option('strip', type=int, short_name='p',
 
124
                            help=strip_help),
 
125
                     Option('silent', help='Suppress chatter.')]
199
126
    def run(self, filename=None, strip=None, silent=False):
200
127
        from patch import patch
201
128
        from bzrlib.workingtree import WorkingTree
205
132
        return patch(wt, filename, strip, silent)
206
133
 
207
134
 
208
 
class cmd_shelve(bzrlib.commands.Command):
 
135
class cmd_shelve1(BzrToolsCommand):
209
136
    """Temporarily set aside some changes from the current tree.
210
137
 
211
138
    Shelve allows you to temporarily put changes you've made "on the shelf",
212
139
    ie. out of the way, until a later time when you can bring them back from
213
 
    the shelf with the 'unshelve' command.
 
140
    the shelf with the 'unshelve1' command.
214
141
 
215
142
    Shelve is intended to help separate several sets of text changes that have
216
143
    been inappropriately mingled.  If you just want to get rid of all changes
217
144
    (text and otherwise) and you don't need to restore them later, use revert.
218
 
    If you want to shelve all text changes at once, use shelve --all.
 
145
    If you want to shelve all text changes at once, use shelve1 --all.
219
146
 
220
 
    By default shelve asks you what you want to shelve, press '?' at the
221
 
    prompt to get help. To shelve everything run shelve --all.
 
147
    By default shelve1 asks you what you want to shelve, press '?' at the
 
148
    prompt to get help. To shelve everything run shelve1 --all.
222
149
 
223
150
    If filenames are specified, only the changes to those files will be
224
151
    shelved, other files will be left untouched.
226
153
    If a revision is specified, changes since that revision will be shelved.
227
154
 
228
155
    You can put multiple items on the shelf. Normally each time you run
229
 
    unshelve the most recently shelved changes will be reinstated. However,
 
156
    unshelve1 the most recently shelved changes will be reinstated. However,
230
157
    you can also unshelve changes in a different order by explicitly
231
 
    specifiying which changes to unshelve. This works best when the changes
 
158
    specifiying which changes to unshelve1. This works best when the changes
232
159
    don't depend on each other.
233
160
 
234
161
    While you have patches on the shelf you can view and manipulate them with
235
 
    the 'shelf' command. Run 'bzr shelf -h' for more info.
 
162
    the 'shelf1' command. Run 'bzr shelf1 -h' for more info.
236
163
    """
237
164
 
238
165
    takes_args = ['file*']
239
 
    takes_options = ['message', 'revision',
240
 
            Option('all', help='Shelve all changes without prompting'), 
241
 
            Option('no-color', help='Never display changes in color')]
 
166
    takes_options = [Option('message',
 
167
            help='A message to associate with the shelved changes.',
 
168
            short_name='m', type=unicode),
 
169
            'revision',
 
170
            Option('all', help='Shelve all changes without prompting.'),
 
171
            Option('no-color', help='Never display changes in color.')]
242
172
 
243
173
    def run(self, all=False, file_list=None, message=None, revision=None,
244
174
            no_color=False):
255
185
        return 0
256
186
 
257
187
 
258
 
# The following classes are only used as subcommands for 'shelf', they're
 
188
# The following classes are only used as subcommands for 'shelf1', they're
259
189
# not to be registered directly with bzr.
260
190
 
261
191
class cmd_shelf_list(bzrlib.commands.Command):
297
227
        self.shelf.upgrade()
298
228
 
299
229
 
300
 
class cmd_shelf(bzrlib.commands.Command):
301
 
    """Perform various operations on your shelved patches. See also shelve."""
 
230
class cmd_shelf1(BzrToolsCommand):
 
231
    """Perform various operations on your shelved patches. See also shelve1."""
302
232
    takes_args = ['subcommand', 'args*']
303
233
 
304
234
    subcommands = [cmd_shelf_list, cmd_shelf_delete, cmd_shelf_switch,
338
268
        cmd_obj = cmd_class()
339
269
        indent = 2 * ' '
340
270
 
341
 
        usage = help.command_usage(cmd_obj)
 
271
        usage = cmd_obj._usage()
342
272
        usage = usage.replace('bzr shelf-', '')
343
273
        text.append('%s%s\n' % (indent, usage))
344
274
 
363
293
        return text
364
294
 
365
295
 
366
 
class cmd_unshelve(bzrlib.commands.Command):
 
296
class cmd_unshelve1(BzrToolsCommand):
367
297
    """Restore shelved changes.
368
298
 
369
299
    By default the most recently shelved changes are restored. However if you
370
300
    specify a patch by name those changes will be restored instead.
371
301
 
372
 
    See 'shelve' for more information.
 
302
    See 'shelve1' for more information.
373
303
    """
374
304
    takes_options = [
375
 
            Option('all', help='Unshelve all changes without prompting'),
376
 
            Option('force', help='Force unshelving even if errors occur'),
377
 
            Option('no-color', help='Never display changes in color')
 
305
            Option('all', help='Unshelve all changes without prompting.'),
 
306
            Option('force', help='Force unshelving even if errors occur.'),
 
307
            Option('no-color', help='Never display changes in color.')
378
308
        ]
379
309
    takes_args = ['patch?']
380
310
    def run(self, patch=None, all=False, force=False, no_color=False):
384
314
        return 0
385
315
 
386
316
 
387
 
class cmd_shell(bzrlib.commands.Command):
 
317
class cmd_shell(BzrToolsCommand):
388
318
    """Begin an interactive shell tailored for bzr.
389
319
    Bzr commands can be used without typing bzr first, and will be run natively
390
320
    when possible.  Tab completion is tailored for bzr.  The shell prompt shows
402
332
    --all        --help       --revision   --show-ids
403
333
    bzr bzrtools:287/> status --
404
334
    """
405
 
    def run(self):
 
335
    takes_options = [
 
336
        Option('directory',
 
337
            help='Branch in which to start the shell, '
 
338
                 'rather than the one containing the working directory.',
 
339
            short_name='d',
 
340
            type=unicode,
 
341
            ),
 
342
        ]
 
343
    def run(self, directory=None):
406
344
        import shell
407
 
        return shell.run_shell()
408
 
 
409
 
 
410
 
class cmd_branch_history(bzrlib.commands.Command):
 
345
        return shell.run_shell(directory)
 
346
 
 
347
 
 
348
class cmd_branch_history(BzrToolsCommand):
411
349
    """\
412
350
    Display the development history of a branch.
413
351
 
417
355
    """
418
356
    takes_args = ["branch?"]
419
357
    def run(self, branch=None):
420
 
        from branchhistory import branch_history 
 
358
        from branchhistory import branch_history
421
359
        return branch_history(branch)
422
360
 
423
361
 
424
 
class cmd_zap(bzrlib.commands.Command):
 
362
class cmd_zap(BzrToolsCommand):
425
363
    """\
426
364
    Remove a lightweight checkout, if it can be done safely.
427
365
 
431
369
 
432
370
    If --branch is specified, the branch will be deleted too, but only if the
433
371
    the branch has no new commits (relative to its parent).
 
372
 
 
373
    If bzr-pipeline is also installed, the --store option will store changes
 
374
    in the branch before deleting the tree.  To restore the changes, do::
 
375
 
 
376
      bzr checkout --lightweight $BRANCH $CHECKOUT
 
377
      bzr switch-pipe -d $CHECKOUT `bzr nick -d $CHECKOUT`
434
378
    """
435
 
    takes_options = [Option("branch", help="Remove associtated branch from"
436
 
                                           " repository")]
 
379
    takes_options = [Option("branch", help="Remove associated branch from"
 
380
                                           " repository."),
 
381
                     RegistryOption('change_policy',
 
382
                                    'How to handle changed files',
 
383
                                    lazy_registry =
 
384
                                    ('bzrlib.plugins.bzrtools.zap',
 
385
                                        'change_policy_registry'),
 
386
                                    value_switches=True,
 
387
                                    enum_switch=False)]
437
388
    takes_args = ["checkout"]
438
 
    def run(self, checkout, branch=False):
439
 
        from zap import zap
440
 
        return zap(checkout, remove_branch=branch)
441
 
 
442
 
 
443
 
class cmd_cbranch(bzrlib.commands.Command):
 
389
    def run(self, checkout, branch=False, change_policy=None):
 
390
        from zap import (
 
391
            change_policy_registry,
 
392
            StoreChanges,
 
393
            zap,
 
394
        )
 
395
        if change_policy is None:
 
396
            change_policy = change_policy_registry.get()
 
397
        if change_policy is StoreChanges:
 
398
            try:
 
399
                import bzrlib.plugins.pipeline
 
400
            except ImportError:
 
401
                raise BzrCommandError('--store requires bzr-pipeline.')
 
402
        return zap(checkout, remove_branch=branch, policy=change_policy)
 
403
 
 
404
 
 
405
class cmd_cbranch(BzrToolsCommand):
444
406
    """
445
407
    Create a new checkout, associated with a new repository branch.
446
 
    
 
408
 
447
409
    When you cbranch, bzr looks up a target location in locations.conf, and
448
410
    creates the branch there.
449
411
 
453
415
    cbranch_target:policy = appendpath
454
416
 
455
417
    This will mean that if you run "bzr cbranch foo/bar foo/baz" in the
456
 
    working directory root, the branch will be created in 
 
418
    working directory root, the branch will be created in
457
419
    "/branch_root/foo/baz"
458
420
 
459
421
    NOTE: cbranch also supports "cbranch_root", but that behaviour is
460
422
    deprecated.
461
423
    """
462
 
    takes_options = [Option("lightweight", 
463
 
                            help="Create a lightweight checkout"), 'revision']
 
424
    takes_options = [Option("lightweight",
 
425
                            help="Create a lightweight checkout."), 'revision',
 
426
                     Option('files-from', type=unicode,
 
427
                            help='Accelerate checkout using files from this'
 
428
                                 ' tree.'),
 
429
                     Option('hardlink',
 
430
                            help='Hard-link files from source/files-from tree'
 
431
                            ' where posible.')]
464
432
    takes_args = ["source", "target?"]
465
 
    def run(self, source, target=None, lightweight=False, revision=None):
 
433
    def run(self, source, target=None, lightweight=False, revision=None,
 
434
            files_from=None, hardlink=False):
466
435
        from cbranch import cbranch
467
 
        return cbranch(source, target, lightweight=lightweight, 
468
 
                       revision=revision)
469
 
 
470
 
 
471
 
class cmd_branches(bzrlib.commands.Command):
 
436
        return cbranch(source, target, lightweight=lightweight,
 
437
                       revision=revision, files_from=files_from,
 
438
                       hardlink=hardlink)
 
439
 
 
440
 
 
441
class cmd_list_branches(BzrToolsCommand):
472
442
    """Scan a location for branches"""
 
443
    @property
 
444
    def aliases(self):
 
445
        from bzrlib import commands
 
446
        return commands.plugin_cmds.get_info('list-branches').aliases
 
447
 
473
448
    takes_args = ["location?"]
474
449
    def run(self, location=None):
475
450
        from branches import branches
476
451
        return branches(location)
477
452
 
 
453
class cmd_trees(BzrToolsCommand):
 
454
    """Scan a location for trees"""
 
455
    takes_args = ['location?']
 
456
    def run(self, location='.'):
 
457
        from bzrlib.workingtree import WorkingTree
 
458
        from bzrlib.transport import get_transport
 
459
        t = get_transport(location)
 
460
        for tree in WorkingTree.find_trees(location):
 
461
            self.outf.write('%s\n' % t.relpath(
 
462
                tree.bzrdir.root_transport.base))
478
463
 
479
 
class cmd_multi_pull(bzrlib.commands.Command):
 
464
class cmd_multi_pull(BzrToolsCommand):
480
465
    """Pull all the branches under a location, e.g. a repository.
481
 
    
 
466
 
482
467
    Both branches present in the directory and the branches of checkouts are
483
468
    pulled.
484
469
    """
485
470
    takes_args = ["location?"]
486
471
    def run(self, location=None):
487
 
        from bzrlib.branch import Branch
488
472
        from bzrlib.transport import get_transport
489
473
        from bzrtools import iter_branch_tree
490
474
        if location is None:
491
475
            location = '.'
492
476
        t = get_transport(location)
 
477
        possible_transports = []
493
478
        if not t.listable():
494
479
            print "Can't list this type of location."
495
480
            return 3
511
496
                relpath = base
512
497
            print "Pulling %s from %s" % (relpath, parent)
513
498
            try:
514
 
                pullable.pull(Branch.open(parent))
 
499
                branch_t = get_transport(parent, possible_transports)
 
500
                pullable.pull(Branch.open_from_transport(branch_t))
515
501
            except Exception, e:
516
502
                print e
517
503
 
518
504
 
519
 
class cmd_branch_mark(bzrlib.commands.Command):
520
 
    """
521
 
    Add, view or list branch markers <EXPERIMENTAL>
522
 
 
523
 
    To add a mark, do 'bzr branch-mark MARK'.
524
 
    To list marks, do 'bzr branch-mark' (this lists all marks for the branch's
525
 
    repository).
526
 
    To delete a mark, do 'bzr branch-mark --delete MARK'
527
 
 
528
 
    These marks can be used to track a branch's status.
529
 
    """
530
 
    takes_args = ['mark?', 'branch?']
531
 
    takes_options = [Option('delete', help='Delete this mark')]
532
 
    def run(self, mark=None, branch=None, delete=False):
533
 
        from branch_mark import branch_mark
534
 
        branch_mark(mark, branch, delete)
535
 
 
536
 
 
537
 
class cmd_import(bzrlib.commands.Command):
 
505
 
 
506
class cmd_import(BzrToolsCommand):
538
507
    """Import sources from a directory, tarball or zip file
539
 
    
 
508
 
540
509
    This command will import a directory, tarball or zip file into a bzr
541
510
    tree, replacing any versioned files already present.  If a directory is
542
511
    specified, it is used as the target.  If the directory does not exist, or
547
516
    If the tarball or zip has a single root directory, that directory is
548
517
    stripped when extracting the tarball.  This is not done for directories.
549
518
    """
550
 
    
 
519
 
551
520
    takes_args = ['source', 'tree?']
552
521
    def run(self, source, tree=None):
553
522
        from upstream_import import do_import
554
523
        do_import(source, tree)
555
524
 
556
525
 
557
 
class cmd_cdiff(bzrlib.commands.Command):
 
526
class cmd_cdiff(BzrToolsCommand):
558
527
    """A color version of bzr's diff"""
559
528
    takes_args = property(lambda x: get_cmd_object('diff').takes_args)
560
 
 
561
 
    def _takes_options(self):
562
 
        options = list(get_cmd_object('diff').takes_options)
563
 
        options.append(Option('check-style',
 
529
    takes_options = list(get_cmd_object('diff').takes_options) + [
 
530
        RegistryOption.from_kwargs('color',
 
531
            'Color mode to use.',
 
532
            title='Color Mode', value_switches=False, enum_switch=True,
 
533
            never='Never colorize output.',
 
534
            auto='Only colorize output if terminal supports it and STDOUT is a'
 
535
            ' TTY.',
 
536
            always='Always colorize output (default).'),
 
537
        Option('check-style',
564
538
            help='Warn if trailing whitespace or spurious changes have been'
565
 
                 ' added.'))
566
 
        return options
567
 
 
568
 
    takes_options = property(_takes_options)
569
 
 
570
 
    def run(self, check_style=False, *args, **kwargs):
 
539
                 ' added.')]
 
540
 
 
541
    def run(self, color='always', check_style=False, *args, **kwargs):
571
542
        from colordiff import colordiff
572
 
        colordiff(check_style, *args, **kwargs)
573
 
 
574
 
 
575
 
class cmd_baz_import(bzrlib.commands.Command):
576
 
    """Import an Arch or Baz archive into a bzr repository.
577
 
 
578
 
    This command should be used on local archives (or mirrors) only.  It is
579
 
    quite slow on remote archives.
580
 
    
581
 
    reuse_history allows you to specify any previous imports you 
582
 
    have done of different archives, which this archive has branches
583
 
    tagged from. This will dramatically reduce the time to convert 
584
 
    the archive as it will not have to convert the history already
585
 
    converted in that other branch.
586
 
 
587
 
    If you specify prefixes, only branches whose names start with that prefix
588
 
    will be imported.  Skipped branches will be listed, so you can import any
589
 
    branches you missed by accident.  Here's an example of doing a partial
590
 
    import from thelove@canonical.com:
591
 
    bzr baz-import thelove thelove@canonical.com --prefixes dists:talloc-except
592
 
 
593
 
    WARNING: Encoding should not be specified unless necessary, because if you
594
 
    specify an encoding, your converted branch will not interoperate with
595
 
    independently-converted branches, unless the other branches were converted
596
 
    with exactly the same encoding.  Any encoding recognized by Python may
597
 
    be specified.  Aliases are not detected, so 'utf_8', 'U8', 'UTF' and 'utf8'
598
 
    are incompatible.
599
 
    """
600
 
    takes_args = ['to_root_dir', 'from_archive', 'reuse_history*']
601
 
    takes_options = ['verbose', Option('prefixes', type=str,
602
 
                     help="Prefixes of branches to import, colon-separated"),
603
 
                     Option('encoding', type=str, 
604
 
                     help='Force encoding to specified value.  See WARNING.')]
605
 
 
606
 
    def run(self, to_root_dir, from_archive, encoding=None, verbose=False,
607
 
            reuse_history_list=[], prefixes=None):
608
 
        from errors import NoPyBaz
609
 
        try:
610
 
            import baz_import
611
 
            baz_import.baz_import(to_root_dir, from_archive, encoding,
612
 
                                  verbose, reuse_history_list, prefixes)
613
 
        except NoPyBaz:
614
 
            print "This command is disabled.  Please install PyBaz."
615
 
 
616
 
 
617
 
class cmd_baz_import_branch(bzrlib.commands.Command):
618
 
    """Import an Arch or Baz branch into a bzr branch.
619
 
 
620
 
    WARNING: Encoding should not be specified unless necessary, because if you
621
 
    specify an encoding, your converted branch will not interoperate with
622
 
    independently-converted branches, unless the other branches were converted
623
 
    with exactly the same encoding.  Any encoding recognized by Python may
624
 
    be specified.  Aliases are not detected, so 'utf_8', 'U8', 'UTF' and 'utf8'
625
 
    are incompatible.
626
 
    """
627
 
    takes_args = ['to_location', 'from_branch?', 'reuse_history*']
628
 
    takes_options = ['verbose', Option('max-count', type=int),
629
 
                     Option('encoding', type=str, 
630
 
                     help='Force encoding to specified value.  See WARNING.')]
631
 
 
632
 
    def run(self, to_location, from_branch=None, fast=False, max_count=None,
633
 
            encoding=None, verbose=False, dry_run=False,
634
 
            reuse_history_list=[]):
635
 
        from errors import NoPyBaz
636
 
        try:
637
 
            import baz_import
638
 
            baz_import.baz_import_branch(to_location, from_branch, fast, 
639
 
                                         max_count, verbose, encoding, dry_run,
640
 
                                         reuse_history_list)
641
 
        except NoPyBaz:
642
 
            print "This command is disabled.  Please install PyBaz."
643
 
 
644
 
 
645
 
class cmd_rspush(bzrlib.commands.Command):
 
543
        colordiff(color, check_style, *args, **kwargs)
 
544
 
 
545
 
 
546
class cmd_conflict_diff(BzrToolsCommand):
 
547
 
 
548
    """Compare a conflicted file against BASE."""
 
549
 
 
550
    encoding_type = 'exact'
 
551
    takes_args = ['file*']
 
552
    takes_options = [
 
553
        RegistryOption.from_kwargs('direction', 'Direction of comparison.',
 
554
            value_switches=True, enum_switch=False,
 
555
            other='Compare OTHER against common base.',
 
556
            this='Compare THIS against common base.')]
 
557
 
 
558
    def run(self, file_list, direction='other'):
 
559
        from bzrlib.plugins.bzrtools.colordiff import DiffWriter
 
560
        from conflict_diff import ConflictDiffer
 
561
        dw = DiffWriter(self.outf, check_style=False, color='auto')
 
562
        ConflictDiffer().run(dw, file_list, direction)
 
563
 
 
564
 
 
565
class cmd_rspush(BzrToolsCommand):
646
566
    """Upload this branch to another location using rsync.
647
567
 
648
 
    If no location is specified, the last-used location will be used.  To 
649
 
    prevent dirty trees from being uploaded, rspush will error out if there are 
650
 
    unknown files or local changes.  It will also error out if the upstream 
651
 
    directory is non-empty and not an earlier version of the branch. 
 
568
    If no location is specified, the last-used location will be used.  To
 
569
    prevent dirty trees from being uploaded, rspush will error out if there are
 
570
    unknown files or local changes.  It will also error out if the upstream
 
571
    directory is non-empty and not an earlier version of the branch.
652
572
    """
653
573
    takes_args = ['location?']
654
574
    takes_options = [Option('overwrite', help='Ignore differences between'
655
 
                            ' branches and overwrite unconditionally'),
 
575
                            ' branches and overwrite unconditionally.'),
656
576
                     Option('no-tree', help='Do not push the working tree,'
657
577
                            ' just the .bzr.')]
658
578
 
660
580
        from bzrlib import workingtree
661
581
        import bzrtools
662
582
        cur_branch = workingtree.WorkingTree.open_containing(".")[0]
663
 
        bzrtools.rspush(cur_branch, location, overwrite=overwrite, 
 
583
        bzrtools.rspush(cur_branch, location, overwrite=overwrite,
664
584
                      working_tree=not no_tree)
665
585
 
666
586
 
667
 
class cmd_switch(bzrlib.commands.Command):
668
 
    """Set the branch of a lightweight checkout and update."""
669
 
 
670
 
    takes_args = ['to_location']
671
 
 
672
 
    def run(self, to_location):
673
 
        from switch import cmd_switch
674
 
        cmd_switch().run(to_location)
675
 
 
676
 
 
677
 
commands = [
678
 
            cmd_baz_import,
679
 
            cmd_baz_import_branch,
680
 
            cmd_branches,
681
 
            cmd_branch_history,
682
 
            cmd_branch_mark,
683
 
            cmd_cbranch,  
684
 
            cmd_cdiff,
685
 
            cmd_clean_tree,
686
 
            cmd_fetch_ghosts,
687
 
            cmd_graph_ancestry,
688
 
            cmd_import,
689
 
            cmd_multi_pull,
690
 
            cmd_patch,
691
 
            cmd_rspush,
692
 
            cmd_shelf, 
693
 
            cmd_shell,
694
 
            cmd_shelve, 
695
 
            cmd_switch,
696
 
            cmd_unshelve, 
697
 
            cmd_zap,            
698
 
            ]
699
 
 
700
 
 
701
 
if hasattr(bzrlib.commands, 'register_command'):
702
 
    for command in commands:
703
 
        bzrlib.commands.register_command(command)
704
 
 
705
 
 
706
 
def test_suite():
707
 
    from bzrlib.tests.TestUtil import TestLoader
708
 
    import tests
709
 
    from doctest import DocTestSuite, ELLIPSIS
710
 
    from unittest import TestSuite
711
 
    import bzrtools
712
 
    import tests.clean_tree
713
 
    import tests.is_clean
714
 
    import tests.upstream_import
715
 
    import zap
716
 
    import tests.blackbox
717
 
    import tests.shelf_tests
718
 
    result = TestSuite()
719
 
    result.addTest(DocTestSuite(bzrtools, optionflags=ELLIPSIS))
720
 
    result.addTest(tests.clean_tree.test_suite())
721
 
    try:
722
 
        import baz_import
723
 
        result.addTest(DocTestSuite(baz_import))
724
 
    except NoPyBaz:
725
 
        pass
726
 
    result.addTest(tests.test_suite())
727
 
    result.addTest(TestLoader().loadTestsFromModule(tests.shelf_tests))
728
 
    result.addTest(tests.blackbox.test_suite())
729
 
    result.addTest(tests.upstream_import.test_suite())
730
 
    result.addTest(zap.test_suite())
731
 
    result.addTest(TestLoader().loadTestsFromModule(tests.is_clean))
732
 
    return result
 
587
class cmd_link_tree(BzrToolsCommand):
 
588
    """Hardlink matching files to another tree.
 
589
 
 
590
    Only files with identical content and execute bit will be linked.
 
591
    """
 
592
    takes_args = ['location']
 
593
 
 
594
    def run(self, location):
 
595
        from bzrlib import workingtree
 
596
        from bzrlib.plugins.bzrtools.link_tree import link_tree
 
597
        target_tree = workingtree.WorkingTree.open_containing(".")[0]
 
598
        source_tree = workingtree.WorkingTree.open(location)
 
599
        target_tree.lock_write()
 
600
        try:
 
601
            source_tree.lock_read()
 
602
            try:
 
603
                link_tree(target_tree, source_tree)
 
604
            finally:
 
605
                source_tree.unlock()
 
606
        finally:
 
607
            target_tree.unlock()
 
608
 
 
609
 
 
610
class cmd_create_mirror(BzrToolsCommand):
 
611
    """Create a mirror of another branch.
 
612
 
 
613
    This is similar to `bzr branch`, but copies more settings, including the
 
614
    submit branch and nickname.
 
615
 
 
616
    It sets the public branch and parent of the target to the source location.
 
617
    """
 
618
 
 
619
    takes_args = ['source', 'target']
 
620
 
 
621
    def run(self, source, target):
 
622
        source_branch = Branch.open(source)
 
623
        from bzrlib.plugins.bzrtools.mirror import create_mirror
 
624
        create_mirror(source_branch, target, [])