← 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-05-10 01:29:41 UTC
  • mfrom: (364.1.4 bzrtools)
  • Revision ID: aaron.bentley@utoronto.ca-20060510012941-c46cf94b001d8d3e
Merge

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
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.
70
36
    """
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):
 
37
    takes_options = ['ignored', 'detritus', 'dry-run']
 
38
    def run(self, ignored=False, detritus=False, dry_run=False):
79
39
        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.
 
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>
88
46
    
89
47
    Output format is detected according to file extension.  Some of the more
90
48
    common output formats are html, png, gif, svg, ps.  An extension of '.dot'
95
53
    with the last 5 characters of their revision identifier are used instead.
96
54
 
97
55
    The value starting with d is "(maximum) distance from the null revision".
98
 
 
 
56
    
99
57
    If --merge-branch is specified, the two branches are compared and a merge
100
58
    base is selected.
101
 
 
 
59
    
102
60
    Legend:
103
61
    white    normal revision
104
62
    yellow   THIS  history
118
76
    If available, rsvg is used to antialias PNG and JPEG output, but this can
119
77
    be disabled with --no-antialias.
120
78
    """
121
 
    takes_args = ['file', 'merge_branch?']
122
 
    takes_options = [Option('no-collapse', help="Do not skip simple nodes."),
 
79
    takes_args = ['branch', 'file']
 
80
    takes_options = [Option('no-collapse', help="Do not skip simple nodes"), 
123
81
                     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
 
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):
141
88
        import graph
142
89
        if cluster:
143
90
            ranking = "cluster"
144
91
        else:
145
92
            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.
 
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>
153
98
    If the other branch is not supplied, the last-pulled branch is used.
154
99
    """
155
100
    aliases = ['fetch-missing']
156
101
    takes_args = ['branch?']
157
 
    takes_options = [Option('no-fix', help="Skip additional synchonization.")]
 
102
    takes_options = [Option('no-fix')]
158
103
    def run(self, branch=None, no_fix=False):
159
104
        from fetch_ghosts import fetch_ghosts
160
105
        fetch_ghosts(branch, no_fix)
161
106
 
162
107
strip_help="""Strip the smallest prefix containing num leading slashes  from \
163
108
each file name found in the patch file."""
164
 
 
165
 
 
166
 
class cmd_patch(BzrToolsCommand):
167
 
    """Apply a named patch to the current tree.
 
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>
168
114
    """
169
115
    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):
 
116
    takes_options = ['strip','bzrdiff']
 
117
    def run(self, filename=None, strip=-1, bzrdiff=0):
173
118
        from patch import patch
174
119
        from bzrlib.workingtree import WorkingTree
175
120
        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.
 
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>
183
129
 
184
130
    Shelve allows you to temporarily put changes you've made "on the shelf",
185
131
    ie. out of the way, until a later time when you can bring them back from
193
139
    By default shelve asks you what you want to shelve, press '?' at the
194
140
    prompt to get help. To shelve everything run shelve --all.
195
141
 
 
142
    You can put multiple items on the shelf, each time you run unshelve the
 
143
    most recently shelved changes will be reinstated.
 
144
 
196
145
    If filenames are specified, only the changes to those files will be
197
146
    shelved, other files will be left untouched.
198
147
 
199
148
    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
149
    """
210
150
 
211
151
    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.')]
 
152
    takes_options = ['message', 'revision',
 
153
            Option('all', help='Shelve all changes without prompting')]
218
154
 
219
 
    def run(self, all=False, file_list=None, message=None, revision=None,
220
 
            no_color=False):
 
155
    def run(self, all=False, file_list=None, message=None, revision=None):
221
156
        if revision is not None and revision:
222
157
            if len(revision) == 1:
223
158
                revision = revision[0]
226
161
                                  "parameter.")
227
162
 
228
163
        source = BzrPatchSource(revision, file_list)
229
 
        s = shelf.Shelf(source.base)
230
 
        s.shelve(source, all, message, no_color)
 
164
        s = Shelf(source.base)
 
165
        s.shelve(source, all, message)
231
166
        return 0
232
167
 
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."""
 
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
    """
278
178
    takes_args = ['subcommand', 'args*']
279
179
 
280
 
    subcommands = [cmd_shelf_list, cmd_shelf_delete, cmd_shelf_switch,
281
 
        cmd_shelf_show, cmd_shelf_upgrade]
282
 
 
283
180
    def run(self, subcommand, args_list):
284
181
        import sys
285
182
 
286
 
        if args_list is None:
287
 
            args_list = []
288
 
        cmd = self._get_cmd_object(subcommand)
289
183
        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
 
 
 
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>
348
217
    See 'shelve' for more information.
349
218
    """
350
219
    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):
 
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):
357
224
        source = BzrPatchSource()
358
 
        s = shelf.Shelf(source.base)
359
 
        s.unshelve(source, patch, all, force, no_color)
 
225
        s = Shelf(source.base)
 
226
        s.unshelve(source, all, force)
360
227
        return 0
361
228
 
362
229
 
363
 
class cmd_shell(BzrToolsCommand):
364
 
    """Begin an interactive shell tailored for bzr.
 
230
class cmd_shell(bzrlib.commands.Command):
 
231
    """Begin an interactive shell tailored for bzr.  <BZRTOOLS>
365
232
    Bzr commands can be used without typing bzr first, and will be run natively
366
233
    when possible.  Tab completion is tailored for bzr.  The shell prompt shows
367
234
    the branch nick, revno, and path.
382
249
        import shell
383
250
        return shell.run_shell()
384
251
 
385
 
 
386
 
class cmd_branch_history(BzrToolsCommand):
 
252
class cmd_branch_history(bzrlib.commands.Command):
387
253
    """\
388
 
    Display the development history of a branch.
 
254
    Display the development history of a branch  <BZRTOOLS>.
389
255
 
390
256
    Each different committer or branch nick is considered a different line of
391
257
    development.  Committers are treated as the same if they have the same
393
259
    """
394
260
    takes_args = ["branch?"]
395
261
    def run(self, branch=None):
396
 
        from branchhistory import branch_history
 
262
        from branchhistory import branch_history 
397
263
        return branch_history(branch)
398
264
 
399
265
 
400
 
class cmd_zap(BzrToolsCommand):
 
266
class cmd_zap(bzrlib.commands.Command):
401
267
    """\
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).
 
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.
410
272
    """
411
 
    takes_options = [Option("branch", help="Remove associated branch from"
412
 
                                           " repository."),
413
 
                     Option('force', help='Delete tree even if contents are'
414
 
                     ' modified.')]
 
273
    takes_options = [Option("branch", help="Remove associtated branch from"
 
274
                                           " repository")]
415
275
    takes_args = ["checkout"]
416
 
    def run(self, checkout, branch=False, force=False):
 
276
    def run(self, checkout, branch=False):
417
277
        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.'),
445
 
                     Option('hardlink',
446
 
                            help='Hard-link files from source/files-from tree'
447
 
                            ' where posible.')]
 
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")]
448
302
    takes_args = ["source", "target?"]
449
 
    def run(self, source, target=None, lightweight=False, revision=None,
450
 
            files_from=None, hardlink=False):
 
303
    def run(self, source, target=None, lightweight=False):
451
304
        from cbranch import cbranch
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"""
 
305
        return cbranch(source, target, lightweight=lightweight)
 
306
 
 
307
 
 
308
class cmd_branches(bzrlib.commands.Command):
 
309
    """Scan a location for branches <BZRTOOLS>"""
459
310
    takes_args = ["location?"]
460
311
    def run(self, location=None):
461
312
        from branches import branches
462
313
        return branches(location)
463
314
 
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
 
 
 
315
 
 
316
class cmd_multi_pull(bzrlib.commands.Command):
 
317
    """Pull all the branches under a location, e.g. a repository. <BZRTOOLS>
 
318
    
478
319
    Both branches present in the directory and the branches of checkouts are
479
320
    pulled.
480
321
    """
481
322
    takes_args = ["location?"]
482
323
    def run(self, location=None):
 
324
        from bzrlib.branch import Branch
483
325
        from bzrlib.transport import get_transport
484
326
        from bzrtools import iter_branch_tree
485
327
        if location is None:
486
328
            location = '.'
487
329
        t = get_transport(location)
488
 
        possible_transports = []
489
330
        if not t.listable():
490
331
            print "Can't list this type of location."
491
332
            return 3
507
348
                relpath = base
508
349
            print "Pulling %s from %s" % (relpath, parent)
509
350
            try:
510
 
                branch_t = get_transport(parent, possible_transports)
511
 
                pullable.pull(Branch.open_from_transport(branch_t))
 
351
                pullable.pull(Branch.open(parent))
512
352
            except Exception, e:
513
353
                print e
514
354
 
515
355
 
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
 
            ]
 
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))
689
411
 
690
412
 
691
413
if hasattr(bzrlib.commands, 'register_command'):
694
416
 
695
417
 
696
418
def test_suite():
 
419
    import baz_import
697
420
    from bzrlib.tests.TestUtil import TestLoader
698
421
    import tests
699
422
    from doctest import DocTestSuite, ELLIPSIS
700
423
    from unittest import TestSuite
701
 
    import bzrtools
702
 
    import tests.clean_tree
703
 
    import tests.is_clean
704
 
    import tests.test_cbranch
705
 
    import tests.test_link_tree
706
 
    import tests.test_patch
707
 
    import tests.test_rspush
708
 
    import tests.upstream_import
 
424
    import clean_tree
709
425
    import zap
710
426
    import tests.blackbox
711
427
    import tests.shelf_tests
712
428
    result = TestSuite()
713
429
    result.addTest(DocTestSuite(bzrtools, optionflags=ELLIPSIS))
714
 
    result.addTest(tests.clean_tree.test_suite())
715
 
    try:
716
 
        import baz_import
717
 
        result.addTest(DocTestSuite(baz_import))
718
 
    except NoPyBaz:
719
 
        pass
 
430
    result.addTest(clean_tree.test_suite())
 
431
    result.addTest(DocTestSuite(baz_import))
720
432
    result.addTest(tests.test_suite())
721
433
    result.addTest(TestLoader().loadTestsFromModule(tests.shelf_tests))
722
434
    result.addTest(tests.blackbox.test_suite())
723
 
    result.addTest(tests.upstream_import.test_suite())
724
435
    result.addTest(zap.test_suite())
725
 
    result.addTest(TestLoader().loadTestsFromModule(tests.is_clean))
726
 
    result.addTest(TestLoader().loadTestsFromModule(tests.test_link_tree))
727
 
    result.addTest(TestLoader().loadTestsFromModule(tests.test_patch))
728
 
    result.addTest(TestLoader().loadTestsFromModule(tests.test_rspush))
729
 
    result.addTest(TestLoader().loadTestsFromModule(tests.test_cbranch))
730
436
    return result