← 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-02-20 14:28:36 UTC
  • Revision ID: aaron@aaronbentley.com-20080220142836-jqsca0avvl2p3bar
Remove ImportReplacer hack

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 rspush
6
 
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
7
34
from patchsource import BzrPatchSource
8
 
from shelf import Shelf
9
 
from switch import cmd_switch
10
35
import sys
11
36
import os.path
12
37
 
13
 
from bzrlib import DEFAULT_IGNORE
14
38
import bzrlib.builtins
15
 
import bzrlib.branch
16
39
import bzrlib.commands
 
40
from bzrlib.branch import Branch
 
41
from bzrlib.bzrdir import BzrDir
 
42
from bzrlib.commands import get_cmd_object
17
43
from bzrlib.errors import BzrCommandError
18
 
from bzrlib.help import command_usage
 
44
import bzrlib.ignores
 
45
from bzrlib.trace import note
19
46
from bzrlib.option import Option
20
 
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__),
21
48
                                                 "external")))
22
49
 
23
 
 
24
 
DEFAULT_IGNORE.append('./.shelf')
25
 
DEFAULT_IGNORE.append('./.bzr-shelf*')
26
 
 
27
 
 
28
 
class cmd_clean_tree(bzrlib.commands.Command):
29
 
    """Remove unwanted files from working tree.  <BZRTOOLS>
30
 
    Normally, ignored files are left alone.
 
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.
31
70
    """
32
 
    takes_options = [Option('ignored', help='delete all ignored files.'), 
33
 
                     Option('detritus', help='delete conflict files merge'
34
 
                            ' backups, and failed selftest dirs.  (*.THIS, '
35
 
                            '*.BASE, *.OTHER, *~, *.tmp)'), 
36
 
                     Option('dry-run', help='show files to delete instead of'
 
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'
37
77
                            ' deleting them.')]
38
 
    def run(self, ignored=False, detritus=False, dry_run=False):
 
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
 
class cmd_graph_ancestry(bzrlib.commands.Command):
43
 
    """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.
44
88
    
45
89
    Output format is detected according to file extension.  Some of the more
46
90
    common output formats are html, png, gif, svg, ps.  An extension of '.dot'
51
95
    with the last 5 characters of their revision identifier are used instead.
52
96
 
53
97
    The value starting with d is "(maximum) distance from the null revision".
54
 
    
 
98
 
55
99
    If --merge-branch is specified, the two branches are compared and a merge
56
100
    base is selected.
57
 
    
 
101
 
58
102
    Legend:
59
103
    white    normal revision
60
104
    yellow   THIS  history
74
118
    If available, rsvg is used to antialias PNG and JPEG output, but this can
75
119
    be disabled with --no-antialias.
76
120
    """
77
 
    takes_args = ['branch', 'file']
78
 
    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."),
79
123
                     Option('no-antialias',
80
 
                     help="Do not use rsvg to produce antialiased output"), 
81
 
                     Option('merge-branch', type=str, 
82
 
                     help="Use this branch to calcuate a merge base"), 
83
 
                     Option('cluster', help="Use clustered output.")]
84
 
    def run(self, branch, file, no_collapse=False, no_antialias=False,
85
 
        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
86
141
        import graph
87
142
        if cluster:
88
143
            ranking = "cluster"
89
144
        else:
90
145
            ranking = "forced"
91
 
        graph.write_ancestry_file(branch, file, not no_collapse, 
92
 
                                  not no_antialias, merge_branch, ranking)
93
 
 
94
 
class cmd_fetch_ghosts(bzrlib.commands.Command):
95
 
    """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.
96
153
    If the other branch is not supplied, the last-pulled branch is used.
97
154
    """
98
155
    aliases = ['fetch-missing']
99
156
    takes_args = ['branch?']
100
 
    takes_options = [Option('no-fix')]
 
157
    takes_options = [Option('no-fix', help="Skip additional synchonization.")]
101
158
    def run(self, branch=None, no_fix=False):
102
159
        from fetch_ghosts import fetch_ghosts
103
160
        fetch_ghosts(branch, no_fix)
104
161
 
105
162
strip_help="""Strip the smallest prefix containing num leading slashes  from \
106
163
each file name found in the patch file."""
107
 
Option.OPTIONS['bzrdiff'] = Option('bzrdiff',type=None,
108
 
                                help="""Handle extra bzr tags""")
109
 
class cmd_patch(bzrlib.commands.Command):
110
 
    """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.
111
168
    """
112
169
    takes_args = ['filename?']
113
 
    takes_options = [Option('strip', type=int, help=strip_help)]
114
 
    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):
115
173
        from patch import patch
116
174
        from bzrlib.workingtree import WorkingTree
117
175
        wt = WorkingTree.open_containing('.')[0]
118
 
        if strip == -1:
119
 
            if bzrdiff: strip = 0
120
 
            else:       strip = 0
121
 
 
122
 
        return patch(wt, filename, strip, legacy= not bzrdiff)
123
 
 
124
 
class cmd_shelve(bzrlib.commands.Command):
125
 
    """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.
126
183
 
127
184
    Shelve allows you to temporarily put changes you've made "on the shelf",
128
185
    ie. out of the way, until a later time when you can bring them back from
146
203
    you can also unshelve changes in a different order by explicitly
147
204
    specifiying which changes to unshelve. This works best when the changes
148
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
233
 
189
254
    aliases = ['switch']
190
255
    takes_args = ['othershelf']
191
256
    def run(self, othershelf):
192
 
        s = Shelf(self.shelf.base, othershelf)
 
257
        s = shelf.Shelf(self.shelf.base, othershelf)
193
258
        s.make_default()
194
259
 
195
260
 
208
273
        self.shelf.upgrade()
209
274
 
210
275
 
211
 
class cmd_shelf(bzrlib.commands.Command):
 
276
class cmd_shelf(BzrToolsCommand):
212
277
    """Perform various operations on your shelved patches. See also shelve."""
213
278
    takes_args = ['subcommand', 'args*']
214
279
 
218
283
    def run(self, subcommand, args_list):
219
284
        import sys
220
285
 
 
286
        if args_list is None:
 
287
            args_list = []
221
288
        cmd = self._get_cmd_object(subcommand)
222
289
        source = BzrPatchSource()
223
 
        s = Shelf(source.base)
 
290
        s = shelf.Shelf(source.base)
224
291
        cmd.shelf = s
 
292
 
 
293
        if args_list is None:
 
294
            args_list = []
225
295
        return cmd.run_argv_aliases(args_list)
226
296
 
227
297
    def _get_cmd_object(self, cmd_name):
244
314
        cmd_obj = cmd_class()
245
315
        indent = 2 * ' '
246
316
 
247
 
        usage = command_usage(cmd_obj)
 
317
        usage = cmd_obj._usage()
248
318
        usage = usage.replace('bzr shelf-', '')
249
319
        text.append('%s%s\n' % (indent, usage))
250
320
 
269
339
        return text
270
340
 
271
341
 
272
 
 
273
 
class cmd_unshelve(bzrlib.commands.Command):
274
 
    """Restore shelved changes.  <BZRTOOLS>
 
342
class cmd_unshelve(BzrToolsCommand):
 
343
    """Restore shelved changes.
275
344
 
276
345
    By default the most recently shelved changes are restored. However if you
277
346
    specify a patch by name those changes will be restored instead.
279
348
    See 'shelve' for more information.
280
349
    """
281
350
    takes_options = [
282
 
            Option('all', help='Unshelve all changes without prompting'),
283
 
            Option('force', help='Force unshelving even if errors occur'),
284
 
    ]
 
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
        ]
285
355
    takes_args = ['patch?']
286
 
    def run(self, patch=None, all=False, force=False):
 
356
    def run(self, patch=None, all=False, force=False, no_color=False):
287
357
        source = BzrPatchSource()
288
 
        s = Shelf(source.base)
289
 
        s.unshelve(source, patch, all, force)
 
358
        s = shelf.Shelf(source.base)
 
359
        s.unshelve(source, patch, all, force, no_color)
290
360
        return 0
291
361
 
292
362
 
293
 
class cmd_shell(bzrlib.commands.Command):
294
 
    """Begin an interactive shell tailored for bzr.  <BZRTOOLS>
 
363
class cmd_shell(BzrToolsCommand):
 
364
    """Begin an interactive shell tailored for bzr.
295
365
    Bzr commands can be used without typing bzr first, and will be run natively
296
366
    when possible.  Tab completion is tailored for bzr.  The shell prompt shows
297
367
    the branch nick, revno, and path.
312
382
        import shell
313
383
        return shell.run_shell()
314
384
 
315
 
class cmd_branch_history(bzrlib.commands.Command):
 
385
 
 
386
class cmd_branch_history(BzrToolsCommand):
316
387
    """\
317
 
    Display the development history of a branch  <BZRTOOLS>.
 
388
    Display the development history of a branch.
318
389
 
319
390
    Each different committer or branch nick is considered a different line of
320
391
    development.  Committers are treated as the same if they have the same
322
393
    """
323
394
    takes_args = ["branch?"]
324
395
    def run(self, branch=None):
325
 
        from branchhistory import branch_history 
 
396
        from branchhistory import branch_history
326
397
        return branch_history(branch)
327
398
 
328
399
 
329
 
class cmd_zap(bzrlib.commands.Command):
 
400
class cmd_zap(BzrToolsCommand):
330
401
    """\
331
 
    Remove a checkout, if it can be done safely. <BZRTOOLS>
332
 
 
333
 
    This command will remove a checkout without losing data.  That means
334
 
    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).
335
410
    """
336
 
    takes_options = [Option("branch", help="Remove associtated branch from"
337
 
                                           " 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.')]
338
415
    takes_args = ["checkout"]
339
 
    def run(self, checkout, branch=False):
 
416
    def run(self, checkout, branch=False, force=False):
340
417
        from zap import zap
341
 
        return zap(checkout, remove_branch=branch)
342
 
 
343
 
 
344
 
class cmd_cbranch(bzrlib.commands.Command):
345
 
    """
346
 
    Create a new checkout, associated with a new repository branch. <BZRTOOLS>
347
 
    
348
 
    When you cbranch, bzr looks up the repository associated with your current
349
 
    directory in branches.conf.  It creates a new branch in that repository
350
 
    with the same name and relative path as the checkout you request.
351
 
 
352
 
    The branches.conf parameter is "cbranch_root".  So if you want 
353
 
    cbranch operations in /home/jrandom/bigproject to produce branches in 
354
 
    /home/jrandom/bigproject/repository, you'd add this:
355
 
 
356
 
    [/home/jrandom/bigproject]
357
 
    cbranch_root = /home/jrandom/bigproject/repository
358
 
 
359
 
    Note that if "/home/jrandom/bigproject/repository" isn't a repository,
360
 
    standalone branches will be produced.  Standalone branches will also
361
 
    be produced if the source branch is in 0.7 format (or earlier).
362
 
    """
363
 
    takes_options = [Option("lightweight", 
364
 
                            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.')]
365
445
    takes_args = ["source", "target?"]
366
 
    def run(self, source, target=None, lightweight=False):
 
446
    def run(self, source, target=None, lightweight=False, revision=None,
 
447
            files_from=None):
367
448
        from cbranch import cbranch
368
 
        return cbranch(source, target, lightweight=lightweight)
369
 
 
370
 
 
371
 
class cmd_branches(bzrlib.commands.Command):
372
 
    """Scan a location for branches <BZRTOOLS>"""
 
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"""
373
455
    takes_args = ["location?"]
374
456
    def run(self, location=None):
375
457
        from branches import branches
376
458
        return branches(location)
377
459
 
378
 
 
379
 
class cmd_multi_pull(bzrlib.commands.Command):
380
 
    """Pull all the branches under a location, e.g. a repository. <BZRTOOLS>
381
 
    
 
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
 
382
474
    Both branches present in the directory and the branches of checkouts are
383
475
    pulled.
384
476
    """
385
477
    takes_args = ["location?"]
386
478
    def run(self, location=None):
387
 
        from bzrlib.branch import Branch
388
479
        from bzrlib.transport import get_transport
389
480
        from bzrtools import iter_branch_tree
390
481
        if location is None:
391
482
            location = '.'
392
483
        t = get_transport(location)
 
484
        possible_transports = []
393
485
        if not t.listable():
394
486
            print "Can't list this type of location."
395
487
            return 3
411
503
                relpath = base
412
504
            print "Pulling %s from %s" % (relpath, parent)
413
505
            try:
414
 
                pullable.pull(Branch.open(parent))
 
506
                branch_t = get_transport(parent, possible_transports)
 
507
                pullable.pull(Branch.open_from_transport(branch_t))
415
508
            except Exception, e:
416
509
                print e
417
510
 
418
511
 
419
 
class cmd_branch_mark(bzrlib.commands.Command):
420
 
    """
421
 
    Add, view or list branch markers <EXPERIMENTAL>
422
 
 
423
 
    To add a mark, do 'bzr branch-mark MARK'.
424
 
    To list marks, do 'bzr branch-mark' (this lists all marks for the branch's
425
 
    repository).
426
 
    To delete a mark, do 'bzr branch-mark --delete MARK'
427
 
 
428
 
    These marks can be used to track a branch's status.
429
 
    """
430
 
    takes_args = ['mark?', 'branch?']
431
 
    takes_options = [Option('delete', help='Delete this mark')]
432
 
    def run(self, mark=None, branch=None, delete=False):
433
 
        from branch_mark import branch_mark
434
 
        branch_mark(mark, branch, delete)
435
 
 
436
 
class cmd_import(bzrlib.commands.Command):
437
 
    """Import sources from a tarball <BZRTOOLS>
438
 
    
439
 
    This command will import a tarball into a bzr tree, replacing any versioned
440
 
    files already present.  If a directory is specified, it is used as the
441
 
    target.  If the directory does not exist, or is not versioned, it is
442
 
    created.
 
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.
443
520
 
444
521
    Tarballs may be gzip or bzip2 compressed.  This is autodetected.
445
522
 
446
 
    If the tarball has a single root directory, that directory is stripped
447
 
    when extracting the tarball.
 
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.
448
525
    """
449
 
    
 
526
 
450
527
    takes_args = ['source', 'tree?']
451
528
    def run(self, source, tree=None):
452
529
        from upstream_import import do_import
453
530
        do_import(source, tree)
454
531
 
455
 
class cmd_shove(bzrlib.commands.Command):
456
 
    """Apply uncommitted changes to another tree <BZRTOOLS>
457
 
    
458
 
    This is useful when you start to make changes in one tree, then realize
459
 
    they should really be done in a different tree.
460
 
 
461
 
    Shove is implemented using merge, so:
462
 
     - All changes, including renames and adds, will be applied.
463
 
     - No changes that have already been applied will be applied.
464
 
     - If the target is significantly different from the source, conflicts may
465
 
       be produced.
466
 
    """
467
 
 
468
 
    takes_args = ['target', 'source?']
469
 
    def run(self, target, source='.'):
470
 
        from shove import do_shove
471
 
        do_shove(source, target)
472
 
 
473
 
class cmd_cdiff(bzrlib.commands.Command):
474
 
    """A color version of bzr's diff <BZRTOOLS>"""
475
 
    takes_args = bzrlib.builtins.cmd_diff.takes_args
476
 
    takes_options = bzrlib.builtins.cmd_diff.takes_options
477
 
    def run(*args, **kwargs):
 
532
 
 
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):
478
542
        from colordiff import colordiff
479
 
        colordiff(*args, **kwargs)
480
 
 
481
 
commands = [cmd_shelve, cmd_unshelve, cmd_shelf, cmd_clean_tree,
482
 
            cmd_graph_ancestry, cmd_fetch_ghosts, cmd_patch, cmd_shell,
483
 
            cmd_branch_history, cmd_zap, cmd_cbranch, cmd_branches, 
484
 
            cmd_multi_pull, cmd_switch, cmd_branch_mark, cmd_import, cmd_shove,
485
 
            cmd_cdiff]
486
 
 
487
 
 
488
 
commands.append(rspush.cmd_rspush)
489
 
 
490
 
from errors import NoPyBaz
491
 
try:
492
 
    import baz_import
493
 
    commands.append(baz_import.cmd_baz_import_branch)
494
 
    commands.append(baz_import.cmd_baz_import)
495
 
 
496
 
except NoPyBaz:
497
 
    class cmd_baz_import_branch(bzrlib.commands.Command):
498
 
        """Disabled. (Requires PyBaz)   <BZRTOOLS>"""
499
 
        takes_args = ['to_location?', 'from_branch?', 'reuse_history*']
500
 
        takes_options = ['verbose', Option('max-count', type=int)]
501
 
        def run(self, to_location=None, from_branch=None, fast=False, 
502
 
                max_count=None, verbose=False, dry_run=False,
503
 
                reuse_history_list=[]):
504
 
            print "This command is disabled.  Please install PyBaz."
505
 
 
506
 
 
507
 
    class cmd_baz_import(bzrlib.commands.Command):
508
 
        """Disabled. (Requires PyBaz)   <BZRTOOLS>"""
509
 
        takes_args = ['to_root_dir?', 'from_archive?', 'reuse_history*']
510
 
        takes_options = ['verbose', Option('prefixes', type=str,
511
 
                         help="Prefixes of branches to import")]
512
 
        def run(self, to_root_dir=None, from_archive=None, verbose=False,
513
 
                reuse_history_list=[], prefixes=None):
514
 
                print "This command is disabled.  Please install PyBaz."
515
 
    commands.extend((cmd_baz_import_branch, cmd_baz_import))
 
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
            ]
516
661
 
517
662
 
518
663
if hasattr(bzrlib.commands, 'register_command'):
525
670
    import tests
526
671
    from doctest import DocTestSuite, ELLIPSIS
527
672
    from unittest import TestSuite
 
673
    import bzrtools
528
674
    import tests.clean_tree
529
 
    import upstream_import
 
675
    import tests.is_clean
 
676
    import tests.test_patch
 
677
    import tests.test_rspush
 
678
    import tests.upstream_import
530
679
    import zap
531
680
    import tests.blackbox
532
681
    import tests.shelf_tests
541
690
    result.addTest(tests.test_suite())
542
691
    result.addTest(TestLoader().loadTestsFromModule(tests.shelf_tests))
543
692
    result.addTest(tests.blackbox.test_suite())
544
 
    result.addTest(upstream_import.test_suite())
 
693
    result.addTest(tests.upstream_import.test_suite())
545
694
    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))
546
698
    return result