~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to __init__.py

  • Committer: Aaron Bentley
  • Date: 2007-01-04 15:15:02 UTC
  • mfrom: (481.1.1 bzrtools)
  • Revision ID: abentley@panoramicfeedback.com-20070104151502-urp8lbge3kh243w4
Merge graph-ancestry distance support

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007 Aaron Bentley <aaron@aaronbentley.com>
 
1
# Copyright (C) 2005, 2006 Aaron Bentley <aaron.bentley@utoronto.ca>
2
2
# Copyright (C) 2005, 2006 Canonical Limited.
3
3
# Copyright (C) 2006 Michael Ellerman.
4
4
#
22
22
 
23
23
import bzrlib
24
24
 
25
 
from bzrlib.lazy_import import lazy_import
26
 
lazy_import(globals(), """
27
 
from bzrlib import help, urlutils
28
 
import shelf
29
 
""")
30
 
 
31
 
from version import version_info, __version__
32
 
from command import BzrToolsCommand
33
 
from errors import CommandError
 
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
34
66
from patchsource import BzrPatchSource
 
67
from shelf import Shelf
35
68
import sys
36
69
import os.path
37
70
 
38
71
import bzrlib.builtins
39
72
import bzrlib.commands
40
 
from bzrlib.branch import Branch
41
 
from bzrlib.bzrdir import BzrDir
42
73
from bzrlib.commands import get_cmd_object
43
74
from bzrlib.errors import BzrCommandError
 
75
from bzrlib.help import command_usage
44
76
import bzrlib.ignores
45
 
from bzrlib.trace import note
46
77
from bzrlib.option import Option
47
 
sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__),
 
78
sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__), 
48
79
                                                 "external")))
49
80
 
50
81
import show_paths
51
 
from command import BzrToolsCommand
52
82
 
53
83
bzrlib.ignores.add_runtime_ignores(['./.shelf'])
54
84
 
55
85
 
56
 
class cmd_clean_tree(BzrToolsCommand):
 
86
class cmd_clean_tree(bzrlib.commands.Command):
57
87
    """Remove unwanted files from working tree.
58
88
 
59
89
    By default, only unknown files, not ignored files, are deleted.  Versioned
68
98
 
69
99
    To check what clean-tree will do, use --dry-run.
70
100
    """
71
 
    takes_options = [Option('ignored', help='Delete all ignored files.'),
72
 
                     Option('detritus', help='Delete conflict files, merge'
73
 
                            ' backups, and failed selftest dirs.'),
74
 
                     Option('unknown',
75
 
                            help='Delete files unknown to bzr (default).'),
76
 
                     Option('dry-run', help='Show files to delete instead of'
 
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'
77
107
                            ' deleting them.')]
78
108
    def run(self, unknown=False, ignored=False, detritus=False, dry_run=False):
79
109
        from clean_tree import clean_tree
83
113
                   dry_run=dry_run)
84
114
 
85
115
 
86
 
class cmd_graph_ancestry(BzrToolsCommand):
 
116
class cmd_graph_ancestry(bzrlib.commands.Command):
87
117
    """Produce ancestry graphs using dot.
88
118
    
89
119
    Output format is detected according to file extension.  Some of the more
95
125
    with the last 5 characters of their revision identifier are used instead.
96
126
 
97
127
    The value starting with d is "(maximum) distance from the null revision".
98
 
 
 
128
    
99
129
    If --merge-branch is specified, the two branches are compared and a merge
100
130
    base is selected.
101
 
 
 
131
    
102
132
    Legend:
103
133
    white    normal revision
104
134
    yellow   THIS  history
118
148
    If available, rsvg is used to antialias PNG and JPEG output, but this can
119
149
    be disabled with --no-antialias.
120
150
    """
121
 
    takes_args = ['file', 'merge_branch?']
122
 
    takes_options = [Option('no-collapse', help="Do not skip simple nodes."),
 
151
    takes_args = ['branch', 'file']
 
152
    takes_options = [Option('no-collapse', help="Do not skip simple nodes"), 
123
153
                     Option('no-antialias',
124
 
                     help="Do not use rsvg to produce antialiased output."),
125
 
                     Option('merge-branch', type=str,
126
 
                     help="Use this branch to calcuate a merge base."),
 
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"), 
127
157
                     Option('cluster', help="Use clustered output."),
128
 
                     Option('max-distance',
129
 
                            help="Show no nodes farther than this.", type=int),
130
 
                     Option('directory',
131
 
                            help='Source branch to use (default is current'
132
 
                            ' directory).',
133
 
                            short_name='d',
134
 
                            type=unicode),
135
 
                    ]
136
 
    def run(self, file, merge_branch=None, no_collapse=False,
137
 
            no_antialias=False, cluster=False, max_distance=100,
138
 
            directory='.'):
139
 
        if max_distance == -1:
140
 
            max_distance = None
 
158
                     Option('max-distance', help="Show no nodes farther than this",
 
159
                            type=int)]
 
160
    def run(self, branch, file, no_collapse=False, no_antialias=False,
 
161
        merge_branch=None, cluster=False, max_distance=None):
141
162
        import graph
142
163
        if cluster:
143
164
            ranking = "cluster"
144
165
        else:
145
166
            ranking = "forced"
146
 
        graph.write_ancestry_file(directory, file, not no_collapse,
147
 
                                  not no_antialias, merge_branch, ranking,
 
167
        graph.write_ancestry_file(branch, file, not no_collapse, 
 
168
                                  not no_antialias, merge_branch, ranking, 
148
169
                                  max_distance=max_distance)
149
170
 
150
171
 
151
 
class cmd_fetch_ghosts(BzrToolsCommand):
 
172
class cmd_fetch_ghosts(bzrlib.commands.Command):
152
173
    """Attempt to retrieve ghosts from another branch.
153
174
    If the other branch is not supplied, the last-pulled branch is used.
154
175
    """
155
176
    aliases = ['fetch-missing']
156
177
    takes_args = ['branch?']
157
 
    takes_options = [Option('no-fix', help="Skip additional synchonization.")]
 
178
    takes_options = [Option('no-fix')]
158
179
    def run(self, branch=None, no_fix=False):
159
180
        from fetch_ghosts import fetch_ghosts
160
181
        fetch_ghosts(branch, no_fix)
163
184
each file name found in the patch file."""
164
185
 
165
186
 
166
 
class cmd_patch(BzrToolsCommand):
 
187
class cmd_patch(bzrlib.commands.Command):
167
188
    """Apply a named patch to the current tree.
168
189
    """
169
190
    takes_args = ['filename?']
170
 
    takes_options = [Option('strip', type=int, help=strip_help),
171
 
                     Option('silent', help='Suppress chatter.')]
172
 
    def run(self, filename=None, strip=None, silent=False):
 
191
    takes_options = [Option('strip', type=int, help=strip_help)]
 
192
    def run(self, filename=None, strip=None):
173
193
        from patch import patch
174
194
        from bzrlib.workingtree import WorkingTree
175
195
        wt = WorkingTree.open_containing('.')[0]
176
196
        if strip is None:
177
197
            strip = 0
178
 
        return patch(wt, filename, strip, silent)
179
 
 
180
 
 
181
 
class cmd_shelve(BzrToolsCommand):
 
198
        return patch(wt, filename, strip)
 
199
 
 
200
 
 
201
class cmd_shelve(bzrlib.commands.Command):
182
202
    """Temporarily set aside some changes from the current tree.
183
203
 
184
204
    Shelve allows you to temporarily put changes you've made "on the shelf",
209
229
    """
210
230
 
211
231
    takes_args = ['file*']
212
 
    takes_options = [Option('message',
213
 
            help='A message to associate with the shelved changes.',
214
 
            short_name='m', type=unicode),
215
 
            'revision',
216
 
            Option('all', help='Shelve all changes without prompting.'),
217
 
            Option('no-color', help='Never display changes in color.')]
 
232
    takes_options = ['message', 'revision',
 
233
            Option('all', help='Shelve all changes without prompting'), 
 
234
            Option('no-color', help='Never display changes in color')]
218
235
 
219
236
    def run(self, all=False, file_list=None, message=None, revision=None,
220
237
            no_color=False):
226
243
                                  "parameter.")
227
244
 
228
245
        source = BzrPatchSource(revision, file_list)
229
 
        s = shelf.Shelf(source.base)
 
246
        s = Shelf(source.base)
230
247
        s.shelve(source, all, message, no_color)
231
248
        return 0
232
249
 
254
271
    aliases = ['switch']
255
272
    takes_args = ['othershelf']
256
273
    def run(self, othershelf):
257
 
        s = shelf.Shelf(self.shelf.base, othershelf)
 
274
        s = Shelf(self.shelf.base, othershelf)
258
275
        s.make_default()
259
276
 
260
277
 
273
290
        self.shelf.upgrade()
274
291
 
275
292
 
276
 
class cmd_shelf(BzrToolsCommand):
 
293
class cmd_shelf(bzrlib.commands.Command):
277
294
    """Perform various operations on your shelved patches. See also shelve."""
278
295
    takes_args = ['subcommand', 'args*']
279
296
 
287
304
            args_list = []
288
305
        cmd = self._get_cmd_object(subcommand)
289
306
        source = BzrPatchSource()
290
 
        s = shelf.Shelf(source.base)
 
307
        s = Shelf(source.base)
291
308
        cmd.shelf = s
292
 
 
293
 
        if args_list is None:
294
 
            args_list = []
295
309
        return cmd.run_argv_aliases(args_list)
296
310
 
297
311
    def _get_cmd_object(self, cmd_name):
314
328
        cmd_obj = cmd_class()
315
329
        indent = 2 * ' '
316
330
 
317
 
        usage = cmd_obj._usage()
 
331
        usage = command_usage(cmd_obj)
318
332
        usage = usage.replace('bzr shelf-', '')
319
333
        text.append('%s%s\n' % (indent, usage))
320
334
 
339
353
        return text
340
354
 
341
355
 
342
 
class cmd_unshelve(BzrToolsCommand):
 
356
class cmd_unshelve(bzrlib.commands.Command):
343
357
    """Restore shelved changes.
344
358
 
345
359
    By default the most recently shelved changes are restored. However if you
348
362
    See 'shelve' for more information.
349
363
    """
350
364
    takes_options = [
351
 
            Option('all', help='Unshelve all changes without prompting.'),
352
 
            Option('force', help='Force unshelving even if errors occur.'),
353
 
            Option('no-color', help='Never display changes in color.')
 
365
            Option('all', help='Unshelve all changes without prompting'),
 
366
            Option('force', help='Force unshelving even if errors occur'),
 
367
            Option('no-color', help='Never display changes in color')
354
368
        ]
355
369
    takes_args = ['patch?']
356
370
    def run(self, patch=None, all=False, force=False, no_color=False):
357
371
        source = BzrPatchSource()
358
 
        s = shelf.Shelf(source.base)
 
372
        s = Shelf(source.base)
359
373
        s.unshelve(source, patch, all, force, no_color)
360
374
        return 0
361
375
 
362
376
 
363
 
class cmd_shell(BzrToolsCommand):
 
377
class cmd_shell(bzrlib.commands.Command):
364
378
    """Begin an interactive shell tailored for bzr.
365
379
    Bzr commands can be used without typing bzr first, and will be run natively
366
380
    when possible.  Tab completion is tailored for bzr.  The shell prompt shows
383
397
        return shell.run_shell()
384
398
 
385
399
 
386
 
class cmd_branch_history(BzrToolsCommand):
 
400
class cmd_branch_history(bzrlib.commands.Command):
387
401
    """\
388
402
    Display the development history of a branch.
389
403
 
393
407
    """
394
408
    takes_args = ["branch?"]
395
409
    def run(self, branch=None):
396
 
        from branchhistory import branch_history
 
410
        from branchhistory import branch_history 
397
411
        return branch_history(branch)
398
412
 
399
413
 
400
 
class cmd_zap(BzrToolsCommand):
 
414
class cmd_zap(bzrlib.commands.Command):
401
415
    """\
402
416
    Remove a lightweight checkout, if it can be done safely.
403
417
 
408
422
    If --branch is specified, the branch will be deleted too, but only if the
409
423
    the branch has no new commits (relative to its parent).
410
424
    """
411
 
    takes_options = [Option("branch", help="Remove associated branch from"
412
 
                                           " repository."),
413
 
                     Option('force', help='Delete tree even if contents are'
414
 
                     ' modified.')]
 
425
    takes_options = [Option("branch", help="Remove associtated branch from"
 
426
                                           " repository")]
415
427
    takes_args = ["checkout"]
416
 
    def run(self, checkout, branch=False, force=False):
 
428
    def run(self, checkout, branch=False):
417
429
        from zap import zap
418
 
        return zap(checkout, remove_branch=branch, allow_modified=force)
419
 
 
420
 
 
421
 
class cmd_cbranch(BzrToolsCommand):
 
430
        return zap(checkout, remove_branch=branch)
 
431
 
 
432
 
 
433
class cmd_cbranch(bzrlib.commands.Command):
422
434
    """
423
435
    Create a new checkout, associated with a new repository branch.
424
 
 
425
 
    When you cbranch, bzr looks up a target location in locations.conf, and
426
 
    creates the branch there.
427
 
 
428
 
    In your locations.conf, add the following lines:
429
 
    [/working_directory_root]
430
 
    cbranch_target = /branch_root
431
 
    cbranch_target:policy = appendpath
432
 
 
433
 
    This will mean that if you run "bzr cbranch foo/bar foo/baz" in the
434
 
    working directory root, the branch will be created in
435
 
    "/branch_root/foo/baz"
436
 
 
437
 
    NOTE: cbranch also supports "cbranch_root", but that behaviour is
438
 
    deprecated.
 
436
    
 
437
    When you cbranch, bzr looks up the repository associated with your current
 
438
    directory in locations.conf.  It creates a new branch in that repository
 
439
    with the same name and relative path as the checkout you request.
 
440
 
 
441
    The locations.conf parameter is "cbranch_root".  So if you want 
 
442
    cbranch operations in /home/jrandom/bigproject to produce branches in 
 
443
    /home/jrandom/bigproject/repository, you'd add this:
 
444
 
 
445
    [/home/jrandom/bigproject]
 
446
    cbranch_root = /home/jrandom/bigproject/repository
 
447
 
 
448
    Note that if "/home/jrandom/bigproject/repository" isn't a repository,
 
449
    standalone branches will be produced.  Standalone branches will also
 
450
    be produced if the source branch is in 0.7 format (or earlier).
439
451
    """
440
 
    takes_options = [Option("lightweight",
441
 
                            help="Create a lightweight checkout."), 'revision',
442
 
                     Option('files-from', type=unicode,
443
 
                            help='Accelerate checkout using files from this'
444
 
                                 ' tree.'),
445
 
                     Option('hardlink',
446
 
                            help='Hard-link files from source/files-from tree'
447
 
                            ' where posible.')]
 
452
    takes_options = [Option("lightweight", 
 
453
                            help="Create a lightweight checkout"), 'revision']
448
454
    takes_args = ["source", "target?"]
449
 
    def run(self, source, target=None, lightweight=False, revision=None,
450
 
            files_from=None, hardlink=False):
 
455
    def run(self, source, target=None, lightweight=False, revision=None):
451
456
        from cbranch import cbranch
452
 
        return cbranch(source, target, lightweight=lightweight,
453
 
                       revision=revision, files_from=files_from,
454
 
                       hardlink=hardlink)
455
 
 
456
 
 
457
 
class cmd_branches(BzrToolsCommand):
 
457
        return cbranch(source, target, lightweight=lightweight, 
 
458
                       revision=revision)
 
459
 
 
460
 
 
461
class cmd_branches(bzrlib.commands.Command):
458
462
    """Scan a location for branches"""
459
463
    takes_args = ["location?"]
460
464
    def run(self, location=None):
461
465
        from branches import branches
462
466
        return branches(location)
463
467
 
464
 
class cmd_trees(BzrToolsCommand):
465
 
    """Scan a location for trees"""
466
 
    takes_args = ['location?']
467
 
    def run(self, location='.'):
468
 
        from bzrlib.workingtree import WorkingTree
469
 
        from bzrlib.transport import get_transport
470
 
        t = get_transport(location)
471
 
        for tree in WorkingTree.find_trees(location):
472
 
            self.outf.write('%s\n' % t.relpath(
473
 
                tree.bzrdir.root_transport.base))
474
468
 
475
 
class cmd_multi_pull(BzrToolsCommand):
 
469
class cmd_multi_pull(bzrlib.commands.Command):
476
470
    """Pull all the branches under a location, e.g. a repository.
477
 
 
 
471
    
478
472
    Both branches present in the directory and the branches of checkouts are
479
473
    pulled.
480
474
    """
481
475
    takes_args = ["location?"]
482
476
    def run(self, location=None):
 
477
        from bzrlib.branch import Branch
483
478
        from bzrlib.transport import get_transport
484
479
        from bzrtools import iter_branch_tree
485
480
        if location is None:
486
481
            location = '.'
487
482
        t = get_transport(location)
488
 
        possible_transports = []
489
483
        if not t.listable():
490
484
            print "Can't list this type of location."
491
485
            return 3
507
501
                relpath = base
508
502
            print "Pulling %s from %s" % (relpath, parent)
509
503
            try:
510
 
                branch_t = get_transport(parent, possible_transports)
511
 
                pullable.pull(Branch.open_from_transport(branch_t))
 
504
                pullable.pull(Branch.open(parent))
512
505
            except Exception, e:
513
506
                print e
514
507
 
515
508
 
516
 
 
517
 
class cmd_import(BzrToolsCommand):
518
 
    """Import sources from a directory, tarball or zip file
519
 
 
520
 
    This command will import a directory, tarball or zip file into a bzr
521
 
    tree, replacing any versioned files already present.  If a directory is
522
 
    specified, it is used as the target.  If the directory does not exist, or
523
 
    is not versioned, it is created.
 
509
class cmd_branch_mark(bzrlib.commands.Command):
 
510
    """
 
511
    Add, view or list branch markers <EXPERIMENTAL>
 
512
 
 
513
    To add a mark, do 'bzr branch-mark MARK'.
 
514
    To list marks, do 'bzr branch-mark' (this lists all marks for the branch's
 
515
    repository).
 
516
    To delete a mark, do 'bzr branch-mark --delete MARK'
 
517
 
 
518
    These marks can be used to track a branch's status.
 
519
    """
 
520
    takes_args = ['mark?', 'branch?']
 
521
    takes_options = [Option('delete', help='Delete this mark')]
 
522
    def run(self, mark=None, branch=None, delete=False):
 
523
        from branch_mark import branch_mark
 
524
        branch_mark(mark, branch, delete)
 
525
 
 
526
 
 
527
class cmd_import(bzrlib.commands.Command):
 
528
    """Import sources from a tarball or zip file
 
529
    
 
530
    This command will import a tarball or zip file into a bzr tree, replacing
 
531
    any versioned files already present.  If a directory is specified, it is
 
532
    used as the target.  If the directory does not exist, or is not versioned,
 
533
    it is created.
524
534
 
525
535
    Tarballs may be gzip or bzip2 compressed.  This is autodetected.
526
536
 
527
 
    If the tarball or zip has a single root directory, that directory is
528
 
    stripped when extracting the tarball.  This is not done for directories.
 
537
    If the tarball has a single root directory, that directory is stripped
 
538
    when extracting the tarball.
529
539
    """
530
 
 
 
540
    
531
541
    takes_args = ['source', 'tree?']
532
542
    def run(self, source, tree=None):
533
543
        from upstream_import import do_import
534
544
        do_import(source, tree)
535
545
 
536
546
 
537
 
class cmd_cdiff(BzrToolsCommand):
 
547
class cmd_cdiff(bzrlib.commands.Command):
538
548
    """A color version of bzr's diff"""
539
549
    takes_args = property(lambda x: get_cmd_object('diff').takes_args)
540
 
    takes_options = list(get_cmd_object('diff').takes_options) + [
541
 
        Option('check-style',
542
 
            help='Warn if trailing whitespace or spurious changes have been'
543
 
                 ' added.')]
544
 
 
545
 
    def run(self, check_style=False, *args, **kwargs):
 
550
    takes_options = property(lambda x: get_cmd_object('diff').takes_options)
 
551
    def run(*args, **kwargs):
546
552
        from colordiff import colordiff
547
 
        colordiff(check_style, *args, **kwargs)
548
 
 
549
 
 
550
 
class cmd_rspush(BzrToolsCommand):
 
553
        colordiff(*args, **kwargs)
 
554
 
 
555
 
 
556
class cmd_baz_import(bzrlib.commands.Command):
 
557
    """Import an Arch or Baz archive into a bzr repository.
 
558
 
 
559
    This command should be used on local archives (or mirrors) only.  It is
 
560
    quite slow on remote archives.
 
561
    
 
562
    reuse_history allows you to specify any previous imports you 
 
563
    have done of different archives, which this archive has branches
 
564
    tagged from. This will dramatically reduce the time to convert 
 
565
    the archive as it will not have to convert the history already
 
566
    converted in that other branch.
 
567
 
 
568
    If you specify prefixes, only branches whose names start with that prefix
 
569
    will be imported.  Skipped branches will be listed, so you can import any
 
570
    branches you missed by accident.  Here's an example of doing a partial
 
571
    import from thelove@canonical.com:
 
572
    bzr baz-import thelove thelove@canonical.com --prefixes dists:talloc-except
 
573
 
 
574
    WARNING: Encoding should not be specified unless necessary, because if you
 
575
    specify an encoding, your converted branch will not interoperate with
 
576
    independently-converted branches, unless the other branches were converted
 
577
    with exactly the same encoding.  Any encoding recognized by Python may
 
578
    be specified.  Aliases are not detected, so 'utf_8', 'U8', 'UTF' and 'utf8'
 
579
    are incompatible.
 
580
    """
 
581
    takes_args = ['to_root_dir', 'from_archive', 'reuse_history*']
 
582
    takes_options = ['verbose', Option('prefixes', type=str,
 
583
                     help="Prefixes of branches to import, colon-separated"),
 
584
                     Option('encoding', type=str, 
 
585
                     help='Force encoding to specified value.  See WARNING.')]
 
586
 
 
587
    def run(self, to_root_dir, from_archive, encoding=None, verbose=False,
 
588
            reuse_history_list=[], prefixes=None):
 
589
        from errors import NoPyBaz
 
590
        try:
 
591
            import baz_import
 
592
            baz_import.baz_import(to_root_dir, from_archive, encoding,
 
593
                                  verbose, reuse_history_list, prefixes)
 
594
        except NoPyBaz:
 
595
            print "This command is disabled.  Please install PyBaz."
 
596
 
 
597
 
 
598
class cmd_baz_import_branch(bzrlib.commands.Command):
 
599
    """Import an Arch or Baz branch into a bzr branch.
 
600
 
 
601
    WARNING: Encoding should not be specified unless necessary, because if you
 
602
    specify an encoding, your converted branch will not interoperate with
 
603
    independently-converted branches, unless the other branches were converted
 
604
    with exactly the same encoding.  Any encoding recognized by Python may
 
605
    be specified.  Aliases are not detected, so 'utf_8', 'U8', 'UTF' and 'utf8'
 
606
    are incompatible.
 
607
    """
 
608
    takes_args = ['to_location', 'from_branch?', 'reuse_history*']
 
609
    takes_options = ['verbose', Option('max-count', type=int),
 
610
                     Option('encoding', type=str, 
 
611
                     help='Force encoding to specified value.  See WARNING.')]
 
612
 
 
613
    def run(self, to_location, from_branch=None, fast=False, max_count=None,
 
614
            encoding=None, verbose=False, dry_run=False,
 
615
            reuse_history_list=[]):
 
616
        from errors import NoPyBaz
 
617
        try:
 
618
            import baz_import
 
619
            baz_import.baz_import_branch(to_location, from_branch, fast, 
 
620
                                         max_count, verbose, encoding, dry_run,
 
621
                                         reuse_history_list)
 
622
        except NoPyBaz:
 
623
            print "This command is disabled.  Please install PyBaz."
 
624
 
 
625
 
 
626
class cmd_rspush(bzrlib.commands.Command):
551
627
    """Upload this branch to another location using rsync.
552
628
 
553
 
    If no location is specified, the last-used location will be used.  To
554
 
    prevent dirty trees from being uploaded, rspush will error out if there are
555
 
    unknown files or local changes.  It will also error out if the upstream
556
 
    directory is non-empty and not an earlier version of the branch.
 
629
    If no location is specified, the last-used location will be used.  To 
 
630
    prevent dirty trees from being uploaded, rspush will error out if there are 
 
631
    unknown files or local changes.  It will also error out if the upstream 
 
632
    directory is non-empty and not an earlier version of the branch. 
557
633
    """
558
634
    takes_args = ['location?']
559
635
    takes_options = [Option('overwrite', help='Ignore differences between'
560
 
                            ' branches and overwrite unconditionally.'),
 
636
                            ' branches and overwrite unconditionally'),
561
637
                     Option('no-tree', help='Do not push the working tree,'
562
638
                            ' just the .bzr.')]
563
639
 
565
641
        from bzrlib import workingtree
566
642
        import bzrtools
567
643
        cur_branch = workingtree.WorkingTree.open_containing(".")[0]
568
 
        bzrtools.rspush(cur_branch, location, overwrite=overwrite,
 
644
        bzrtools.rspush(cur_branch, location, overwrite=overwrite, 
569
645
                      working_tree=not no_tree)
570
646
 
571
647
 
572
 
class cmd_link_tree(BzrToolsCommand):
573
 
    """Hardlink matching files to another tree.
574
 
 
575
 
    Only files with identical content and execute bit will be linked.
576
 
    """
577
 
    takes_args = ['location']
578
 
 
579
 
    def run(self, location):
580
 
        from bzrlib import workingtree
581
 
        from bzrlib.plugins.bzrtools.link_tree import link_tree
582
 
        target_tree = workingtree.WorkingTree.open_containing(".")[0]
583
 
        source_tree = workingtree.WorkingTree.open(location)
584
 
        target_tree.lock_write()
585
 
        try:
586
 
            source_tree.lock_read()
587
 
            try:
588
 
                link_tree(target_tree, source_tree)
589
 
            finally:
590
 
                source_tree.unlock()
591
 
        finally:
592
 
            target_tree.unlock()
593
 
 
594
 
from heads import cmd_heads
 
648
class cmd_switch(bzrlib.commands.Command):
 
649
    """Set the branch of a lightweight checkout and update."""
 
650
 
 
651
    takes_args = ['to_location']
 
652
 
 
653
    def run(self, to_location):
 
654
        from switch import cmd_switch
 
655
        cmd_switch().run(to_location)
 
656
 
 
657
 
595
658
commands = [
 
659
            cmd_baz_import,
 
660
            cmd_baz_import_branch,
596
661
            cmd_branches,
597
662
            cmd_branch_history,
598
 
            cmd_cbranch,
 
663
            cmd_branch_mark,
 
664
            cmd_cbranch,  
599
665
            cmd_cdiff,
600
666
            cmd_clean_tree,
601
667
            cmd_fetch_ghosts,
602
668
            cmd_graph_ancestry,
603
 
            cmd_heads,
604
669
            cmd_import,
605
 
            cmd_link_tree,
606
670
            cmd_multi_pull,
607
671
            cmd_patch,
608
672
            cmd_rspush,
609
 
            cmd_shelf,
 
673
            cmd_shelf, 
610
674
            cmd_shell,
611
 
            cmd_shelve,
612
 
            cmd_trees,
613
 
            cmd_unshelve,
614
 
            cmd_zap,
 
675
            cmd_shelve, 
 
676
            cmd_switch,
 
677
            cmd_unshelve, 
 
678
            cmd_zap,            
615
679
            ]
616
680
 
617
681
 
627
691
    from unittest import TestSuite
628
692
    import bzrtools
629
693
    import tests.clean_tree
630
 
    import tests.test_dotgraph
631
 
    import tests.is_clean
632
 
    import tests.test_cbranch
633
 
    import tests.test_link_tree
634
 
    import tests.test_patch
635
 
    import tests.test_rspush
636
694
    import tests.upstream_import
637
695
    import zap
638
696
    import tests.blackbox
640
698
    result = TestSuite()
641
699
    result.addTest(DocTestSuite(bzrtools, optionflags=ELLIPSIS))
642
700
    result.addTest(tests.clean_tree.test_suite())
 
701
    try:
 
702
        import baz_import
 
703
        result.addTest(DocTestSuite(baz_import))
 
704
    except NoPyBaz:
 
705
        pass
643
706
    result.addTest(tests.test_suite())
644
707
    result.addTest(TestLoader().loadTestsFromModule(tests.shelf_tests))
645
708
    result.addTest(tests.blackbox.test_suite())
646
709
    result.addTest(tests.upstream_import.test_suite())
647
710
    result.addTest(zap.test_suite())
648
 
    result.addTest(TestLoader().loadTestsFromModule(tests.test_dotgraph))
649
 
    result.addTest(TestLoader().loadTestsFromModule(tests.is_clean))
650
 
    result.addTest(TestLoader().loadTestsFromModule(tests.test_link_tree))
651
 
    result.addTest(TestLoader().loadTestsFromModule(tests.test_patch))
652
 
    result.addTest(TestLoader().loadTestsFromModule(tests.test_rspush))
653
 
    result.addTest(TestLoader().loadTestsFromModule(tests.test_cbranch))
654
711
    return result