← 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-04-27 00:06:36 UTC
  • Revision ID: aaron@aaronbentley.com-20110427000636-od4xzn1u465mqzfm
Fix long line.

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