← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to __init__.py

  • Committer: Aaron Bentley
  • Date: 2008-03-11 13:25:33 UTC
  • Revision ID: aaron@aaronbentley.com-20080311132533-m4ycn0ck7wqwmkq9
Update for API change

Show diffs side-by-side

added added

removed removed

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