← 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-24 19:01:30 UTC
  • Revision ID: abentley@panoramicfeedback.com-20060324190130-2208c693486a8b33
Added apache index scraping to the branches command

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