← 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 14:06:54 UTC
  • Revision ID: abentley@panoramicfeedback.com-20060324140654-cc9a6b0e8bd1f60a
Improved cbranch docs

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