← 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-06-08 11:52:21 UTC
  • Revision ID: aaron.bentley@utoronto.ca-20060608115221-1b8122a2c3b24c50
Updated formatting

Show diffs side-by-side

added added

removed removed

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