← 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: 2011-09-25 03:13:49 UTC
  • Revision ID: aaron@aaronbentley.com-20110925031349-a3n39pq16ih54fwn
Rename 'branches' to list-branches, keep 'branches' as alias if not built in.

Show diffs side-by-side

added added

removed removed

Lines of Context:
command_classes.py
1
 
# Copyright (C) 2005, 2006 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.13.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
 
21
from bzrlib.lazy_import import lazy_import
 
22
lazy_import(globals(), """
 
23
from bzrlib import help, urlutils
 
24
import shelf
 
25
""")
 
26
 
 
27
from bzrlib.plugins import bzrtools
 
28
from command import BzrToolsCommand
 
29
from errors import CommandError
66
30
from patchsource import BzrPatchSource
67
 
from shelf import Shelf
68
 
import sys
69
 
import os.path
70
31
 
71
 
import bzrlib.builtins
72
32
import bzrlib.commands
 
33
from bzrlib.branch import Branch
73
34
from bzrlib.commands import get_cmd_object
74
35
from bzrlib.errors import BzrCommandError
75
 
from bzrlib.help import command_usage
76
 
import bzrlib.ignores
77
 
from bzrlib.option import Option
78
 
sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__), 
79
 
                                                 "external")))
80
 
 
81
 
bzrlib.ignores.add_runtime_ignores(['./.shelf'])
82
 
 
83
 
 
84
 
class cmd_clean_tree(bzrlib.commands.Command):
85
 
    """Remove unwanted files from working tree.
86
 
 
87
 
    By default, only unknown files, not ignored files, are deleted.  Versioned
88
 
    files are never deleted.
89
 
 
90
 
    Another class is 'detritus', which includes files emitted by bzr during
91
 
    normal operations and selftests.  (The value of these files decreases with
92
 
    time.)
93
 
 
94
 
    If no options are specified, unknown files are deleted.  Otherwise, option
95
 
    flags are respected, and may be combined.
96
 
 
97
 
    To check what clean-tree will do, use --dry-run.
98
 
    """
99
 
    takes_options = [Option('ignored', help='delete all ignored files.'), 
100
 
                     Option('detritus', help='delete conflict files, merge'
101
 
                            ' backups, and failed selftest dirs.'), 
102
 
                     Option('unknown', 
103
 
                            help='delete files unknown to bzr.  (default)'),
104
 
                     Option('dry-run', help='show files to delete instead of'
105
 
                            ' deleting them.')]
106
 
    def run(self, unknown=False, ignored=False, detritus=False, dry_run=False):
107
 
        from clean_tree import clean_tree
108
 
        if not (unknown or ignored or detritus):
109
 
            unknown = True
110
 
        clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus, 
111
 
                   dry_run=dry_run)
112
 
 
113
 
 
114
 
class cmd_graph_ancestry(bzrlib.commands.Command):
 
36
from bzrlib.option import Option, RegistryOption
 
37
 
 
38
 
 
39
class cmd_graph_ancestry(BzrToolsCommand):
115
40
    """Produce ancestry graphs using dot.
116
 
    
 
41
 
117
42
    Output format is detected according to file extension.  Some of the more
118
43
    common output formats are html, png, gif, svg, ps.  An extension of '.dot'
119
44
    will cause a dot graph file to be produced.  HTML output has mouseovers
123
48
    with the last 5 characters of their revision identifier are used instead.
124
49
 
125
50
    The value starting with d is "(maximum) distance from the null revision".
126
 
    
 
51
 
127
52
    If --merge-branch is specified, the two branches are compared and a merge
128
53
    base is selected.
129
 
    
 
54
 
130
55
    Legend:
131
56
    white    normal revision
132
57
    yellow   THIS  history
146
71
    If available, rsvg is used to antialias PNG and JPEG output, but this can
147
72
    be disabled with --no-antialias.
148
73
    """
149
 
    takes_args = ['branch', 'file']
150
 
    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."),
151
76
                     Option('no-antialias',
152
 
                     help="Do not use rsvg to produce antialiased output"), 
153
 
                     Option('merge-branch', type=str, 
154
 
                     help="Use this branch to calcuate a merge base"), 
155
 
                     Option('cluster', help="Use clustered output.")]
156
 
    def run(self, branch, file, no_collapse=False, no_antialias=False,
157
 
        merge_branch=None, cluster=False):
 
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."),
 
80
                     Option('cluster', help="Use clustered output."),
 
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
158
94
        import graph
159
95
        if cluster:
160
96
            ranking = "cluster"
161
97
        else:
162
98
            ranking = "forced"
163
 
        graph.write_ancestry_file(branch, file, not no_collapse, 
164
 
                                  not no_antialias, merge_branch, ranking)
165
 
 
166
 
 
167
 
class cmd_fetch_ghosts(bzrlib.commands.Command):
 
99
        graph.write_ancestry_file(directory, file, not no_collapse,
 
100
                                  not no_antialias, merge_branch, ranking,
 
101
                                  max_distance=max_distance)
 
102
 
 
103
 
 
104
class cmd_fetch_ghosts(BzrToolsCommand):
168
105
    """Attempt to retrieve ghosts from another branch.
169
106
    If the other branch is not supplied, the last-pulled branch is used.
170
107
    """
171
108
    aliases = ['fetch-missing']
172
109
    takes_args = ['branch?']
173
 
    takes_options = [Option('no-fix')]
 
110
    takes_options = [Option('no-fix', help="Skip additional synchonization.")]
174
111
    def run(self, branch=None, no_fix=False):
175
112
        from fetch_ghosts import fetch_ghosts
176
 
        fetch_ghosts(branch, no_fix)
 
113
        fetch_ghosts(branch, do_reconcile=not no_fix)
177
114
 
178
115
strip_help="""Strip the smallest prefix containing num leading slashes  from \
179
116
each file name found in the patch file."""
180
 
Option.OPTIONS['bzrdiff'] = Option('bzrdiff',type=None,
181
 
                                help="""Handle extra bzr tags""")
182
 
 
183
 
 
184
 
class cmd_patch(bzrlib.commands.Command):
 
117
 
 
118
 
 
119
class cmd_patch(BzrToolsCommand):
185
120
    """Apply a named patch to the current tree.
186
121
    """
187
122
    takes_args = ['filename?']
188
 
    takes_options = [Option('strip', type=int, help=strip_help)]
189
 
    def run(self, filename=None, strip=-1, bzrdiff=0):
 
123
    takes_options = [Option('strip', type=int, short_name='p',
 
124
                            help=strip_help),
 
125
                     Option('silent', help='Suppress chatter.')]
 
126
    def run(self, filename=None, strip=None, silent=False):
190
127
        from patch import patch
191
128
        from bzrlib.workingtree import WorkingTree
192
129
        wt = WorkingTree.open_containing('.')[0]
193
 
        if strip == -1:
194
 
            if bzrdiff: strip = 0
195
 
            else:       strip = 0
196
 
 
197
 
        return patch(wt, filename, strip, legacy= not bzrdiff)
198
 
 
199
 
 
200
 
class cmd_shelve(bzrlib.commands.Command):
 
130
        if strip is None:
 
131
            strip = 0
 
132
        return patch(wt, filename, strip, silent)
 
133
 
 
134
 
 
135
class cmd_shelve1(BzrToolsCommand):
201
136
    """Temporarily set aside some changes from the current tree.
202
137
 
203
138
    Shelve allows you to temporarily put changes you've made "on the shelf",
204
139
    ie. out of the way, until a later time when you can bring them back from
205
 
    the shelf with the 'unshelve' command.
 
140
    the shelf with the 'unshelve1' command.
206
141
 
207
142
    Shelve is intended to help separate several sets of text changes that have
208
143
    been inappropriately mingled.  If you just want to get rid of all changes
209
144
    (text and otherwise) and you don't need to restore them later, use revert.
210
 
    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.
211
146
 
212
 
    By default shelve asks you what you want to shelve, press '?' at the
213
 
    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.
214
149
 
215
150
    If filenames are specified, only the changes to those files will be
216
151
    shelved, other files will be left untouched.
218
153
    If a revision is specified, changes since that revision will be shelved.
219
154
 
220
155
    You can put multiple items on the shelf. Normally each time you run
221
 
    unshelve the most recently shelved changes will be reinstated. However,
 
156
    unshelve1 the most recently shelved changes will be reinstated. However,
222
157
    you can also unshelve changes in a different order by explicitly
223
 
    specifiying which changes to unshelve. This works best when the changes
 
158
    specifiying which changes to unshelve1. This works best when the changes
224
159
    don't depend on each other.
225
160
 
226
161
    While you have patches on the shelf you can view and manipulate them with
227
 
    the 'shelf' command. Run 'bzr shelf -h' for more info.
 
162
    the 'shelf1' command. Run 'bzr shelf1 -h' for more info.
228
163
    """
229
164
 
230
165
    takes_args = ['file*']
231
 
    takes_options = ['message', 'revision',
232
 
            Option('all', help='Shelve all changes without prompting'), 
233
 
            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.')]
234
172
 
235
173
    def run(self, all=False, file_list=None, message=None, revision=None,
236
174
            no_color=False):
242
180
                                  "parameter.")
243
181
 
244
182
        source = BzrPatchSource(revision, file_list)
245
 
        s = Shelf(source.base)
 
183
        s = shelf.Shelf(source.base)
246
184
        s.shelve(source, all, message, no_color)
247
185
        return 0
248
186
 
249
187
 
250
 
# 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
251
189
# not to be registered directly with bzr.
252
190
 
253
191
class cmd_shelf_list(bzrlib.commands.Command):
270
208
    aliases = ['switch']
271
209
    takes_args = ['othershelf']
272
210
    def run(self, othershelf):
273
 
        s = Shelf(self.shelf.base, othershelf)
 
211
        s = shelf.Shelf(self.shelf.base, othershelf)
274
212
        s.make_default()
275
213
 
276
214
 
289
227
        self.shelf.upgrade()
290
228
 
291
229
 
292
 
class cmd_shelf(bzrlib.commands.Command):
293
 
    """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."""
294
232
    takes_args = ['subcommand', 'args*']
295
233
 
296
234
    subcommands = [cmd_shelf_list, cmd_shelf_delete, cmd_shelf_switch,
303
241
            args_list = []
304
242
        cmd = self._get_cmd_object(subcommand)
305
243
        source = BzrPatchSource()
306
 
        s = Shelf(source.base)
 
244
        s = shelf.Shelf(source.base)
307
245
        cmd.shelf = s
 
246
 
 
247
        if args_list is None:
 
248
            args_list = []
308
249
        return cmd.run_argv_aliases(args_list)
309
250
 
310
251
    def _get_cmd_object(self, cmd_name):
327
268
        cmd_obj = cmd_class()
328
269
        indent = 2 * ' '
329
270
 
330
 
        usage = command_usage(cmd_obj)
 
271
        usage = cmd_obj._usage()
331
272
        usage = usage.replace('bzr shelf-', '')
332
273
        text.append('%s%s\n' % (indent, usage))
333
274
 
352
293
        return text
353
294
 
354
295
 
355
 
class cmd_unshelve(bzrlib.commands.Command):
 
296
class cmd_unshelve1(BzrToolsCommand):
356
297
    """Restore shelved changes.
357
298
 
358
299
    By default the most recently shelved changes are restored. However if you
359
300
    specify a patch by name those changes will be restored instead.
360
301
 
361
 
    See 'shelve' for more information.
 
302
    See 'shelve1' for more information.
362
303
    """
363
304
    takes_options = [
364
 
            Option('all', help='Unshelve all changes without prompting'),
365
 
            Option('force', help='Force unshelving even if errors occur'),
366
 
            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.')
367
308
        ]
368
309
    takes_args = ['patch?']
369
310
    def run(self, patch=None, all=False, force=False, no_color=False):
370
311
        source = BzrPatchSource()
371
 
        s = Shelf(source.base)
 
312
        s = shelf.Shelf(source.base)
372
313
        s.unshelve(source, patch, all, force, no_color)
373
314
        return 0
374
315
 
375
316
 
376
 
class cmd_shell(bzrlib.commands.Command):
 
317
class cmd_shell(BzrToolsCommand):
377
318
    """Begin an interactive shell tailored for bzr.
378
319
    Bzr commands can be used without typing bzr first, and will be run natively
379
320
    when possible.  Tab completion is tailored for bzr.  The shell prompt shows
391
332
    --all        --help       --revision   --show-ids
392
333
    bzr bzrtools:287/> status --
393
334
    """
394
 
    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):
395
344
        import shell
396
 
        return shell.run_shell()
397
 
 
398
 
 
399
 
class cmd_branch_history(bzrlib.commands.Command):
 
345
        return shell.run_shell(directory)
 
346
 
 
347
 
 
348
class cmd_branch_history(BzrToolsCommand):
400
349
    """\
401
350
    Display the development history of a branch.
402
351
 
406
355
    """
407
356
    takes_args = ["branch?"]
408
357
    def run(self, branch=None):
409
 
        from branchhistory import branch_history 
 
358
        from branchhistory import branch_history
410
359
        return branch_history(branch)
411
360
 
412
361
 
413
 
class cmd_zap(bzrlib.commands.Command):
 
362
class cmd_zap(BzrToolsCommand):
414
363
    """\
415
364
    Remove a lightweight checkout, if it can be done safely.
416
365
 
420
369
 
421
370
    If --branch is specified, the branch will be deleted too, but only if the
422
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`
423
378
    """
424
 
    takes_options = [Option("branch", help="Remove associtated branch from"
425
 
                                           " 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)]
426
388
    takes_args = ["checkout"]
427
 
    def run(self, checkout, branch=False):
428
 
        from zap import zap
429
 
        return zap(checkout, remove_branch=branch)
430
 
 
431
 
 
432
 
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):
433
406
    """
434
407
    Create a new checkout, associated with a new repository branch.
435
 
    
436
 
    When you cbranch, bzr looks up the repository associated with your current
437
 
    directory in locations.conf.  It creates a new branch in that repository
438
 
    with the same name and relative path as the checkout you request.
439
 
 
440
 
    The locations.conf parameter is "cbranch_root".  So if you want 
441
 
    cbranch operations in /home/jrandom/bigproject to produce branches in 
442
 
    /home/jrandom/bigproject/repository, you'd add this:
443
 
 
444
 
    [/home/jrandom/bigproject]
445
 
    cbranch_root = /home/jrandom/bigproject/repository
446
 
 
447
 
    Note that if "/home/jrandom/bigproject/repository" isn't a repository,
448
 
    standalone branches will be produced.  Standalone branches will also
449
 
    be produced if the source branch is in 0.7 format (or earlier).
 
408
 
 
409
    When you cbranch, bzr looks up a target location in locations.conf, and
 
410
    creates the branch there.
 
411
 
 
412
    In your locations.conf, add the following lines:
 
413
    [/working_directory_root]
 
414
    cbranch_target = /branch_root
 
415
    cbranch_target:policy = appendpath
 
416
 
 
417
    This will mean that if you run "bzr cbranch foo/bar foo/baz" in the
 
418
    working directory root, the branch will be created in
 
419
    "/branch_root/foo/baz"
 
420
 
 
421
    NOTE: cbranch also supports "cbranch_root", but that behaviour is
 
422
    deprecated.
450
423
    """
451
 
    takes_options = [Option("lightweight", 
452
 
                            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.')]
453
432
    takes_args = ["source", "target?"]
454
 
    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):
455
435
        from cbranch import cbranch
456
 
        return cbranch(source, target, lightweight=lightweight, 
457
 
                       revision=revision)
458
 
 
459
 
 
460
 
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):
461
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
 
462
448
    takes_args = ["location?"]
463
449
    def run(self, location=None):
464
450
        from branches import branches
465
451
        return branches(location)
466
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))
467
463
 
468
 
class cmd_multi_pull(bzrlib.commands.Command):
 
464
class cmd_multi_pull(BzrToolsCommand):
469
465
    """Pull all the branches under a location, e.g. a repository.
470
 
    
 
466
 
471
467
    Both branches present in the directory and the branches of checkouts are
472
468
    pulled.
473
469
    """
474
470
    takes_args = ["location?"]
475
471
    def run(self, location=None):
476
 
        from bzrlib.branch import Branch
477
472
        from bzrlib.transport import get_transport
478
473
        from bzrtools import iter_branch_tree
479
474
        if location is None:
480
475
            location = '.'
481
476
        t = get_transport(location)
 
477
        possible_transports = []
482
478
        if not t.listable():
483
479
            print "Can't list this type of location."
484
480
            return 3
500
496
                relpath = base
501
497
            print "Pulling %s from %s" % (relpath, parent)
502
498
            try:
503
 
                pullable.pull(Branch.open(parent))
 
499
                branch_t = get_transport(parent, possible_transports)
 
500
                pullable.pull(Branch.open_from_transport(branch_t))
504
501
            except Exception, e:
505
502
                print e
506
503
 
507
504
 
508
 
class cmd_branch_mark(bzrlib.commands.Command):
509
 
    """
510
 
    Add, view or list branch markers <EXPERIMENTAL>
511
 
 
512
 
    To add a mark, do 'bzr branch-mark MARK'.
513
 
    To list marks, do 'bzr branch-mark' (this lists all marks for the branch's
514
 
    repository).
515
 
    To delete a mark, do 'bzr branch-mark --delete MARK'
516
 
 
517
 
    These marks can be used to track a branch's status.
518
 
    """
519
 
    takes_args = ['mark?', 'branch?']
520
 
    takes_options = [Option('delete', help='Delete this mark')]
521
 
    def run(self, mark=None, branch=None, delete=False):
522
 
        from branch_mark import branch_mark
523
 
        branch_mark(mark, branch, delete)
524
 
 
525
 
 
526
 
class cmd_import(bzrlib.commands.Command):
527
 
    """Import sources from a tarball
528
 
    
529
 
    This command will import a tarball into a bzr tree, replacing any versioned
530
 
    files already present.  If a directory is specified, it is used as the
531
 
    target.  If the directory does not exist, or is not versioned, it is
532
 
    created.
 
505
 
 
506
class cmd_import(BzrToolsCommand):
 
507
    """Import sources from a directory, tarball or zip file
 
508
 
 
509
    This command will import a directory, tarball or zip file into a bzr
 
510
    tree, replacing any versioned files already present.  If a directory is
 
511
    specified, it is used as the target.  If the directory does not exist, or
 
512
    is not versioned, it is created.
533
513
 
534
514
    Tarballs may be gzip or bzip2 compressed.  This is autodetected.
535
515
 
536
 
    If the tarball has a single root directory, that directory is stripped
537
 
    when extracting the tarball.
 
516
    If the tarball or zip has a single root directory, that directory is
 
517
    stripped when extracting the tarball.  This is not done for directories.
538
518
    """
539
 
    
 
519
 
540
520
    takes_args = ['source', 'tree?']
541
521
    def run(self, source, tree=None):
542
522
        from upstream_import import do_import
543
523
        do_import(source, tree)
544
524
 
545
525
 
546
 
class cmd_cdiff(bzrlib.commands.Command):
 
526
class cmd_cdiff(BzrToolsCommand):
547
527
    """A color version of bzr's diff"""
548
528
    takes_args = property(lambda x: get_cmd_object('diff').takes_args)
549
 
    takes_options = property(lambda x: get_cmd_object('diff').takes_options)
550
 
    def run(*args, **kwargs):
 
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',
 
538
            help='Warn if trailing whitespace or spurious changes have been'
 
539
                 ' added.')]
 
540
 
 
541
    def run(self, color='always', check_style=False, *args, **kwargs):
551
542
        from colordiff import colordiff
552
 
        colordiff(*args, **kwargs)
553
 
 
554
 
 
555
 
class cmd_baz_import(bzrlib.commands.Command):
556
 
    """Import an Arch or Baz archive into a bzr repository.
557
 
 
558
 
    This command should be used on local archives (or mirrors) only.  It is
559
 
    quite slow on remote archives.
560
 
    
561
 
    reuse_history allows you to specify any previous imports you 
562
 
    have done of different archives, which this archive has branches
563
 
    tagged from. This will dramatically reduce the time to convert 
564
 
    the archive as it will not have to convert the history already
565
 
    converted in that other branch.
566
 
 
567
 
    If you specify prefixes, only branches whose names start with that prefix
568
 
    will be imported.  Skipped branches will be listed, so you can import any
569
 
    branches you missed by accident.  Here's an example of doing a partial
570
 
    import from thelove@canonical.com:
571
 
    bzr baz-import thelove thelove@canonical.com --prefixes dists:talloc-except
572
 
    """
573
 
    takes_args = ['to_root_dir', 'from_archive', 'reuse_history*']
574
 
    takes_options = ['verbose', Option('prefixes', type=str,
575
 
                     help="Prefixes of branches to import, colon-separated")]
576
 
 
577
 
    def run(self, to_root_dir, from_archive, encoding=None, verbose=False,
578
 
            reuse_history_list=[], prefixes=None):
579
 
        from errors import NoPyBaz
580
 
        try:
581
 
            import baz_import
582
 
            baz_import.baz_import(to_root_dir, from_archive, encoding,
583
 
                                  verbose, reuse_history_list, prefixes)
584
 
        except NoPyBaz:
585
 
            print "This command is disabled.  Please install PyBaz."
586
 
 
587
 
 
588
 
class cmd_baz_import_branch(bzrlib.commands.Command):
589
 
    """Import an Arch or Baz branch into a bzr branch."""
590
 
    takes_args = ['to_location', 'from_branch?', 'reuse_history*']
591
 
    takes_options = ['verbose', Option('max-count', type=int)]
592
 
 
593
 
    def run(self, to_location, from_branch=None, fast=False, max_count=None,
594
 
            encoding=None, verbose=False, dry_run=False,
595
 
            reuse_history_list=[]):
596
 
        from errors import NoPyBaz
597
 
        try:
598
 
            import baz_import
599
 
            baz_import.baz_import_branch(to_location, from_branch, fast, 
600
 
                                         max_count, verbose, encoding, dry_run,
601
 
                                         reuse_history_list)
602
 
        except NoPyBaz:
603
 
            print "This command is disabled.  Please install PyBaz."
604
 
 
605
 
 
606
 
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):
607
566
    """Upload this branch to another location using rsync.
608
567
 
609
 
    If no location is specified, the last-used location will be used.  To 
610
 
    prevent dirty trees from being uploaded, rspush will error out if there are 
611
 
    unknown files or local changes.  It will also error out if the upstream 
612
 
    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.
613
572
    """
614
573
    takes_args = ['location?']
615
574
    takes_options = [Option('overwrite', help='Ignore differences between'
616
 
                            ' branches and overwrite unconditionally'),
 
575
                            ' branches and overwrite unconditionally.'),
617
576
                     Option('no-tree', help='Do not push the working tree,'
618
577
                            ' just the .bzr.')]
619
578
 
621
580
        from bzrlib import workingtree
622
581
        import bzrtools
623
582
        cur_branch = workingtree.WorkingTree.open_containing(".")[0]
624
 
        bzrtools.rspush(cur_branch, location, overwrite=overwrite, 
 
583
        bzrtools.rspush(cur_branch, location, overwrite=overwrite,
625
584
                      working_tree=not no_tree)
626
585
 
627
586
 
628
 
class cmd_switch(bzrlib.commands.Command):
629
 
    """Set the branch of a lightweight checkout and update."""
630
 
 
631
 
    takes_args = ['to_location']
632
 
 
633
 
    def run(self, to_location):
634
 
        from switch import cmd_switch
635
 
        cmd_switch().run(to_location)
636
 
 
637
 
 
638
 
commands = [
639
 
            cmd_baz_import,
640
 
            cmd_baz_import_branch,
641
 
            cmd_branches,
642
 
            cmd_branch_history,
643
 
            cmd_branch_mark,
644
 
            cmd_cbranch,  
645
 
            cmd_cdiff,
646
 
            cmd_clean_tree,
647
 
            cmd_fetch_ghosts,
648
 
            cmd_graph_ancestry,
649
 
            cmd_import,
650
 
            cmd_multi_pull,
651
 
            cmd_patch,
652
 
            cmd_rspush,
653
 
            cmd_shelf, 
654
 
            cmd_shell,
655
 
            cmd_shelve, 
656
 
            cmd_switch,
657
 
            cmd_unshelve, 
658
 
            cmd_zap,            
659
 
            ]
660
 
 
661
 
 
662
 
if hasattr(bzrlib.commands, 'register_command'):
663
 
    for command in commands:
664
 
        bzrlib.commands.register_command(command)
665
 
 
666
 
 
667
 
def test_suite():
668
 
    from bzrlib.tests.TestUtil import TestLoader
669
 
    import tests
670
 
    from doctest import DocTestSuite, ELLIPSIS
671
 
    from unittest import TestSuite
672
 
    import bzrtools
673
 
    import tests.clean_tree
674
 
    import upstream_import
675
 
    import zap
676
 
    import tests.blackbox
677
 
    import tests.shelf_tests
678
 
    result = TestSuite()
679
 
    result.addTest(DocTestSuite(bzrtools, optionflags=ELLIPSIS))
680
 
    result.addTest(tests.clean_tree.test_suite())
681
 
    try:
682
 
        import baz_import
683
 
        result.addTest(DocTestSuite(baz_import))
684
 
    except NoPyBaz:
685
 
        pass
686
 
    result.addTest(tests.test_suite())
687
 
    result.addTest(TestLoader().loadTestsFromModule(tests.shelf_tests))
688
 
    result.addTest(tests.blackbox.test_suite())
689
 
    result.addTest(upstream_import.test_suite())
690
 
    result.addTest(zap.test_suite())
691
 
    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, [])