~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:
1
 
#!/usr/bin/python
2
 
"""\
3
 
Various useful plugins for working with bzr.
4
 
"""
 
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
 
18
 
 
19
import bzrlib
 
20
 
 
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
 
30
from patchsource import BzrPatchSource
 
31
 
5
32
import bzrlib.commands
6
 
import push
7
 
from shelf import Shelf
8
 
import sys
9
 
import os.path
10
 
from bzrlib.option import Option
11
 
import bzrlib.branch
 
33
from bzrlib.branch import Branch
 
34
from bzrlib.commands import get_cmd_object
12
35
from bzrlib.errors import BzrCommandError
13
 
sys.path.append(os.path.dirname(__file__))
14
 
from reweave_inventory import cmd_fix
15
 
 
16
 
Option.OPTIONS['ignored'] = Option('ignored',
17
 
        help='delete all ignored files.')
18
 
Option.OPTIONS['detritus'] = Option('detritus',
19
 
        help='delete conflict files merge backups, and failed selftest dirs.' +
20
 
              '(*.THIS, *.BASE, *.OTHER, *~, *.tmp')
21
 
Option.OPTIONS['dry-run'] = Option('dry-run',
22
 
        help='show files to delete instead of deleting them.')
23
 
 
24
 
class cmd_clean_tree(bzrlib.commands.Command):
25
 
    """Remove unwanted files from working tree.
26
 
    Normally, ignored files are left alone.
27
 
    """
28
 
    takes_options = ['ignored', 'detritus', 'dry-run']
29
 
    def run(self, ignored=False, detritus=False, dry_run=False):
30
 
        from clean_tree import clean_tree
31
 
        clean_tree('.', ignored=ignored, detritus=detritus, dry_run=dry_run)
32
 
 
33
 
Option.OPTIONS['merge-branch'] = Option('merge-branch',type=str)
34
 
 
35
 
class cmd_graph_ancestry(bzrlib.commands.Command):
 
36
from bzrlib.option import Option, RegistryOption
 
37
 
 
38
 
 
39
class cmd_graph_ancestry(BzrToolsCommand):
36
40
    """Produce ancestry graphs using dot.
37
 
    
 
41
 
38
42
    Output format is detected according to file extension.  Some of the more
39
43
    common output formats are html, png, gif, svg, ps.  An extension of '.dot'
40
44
    will cause a dot graph file to be produced.  HTML output has mouseovers
44
48
    with the last 5 characters of their revision identifier are used instead.
45
49
 
46
50
    The value starting with d is "(maximum) distance from the null revision".
47
 
    
 
51
 
48
52
    If --merge-branch is specified, the two branches are compared and a merge
49
53
    base is selected.
50
 
    
 
54
 
51
55
    Legend:
52
56
    white    normal revision
53
57
    yellow   THIS  history
67
71
    If available, rsvg is used to antialias PNG and JPEG output, but this can
68
72
    be disabled with --no-antialias.
69
73
    """
70
 
    takes_args = ['branch', 'file']
71
 
    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."),
72
76
                     Option('no-antialias',
73
 
                     help="Do not use rsvg to produce antialiased output"), 
74
 
                     Option('merge-branch', type=str, 
75
 
                     help="Use this branch to calcuate a merge base"), 
76
 
                     Option('cluster', help="Use clustered output.")]
77
 
    def run(self, branch, file, no_collapse=False, no_antialias=False,
78
 
        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
79
94
        import graph
80
95
        if cluster:
81
96
            ranking = "cluster"
82
97
        else:
83
98
            ranking = "forced"
84
 
        graph.write_ancestry_file(branch, file, not no_collapse, 
85
 
                                  not no_antialias, merge_branch, ranking)
86
 
 
87
 
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):
88
105
    """Attempt to retrieve ghosts from another branch.
89
106
    If the other branch is not supplied, the last-pulled branch is used.
90
107
    """
91
108
    aliases = ['fetch-missing']
92
109
    takes_args = ['branch?']
93
 
    takes_options = [Option('no-fix')]
 
110
    takes_options = [Option('no-fix', help="Skip additional synchonization.")]
94
111
    def run(self, branch=None, no_fix=False):
95
112
        from fetch_ghosts import fetch_ghosts
96
 
        fetch_ghosts(branch, no_fix)
 
113
        fetch_ghosts(branch, do_reconcile=not no_fix)
97
114
 
98
115
strip_help="""Strip the smallest prefix containing num leading slashes  from \
99
116
each file name found in the patch file."""
100
 
Option.OPTIONS['strip'] = Option('strip', type=int, help=strip_help)
101
 
class cmd_patch(bzrlib.commands.Command):
 
117
 
 
118
 
 
119
class cmd_patch(BzrToolsCommand):
102
120
    """Apply a named patch to the current tree.
103
121
    """
104
122
    takes_args = ['filename?']
105
 
    takes_options = ['strip']
106
 
    def run(self, filename=None, strip=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):
107
127
        from patch import patch
108
 
        from bzrlib.branch import Branch
109
 
        b = Branch.open_containing('.')[0]
110
 
        return patch(b, filename, strip)
111
 
 
112
 
 
113
 
class cmd_shelve(bzrlib.commands.Command):
114
 
    """Temporarily remove some text changes from the current tree.
115
 
    Use 'unshelve' to restore these changes.
 
128
        from bzrlib.workingtree import WorkingTree
 
129
        wt = WorkingTree.open_containing('.')[0]
 
130
        if strip is None:
 
131
            strip = 0
 
132
        return patch(wt, filename, strip, silent)
 
133
 
 
134
 
 
135
class cmd_shelve1(BzrToolsCommand):
 
136
    """Temporarily set aside some changes from the current tree.
 
137
 
 
138
    Shelve allows you to temporarily put changes you've made "on the shelf",
 
139
    ie. out of the way, until a later time when you can bring them back from
 
140
    the shelf with the 'unshelve1' command.
116
141
 
117
142
    Shelve is intended to help separate several sets of text changes that have
118
143
    been inappropriately mingled.  If you just want to get rid of all changes
119
144
    (text and otherwise) and you don't need to restore them later, use revert.
120
 
    If you want to shelve all text changes at once, use shelve --all.
121
 
 
122
 
    If filenames are specified, only changes to those files will be shelved.
123
 
    If a revision is specified, all changes since that revision will may be
124
 
    shelved.
 
145
    If you want to shelve all text changes at once, use shelve1 --all.
 
146
 
 
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.
 
149
 
 
150
    If filenames are specified, only the changes to those files will be
 
151
    shelved, other files will be left untouched.
 
152
 
 
153
    If a revision is specified, changes since that revision will be shelved.
 
154
 
 
155
    You can put multiple items on the shelf. Normally each time you run
 
156
    unshelve1 the most recently shelved changes will be reinstated. However,
 
157
    you can also unshelve changes in a different order by explicitly
 
158
    specifiying which changes to unshelve1. This works best when the changes
 
159
    don't depend on each other.
 
160
 
 
161
    While you have patches on the shelf you can view and manipulate them with
 
162
    the 'shelf1' command. Run 'bzr shelf1 -h' for more info.
125
163
    """
 
164
 
126
165
    takes_args = ['file*']
127
 
    takes_options = [Option('all', 
128
 
                            help='Shelve all changes without prompting'), 
129
 
                     'message', 'revision']
130
 
    def run(self, all=False, file_list=None, message=None, revision=None):
131
 
        if file_list is not None and len(file_list) > 0:
132
 
            branchdir = file_list[0]
133
 
        else:
134
 
            branchdir = '.'
 
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.')]
135
172
 
 
173
    def run(self, all=False, file_list=None, message=None, revision=None,
 
174
            no_color=False):
136
175
        if revision is not None and revision:
137
176
            if len(revision) == 1:
138
177
                revision = revision[0]
139
178
            else:
140
 
                raise BzrCommandError("shelve only accepts a single revision "
 
179
                raise CommandError("shelve only accepts a single revision "
141
180
                                  "parameter.")
142
181
 
143
 
        s = Shelf(branchdir)
144
 
        return s.shelve(all, message, revision, file_list)
145
 
 
146
 
 
147
 
class cmd_unshelve(bzrlib.commands.Command):
148
 
    """Restore previously-shelved changes to the current tree.
149
 
    See also 'shelve'.
 
182
        source = BzrPatchSource(revision, file_list)
 
183
        s = shelf.Shelf(source.base)
 
184
        s.shelve(source, all, message, no_color)
 
185
        return 0
 
186
 
 
187
 
 
188
# The following classes are only used as subcommands for 'shelf1', they're
 
189
# not to be registered directly with bzr.
 
190
 
 
191
class cmd_shelf_list(bzrlib.commands.Command):
 
192
    """List the patches on the current shelf."""
 
193
    aliases = ['list', 'ls']
 
194
    def run(self):
 
195
        self.shelf.list()
 
196
 
 
197
 
 
198
class cmd_shelf_delete(bzrlib.commands.Command):
 
199
    """Delete the patch from the current shelf."""
 
200
    aliases = ['delete', 'del']
 
201
    takes_args = ['patch']
 
202
    def run(self, patch):
 
203
        self.shelf.delete(patch)
 
204
 
 
205
 
 
206
class cmd_shelf_switch(bzrlib.commands.Command):
 
207
    """Switch to the other shelf, create it if necessary."""
 
208
    aliases = ['switch']
 
209
    takes_args = ['othershelf']
 
210
    def run(self, othershelf):
 
211
        s = shelf.Shelf(self.shelf.base, othershelf)
 
212
        s.make_default()
 
213
 
 
214
 
 
215
class cmd_shelf_show(bzrlib.commands.Command):
 
216
    """Show the contents of the specified or topmost patch."""
 
217
    aliases = ['show', 'cat', 'display']
 
218
    takes_args = ['patch?']
 
219
    def run(self, patch=None):
 
220
        self.shelf.display(patch)
 
221
 
 
222
 
 
223
class cmd_shelf_upgrade(bzrlib.commands.Command):
 
224
    """Upgrade old format shelves."""
 
225
    aliases = ['upgrade']
 
226
    def run(self):
 
227
        self.shelf.upgrade()
 
228
 
 
229
 
 
230
class cmd_shelf1(BzrToolsCommand):
 
231
    """Perform various operations on your shelved patches. See also shelve1."""
 
232
    takes_args = ['subcommand', 'args*']
 
233
 
 
234
    subcommands = [cmd_shelf_list, cmd_shelf_delete, cmd_shelf_switch,
 
235
        cmd_shelf_show, cmd_shelf_upgrade]
 
236
 
 
237
    def run(self, subcommand, args_list):
 
238
        import sys
 
239
 
 
240
        if args_list is None:
 
241
            args_list = []
 
242
        cmd = self._get_cmd_object(subcommand)
 
243
        source = BzrPatchSource()
 
244
        s = shelf.Shelf(source.base)
 
245
        cmd.shelf = s
 
246
 
 
247
        if args_list is None:
 
248
            args_list = []
 
249
        return cmd.run_argv_aliases(args_list)
 
250
 
 
251
    def _get_cmd_object(self, cmd_name):
 
252
        for cmd_class in self.subcommands:
 
253
            for alias in cmd_class.aliases:
 
254
                if alias == cmd_name:
 
255
                    return cmd_class()
 
256
        raise CommandError("Unknown shelf subcommand '%s'" % cmd_name)
 
257
 
 
258
    def help(self):
 
259
        text = ["%s\n\nSubcommands:\n" % self.__doc__]
 
260
 
 
261
        for cmd_class in self.subcommands:
 
262
            text.extend(self.sub_help(cmd_class) + ['\n'])
 
263
 
 
264
        return ''.join(text)
 
265
 
 
266
    def sub_help(self, cmd_class):
 
267
        text = []
 
268
        cmd_obj = cmd_class()
 
269
        indent = 2 * ' '
 
270
 
 
271
        usage = cmd_obj._usage()
 
272
        usage = usage.replace('bzr shelf-', '')
 
273
        text.append('%s%s\n' % (indent, usage))
 
274
 
 
275
        text.append('%s%s\n' % (2 * indent, cmd_class.__doc__))
 
276
 
 
277
        # Somewhat copied from bzrlib.help.help_on_command_options
 
278
        option_help = []
 
279
        for option_name, option in sorted(cmd_obj.options().items()):
 
280
            if option_name == 'help':
 
281
                continue
 
282
            option_help.append('%s--%s' % (3 * indent, option_name))
 
283
            if option.type is not None:
 
284
                option_help.append(' %s' % option.argname.upper())
 
285
            if option.short_name():
 
286
                option_help.append(', -%s' % option.short_name())
 
287
            option_help.append('%s%s\n' % (2 * indent, option.help))
 
288
 
 
289
        if len(option_help) > 0:
 
290
            text.append('%soptions:\n' % (2 * indent))
 
291
            text.extend(option_help)
 
292
 
 
293
        return text
 
294
 
 
295
 
 
296
class cmd_unshelve1(BzrToolsCommand):
 
297
    """Restore shelved changes.
 
298
 
 
299
    By default the most recently shelved changes are restored. However if you
 
300
    specify a patch by name those changes will be restored instead.
 
301
 
 
302
    See 'shelve1' for more information.
150
303
    """
151
 
    def run(self):
152
 
        s = Shelf('.')
153
 
        return s.unshelve()
154
 
 
155
 
class cmd_shell(bzrlib.commands.Command):
 
304
    takes_options = [
 
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.')
 
308
        ]
 
309
    takes_args = ['patch?']
 
310
    def run(self, patch=None, all=False, force=False, no_color=False):
 
311
        source = BzrPatchSource()
 
312
        s = shelf.Shelf(source.base)
 
313
        s.unshelve(source, patch, all, force, no_color)
 
314
        return 0
 
315
 
 
316
 
 
317
class cmd_shell(BzrToolsCommand):
156
318
    """Begin an interactive shell tailored for bzr.
157
319
    Bzr commands can be used without typing bzr first, and will be run natively
158
320
    when possible.  Tab completion is tailored for bzr.  The shell prompt shows
170
332
    --all        --help       --revision   --show-ids
171
333
    bzr bzrtools:287/> status --
172
334
    """
173
 
    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):
174
344
        import shell
175
 
        return shell.run_shell()
176
 
 
177
 
class cmd_branch_history(bzrlib.commands.Command):
 
345
        return shell.run_shell(directory)
 
346
 
 
347
 
 
348
class cmd_branch_history(BzrToolsCommand):
178
349
    """\
179
 
    Display the revision history with reference to lines of development.
 
350
    Display the development history of a branch.
180
351
 
181
352
    Each different committer or branch nick is considered a different line of
182
353
    development.  Committers are treated as the same if they have the same
184
355
    """
185
356
    takes_args = ["branch?"]
186
357
    def run(self, branch=None):
187
 
        from branchhistory import branch_history 
 
358
        from branchhistory import branch_history
188
359
        return branch_history(branch)
189
360
 
190
 
commands = [cmd_shelve, cmd_unshelve, cmd_clean_tree, cmd_graph_ancestry,
191
 
            cmd_fetch_ghosts, cmd_patch, cmd_shell, cmd_fix, cmd_branch_history]
192
 
 
193
 
command_decorators = []
194
 
 
195
 
import bzrlib.builtins
196
 
if not hasattr(bzrlib.builtins, "cmd_push"):
197
 
    commands.append(push.cmd_push)
198
 
else:
199
 
    command_decorators.append(push.cmd_push)
200
 
 
201
 
from errors import NoPyBaz
202
 
try:
203
 
    import baz_import
204
 
    commands.append(baz_import.cmd_baz_import)
205
 
 
206
 
except NoPyBaz:
207
 
    class cmd_baz_import(bzrlib.commands.Command):
208
 
        """Disabled. (Requires PyBaz)"""
209
 
        takes_args = ['to_root_dir?', 'from_archive?']
210
 
        takes_options = ['verbose']
211
 
        def run(self, to_root_dir=None, from_archive=None, verbose=False):
212
 
            print "This command is disabled.  Please install PyBaz."
213
 
    commands.append(cmd_baz_import)
214
 
 
215
 
 
216
 
if hasattr(bzrlib.commands, 'register_command'):
217
 
    for command in commands:
218
 
        bzrlib.commands.register_command(command)
219
 
    for command in command_decorators:
220
 
        command._original_command = bzrlib.commands.register_command(
221
 
            command, True)
222
 
 
223
 
 
224
 
def test_suite():
225
 
    from doctest import DocTestSuite
226
 
    from unittest import TestSuite, TestLoader
227
 
    import clean_tree
228
 
    import blackbox
229
 
    import shelf_tests
230
 
    result = TestSuite()
231
 
    result.addTest(DocTestSuite(bzrtools))
232
 
    result.addTest(clean_tree.test_suite())
233
 
    result.addTest(TestLoader().loadTestsFromModule(shelf_tests))
234
 
    result.addTest(blackbox.test_suite())
235
 
    return result
 
361
 
 
362
class cmd_zap(BzrToolsCommand):
 
363
    """\
 
364
    Remove a lightweight checkout, if it can be done safely.
 
365
 
 
366
    This command will remove a lightweight checkout without losing data.  That
 
367
    means it only removes lightweight checkouts, and only if they have no
 
368
    uncommitted changes.
 
369
 
 
370
    If --branch is specified, the branch will be deleted too, but only if the
 
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`
 
378
    """
 
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)]
 
388
    takes_args = ["checkout"]
 
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):
 
406
    """
 
407
    Create a new checkout, associated with a new repository branch.
 
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.
 
423
    """
 
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
    takes_args = ["source", "target?"]
 
433
    def run(self, source, target=None, lightweight=False, revision=None,
 
434
            files_from=None, hardlink=False):
 
435
        from cbranch import cbranch
 
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):
 
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
 
 
448
    takes_args = ["location?"]
 
449
    def run(self, location=None):
 
450
        from branches import branches
 
451
        return branches(location)
 
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))
 
463
 
 
464
class cmd_multi_pull(BzrToolsCommand):
 
465
    """Pull all the branches under a location, e.g. a repository.
 
466
 
 
467
    Both branches present in the directory and the branches of checkouts are
 
468
    pulled.
 
469
    """
 
470
    takes_args = ["location?"]
 
471
    def run(self, location=None):
 
472
        from bzrlib.transport import get_transport
 
473
        from bzrtools import iter_branch_tree
 
474
        if location is None:
 
475
            location = '.'
 
476
        t = get_transport(location)
 
477
        possible_transports = []
 
478
        if not t.listable():
 
479
            print "Can't list this type of location."
 
480
            return 3
 
481
        for branch, wt in iter_branch_tree(t):
 
482
            if wt is None:
 
483
                pullable = branch
 
484
            else:
 
485
                pullable = wt
 
486
            parent = branch.get_parent()
 
487
            if parent is None:
 
488
                continue
 
489
            if wt is not None:
 
490
                base = wt.basedir
 
491
            else:
 
492
                base = branch.base
 
493
            if base.startswith(t.base):
 
494
                relpath = base[len(t.base):].rstrip('/')
 
495
            else:
 
496
                relpath = base
 
497
            print "Pulling %s from %s" % (relpath, parent)
 
498
            try:
 
499
                branch_t = get_transport(parent, possible_transports)
 
500
                pullable.pull(Branch.open_from_transport(branch_t))
 
501
            except Exception, e:
 
502
                print e
 
503
 
 
504
 
 
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.
 
513
 
 
514
    Tarballs may be gzip or bzip2 compressed.  This is autodetected.
 
515
 
 
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.
 
518
    """
 
519
 
 
520
    takes_args = ['source', 'tree?']
 
521
    def run(self, source, tree=None):
 
522
        from upstream_import import do_import
 
523
        do_import(source, tree)
 
524
 
 
525
 
 
526
class cmd_cdiff(BzrToolsCommand):
 
527
    """A color version of bzr's diff"""
 
528
    takes_args = property(lambda x: get_cmd_object('diff').takes_args)
 
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):
 
542
        from colordiff import colordiff
 
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, [])