← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to __init__.py

  • Committer: Aaron Bentley
  • Date: 2006-12-12 16:50:31 UTC
  • Revision ID: abentley@panoramicfeedback.com-20061212165031-51w8gjy1eps1vnw0
update NEWS

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