← 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 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.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
 
21
from bzrlib.lazy_import import lazy_import
 
22
lazy_import(globals(), """
 
23
from bzrlib import help, urlutils
 
24
from bzrlib.plugins.bzrtools 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
 
import show_paths
82
 
 
83
 
bzrlib.ignores.add_runtime_ignores(['./.shelf'])
84
 
 
85
 
 
86
 
class cmd_clean_tree(bzrlib.commands.Command):
87
 
    """Remove unwanted files from working tree.
88
 
 
89
 
    By default, only unknown files, not ignored files, are deleted.  Versioned
90
 
    files are never deleted.
91
 
 
92
 
    Another class is 'detritus', which includes files emitted by bzr during
93
 
    normal operations and selftests.  (The value of these files decreases with
94
 
    time.)
95
 
 
96
 
    If no options are specified, unknown files are deleted.  Otherwise, option
97
 
    flags are respected, and may be combined.
98
 
 
99
 
    To check what clean-tree will do, use --dry-run.
100
 
    """
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'
107
 
                            ' deleting them.')]
108
 
    def run(self, unknown=False, ignored=False, detritus=False, dry_run=False):
109
 
        from clean_tree import clean_tree
110
 
        if not (unknown or ignored or detritus):
111
 
            unknown = True
112
 
        clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus, 
113
 
                   dry_run=dry_run)
114
 
 
115
 
 
116
 
class cmd_graph_ancestry(bzrlib.commands.Command):
 
36
from bzrlib.option import Option, RegistryOption
 
37
 
 
38
 
 
39
class cmd_graph_ancestry(BzrToolsCommand):
117
40
    """Produce ancestry graphs using dot.
118
 
    
 
41
 
119
42
    Output format is detected according to file extension.  Some of the more
120
43
    common output formats are html, png, gif, svg, ps.  An extension of '.dot'
121
44
    will cause a dot graph file to be produced.  HTML output has mouseovers
125
48
    with the last 5 characters of their revision identifier are used instead.
126
49
 
127
50
    The value starting with d is "(maximum) distance from the null revision".
128
 
    
 
51
 
129
52
    If --merge-branch is specified, the two branches are compared and a merge
130
53
    base is selected.
131
 
    
 
54
 
132
55
    Legend:
133
56
    white    normal revision
134
57
    yellow   THIS  history
148
71
    If available, rsvg is used to antialias PNG and JPEG output, but this can
149
72
    be disabled with --no-antialias.
150
73
    """
151
 
    takes_args = ['branch', 'file']
152
 
    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."),
153
76
                     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):
 
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
160
94
        import graph
161
95
        if cluster:
162
96
            ranking = "cluster"
163
97
        else:
164
98
            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):
 
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):
170
105
    """Attempt to retrieve ghosts from another branch.
171
106
    If the other branch is not supplied, the last-pulled branch is used.
172
107
    """
173
108
    aliases = ['fetch-missing']
174
109
    takes_args = ['branch?']
175
 
    takes_options = [Option('no-fix')]
 
110
    takes_options = [Option('no-fix', help="Skip additional synchonization.")]
176
111
    def run(self, branch=None, no_fix=False):
177
112
        from fetch_ghosts import fetch_ghosts
178
 
        fetch_ghosts(branch, no_fix)
 
113
        fetch_ghosts(branch, do_reconcile=not no_fix)
179
114
 
180
115
strip_help="""Strip the smallest prefix containing num leading slashes  from \
181
116
each file name found in the patch file."""
182
117
 
183
118
 
184
 
class cmd_patch(bzrlib.commands.Command):
 
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=None):
 
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
130
        if strip is None:
194
131
            strip = 0
195
 
        return patch(wt, filename, strip)
196
 
 
197
 
 
198
 
class cmd_shelve(bzrlib.commands.Command):
 
132
        return patch(wt, filename, strip, silent)
 
133
 
 
134
 
 
135
class cmd_shelve1(BzrToolsCommand):
199
136
    """Temporarily set aside some changes from the current tree.
200
137
 
201
138
    Shelve allows you to temporarily put changes you've made "on the shelf",
202
139
    ie. out of the way, until a later time when you can bring them back from
203
 
    the shelf with the 'unshelve' command.
 
140
    the shelf with the 'unshelve1' command.
204
141
 
205
142
    Shelve is intended to help separate several sets of text changes that have
206
143
    been inappropriately mingled.  If you just want to get rid of all changes
207
144
    (text and otherwise) and you don't need to restore them later, use revert.
208
 
    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.
209
146
 
210
 
    By default shelve asks you what you want to shelve, press '?' at the
211
 
    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.
212
149
 
213
150
    If filenames are specified, only the changes to those files will be
214
151
    shelved, other files will be left untouched.
216
153
    If a revision is specified, changes since that revision will be shelved.
217
154
 
218
155
    You can put multiple items on the shelf. Normally each time you run
219
 
    unshelve the most recently shelved changes will be reinstated. However,
 
156
    unshelve1 the most recently shelved changes will be reinstated. However,
220
157
    you can also unshelve changes in a different order by explicitly
221
 
    specifiying which changes to unshelve. This works best when the changes
 
158
    specifiying which changes to unshelve1. This works best when the changes
222
159
    don't depend on each other.
223
160
 
224
161
    While you have patches on the shelf you can view and manipulate them with
225
 
    the 'shelf' command. Run 'bzr shelf -h' for more info.
 
162
    the 'shelf1' command. Run 'bzr shelf1 -h' for more info.
226
163
    """
227
164
 
228
165
    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')]
 
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.')]
232
172
 
233
173
    def run(self, all=False, file_list=None, message=None, revision=None,
234
174
            no_color=False):
240
180
                                  "parameter.")
241
181
 
242
182
        source = BzrPatchSource(revision, file_list)
243
 
        s = Shelf(source.base)
 
183
        s = shelf.Shelf(source.base)
244
184
        s.shelve(source, all, message, no_color)
245
185
        return 0
246
186
 
247
187
 
248
 
# 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
249
189
# not to be registered directly with bzr.
250
190
 
251
191
class cmd_shelf_list(bzrlib.commands.Command):
268
208
    aliases = ['switch']
269
209
    takes_args = ['othershelf']
270
210
    def run(self, othershelf):
271
 
        s = Shelf(self.shelf.base, othershelf)
 
211
        s = shelf.Shelf(self.shelf.base, othershelf)
272
212
        s.make_default()
273
213
 
274
214
 
287
227
        self.shelf.upgrade()
288
228
 
289
229
 
290
 
class cmd_shelf(bzrlib.commands.Command):
291
 
    """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."""
292
232
    takes_args = ['subcommand', 'args*']
293
233
 
294
234
    subcommands = [cmd_shelf_list, cmd_shelf_delete, cmd_shelf_switch,
301
241
            args_list = []
302
242
        cmd = self._get_cmd_object(subcommand)
303
243
        source = BzrPatchSource()
304
 
        s = Shelf(source.base)
 
244
        s = shelf.Shelf(source.base)
305
245
        cmd.shelf = s
 
246
 
 
247
        if args_list is None:
 
248
            args_list = []
306
249
        return cmd.run_argv_aliases(args_list)
307
250
 
308
251
    def _get_cmd_object(self, cmd_name):
325
268
        cmd_obj = cmd_class()
326
269
        indent = 2 * ' '
327
270
 
328
 
        usage = command_usage(cmd_obj)
 
271
        usage = cmd_obj._usage()
329
272
        usage = usage.replace('bzr shelf-', '')
330
273
        text.append('%s%s\n' % (indent, usage))
331
274
 
350
293
        return text
351
294
 
352
295
 
353
 
class cmd_unshelve(bzrlib.commands.Command):
 
296
class cmd_unshelve1(BzrToolsCommand):
354
297
    """Restore shelved changes.
355
298
 
356
299
    By default the most recently shelved changes are restored. However if you
357
300
    specify a patch by name those changes will be restored instead.
358
301
 
359
 
    See 'shelve' for more information.
 
302
    See 'shelve1' for more information.
360
303
    """
361
304
    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')
 
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.')
365
308
        ]
366
309
    takes_args = ['patch?']
367
310
    def run(self, patch=None, all=False, force=False, no_color=False):
368
311
        source = BzrPatchSource()
369
 
        s = Shelf(source.base)
 
312
        s = shelf.Shelf(source.base)
370
313
        s.unshelve(source, patch, all, force, no_color)
371
314
        return 0
372
315
 
373
316
 
374
 
class cmd_shell(bzrlib.commands.Command):
 
317
class cmd_shell(BzrToolsCommand):
375
318
    """Begin an interactive shell tailored for bzr.
376
319
    Bzr commands can be used without typing bzr first, and will be run natively
377
320
    when possible.  Tab completion is tailored for bzr.  The shell prompt shows
389
332
    --all        --help       --revision   --show-ids
390
333
    bzr bzrtools:287/> status --
391
334
    """
392
 
    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):
393
344
        import shell
394
 
        return shell.run_shell()
395
 
 
396
 
 
397
 
class cmd_branch_history(bzrlib.commands.Command):
 
345
        return shell.run_shell(directory)
 
346
 
 
347
 
 
348
class cmd_branch_history(BzrToolsCommand):
398
349
    """\
399
350
    Display the development history of a branch.
400
351
 
404
355
    """
405
356
    takes_args = ["branch?"]
406
357
    def run(self, branch=None):
407
 
        from branchhistory import branch_history 
 
358
        from branchhistory import branch_history
408
359
        return branch_history(branch)
409
360
 
410
361
 
411
 
class cmd_zap(bzrlib.commands.Command):
 
362
class cmd_zap(BzrToolsCommand):
412
363
    """\
413
364
    Remove a lightweight checkout, if it can be done safely.
414
365
 
418
369
 
419
370
    If --branch is specified, the branch will be deleted too, but only if the
420
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`
421
378
    """
422
 
    takes_options = [Option("branch", help="Remove associtated branch from"
423
 
                                           " 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)]
424
388
    takes_args = ["checkout"]
425
 
    def run(self, checkout, branch=False):
426
 
        from zap import zap
427
 
        return zap(checkout, remove_branch=branch)
428
 
 
429
 
 
430
 
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):
431
406
    """
432
407
    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).
 
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.
448
423
    """
449
 
    takes_options = [Option("lightweight", 
450
 
                            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.')]
451
432
    takes_args = ["source", "target?"]
452
 
    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):
453
435
        from cbranch import cbranch
454
 
        return cbranch(source, target, lightweight=lightweight, 
455
 
                       revision=revision)
456
 
 
457
 
 
458
 
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):
459
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
 
460
448
    takes_args = ["location?"]
461
449
    def run(self, location=None):
462
450
        from branches import branches
463
451
        return branches(location)
464
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))
465
463
 
466
 
class cmd_multi_pull(bzrlib.commands.Command):
 
464
class cmd_multi_pull(BzrToolsCommand):
467
465
    """Pull all the branches under a location, e.g. a repository.
468
 
    
 
466
 
469
467
    Both branches present in the directory and the branches of checkouts are
470
468
    pulled.
471
469
    """
472
470
    takes_args = ["location?"]
473
471
    def run(self, location=None):
474
 
        from bzrlib.branch import Branch
475
472
        from bzrlib.transport import get_transport
476
473
        from bzrtools import iter_branch_tree
477
474
        if location is None:
478
475
            location = '.'
479
476
        t = get_transport(location)
 
477
        possible_transports = []
480
478
        if not t.listable():
481
479
            print "Can't list this type of location."
482
480
            return 3
498
496
                relpath = base
499
497
            print "Pulling %s from %s" % (relpath, parent)
500
498
            try:
501
 
                pullable.pull(Branch.open(parent))
 
499
                branch_t = get_transport(parent, possible_transports)
 
500
                pullable.pull(Branch.open_from_transport(branch_t))
502
501
            except Exception, e:
503
502
                print e
504
503
 
505
504
 
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.
 
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.
531
513
 
532
514
    Tarballs may be gzip or bzip2 compressed.  This is autodetected.
533
515
 
534
 
    If the tarball has a single root directory, that directory is stripped
535
 
    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.
536
518
    """
537
 
    
 
519
 
538
520
    takes_args = ['source', 'tree?']
539
521
    def run(self, source, tree=None):
540
522
        from upstream_import import do_import
541
523
        do_import(source, tree)
542
524
 
543
525
 
544
 
class cmd_cdiff(bzrlib.commands.Command):
 
526
class cmd_cdiff(BzrToolsCommand):
545
527
    """A color version of bzr's diff"""
546
528
    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):
 
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):
549
542
        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):
 
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):
624
566
    """Upload this branch to another location using rsync.
625
567
 
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. 
 
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.
630
572
    """
631
573
    takes_args = ['location?']
632
574
    takes_options = [Option('overwrite', help='Ignore differences between'
633
 
                            ' branches and overwrite unconditionally'),
 
575
                            ' branches and overwrite unconditionally.'),
634
576
                     Option('no-tree', help='Do not push the working tree,'
635
577
                            ' just the .bzr.')]
636
578
 
638
580
        from bzrlib import workingtree
639
581
        import bzrtools
640
582
        cur_branch = workingtree.WorkingTree.open_containing(".")[0]
641
 
        bzrtools.rspush(cur_branch, location, overwrite=overwrite, 
 
583
        bzrtools.rspush(cur_branch, location, overwrite=overwrite,
642
584
                      working_tree=not no_tree)
643
585
 
644
586
 
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
 
 
655
 
commands = [
656
 
            cmd_baz_import,
657
 
            cmd_baz_import_branch,
658
 
            cmd_branches,
659
 
            cmd_branch_history,
660
 
            cmd_branch_mark,
661
 
            cmd_cbranch,  
662
 
            cmd_cdiff,
663
 
            cmd_clean_tree,
664
 
            cmd_fetch_ghosts,
665
 
            cmd_graph_ancestry,
666
 
            cmd_import,
667
 
            cmd_multi_pull,
668
 
            cmd_patch,
669
 
            cmd_rspush,
670
 
            cmd_shelf, 
671
 
            cmd_shell,
672
 
            cmd_shelve, 
673
 
            cmd_switch,
674
 
            cmd_unshelve, 
675
 
            cmd_zap,            
676
 
            ]
677
 
 
678
 
 
679
 
if hasattr(bzrlib.commands, 'register_command'):
680
 
    for command in commands:
681
 
        bzrlib.commands.register_command(command)
682
 
 
683
 
 
684
 
def test_suite():
685
 
    from bzrlib.tests.TestUtil import TestLoader
686
 
    import tests
687
 
    from doctest import DocTestSuite, ELLIPSIS
688
 
    from unittest import TestSuite
689
 
    import bzrtools
690
 
    import tests.clean_tree
691
 
    import upstream_import
692
 
    import zap
693
 
    import tests.blackbox
694
 
    import tests.shelf_tests
695
 
    result = TestSuite()
696
 
    result.addTest(DocTestSuite(bzrtools, optionflags=ELLIPSIS))
697
 
    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
 
    result.addTest(tests.test_suite())
704
 
    result.addTest(TestLoader().loadTestsFromModule(tests.shelf_tests))
705
 
    result.addTest(tests.blackbox.test_suite())
706
 
    result.addTest(upstream_import.test_suite())
707
 
    result.addTest(zap.test_suite())
708
 
    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, [])