← 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-06-12 22:09:44 UTC
  • mfrom: (540.1.2 bzrtools-0.17)
  • Revision ID: aaron.bentley@utoronto.ca-20070612220944-5zw4hlzp1ctq6mkl
Merge fixes from 0.17

Show diffs side-by-side

added added

removed removed

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