← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to __init__.py

  • Committer: Aaron Bentley
  • Date: 2005-11-11 17:43:12 UTC
  • Revision ID: aaron.bentley@utoronto.ca-20051111174312-1c627d82a07bf8fd
Added patch for tab-in-patch-filename support

Show diffs side-by-side

added added

removed removed

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