← 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: 2014-01-13 00:50:22 UTC
  • Revision ID: aaron@aaronbentley.com-20140113005022-q40nvybtox1mt19o
Tags: release-2.6.0
Update for release 2.6.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
command_classes.py
1
 
"""\
2
 
Various useful plugins for working with bzr.
3
 
"""
 
1
# Copyright (C) 2005, 2006, 2007, 2011 Aaron Bentley <aaron@aaronbentley.com>
 
2
# Copyright (C) 2005, 2006, 2011 Canonical Limited.
 
3
# Copyright (C) 2006 Michael Ellerman.
 
4
#
 
5
#    This program is free software; you can redistribute it and/or modify
 
6
#    it under the terms of the GNU General Public License as published by
 
7
#    the Free Software Foundation; either version 2 of the License, or
 
8
#    (at your option) any later version.
 
9
#
 
10
#    This program is distributed in the hope that it will be useful,
 
11
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
#    GNU General Public License for more details.
 
14
#
 
15
#    You should have received a copy of the GNU General Public License
 
16
#    along with this program; if not, write to the Free Software
 
17
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
4
18
 
5
19
import bzrlib
6
20
 
7
 
 
8
 
__version__ = '0.11.0'
9
 
 
10
 
 
11
 
version_info = tuple(int(n) for n in __version__.split('.'))
12
 
 
13
 
 
14
 
def check_bzrlib_version(desired):
15
 
    """Check that bzrlib is compatible.
16
 
 
17
 
    If version is < bzrtools version, assume incompatible.
18
 
    If version == bzrtools version, assume completely compatible
19
 
    If version == bzrtools version + 1, assume compatible, with deprecations
20
 
    Otherwise, assume incompatible.
21
 
    """
22
 
    desired_plus = (desired[0], desired[1]+1)
23
 
    bzrlib_version = bzrlib.version_info[:2]
24
 
    if bzrlib_version == desired:
25
 
        return
26
 
    try:
27
 
        from bzrlib.trace import warning
28
 
    except ImportError:
29
 
        # get the message out any way we can
30
 
        from warnings import warn as warning
31
 
    if bzrlib_version < desired:
32
 
        warning('Installed bzr version %s is too old to be used with bzrtools'
33
 
                ' %s.' % (bzrlib.__version__, __version__))
34
 
        # Not using BzrNewError, because it may not exist.
35
 
        raise Exception, 'Version mismatch', version_info
36
 
    else:
37
 
        warning('Bzrtools is not up to date with installed bzr version %s.'
38
 
                ' \nThere should be a newer version available, e.g. %i.%i.' 
39
 
                % (bzrlib.__version__, bzrlib_version[0], bzrlib_version[1]))
40
 
        if bzrlib_version != desired_plus:
41
 
            raise Exception, 'Version mismatch'
42
 
 
43
 
 
44
 
check_bzrlib_version(version_info[:2])
45
 
 
46
 
 
47
 
import rspush
 
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
48
29
from errors import CommandError
49
30
from patchsource import BzrPatchSource
50
 
from shelf import Shelf
51
 
from switch import cmd_switch
52
 
import sys
53
 
import os.path
54
31
 
55
 
import bzrlib.builtins
56
 
import bzrlib.branch
57
32
import bzrlib.commands
 
33
from bzrlib.branch import Branch
58
34
from bzrlib.commands import get_cmd_object
59
35
from bzrlib.errors import BzrCommandError
60
 
from bzrlib.help import command_usage
61
 
import bzrlib.ignores
62
 
from bzrlib.option import Option
63
 
sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__), 
64
 
                                                 "external")))
65
 
 
66
 
bzrlib.ignores.add_runtime_ignores(['./.shelf'])
67
 
 
68
 
 
69
 
class cmd_clean_tree(bzrlib.commands.Command):
70
 
    """Remove unwanted files from working tree.
71
 
 
72
 
    By default, only unknown files, not ignored files, are deleted.  Versioned
73
 
    files are never deleted.
74
 
 
75
 
    Another class is 'detritus', which includes files emitted by bzr during
76
 
    normal operations and selftests.  (The value of these files decreases with
77
 
    time.)
78
 
 
79
 
    If no options are specified, unknown files are deleted.  Otherwise, option
80
 
    flags are respected, and may be combined.
81
 
 
82
 
    To check what clean-tree will do, use --dry-run.
83
 
    """
84
 
    takes_options = [Option('ignored', help='delete all ignored files.'), 
85
 
                     Option('detritus', help='delete conflict files, merge'
86
 
                            ' backups, and failed selftest dirs.'), 
87
 
                     Option('unknown', 
88
 
                            help='delete files unknown to bzr.  (default)'),
89
 
                     Option('dry-run', help='show files to delete instead of'
90
 
                            ' deleting them.')]
91
 
    def run(self, unknown=False, ignored=False, detritus=False, dry_run=False):
92
 
        from clean_tree import clean_tree
93
 
        if not (unknown or ignored or detritus):
94
 
            unknown = True
95
 
        clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus, 
96
 
                   dry_run=dry_run)
97
 
 
98
 
class cmd_graph_ancestry(bzrlib.commands.Command):
 
36
from bzrlib.option import Option, RegistryOption
 
37
 
 
38
 
 
39
class cmd_graph_ancestry(BzrToolsCommand):
99
40
    """Produce ancestry graphs using dot.
100
 
    
 
41
 
101
42
    Output format is detected according to file extension.  Some of the more
102
43
    common output formats are html, png, gif, svg, ps.  An extension of '.dot'
103
44
    will cause a dot graph file to be produced.  HTML output has mouseovers
107
48
    with the last 5 characters of their revision identifier are used instead.
108
49
 
109
50
    The value starting with d is "(maximum) distance from the null revision".
110
 
    
 
51
 
111
52
    If --merge-branch is specified, the two branches are compared and a merge
112
53
    base is selected.
113
 
    
 
54
 
114
55
    Legend:
115
56
    white    normal revision
116
57
    yellow   THIS  history
130
71
    If available, rsvg is used to antialias PNG and JPEG output, but this can
131
72
    be disabled with --no-antialias.
132
73
    """
133
 
    takes_args = ['branch', 'file']
134
 
    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."),
135
76
                     Option('no-antialias',
136
 
                     help="Do not use rsvg to produce antialiased output"), 
137
 
                     Option('merge-branch', type=str, 
138
 
                     help="Use this branch to calcuate a merge base"), 
139
 
                     Option('cluster', help="Use clustered output.")]
140
 
    def run(self, branch, file, no_collapse=False, no_antialias=False,
141
 
        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
142
94
        import graph
143
95
        if cluster:
144
96
            ranking = "cluster"
145
97
        else:
146
98
            ranking = "forced"
147
 
        graph.write_ancestry_file(branch, file, not no_collapse, 
148
 
                                  not no_antialias, merge_branch, ranking)
149
 
 
150
 
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):
151
105
    """Attempt to retrieve ghosts from another branch.
152
106
    If the other branch is not supplied, the last-pulled branch is used.
153
107
    """
154
108
    aliases = ['fetch-missing']
155
109
    takes_args = ['branch?']
156
 
    takes_options = [Option('no-fix')]
 
110
    takes_options = [Option('no-fix', help="Skip additional synchonization.")]
157
111
    def run(self, branch=None, no_fix=False):
158
112
        from fetch_ghosts import fetch_ghosts
159
 
        fetch_ghosts(branch, no_fix)
 
113
        fetch_ghosts(branch, do_reconcile=not no_fix)
160
114
 
161
115
strip_help="""Strip the smallest prefix containing num leading slashes  from \
162
116
each file name found in the patch file."""
163
 
Option.OPTIONS['bzrdiff'] = Option('bzrdiff',type=None,
164
 
                                help="""Handle extra bzr tags""")
165
 
class cmd_patch(bzrlib.commands.Command):
 
117
 
 
118
 
 
119
class cmd_patch(BzrToolsCommand):
166
120
    """Apply a named patch to the current tree.
167
121
    """
168
122
    takes_args = ['filename?']
169
 
    takes_options = [Option('strip', type=int, help=strip_help)]
170
 
    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):
171
127
        from patch import patch
172
128
        from bzrlib.workingtree import WorkingTree
173
129
        wt = WorkingTree.open_containing('.')[0]
174
 
        if strip == -1:
175
 
            if bzrdiff: strip = 0
176
 
            else:       strip = 0
177
 
 
178
 
        return patch(wt, filename, strip, legacy= not bzrdiff)
179
 
 
180
 
 
181
 
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):
182
136
    """Temporarily set aside some changes from the current tree.
183
137
 
184
138
    Shelve allows you to temporarily put changes you've made "on the shelf",
185
139
    ie. out of the way, until a later time when you can bring them back from
186
 
    the shelf with the 'unshelve' command.
 
140
    the shelf with the 'unshelve1' command.
187
141
 
188
142
    Shelve is intended to help separate several sets of text changes that have
189
143
    been inappropriately mingled.  If you just want to get rid of all changes
190
144
    (text and otherwise) and you don't need to restore them later, use revert.
191
 
    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.
192
146
 
193
 
    By default shelve asks you what you want to shelve, press '?' at the
194
 
    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.
195
149
 
196
150
    If filenames are specified, only the changes to those files will be
197
151
    shelved, other files will be left untouched.
199
153
    If a revision is specified, changes since that revision will be shelved.
200
154
 
201
155
    You can put multiple items on the shelf. Normally each time you run
202
 
    unshelve the most recently shelved changes will be reinstated. However,
 
156
    unshelve1 the most recently shelved changes will be reinstated. However,
203
157
    you can also unshelve changes in a different order by explicitly
204
 
    specifiying which changes to unshelve. This works best when the changes
 
158
    specifiying which changes to unshelve1. This works best when the changes
205
159
    don't depend on each other.
206
160
 
207
161
    While you have patches on the shelf you can view and manipulate them with
208
 
    the 'shelf' command. Run 'bzr shelf -h' for more info.
 
162
    the 'shelf1' command. Run 'bzr shelf1 -h' for more info.
209
163
    """
210
164
 
211
165
    takes_args = ['file*']
212
 
    takes_options = ['message', 'revision',
213
 
            Option('all', help='Shelve all changes without prompting'), 
214
 
            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.')]
215
172
 
216
173
    def run(self, all=False, file_list=None, message=None, revision=None,
217
174
            no_color=False):
223
180
                                  "parameter.")
224
181
 
225
182
        source = BzrPatchSource(revision, file_list)
226
 
        s = Shelf(source.base)
 
183
        s = shelf.Shelf(source.base)
227
184
        s.shelve(source, all, message, no_color)
228
185
        return 0
229
186
 
230
187
 
231
 
# 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
232
189
# not to be registered directly with bzr.
233
190
 
234
191
class cmd_shelf_list(bzrlib.commands.Command):
251
208
    aliases = ['switch']
252
209
    takes_args = ['othershelf']
253
210
    def run(self, othershelf):
254
 
        s = Shelf(self.shelf.base, othershelf)
 
211
        s = shelf.Shelf(self.shelf.base, othershelf)
255
212
        s.make_default()
256
213
 
257
214
 
270
227
        self.shelf.upgrade()
271
228
 
272
229
 
273
 
class cmd_shelf(bzrlib.commands.Command):
274
 
    """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."""
275
232
    takes_args = ['subcommand', 'args*']
276
233
 
277
234
    subcommands = [cmd_shelf_list, cmd_shelf_delete, cmd_shelf_switch,
280
237
    def run(self, subcommand, args_list):
281
238
        import sys
282
239
 
 
240
        if args_list is None:
 
241
            args_list = []
283
242
        cmd = self._get_cmd_object(subcommand)
284
243
        source = BzrPatchSource()
285
 
        s = Shelf(source.base)
 
244
        s = shelf.Shelf(source.base)
286
245
        cmd.shelf = s
 
246
 
 
247
        if args_list is None:
 
248
            args_list = []
287
249
        return cmd.run_argv_aliases(args_list)
288
250
 
289
251
    def _get_cmd_object(self, cmd_name):
306
268
        cmd_obj = cmd_class()
307
269
        indent = 2 * ' '
308
270
 
309
 
        usage = command_usage(cmd_obj)
 
271
        usage = cmd_obj._usage()
310
272
        usage = usage.replace('bzr shelf-', '')
311
273
        text.append('%s%s\n' % (indent, usage))
312
274
 
331
293
        return text
332
294
 
333
295
 
334
 
 
335
 
class cmd_unshelve(bzrlib.commands.Command):
 
296
class cmd_unshelve1(BzrToolsCommand):
336
297
    """Restore shelved changes.
337
298
 
338
299
    By default the most recently shelved changes are restored. However if you
339
300
    specify a patch by name those changes will be restored instead.
340
301
 
341
 
    See 'shelve' for more information.
 
302
    See 'shelve1' for more information.
342
303
    """
343
304
    takes_options = [
344
 
            Option('all', help='Unshelve all changes without prompting'),
345
 
            Option('force', help='Force unshelving even if errors occur'),
346
 
            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.')
347
308
        ]
348
309
    takes_args = ['patch?']
349
310
    def run(self, patch=None, all=False, force=False, no_color=False):
350
311
        source = BzrPatchSource()
351
 
        s = Shelf(source.base)
 
312
        s = shelf.Shelf(source.base)
352
313
        s.unshelve(source, patch, all, force, no_color)
353
314
        return 0
354
315
 
355
316
 
356
 
class cmd_shell(bzrlib.commands.Command):
 
317
class cmd_shell(BzrToolsCommand):
357
318
    """Begin an interactive shell tailored for bzr.
358
319
    Bzr commands can be used without typing bzr first, and will be run natively
359
320
    when possible.  Tab completion is tailored for bzr.  The shell prompt shows
371
332
    --all        --help       --revision   --show-ids
372
333
    bzr bzrtools:287/> status --
373
334
    """
374
 
    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):
375
344
        import shell
376
 
        return shell.run_shell()
377
 
 
378
 
class cmd_branch_history(bzrlib.commands.Command):
 
345
        return shell.run_shell(directory)
 
346
 
 
347
 
 
348
class cmd_branch_history(BzrToolsCommand):
379
349
    """\
380
350
    Display the development history of a branch.
381
351
 
385
355
    """
386
356
    takes_args = ["branch?"]
387
357
    def run(self, branch=None):
388
 
        from branchhistory import branch_history 
 
358
        from branchhistory import branch_history
389
359
        return branch_history(branch)
390
360
 
391
361
 
392
 
class cmd_zap(bzrlib.commands.Command):
 
362
class cmd_zap(BzrToolsCommand):
393
363
    """\
394
364
    Remove a lightweight checkout, if it can be done safely.
395
365
 
399
369
 
400
370
    If --branch is specified, the branch will be deleted too, but only if the
401
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`
402
378
    """
403
 
    takes_options = [Option("branch", help="Remove associtated branch from"
404
 
                                           " 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)]
405
388
    takes_args = ["checkout"]
406
 
    def run(self, checkout, branch=False):
407
 
        from zap import zap
408
 
        return zap(checkout, remove_branch=branch)
409
 
 
410
 
 
411
 
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):
412
406
    """
413
407
    Create a new checkout, associated with a new repository branch.
414
 
    
415
 
    When you cbranch, bzr looks up the repository associated with your current
416
 
    directory in branches.conf.  It creates a new branch in that repository
417
 
    with the same name and relative path as the checkout you request.
418
 
 
419
 
    The branches.conf parameter is "cbranch_root".  So if you want 
420
 
    cbranch operations in /home/jrandom/bigproject to produce branches in 
421
 
    /home/jrandom/bigproject/repository, you'd add this:
422
 
 
423
 
    [/home/jrandom/bigproject]
424
 
    cbranch_root = /home/jrandom/bigproject/repository
425
 
 
426
 
    Note that if "/home/jrandom/bigproject/repository" isn't a repository,
427
 
    standalone branches will be produced.  Standalone branches will also
428
 
    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.
429
423
    """
430
 
    takes_options = [Option("lightweight", 
431
 
                            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.')]
432
432
    takes_args = ["source", "target?"]
433
 
    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):
434
435
        from cbranch import cbranch
435
 
        return cbranch(source, target, lightweight=lightweight, 
436
 
                       revision=revision)
437
 
 
438
 
 
439
 
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):
440
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
 
441
448
    takes_args = ["location?"]
442
449
    def run(self, location=None):
443
450
        from branches import branches
444
451
        return branches(location)
445
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))
446
463
 
447
 
class cmd_multi_pull(bzrlib.commands.Command):
 
464
class cmd_multi_pull(BzrToolsCommand):
448
465
    """Pull all the branches under a location, e.g. a repository.
449
 
    
 
466
 
450
467
    Both branches present in the directory and the branches of checkouts are
451
468
    pulled.
452
469
    """
453
470
    takes_args = ["location?"]
454
471
    def run(self, location=None):
455
 
        from bzrlib.branch import Branch
456
472
        from bzrlib.transport import get_transport
457
473
        from bzrtools import iter_branch_tree
458
474
        if location is None:
459
475
            location = '.'
460
476
        t = get_transport(location)
 
477
        possible_transports = []
461
478
        if not t.listable():
462
479
            print "Can't list this type of location."
463
480
            return 3
479
496
                relpath = base
480
497
            print "Pulling %s from %s" % (relpath, parent)
481
498
            try:
482
 
                pullable.pull(Branch.open(parent))
 
499
                branch_t = get_transport(parent, possible_transports)
 
500
                pullable.pull(Branch.open_from_transport(branch_t))
483
501
            except Exception, e:
484
502
                print e
485
503
 
486
504
 
487
 
class cmd_branch_mark(bzrlib.commands.Command):
488
 
    """
489
 
    Add, view or list branch markers <EXPERIMENTAL>
490
 
 
491
 
    To add a mark, do 'bzr branch-mark MARK'.
492
 
    To list marks, do 'bzr branch-mark' (this lists all marks for the branch's
493
 
    repository).
494
 
    To delete a mark, do 'bzr branch-mark --delete MARK'
495
 
 
496
 
    These marks can be used to track a branch's status.
497
 
    """
498
 
    takes_args = ['mark?', 'branch?']
499
 
    takes_options = [Option('delete', help='Delete this mark')]
500
 
    def run(self, mark=None, branch=None, delete=False):
501
 
        from branch_mark import branch_mark
502
 
        branch_mark(mark, branch, delete)
503
 
 
504
 
class cmd_import(bzrlib.commands.Command):
505
 
    """Import sources from a tarball
506
 
    
507
 
    This command will import a tarball into a bzr tree, replacing any versioned
508
 
    files already present.  If a directory is specified, it is used as the
509
 
    target.  If the directory does not exist, or is not versioned, it is
510
 
    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.
511
513
 
512
514
    Tarballs may be gzip or bzip2 compressed.  This is autodetected.
513
515
 
514
 
    If the tarball has a single root directory, that directory is stripped
515
 
    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.
516
518
    """
517
 
    
 
519
 
518
520
    takes_args = ['source', 'tree?']
519
521
    def run(self, source, tree=None):
520
522
        from upstream_import import do_import
521
523
        do_import(source, tree)
522
524
 
523
 
class cmd_shove(bzrlib.commands.Command):
524
 
    """Apply uncommitted changes to another tree
525
 
    
526
 
    This is useful when you start to make changes in one tree, then realize
527
 
    they should really be done in a different tree.
528
 
 
529
 
    Shove is implemented using merge, so:
530
 
     - All changes, including renames and adds, will be applied.
531
 
     - No changes that have already been applied will be applied.
532
 
     - If the target is significantly different from the source, conflicts may
533
 
       be produced.
534
 
    """
535
 
 
536
 
    takes_args = ['target', 'source?']
537
 
    def run(self, target, source='.'):
538
 
        from shove import do_shove
539
 
        do_shove(source, target)
540
 
 
541
 
class cmd_cdiff(bzrlib.commands.Command):
 
525
 
 
526
class cmd_cdiff(BzrToolsCommand):
542
527
    """A color version of bzr's diff"""
543
528
    takes_args = property(lambda x: get_cmd_object('diff').takes_args)
544
 
    takes_options = property(lambda x: get_cmd_object('diff').takes_options)
545
 
    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):
546
542
        from colordiff import colordiff
547
 
        colordiff(*args, **kwargs)
548
 
 
549
 
 
550
 
class cmd_baz_import(bzrlib.commands.Command):
551
 
    """Import an Arch or Baz archive into a bzr repository.
552
 
 
553
 
    This command should be used on local archives (or mirrors) only.  It is
554
 
    quite slow on remote archives.
555
 
    
556
 
    reuse_history allows you to specify any previous imports you 
557
 
    have done of different archives, which this archive has branches
558
 
    tagged from. This will dramatically reduce the time to convert 
559
 
    the archive as it will not have to convert the history already
560
 
    converted in that other branch.
561
 
 
562
 
    If you specify prefixes, only branches whose names start with that prefix
563
 
    will be imported.  Skipped branches will be listed, so you can import any
564
 
    branches you missed by accident.  Here's an example of doing a partial
565
 
    import from thelove@canonical.com:
566
 
    bzr baz-import thelove thelove@canonical.com --prefixes dists:talloc-except
567
 
    """
568
 
    takes_args = ['to_root_dir', 'from_archive', 'reuse_history*']
569
 
    takes_options = ['verbose', Option('prefixes', type=str,
570
 
                     help="Prefixes of branches to import, colon-separated")]
571
 
 
572
 
    def run(self, to_root_dir, from_archive, verbose=False,
573
 
            reuse_history_list=[], prefixes=None):
574
 
        from errors import NoPyBaz
575
 
        try:
576
 
            import baz_import
577
 
            baz_import.baz_import(to_root_dir, from_archive,
578
 
                                  verbose, reuse_history_list, prefixes)
579
 
        except NoPyBaz:
580
 
            print "This command is disabled.  Please install PyBaz."
581
 
 
582
 
 
583
 
class cmd_baz_import_branch(bzrlib.commands.Command):
584
 
    """Import an Arch or Baz branch into a bzr branch."""
585
 
    takes_args = ['to_location', 'from_branch?', 'reuse_history*']
586
 
    takes_options = ['verbose', Option('max-count', type=int)]
587
 
 
588
 
    def run(self, to_location, from_branch=None, fast=False, max_count=None,
589
 
            verbose=False, dry_run=False, reuse_history_list=[]):
590
 
        from errors import NoPyBaz
591
 
        try:
592
 
            import baz_import
593
 
            baz_import.baz_import_branch(to_location, from_branch, fast, 
594
 
                                         max_count, verbose, dry_run,
595
 
                                         reuse_history_list)
596
 
        except NoPyBaz:
597
 
            print "This command is disabled.  Please install PyBaz."
598
 
 
599
 
 
600
 
commands = [cmd_shelve, cmd_unshelve, cmd_shelf, cmd_clean_tree,
601
 
            cmd_graph_ancestry, cmd_fetch_ghosts, cmd_patch, cmd_shell,
602
 
            cmd_branch_history, cmd_zap, cmd_cbranch, cmd_branches, 
603
 
            cmd_multi_pull, cmd_switch, cmd_branch_mark, cmd_import, cmd_shove,
604
 
            cmd_cdiff, cmd_baz_import_branch, cmd_baz_import]
605
 
 
606
 
commands.append(rspush.cmd_rspush)
607
 
 
608
 
if hasattr(bzrlib.commands, 'register_command'):
609
 
    for command in commands:
610
 
        bzrlib.commands.register_command(command)
611
 
 
612
 
 
613
 
def test_suite():
614
 
    from bzrlib.tests.TestUtil import TestLoader
615
 
    import tests
616
 
    from doctest import DocTestSuite, ELLIPSIS
617
 
    from unittest import TestSuite
618
 
    import tests.clean_tree
619
 
    import upstream_import
620
 
    import zap
621
 
    import tests.blackbox
622
 
    import tests.shelf_tests
623
 
    result = TestSuite()
624
 
    result.addTest(DocTestSuite(bzrtools, optionflags=ELLIPSIS))
625
 
    result.addTest(tests.clean_tree.test_suite())
626
 
    try:
627
 
        import baz_import
628
 
        result.addTest(DocTestSuite(baz_import))
629
 
    except NoPyBaz:
630
 
        pass
631
 
    result.addTest(tests.test_suite())
632
 
    result.addTest(TestLoader().loadTestsFromModule(tests.shelf_tests))
633
 
    result.addTest(tests.blackbox.test_suite())
634
 
    result.addTest(upstream_import.test_suite())
635
 
    result.addTest(zap.test_suite())
636
 
    return result
 
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):
 
566
    """Upload this branch to another location using rsync.
 
567
 
 
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.
 
572
    """
 
573
    takes_args = ['location?']
 
574
    takes_options = [Option('overwrite', help='Ignore differences between'
 
575
                            ' branches and overwrite unconditionally.'),
 
576
                     Option('no-tree', help='Do not push the working tree,'
 
577
                            ' just the .bzr.')]
 
578
 
 
579
    def run(self, location=None, overwrite=False, no_tree=False):
 
580
        from bzrlib import workingtree
 
581
        import bzrtools
 
582
        cur_branch = workingtree.WorkingTree.open_containing(".")[0]
 
583
        bzrtools.rspush(cur_branch, location, overwrite=overwrite,
 
584
                      working_tree=not no_tree)
 
585
 
 
586
 
 
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, [])