← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to __init__.py

  • Committer: Aaron Bentley
  • Date: 2007-03-09 18:25:10 UTC
  • mto: This revision was merged to the branch mainline in revision 520.
  • Revision ID: abentley@panoramicfeedback.com-20070309182510-fkj1j6t119d1cj5q
Handle broken python tar implementations

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
1
 
#!/usr/bin/python
 
1
# Copyright (C) 2005, 2006, 2007 Aaron Bentley <aaron.bentley@utoronto.ca>
 
2
# Copyright (C) 2005, 2006 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
 
2
19
"""\
3
20
Various useful plugins for working with bzr.
4
21
"""
5
 
import bzrlib.commands
6
 
import push
7
 
from errors import CommandError
 
22
 
 
23
import bzrlib
 
24
 
 
25
 
 
26
__version__ = '0.15.1'
 
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 Bazaar version %s is too old to be used with'
 
51
                ' plugin \n'
 
52
                '"Bzrtools" %s.' % (bzrlib.__version__, __version__))
 
53
        # Not using BzrNewError, because it may not exist.
 
54
        raise Exception, ('Version mismatch', version_info)
 
55
    else:
 
56
        warning('Plugin "Bzrtools" is not up to date with installed Bazaar'
 
57
                ' version %s.\n'
 
58
                ' There should be a newer version of Bzrtools available, e.g.'
 
59
                ' %i.%i.'
 
60
                % (bzrlib.__version__, bzrlib_version[0], bzrlib_version[1]))
 
61
        if bzrlib_version != desired_plus:
 
62
            raise Exception, 'Version mismatch'
 
63
 
 
64
 
 
65
check_bzrlib_version(version_info[:2])
 
66
 
 
67
from bzrlib.lazy_import import lazy_import
 
68
lazy_import(globals(), """
 
69
from bzrlib import help
 
70
import shelf
 
71
""")
 
72
 
 
73
from errors import CommandError, NoPyBaz
8
74
from patchsource import BzrPatchSource
9
 
from shelf import Shelf
10
75
import sys
11
76
import os.path
 
77
 
 
78
import bzrlib.builtins
 
79
import bzrlib.commands
 
80
from bzrlib.commands import get_cmd_object
 
81
from bzrlib.errors import BzrCommandError
 
82
import bzrlib.ignores
12
83
from bzrlib.option import Option
13
 
import bzrlib.branch
14
 
from bzrlib.errors import BzrCommandError
15
84
sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__), 
16
 
                                                 "external")))
17
 
from bzrlib import DEFAULT_IGNORE
18
 
 
19
 
 
20
 
DEFAULT_IGNORE.append('./.shelf')
21
 
DEFAULT_IGNORE.append('./.bzr-shelf*')
22
 
 
23
 
 
24
 
Option.OPTIONS['ignored'] = Option('ignored',
25
 
        help='delete all ignored files.')
26
 
Option.OPTIONS['detritus'] = Option('detritus',
27
 
        help='delete conflict files merge backups, and failed selftest dirs.' +
28
 
              '(*.THIS, *.BASE, *.OTHER, *~, *.tmp')
29
 
Option.OPTIONS['dry-run'] = Option('dry-run',
30
 
        help='show files to delete instead of deleting them.')
 
85
                                                 "external")))
 
86
 
 
87
import show_paths
 
88
 
 
89
bzrlib.ignores.add_runtime_ignores(['./.shelf'])
 
90
 
31
91
 
32
92
class cmd_clean_tree(bzrlib.commands.Command):
33
 
    """Remove unwanted files from working tree.  <BZRTOOLS>
34
 
    Normally, ignored files are left alone.
 
93
    """Remove unwanted files from working tree.
 
94
 
 
95
    By default, only unknown files, not ignored files, are deleted.  Versioned
 
96
    files are never deleted.
 
97
 
 
98
    Another class is 'detritus', which includes files emitted by bzr during
 
99
    normal operations and selftests.  (The value of these files decreases with
 
100
    time.)
 
101
 
 
102
    If no options are specified, unknown files are deleted.  Otherwise, option
 
103
    flags are respected, and may be combined.
 
104
 
 
105
    To check what clean-tree will do, use --dry-run.
35
106
    """
36
 
    takes_options = ['ignored', 'detritus', 'dry-run']
37
 
    def run(self, ignored=False, detritus=False, dry_run=False):
 
107
    takes_options = [Option('ignored', help='delete all ignored files.'), 
 
108
                     Option('detritus', help='delete conflict files, merge'
 
109
                            ' backups, and failed selftest dirs.'), 
 
110
                     Option('unknown', 
 
111
                            help='delete files unknown to bzr.  (default)'),
 
112
                     Option('dry-run', help='show files to delete instead of'
 
113
                            ' deleting them.')]
 
114
    def run(self, unknown=False, ignored=False, detritus=False, dry_run=False):
38
115
        from clean_tree import clean_tree
39
 
        clean_tree('.', ignored=ignored, detritus=detritus, dry_run=dry_run)
 
116
        if not (unknown or ignored or detritus):
 
117
            unknown = True
 
118
        clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus, 
 
119
                   dry_run=dry_run)
40
120
 
41
 
Option.OPTIONS['merge-branch'] = Option('merge-branch',type=str)
42
121
 
43
122
class cmd_graph_ancestry(bzrlib.commands.Command):
44
 
    """Produce ancestry graphs using dot.  <BZRTOOLS>
 
123
    """Produce ancestry graphs using dot.
45
124
    
46
125
    Output format is detected according to file extension.  Some of the more
47
126
    common output formats are html, png, gif, svg, ps.  An extension of '.dot'
81
160
                     help="Do not use rsvg to produce antialiased output"), 
82
161
                     Option('merge-branch', type=str, 
83
162
                     help="Use this branch to calcuate a merge base"), 
84
 
                     Option('cluster', help="Use clustered output.")]
 
163
                     Option('cluster', help="Use clustered output."),
 
164
                     Option('max-distance', help="Show no nodes farther than this",
 
165
                            type=int)]
85
166
    def run(self, branch, file, no_collapse=False, no_antialias=False,
86
 
        merge_branch=None, cluster=False):
 
167
        merge_branch=None, cluster=False, max_distance=None):
87
168
        import graph
88
169
        if cluster:
89
170
            ranking = "cluster"
90
171
        else:
91
172
            ranking = "forced"
92
173
        graph.write_ancestry_file(branch, file, not no_collapse, 
93
 
                                  not no_antialias, merge_branch, ranking)
 
174
                                  not no_antialias, merge_branch, ranking, 
 
175
                                  max_distance=max_distance)
 
176
 
94
177
 
95
178
class cmd_fetch_ghosts(bzrlib.commands.Command):
96
 
    """Attempt to retrieve ghosts from another branch.  <BZRTOOLS>
 
179
    """Attempt to retrieve ghosts from another branch.
97
180
    If the other branch is not supplied, the last-pulled branch is used.
98
181
    """
99
182
    aliases = ['fetch-missing']
105
188
 
106
189
strip_help="""Strip the smallest prefix containing num leading slashes  from \
107
190
each file name found in the patch file."""
108
 
Option.OPTIONS['strip'] = Option('strip', type=int, help=strip_help)
109
 
Option.OPTIONS['bzrdiff'] = Option('bzrdiff',type=None,
110
 
                                help="""Handle extra bzr tags""")
 
191
 
 
192
 
111
193
class cmd_patch(bzrlib.commands.Command):
112
 
    """Apply a named patch to the current tree.  <BZRTOOLS>
 
194
    """Apply a named patch to the current tree.
113
195
    """
114
196
    takes_args = ['filename?']
115
 
    takes_options = ['strip','bzrdiff']
116
 
    def run(self, filename=None, strip=-1, bzrdiff=0):
 
197
    takes_options = [Option('strip', type=int, help=strip_help),
 
198
                     Option('silent', help='Suppress chatter')]
 
199
    def run(self, filename=None, strip=None, silent=False):
117
200
        from patch import patch
118
201
        from bzrlib.workingtree import WorkingTree
119
202
        wt = WorkingTree.open_containing('.')[0]
120
 
        if strip == -1:
121
 
            if bzrdiff: strip = 0
122
 
            else:       strip = 1
 
203
        if strip is None:
 
204
            strip = 0
 
205
        return patch(wt, filename, strip, silent)
123
206
 
124
 
        return patch(wt, filename, strip, legacy= not bzrdiff)
125
207
 
126
208
class cmd_shelve(bzrlib.commands.Command):
127
 
    """Temporarily set aside some changes from the current tree.  <BZRTOOLS>
 
209
    """Temporarily set aside some changes from the current tree.
128
210
 
129
211
    Shelve allows you to temporarily put changes you've made "on the shelf",
130
212
    ie. out of the way, until a later time when you can bring them back from
138
220
    By default shelve asks you what you want to shelve, press '?' at the
139
221
    prompt to get help. To shelve everything run shelve --all.
140
222
 
141
 
    You can put multiple items on the shelf, each time you run unshelve the
142
 
    most recently shelved changes will be reinstated.
143
 
 
144
223
    If filenames are specified, only the changes to those files will be
145
224
    shelved, other files will be left untouched.
146
225
 
147
226
    If a revision is specified, changes since that revision will be shelved.
 
227
 
 
228
    You can put multiple items on the shelf. Normally each time you run
 
229
    unshelve the most recently shelved changes will be reinstated. However,
 
230
    you can also unshelve changes in a different order by explicitly
 
231
    specifiying which changes to unshelve. This works best when the changes
 
232
    don't depend on each other.
 
233
 
 
234
    While you have patches on the shelf you can view and manipulate them with
 
235
    the 'shelf' command. Run 'bzr shelf -h' for more info.
148
236
    """
149
237
 
150
238
    takes_args = ['file*']
151
239
    takes_options = ['message', 'revision',
152
 
            Option('all', help='Shelve all changes without prompting')]
 
240
            Option('all', help='Shelve all changes without prompting'), 
 
241
            Option('no-color', help='Never display changes in color')]
153
242
 
154
 
    def run(self, all=False, file_list=None, message=None, revision=None):
 
243
    def run(self, all=False, file_list=None, message=None, revision=None,
 
244
            no_color=False):
155
245
        if revision is not None and revision:
156
246
            if len(revision) == 1:
157
247
                revision = revision[0]
160
250
                                  "parameter.")
161
251
 
162
252
        source = BzrPatchSource(revision, file_list)
163
 
        s = Shelf(source.base)
164
 
        s.shelve(source, all, message)
 
253
        s = shelf.Shelf(source.base)
 
254
        s.shelve(source, all, message, no_color)
165
255
        return 0
166
256
 
 
257
 
 
258
# The following classes are only used as subcommands for 'shelf', they're
 
259
# not to be registered directly with bzr.
 
260
 
 
261
class cmd_shelf_list(bzrlib.commands.Command):
 
262
    """List the patches on the current shelf."""
 
263
    aliases = ['list', 'ls']
 
264
    def run(self):
 
265
        self.shelf.list()
 
266
 
 
267
 
 
268
class cmd_shelf_delete(bzrlib.commands.Command):
 
269
    """Delete the patch from the current shelf."""
 
270
    aliases = ['delete', 'del']
 
271
    takes_args = ['patch']
 
272
    def run(self, patch):
 
273
        self.shelf.delete(patch)
 
274
 
 
275
 
 
276
class cmd_shelf_switch(bzrlib.commands.Command):
 
277
    """Switch to the other shelf, create it if necessary."""
 
278
    aliases = ['switch']
 
279
    takes_args = ['othershelf']
 
280
    def run(self, othershelf):
 
281
        s = shelf.Shelf(self.shelf.base, othershelf)
 
282
        s.make_default()
 
283
 
 
284
 
 
285
class cmd_shelf_show(bzrlib.commands.Command):
 
286
    """Show the contents of the specified or topmost patch."""
 
287
    aliases = ['show', 'cat', 'display']
 
288
    takes_args = ['patch?']
 
289
    def run(self, patch=None):
 
290
        self.shelf.display(patch)
 
291
 
 
292
 
 
293
class cmd_shelf_upgrade(bzrlib.commands.Command):
 
294
    """Upgrade old format shelves."""
 
295
    aliases = ['upgrade']
 
296
    def run(self):
 
297
        self.shelf.upgrade()
 
298
 
 
299
 
167
300
class cmd_shelf(bzrlib.commands.Command):
168
 
    """Perform various operations on your shelved patches. See also shelve.
169
 
 
170
 
    Subcommands:
171
 
        list   (ls)           List the patches on the current shelf.
172
 
        delete (del) <patch>  Delete a patch from the current shelf.
173
 
        switch       <shelf>  Switch to the named shelf, create it if necessary.
174
 
        show         <patch>  Show the contents of the specified patch.
175
 
        upgrade               Upgrade old format shelves.
176
 
    """
 
301
    """Perform various operations on your shelved patches. See also shelve."""
177
302
    takes_args = ['subcommand', 'args*']
178
303
 
 
304
    subcommands = [cmd_shelf_list, cmd_shelf_delete, cmd_shelf_switch,
 
305
        cmd_shelf_show, cmd_shelf_upgrade]
 
306
 
179
307
    def run(self, subcommand, args_list):
180
308
        import sys
181
309
 
 
310
        if args_list is None:
 
311
            args_list = []
 
312
        cmd = self._get_cmd_object(subcommand)
182
313
        source = BzrPatchSource()
183
 
        s = Shelf(source.base)
184
 
 
185
 
        if subcommand == 'ls' or subcommand == 'list':
186
 
            self.__check_no_args(args_list, "shelf list takes no arguments!")
187
 
            s.list()
188
 
        elif subcommand == 'delete' or subcommand == 'del':
189
 
            self.__check_one_arg(args_list, "shelf delete takes one argument!")
190
 
            s.delete(args_list[0])
191
 
        elif subcommand == 'switch':
192
 
            self.__check_one_arg(args_list, "shelf switch takes one argument!")
193
 
            s = Shelf(source.base, args_list[0])
194
 
            s.make_default()
195
 
        elif subcommand == 'show':
196
 
            self.__check_one_arg(args_list, "shelf show takes one argument!")
197
 
            s.display(args_list[0])
198
 
        elif subcommand == 'upgrade':
199
 
            self.__check_no_args(args_list, "shelf upgrade takes no arguments!")
200
 
            s.upgrade()
201
 
        else:
202
 
            print subcommand, args_list
203
 
            print >>sys.stderr, "Unknown shelf subcommand '%s'" % subcommand
204
 
 
205
 
    def __check_one_arg(self, args, msg):
206
 
        if args is None or len(args) != 1:
207
 
            raise CommandError(msg)
208
 
 
209
 
    def __check_no_args(self, args, msg):
210
 
        if args is not None:
211
 
            raise CommandError(msg)
 
314
        s = shelf.Shelf(source.base)
 
315
        cmd.shelf = s
 
316
 
 
317
        if args_list is None:
 
318
            args_list = []
 
319
        return cmd.run_argv_aliases(args_list)
 
320
 
 
321
    def _get_cmd_object(self, cmd_name):
 
322
        for cmd_class in self.subcommands:
 
323
            for alias in cmd_class.aliases:
 
324
                if alias == cmd_name:
 
325
                    return cmd_class()
 
326
        raise CommandError("Unknown shelf subcommand '%s'" % cmd_name)
 
327
 
 
328
    def help(self):
 
329
        text = ["%s\n\nSubcommands:\n" % self.__doc__]
 
330
 
 
331
        for cmd_class in self.subcommands:
 
332
            text.extend(self.sub_help(cmd_class) + ['\n'])
 
333
 
 
334
        return ''.join(text)
 
335
 
 
336
    def sub_help(self, cmd_class):
 
337
        text = []
 
338
        cmd_obj = cmd_class()
 
339
        indent = 2 * ' '
 
340
 
 
341
        usage = help.command_usage(cmd_obj)
 
342
        usage = usage.replace('bzr shelf-', '')
 
343
        text.append('%s%s\n' % (indent, usage))
 
344
 
 
345
        text.append('%s%s\n' % (2 * indent, cmd_class.__doc__))
 
346
 
 
347
        # Somewhat copied from bzrlib.help.help_on_command_options
 
348
        option_help = []
 
349
        for option_name, option in sorted(cmd_obj.options().items()):
 
350
            if option_name == 'help':
 
351
                continue
 
352
            option_help.append('%s--%s' % (3 * indent, option_name))
 
353
            if option.type is not None:
 
354
                option_help.append(' %s' % option.argname.upper())
 
355
            if option.short_name():
 
356
                option_help.append(', -%s' % option.short_name())
 
357
            option_help.append('%s%s\n' % (2 * indent, option.help))
 
358
 
 
359
        if len(option_help) > 0:
 
360
            text.append('%soptions:\n' % (2 * indent))
 
361
            text.extend(option_help)
 
362
 
 
363
        return text
212
364
 
213
365
 
214
366
class cmd_unshelve(bzrlib.commands.Command):
215
 
    """Restore the most recently shelved changes to current tree.  <BZRTOOLS>
 
367
    """Restore shelved changes.
 
368
 
 
369
    By default the most recently shelved changes are restored. However if you
 
370
    specify a patch by name those changes will be restored instead.
 
371
 
216
372
    See 'shelve' for more information.
217
373
    """
218
374
    takes_options = [
219
375
            Option('all', help='Unshelve all changes without prompting'),
220
376
            Option('force', help='Force unshelving even if errors occur'),
221
 
    ]
222
 
    def run(self, all=False, force=False):
 
377
            Option('no-color', help='Never display changes in color')
 
378
        ]
 
379
    takes_args = ['patch?']
 
380
    def run(self, patch=None, all=False, force=False, no_color=False):
223
381
        source = BzrPatchSource()
224
 
        s = Shelf(source.base)
225
 
        s.unshelve(source, all, force)
 
382
        s = shelf.Shelf(source.base)
 
383
        s.unshelve(source, patch, all, force, no_color)
226
384
        return 0
227
385
 
228
386
 
229
387
class cmd_shell(bzrlib.commands.Command):
230
 
    """Begin an interactive shell tailored for bzr.  <BZRTOOLS>
 
388
    """Begin an interactive shell tailored for bzr.
231
389
    Bzr commands can be used without typing bzr first, and will be run natively
232
390
    when possible.  Tab completion is tailored for bzr.  The shell prompt shows
233
391
    the branch nick, revno, and path.
248
406
        import shell
249
407
        return shell.run_shell()
250
408
 
 
409
 
251
410
class cmd_branch_history(bzrlib.commands.Command):
252
411
    """\
253
 
    Display the development history of a branch  <BZRTOOLS>.
 
412
    Display the development history of a branch.
254
413
 
255
414
    Each different committer or branch nick is considered a different line of
256
415
    development.  Committers are treated as the same if they have the same
264
423
 
265
424
class cmd_zap(bzrlib.commands.Command):
266
425
    """\
267
 
    Remove a checkout, if it can be done safely. <BZRTOOLS>
268
 
 
269
 
    This command will remove a checkout without losing data.  That means
270
 
    it only removes checkouts, 
 
426
    Remove a lightweight checkout, if it can be done safely.
 
427
 
 
428
    This command will remove a lightweight checkout without losing data.  That
 
429
    means it only removes lightweight checkouts, and only if they have no
 
430
    uncommitted changes.
 
431
 
 
432
    If --branch is specified, the branch will be deleted too, but only if the
 
433
    the branch has no new commits (relative to its parent).
271
434
    """
 
435
    takes_options = [Option("branch", help="Remove associtated branch from"
 
436
                                           " repository")]
272
437
    takes_args = ["checkout"]
273
 
    def run(self, checkout):
 
438
    def run(self, checkout, branch=False):
274
439
        from zap import zap
275
 
        return zap(checkout)
276
 
 
277
 
 
278
 
commands = [cmd_shelve, cmd_unshelve, cmd_shelf, cmd_clean_tree,
279
 
            cmd_graph_ancestry, cmd_fetch_ghosts, cmd_patch, cmd_shell,
280
 
            cmd_branch_history, cmd_zap]
281
 
 
282
 
 
283
 
command_decorators = []
284
 
 
285
 
 
286
 
import bzrlib.builtins
287
 
if not hasattr(bzrlib.builtins, "cmd_push"):
288
 
    commands.append(push.cmd_push)
289
 
else:
290
 
    command_decorators.append(push.cmd_push)
291
 
 
292
 
from errors import NoPyBaz
293
 
try:
294
 
    import baz_import
295
 
    commands.append(baz_import.cmd_baz_import_branch)
296
 
    commands.append(baz_import.cmd_baz_import)
297
 
 
298
 
except NoPyBaz:
299
 
    class cmd_baz_import_branch(bzrlib.commands.Command):
300
 
        """Disabled. (Requires PyBaz)   <BZRTOOLS>"""
301
 
        takes_args = ['to_location?', 'from_branch?', 'reuse_history*']
302
 
        takes_options = ['verbose', Option('max-count', type=int)]
303
 
        def run(self, to_location=None, from_branch=None, fast=False, 
304
 
                max_count=None, verbose=False, dry_run=False,
305
 
                reuse_history_list=[]):
306
 
            print "This command is disabled.  Please install PyBaz."
307
 
 
308
 
 
309
 
    class cmd_baz_import(bzrlib.commands.Command):
310
 
        """Disabled. (Requires PyBaz)   <BZRTOOLS>"""
311
 
        takes_args = ['to_root_dir?', 'from_archive?', 'reuse_history*']
312
 
        takes_options = ['verbose', Option('prefixes', type=str,
313
 
                         help="Prefixes of branches to import")]
314
 
        def run(self, to_root_dir=None, from_archive=None, verbose=False,
315
 
                reuse_history_list=[], prefixes=None):
316
 
                print "This command is disabled.  Please install PyBaz."
317
 
    commands.extend((cmd_baz_import_branch, cmd_baz_import))
 
440
        return zap(checkout, remove_branch=branch)
 
441
 
 
442
 
 
443
class cmd_cbranch(bzrlib.commands.Command):
 
444
    """
 
445
    Create a new checkout, associated with a new repository branch.
 
446
    
 
447
    When you cbranch, bzr looks up a target location in locations.conf, and
 
448
    creates the branch there.
 
449
 
 
450
    In your locations.conf, add the following lines:
 
451
    [/working_directory_root]
 
452
    cbranch_target = /branch_root
 
453
    cbranch_target:policy = appendpath
 
454
 
 
455
    This will mean that if you run "bzr cbranch foo/bar foo/baz" in the
 
456
    working directory root, the branch will be created in 
 
457
    "/branch_root/foo/baz"
 
458
 
 
459
    NOTE: cbranch also supports "cbranch_root", but that behaviour is
 
460
    deprecated.
 
461
    """
 
462
    takes_options = [Option("lightweight", 
 
463
                            help="Create a lightweight checkout"), 'revision']
 
464
    takes_args = ["source", "target?"]
 
465
    def run(self, source, target=None, lightweight=False, revision=None):
 
466
        from cbranch import cbranch
 
467
        return cbranch(source, target, lightweight=lightweight, 
 
468
                       revision=revision)
 
469
 
 
470
 
 
471
class cmd_branches(bzrlib.commands.Command):
 
472
    """Scan a location for branches"""
 
473
    takes_args = ["location?"]
 
474
    def run(self, location=None):
 
475
        from branches import branches
 
476
        return branches(location)
 
477
 
 
478
 
 
479
class cmd_multi_pull(bzrlib.commands.Command):
 
480
    """Pull all the branches under a location, e.g. a repository.
 
481
    
 
482
    Both branches present in the directory and the branches of checkouts are
 
483
    pulled.
 
484
    """
 
485
    takes_args = ["location?"]
 
486
    def run(self, location=None):
 
487
        from bzrlib.branch import Branch
 
488
        from bzrlib.transport import get_transport
 
489
        from bzrtools import iter_branch_tree
 
490
        if location is None:
 
491
            location = '.'
 
492
        t = get_transport(location)
 
493
        if not t.listable():
 
494
            print "Can't list this type of location."
 
495
            return 3
 
496
        for branch, wt in iter_branch_tree(t):
 
497
            if wt is None:
 
498
                pullable = branch
 
499
            else:
 
500
                pullable = wt
 
501
            parent = branch.get_parent()
 
502
            if parent is None:
 
503
                continue
 
504
            if wt is not None:
 
505
                base = wt.basedir
 
506
            else:
 
507
                base = branch.base
 
508
            if base.startswith(t.base):
 
509
                relpath = base[len(t.base):].rstrip('/')
 
510
            else:
 
511
                relpath = base
 
512
            print "Pulling %s from %s" % (relpath, parent)
 
513
            try:
 
514
                pullable.pull(Branch.open(parent))
 
515
            except Exception, e:
 
516
                print e
 
517
 
 
518
 
 
519
class cmd_branch_mark(bzrlib.commands.Command):
 
520
    """
 
521
    Add, view or list branch markers <EXPERIMENTAL>
 
522
 
 
523
    To add a mark, do 'bzr branch-mark MARK'.
 
524
    To list marks, do 'bzr branch-mark' (this lists all marks for the branch's
 
525
    repository).
 
526
    To delete a mark, do 'bzr branch-mark --delete MARK'
 
527
 
 
528
    These marks can be used to track a branch's status.
 
529
    """
 
530
    takes_args = ['mark?', 'branch?']
 
531
    takes_options = [Option('delete', help='Delete this mark')]
 
532
    def run(self, mark=None, branch=None, delete=False):
 
533
        from branch_mark import branch_mark
 
534
        branch_mark(mark, branch, delete)
 
535
 
 
536
 
 
537
class cmd_import(bzrlib.commands.Command):
 
538
    """Import sources from a directory, tarball or zip file
 
539
    
 
540
    This command will import a directory, tarball or zip file into a bzr
 
541
    tree, replacing any versioned files already present.  If a directory is
 
542
    specified, it is used as the target.  If the directory does not exist, or
 
543
    is not versioned, it is created.
 
544
 
 
545
    Tarballs may be gzip or bzip2 compressed.  This is autodetected.
 
546
 
 
547
    If the tarball or zip has a single root directory, that directory is
 
548
    stripped when extracting the tarball.  This is not done for directories.
 
549
    """
 
550
    
 
551
    takes_args = ['source', 'tree?']
 
552
    def run(self, source, tree=None):
 
553
        from upstream_import import do_import
 
554
        do_import(source, tree)
 
555
 
 
556
 
 
557
class cmd_cdiff(bzrlib.commands.Command):
 
558
    """A color version of bzr's diff"""
 
559
    takes_args = property(lambda x: get_cmd_object('diff').takes_args)
 
560
 
 
561
    def _takes_options(self):
 
562
        options = list(get_cmd_object('diff').takes_options)
 
563
        options.append(Option('check-style',
 
564
            help='Warn if trailing whitespace or spurious changes have been'
 
565
                 ' added.'))
 
566
        return options
 
567
 
 
568
    takes_options = property(_takes_options)
 
569
 
 
570
    def run(self, check_style=False, *args, **kwargs):
 
571
        from colordiff import colordiff
 
572
        colordiff(check_style, *args, **kwargs)
 
573
 
 
574
 
 
575
class cmd_baz_import(bzrlib.commands.Command):
 
576
    """Import an Arch or Baz archive into a bzr repository.
 
577
 
 
578
    This command should be used on local archives (or mirrors) only.  It is
 
579
    quite slow on remote archives.
 
580
    
 
581
    reuse_history allows you to specify any previous imports you 
 
582
    have done of different archives, which this archive has branches
 
583
    tagged from. This will dramatically reduce the time to convert 
 
584
    the archive as it will not have to convert the history already
 
585
    converted in that other branch.
 
586
 
 
587
    If you specify prefixes, only branches whose names start with that prefix
 
588
    will be imported.  Skipped branches will be listed, so you can import any
 
589
    branches you missed by accident.  Here's an example of doing a partial
 
590
    import from thelove@canonical.com:
 
591
    bzr baz-import thelove thelove@canonical.com --prefixes dists:talloc-except
 
592
 
 
593
    WARNING: Encoding should not be specified unless necessary, because if you
 
594
    specify an encoding, your converted branch will not interoperate with
 
595
    independently-converted branches, unless the other branches were converted
 
596
    with exactly the same encoding.  Any encoding recognized by Python may
 
597
    be specified.  Aliases are not detected, so 'utf_8', 'U8', 'UTF' and 'utf8'
 
598
    are incompatible.
 
599
    """
 
600
    takes_args = ['to_root_dir', 'from_archive', 'reuse_history*']
 
601
    takes_options = ['verbose', Option('prefixes', type=str,
 
602
                     help="Prefixes of branches to import, colon-separated"),
 
603
                     Option('encoding', type=str, 
 
604
                     help='Force encoding to specified value.  See WARNING.')]
 
605
 
 
606
    def run(self, to_root_dir, from_archive, encoding=None, verbose=False,
 
607
            reuse_history_list=[], prefixes=None):
 
608
        from errors import NoPyBaz
 
609
        try:
 
610
            import baz_import
 
611
            baz_import.baz_import(to_root_dir, from_archive, encoding,
 
612
                                  verbose, reuse_history_list, prefixes)
 
613
        except NoPyBaz:
 
614
            print "This command is disabled.  Please install PyBaz."
 
615
 
 
616
 
 
617
class cmd_baz_import_branch(bzrlib.commands.Command):
 
618
    """Import an Arch or Baz branch into a bzr branch.
 
619
 
 
620
    WARNING: Encoding should not be specified unless necessary, because if you
 
621
    specify an encoding, your converted branch will not interoperate with
 
622
    independently-converted branches, unless the other branches were converted
 
623
    with exactly the same encoding.  Any encoding recognized by Python may
 
624
    be specified.  Aliases are not detected, so 'utf_8', 'U8', 'UTF' and 'utf8'
 
625
    are incompatible.
 
626
    """
 
627
    takes_args = ['to_location', 'from_branch?', 'reuse_history*']
 
628
    takes_options = ['verbose', Option('max-count', type=int),
 
629
                     Option('encoding', type=str, 
 
630
                     help='Force encoding to specified value.  See WARNING.')]
 
631
 
 
632
    def run(self, to_location, from_branch=None, fast=False, max_count=None,
 
633
            encoding=None, verbose=False, dry_run=False,
 
634
            reuse_history_list=[]):
 
635
        from errors import NoPyBaz
 
636
        try:
 
637
            import baz_import
 
638
            baz_import.baz_import_branch(to_location, from_branch, fast, 
 
639
                                         max_count, verbose, encoding, dry_run,
 
640
                                         reuse_history_list)
 
641
        except NoPyBaz:
 
642
            print "This command is disabled.  Please install PyBaz."
 
643
 
 
644
 
 
645
class cmd_rspush(bzrlib.commands.Command):
 
646
    """Upload this branch to another location using rsync.
 
647
 
 
648
    If no location is specified, the last-used location will be used.  To 
 
649
    prevent dirty trees from being uploaded, rspush will error out if there are 
 
650
    unknown files or local changes.  It will also error out if the upstream 
 
651
    directory is non-empty and not an earlier version of the branch. 
 
652
    """
 
653
    takes_args = ['location?']
 
654
    takes_options = [Option('overwrite', help='Ignore differences between'
 
655
                            ' branches and overwrite unconditionally'),
 
656
                     Option('no-tree', help='Do not push the working tree,'
 
657
                            ' just the .bzr.')]
 
658
 
 
659
    def run(self, location=None, overwrite=False, no_tree=False):
 
660
        from bzrlib import workingtree
 
661
        import bzrtools
 
662
        cur_branch = workingtree.WorkingTree.open_containing(".")[0]
 
663
        bzrtools.rspush(cur_branch, location, overwrite=overwrite, 
 
664
                      working_tree=not no_tree)
 
665
 
 
666
 
 
667
class cmd_switch(bzrlib.commands.Command):
 
668
    """Set the branch of a lightweight checkout and update."""
 
669
 
 
670
    takes_args = ['to_location']
 
671
 
 
672
    def run(self, to_location):
 
673
        from switch import cmd_switch
 
674
        cmd_switch().run(to_location)
 
675
 
 
676
 
 
677
commands = [
 
678
            cmd_baz_import,
 
679
            cmd_baz_import_branch,
 
680
            cmd_branches,
 
681
            cmd_branch_history,
 
682
            cmd_branch_mark,
 
683
            cmd_cbranch,  
 
684
            cmd_cdiff,
 
685
            cmd_clean_tree,
 
686
            cmd_fetch_ghosts,
 
687
            cmd_graph_ancestry,
 
688
            cmd_import,
 
689
            cmd_multi_pull,
 
690
            cmd_patch,
 
691
            cmd_rspush,
 
692
            cmd_shelf, 
 
693
            cmd_shell,
 
694
            cmd_shelve, 
 
695
            cmd_switch,
 
696
            cmd_unshelve, 
 
697
            cmd_zap,            
 
698
            ]
318
699
 
319
700
 
320
701
if hasattr(bzrlib.commands, 'register_command'):
321
702
    for command in commands:
322
703
        bzrlib.commands.register_command(command)
323
 
    for command in command_decorators:
324
 
        command._original_command = bzrlib.commands.register_command(
325
 
            command, True)
326
704
 
327
705
 
328
706
def test_suite():
329
 
    import baz_import
330
707
    from bzrlib.tests.TestUtil import TestLoader
331
708
    import tests
332
709
    from doctest import DocTestSuite, ELLIPSIS
333
710
    from unittest import TestSuite
334
 
    import clean_tree
 
711
    import bzrtools
 
712
    import tests.clean_tree
 
713
    import tests.is_clean
 
714
    import tests.upstream_import
335
715
    import zap
336
716
    import tests.blackbox
337
717
    import tests.shelf_tests
338
718
    result = TestSuite()
339
719
    result.addTest(DocTestSuite(bzrtools, optionflags=ELLIPSIS))
340
 
    result.addTest(clean_tree.test_suite())
341
 
    result.addTest(DocTestSuite(baz_import))
 
720
    result.addTest(tests.clean_tree.test_suite())
 
721
    try:
 
722
        import baz_import
 
723
        result.addTest(DocTestSuite(baz_import))
 
724
    except NoPyBaz:
 
725
        pass
342
726
    result.addTest(tests.test_suite())
343
727
    result.addTest(TestLoader().loadTestsFromModule(tests.shelf_tests))
344
728
    result.addTest(tests.blackbox.test_suite())
 
729
    result.addTest(tests.upstream_import.test_suite())
345
730
    result.addTest(zap.test_suite())
 
731
    result.addTest(TestLoader().loadTestsFromModule(tests.is_clean))
346
732
    return result