← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to __init__.py

  • Committer: Aaron Bentley
  • Date: 2006-03-31 01:47:15 UTC
  • Revision ID: aaron.bentley@utoronto.ca-20060331014715-127c9cda9bbc1e6f
Strip trailing / from input location

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
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
 
 
 
1
#!/usr/bin/python
19
2
"""\
20
3
Various useful plugins for working with bzr.
21
4
"""
22
 
 
23
 
import bzrlib
24
 
 
25
 
 
26
 
__version__ = '0.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
 
5
import bzrlib.commands
 
6
import push
 
7
from errors import CommandError
75
8
from patchsource import BzrPatchSource
 
9
from shelf import Shelf
76
10
import sys
77
11
import os.path
78
 
 
79
 
import bzrlib.builtins
80
 
import bzrlib.commands
81
 
from bzrlib.commands import get_cmd_object
 
12
from bzrlib.option import Option
 
13
import bzrlib.branch
82
14
from bzrlib.errors import BzrCommandError
83
 
import bzrlib.ignores
84
 
from bzrlib.option import Option
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
 
 
 
15
sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__), 
 
16
                                                 "external")))
 
17
from bzrlib import DEFAULT_IGNORE
 
18
 
 
19
 
 
20
DEFAULT_IGNORE.append('./.shelf')
 
21
DEFAULT_IGNORE.append('./.bzr-shelf*')
 
22
 
 
23
 
 
24
Option.OPTIONS['ignored'] = Option('ignored',
 
25
        help='delete all ignored files.')
 
26
Option.OPTIONS['detritus'] = Option('detritus',
 
27
        help='delete conflict files merge backups, and failed selftest dirs.' +
 
28
              '(*.THIS, *.BASE, *.OTHER, *~, *.tmp')
 
29
Option.OPTIONS['dry-run'] = Option('dry-run',
 
30
        help='show files to delete instead of deleting them.')
92
31
 
93
32
class cmd_clean_tree(bzrlib.commands.Command):
94
 
    """Remove unwanted files from working tree.
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.
 
33
    """Remove unwanted files from working tree.  <BZRTOOLS>
 
34
    Normally, ignored files are left alone.
107
35
    """
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):
 
36
    takes_options = ['ignored', 'detritus', 'dry-run']
 
37
    def run(self, ignored=False, detritus=False, dry_run=False):
116
38
        from clean_tree import clean_tree
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)
 
39
        clean_tree('.', ignored=ignored, detritus=detritus, dry_run=dry_run)
121
40
 
 
41
Option.OPTIONS['merge-branch'] = Option('merge-branch',type=str)
122
42
 
123
43
class cmd_graph_ancestry(bzrlib.commands.Command):
124
 
    """Produce ancestry graphs using dot.
 
44
    """Produce ancestry graphs using dot.  <BZRTOOLS>
125
45
    
126
46
    Output format is detected according to file extension.  Some of the more
127
47
    common output formats are html, png, gif, svg, ps.  An extension of '.dot'
132
52
    with the last 5 characters of their revision identifier are used instead.
133
53
 
134
54
    The value starting with d is "(maximum) distance from the null revision".
135
 
 
 
55
    
136
56
    If --merge-branch is specified, the two branches are compared and a merge
137
57
    base is selected.
138
 
 
 
58
    
139
59
    Legend:
140
60
    white    normal revision
141
61
    yellow   THIS  history
156
76
    be disabled with --no-antialias.
157
77
    """
158
78
    takes_args = ['branch', 'file']
159
 
    takes_options = [Option('no-collapse', help="Do not skip simple nodes"),
 
79
    takes_options = [Option('no-collapse', help="Do not skip simple nodes"), 
160
80
                     Option('no-antialias',
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)]
 
81
                     help="Do not use rsvg to produce antialiased output"), 
 
82
                     Option('merge-branch', type=str, 
 
83
                     help="Use this branch to calcuate a merge base"), 
 
84
                     Option('cluster', help="Use clustered output.")]
167
85
    def run(self, branch, file, no_collapse=False, no_antialias=False,
168
 
        merge_branch=None, cluster=False, max_distance=None):
 
86
        merge_branch=None, cluster=False):
169
87
        import graph
170
88
        if cluster:
171
89
            ranking = "cluster"
172
90
        else:
173
91
            ranking = "forced"
174
 
        graph.write_ancestry_file(branch, file, not no_collapse,
175
 
                                  not no_antialias, merge_branch, ranking,
176
 
                                  max_distance=max_distance)
177
 
 
 
92
        graph.write_ancestry_file(branch, file, not no_collapse, 
 
93
                                  not no_antialias, merge_branch, ranking)
178
94
 
179
95
class cmd_fetch_ghosts(bzrlib.commands.Command):
180
 
    """Attempt to retrieve ghosts from another branch.
 
96
    """Attempt to retrieve ghosts from another branch.  <BZRTOOLS>
181
97
    If the other branch is not supplied, the last-pulled branch is used.
182
98
    """
183
99
    aliases = ['fetch-missing']
189
105
 
190
106
strip_help="""Strip the smallest prefix containing num leading slashes  from \
191
107
each file name found in the patch file."""
192
 
 
193
 
 
 
108
Option.OPTIONS['strip'] = Option('strip', type=int, help=strip_help)
 
109
Option.OPTIONS['bzrdiff'] = Option('bzrdiff',type=None,
 
110
                                help="""Handle extra bzr tags""")
194
111
class cmd_patch(bzrlib.commands.Command):
195
 
    """Apply a named patch to the current tree.
 
112
    """Apply a named patch to the current tree.  <BZRTOOLS>
196
113
    """
197
114
    takes_args = ['filename?']
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):
 
115
    takes_options = ['strip','bzrdiff']
 
116
    def run(self, filename=None, strip=-1, bzrdiff=0):
201
117
        from patch import patch
202
118
        from bzrlib.workingtree import WorkingTree
203
119
        wt = WorkingTree.open_containing('.')[0]
204
 
        if strip is None:
205
 
            strip = 0
206
 
        return patch(wt, filename, strip, silent)
 
120
        if strip == -1:
 
121
            if bzrdiff: strip = 0
 
122
            else:       strip = 1
207
123
 
 
124
        return patch(wt, filename, strip, legacy= not bzrdiff)
208
125
 
209
126
class cmd_shelve(bzrlib.commands.Command):
210
 
    """Temporarily set aside some changes from the current tree.
 
127
    """Temporarily set aside some changes from the current tree.  <BZRTOOLS>
211
128
 
212
129
    Shelve allows you to temporarily put changes you've made "on the shelf",
213
130
    ie. out of the way, until a later time when you can bring them back from
221
138
    By default shelve asks you what you want to shelve, press '?' at the
222
139
    prompt to get help. To shelve everything run shelve --all.
223
140
 
 
141
    You can put multiple items on the shelf, each time you run unshelve the
 
142
    most recently shelved changes will be reinstated.
 
143
 
224
144
    If filenames are specified, only the changes to those files will be
225
145
    shelved, other files will be left untouched.
226
146
 
227
147
    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.
237
148
    """
238
149
 
239
150
    takes_args = ['file*']
240
151
    takes_options = ['message', 'revision',
241
 
            Option('all', help='Shelve all changes without prompting'),
242
 
            Option('no-color', help='Never display changes in color')]
 
152
            Option('all', help='Shelve all changes without prompting')]
243
153
 
244
 
    def run(self, all=False, file_list=None, message=None, revision=None,
245
 
            no_color=False):
 
154
    def run(self, all=False, file_list=None, message=None, revision=None):
246
155
        if revision is not None and revision:
247
156
            if len(revision) == 1:
248
157
                revision = revision[0]
251
160
                                  "parameter.")
252
161
 
253
162
        source = BzrPatchSource(revision, file_list)
254
 
        s = shelf.Shelf(source.base)
255
 
        s.shelve(source, all, message, no_color)
 
163
        s = Shelf(source.base)
 
164
        s.shelve(source, all, message)
256
165
        return 0
257
166
 
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
167
class cmd_shelf(bzrlib.commands.Command):
302
 
    """Perform various operations on your shelved patches. See also shelve."""
 
168
    """Perform various operations on your shelved patches. See also shelve.
 
169
 
 
170
    Subcommands:
 
171
        list   (ls)           List the patches on the current shelf.
 
172
        delete (del) <patch>  Delete a patch from the current shelf.
 
173
        switch       <shelf>  Switch to the named shelf, create it if necessary.
 
174
        show         <patch>  Show the contents of the specified patch.
 
175
        upgrade               Upgrade old format shelves.
 
176
    """
303
177
    takes_args = ['subcommand', 'args*']
304
178
 
305
 
    subcommands = [cmd_shelf_list, cmd_shelf_delete, cmd_shelf_switch,
306
 
        cmd_shelf_show, cmd_shelf_upgrade]
307
 
 
308
179
    def run(self, subcommand, args_list):
309
180
        import sys
310
181
 
311
 
        if args_list is None:
312
 
            args_list = []
313
 
        cmd = self._get_cmd_object(subcommand)
314
182
        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
 
183
        s = Shelf(source.base)
 
184
 
 
185
        if subcommand == 'ls' or subcommand == 'list':
 
186
            self.__check_no_args(args_list, "shelf list takes no arguments!")
 
187
            s.list()
 
188
        elif subcommand == 'delete' or subcommand == 'del':
 
189
            self.__check_one_arg(args_list, "shelf delete takes one argument!")
 
190
            s.delete(args_list[0])
 
191
        elif subcommand == 'switch':
 
192
            self.__check_one_arg(args_list, "shelf switch takes one argument!")
 
193
            s = Shelf(source.base, args_list[0])
 
194
            s.make_default()
 
195
        elif subcommand == 'show':
 
196
            self.__check_one_arg(args_list, "shelf show takes one argument!")
 
197
            s.display(args_list[0])
 
198
        elif subcommand == 'upgrade':
 
199
            self.__check_no_args(args_list, "shelf upgrade takes no arguments!")
 
200
            s.upgrade()
 
201
        else:
 
202
            print subcommand, args_list
 
203
            print >>sys.stderr, "Unknown shelf subcommand '%s'" % subcommand
 
204
 
 
205
    def __check_one_arg(self, args, msg):
 
206
        if args is None or len(args) != 1:
 
207
            raise CommandError(msg)
 
208
 
 
209
    def __check_no_args(self, args, msg):
 
210
        if args is not None:
 
211
            raise CommandError(msg)
365
212
 
366
213
 
367
214
class cmd_unshelve(bzrlib.commands.Command):
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
 
 
 
215
    """Restore the most recently shelved changes to current tree.  <BZRTOOLS>
373
216
    See 'shelve' for more information.
374
217
    """
375
218
    takes_options = [
376
219
            Option('all', help='Unshelve all changes without prompting'),
377
220
            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):
 
221
    ]
 
222
    def run(self, all=False, force=False):
382
223
        source = BzrPatchSource()
383
 
        s = shelf.Shelf(source.base)
384
 
        s.unshelve(source, patch, all, force, no_color)
 
224
        s = Shelf(source.base)
 
225
        s.unshelve(source, all, force)
385
226
        return 0
386
227
 
387
228
 
388
229
class cmd_shell(bzrlib.commands.Command):
389
 
    """Begin an interactive shell tailored for bzr.
 
230
    """Begin an interactive shell tailored for bzr.  <BZRTOOLS>
390
231
    Bzr commands can be used without typing bzr first, and will be run natively
391
232
    when possible.  Tab completion is tailored for bzr.  The shell prompt shows
392
233
    the branch nick, revno, and path.
407
248
        import shell
408
249
        return shell.run_shell()
409
250
 
410
 
 
411
251
class cmd_branch_history(bzrlib.commands.Command):
412
252
    """\
413
 
    Display the development history of a branch.
 
253
    Display the development history of a branch  <BZRTOOLS>.
414
254
 
415
255
    Each different committer or branch nick is considered a different line of
416
256
    development.  Committers are treated as the same if they have the same
418
258
    """
419
259
    takes_args = ["branch?"]
420
260
    def run(self, branch=None):
421
 
        from branchhistory import branch_history
 
261
        from branchhistory import branch_history 
422
262
        return branch_history(branch)
423
263
 
424
264
 
425
265
class cmd_zap(bzrlib.commands.Command):
426
266
    """\
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).
 
267
    Remove a checkout, if it can be done safely. <BZRTOOLS>
 
268
 
 
269
    This command will remove a checkout without losing data.  That means
 
270
    it only removes checkouts, and only if they have no uncommitted changes.
435
271
    """
436
272
    takes_options = [Option("branch", help="Remove associtated branch from"
437
273
                                           " repository")]
443
279
 
444
280
class cmd_cbranch(bzrlib.commands.Command):
445
281
    """
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.
 
282
    Create a new checkout, associated with a new repository branch. <BZRTOOLS>
 
283
    
 
284
    When you cbranch, bzr looks up the repository associated with your current
 
285
    directory in branches.conf.  It creates a new branch in that repository
 
286
    with the same name and relative path as the checkout you request.
 
287
 
 
288
    The branches.conf parameter is "cbranch_root".  So if you want 
 
289
    cbranch operations in /home/jrandom/bigproject to produce branches in 
 
290
    /home/jrandom/bigproject/repository, you'd add this:
 
291
 
 
292
    [/home/jrandom/bigproject]
 
293
    cbranch_root = /home/jrandom/bigproject/repository
 
294
 
 
295
    Note that if "/home/jrandom/bigproject/repository" isn't a repository,
 
296
    standalone branches will be produced.  Standalone branches will also
 
297
    be produced if the source branch is in 0.7 format (or earlier).
462
298
    """
463
 
    takes_options = [Option("lightweight",
464
 
                            help="Create a lightweight checkout"), 'revision']
 
299
    takes_options = [Option("lightweight", 
 
300
                            help="Create a lightweight checkout")]
465
301
    takes_args = ["source", "target?"]
466
 
    def run(self, source, target=None, lightweight=False, revision=None):
 
302
    def run(self, source, target=None, lightweight=False):
467
303
        from cbranch import cbranch
468
 
        return cbranch(source, target, lightweight=lightweight,
469
 
                       revision=revision)
 
304
        return cbranch(source, target, lightweight=lightweight)
470
305
 
471
306
 
472
307
class cmd_branches(bzrlib.commands.Command):
473
 
    """Scan a location for branches"""
 
308
    """Scan a location for branches <BZRTOOLS>"""
474
309
    takes_args = ["location?"]
475
310
    def run(self, location=None):
476
311
        from branches import branches
478
313
 
479
314
 
480
315
class cmd_multi_pull(bzrlib.commands.Command):
481
 
    """Pull all the branches under a location, e.g. a repository.
482
 
 
 
316
    """Pull all the branches under a location, e.g. a repository. <BZRTOOLS>
 
317
    
483
318
    Both branches present in the directory and the branches of checkouts are
484
319
    pulled.
485
320
    """
517
352
                print e
518
353
 
519
354
 
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
 
            ]
 
355
commands = [cmd_shelve, cmd_unshelve, cmd_shelf, cmd_clean_tree,
 
356
            cmd_graph_ancestry, cmd_fetch_ghosts, cmd_patch, cmd_shell,
 
357
            cmd_branch_history, cmd_zap, cmd_cbranch, cmd_branches, 
 
358
            cmd_multi_pull]
 
359
 
 
360
 
 
361
command_decorators = []
 
362
 
 
363
 
 
364
import bzrlib.builtins
 
365
if not hasattr(bzrlib.builtins, "cmd_push"):
 
366
    commands.append(push.cmd_push)
 
367
else:
 
368
    command_decorators.append(push.cmd_push)
 
369
 
 
370
from errors import NoPyBaz
 
371
try:
 
372
    import baz_import
 
373
    commands.append(baz_import.cmd_baz_import_branch)
 
374
    commands.append(baz_import.cmd_baz_import)
 
375
 
 
376
except NoPyBaz:
 
377
    class cmd_baz_import_branch(bzrlib.commands.Command):
 
378
        """Disabled. (Requires PyBaz)   <BZRTOOLS>"""
 
379
        takes_args = ['to_location?', 'from_branch?', 'reuse_history*']
 
380
        takes_options = ['verbose', Option('max-count', type=int)]
 
381
        def run(self, to_location=None, from_branch=None, fast=False, 
 
382
                max_count=None, verbose=False, dry_run=False,
 
383
                reuse_history_list=[]):
 
384
            print "This command is disabled.  Please install PyBaz."
 
385
 
 
386
 
 
387
    class cmd_baz_import(bzrlib.commands.Command):
 
388
        """Disabled. (Requires PyBaz)   <BZRTOOLS>"""
 
389
        takes_args = ['to_root_dir?', 'from_archive?', 'reuse_history*']
 
390
        takes_options = ['verbose', Option('prefixes', type=str,
 
391
                         help="Prefixes of branches to import")]
 
392
        def run(self, to_root_dir=None, from_archive=None, verbose=False,
 
393
                reuse_history_list=[], prefixes=None):
 
394
                print "This command is disabled.  Please install PyBaz."
 
395
    commands.extend((cmd_baz_import_branch, cmd_baz_import))
700
396
 
701
397
 
702
398
if hasattr(bzrlib.commands, 'register_command'):
703
399
    for command in commands:
704
400
        bzrlib.commands.register_command(command)
 
401
    for command in command_decorators:
 
402
        command._original_command = bzrlib.commands.register_command(
 
403
            command, True)
705
404
 
706
405
 
707
406
def test_suite():
 
407
    import baz_import
708
408
    from bzrlib.tests.TestUtil import TestLoader
709
409
    import tests
710
410
    from doctest import DocTestSuite, ELLIPSIS
711
411
    from unittest import TestSuite
712
 
    import bzrtools
713
 
    import tests.clean_tree
714
 
    import tests.is_clean
715
 
    import tests.upstream_import
 
412
    import clean_tree
716
413
    import zap
717
414
    import tests.blackbox
718
415
    import tests.shelf_tests
719
416
    result = TestSuite()
720
417
    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
 
418
    result.addTest(clean_tree.test_suite())
 
419
    result.addTest(DocTestSuite(baz_import))
727
420
    result.addTest(tests.test_suite())
728
421
    result.addTest(TestLoader().loadTestsFromModule(tests.shelf_tests))
729
422
    result.addTest(tests.blackbox.test_suite())
730
 
    result.addTest(tests.upstream_import.test_suite())
731
423
    result.addTest(zap.test_suite())
732
 
    result.addTest(TestLoader().loadTestsFromModule(tests.is_clean))
733
424
    return result