← 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-10 20:15:27 UTC
  • Revision ID: aaron.bentley@utoronto.ca-20051110201527-8caa84ae529a1871
Added Daniel Silverstone to credits

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