← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to __init__.py

  • Committer: Aaron Bentley
  • Date: 2007-01-16 17:42:19 UTC
  • Revision ID: abentley@panoramicfeedback.com-20070116174219-qejrgg19zia79yrt
Add NEWS

Show diffs side-by-side

added added

removed removed

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