← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: Robert Collins
  • Date: 2005-10-17 11:56:54 UTC
  • mfrom: (1185.16.59)
  • Revision ID: robertc@robertcollins.net-20051017115654-662239e1587524a8
merge from martin.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/builtins.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
"""builtin bzr commands"""
18
 
 
19
 
# DO NOT change this to cStringIO - it results in control files 
20
 
# written as UCS4
21
 
# FIXIT! (Only deal with byte streams OR unicode at any one layer.)
22
 
# RBC 20051018
23
 
 
24
 
from StringIO import StringIO
 
17
 
25
18
import sys
26
19
import os
27
20
 
28
21
import bzrlib
29
22
from bzrlib import BZRDIR
30
 
from bzrlib.commands import Command, display_command
 
23
from bzrlib.commands import Command
31
24
from bzrlib.branch import Branch
32
 
from bzrlib.revision import common_ancestor
33
 
import bzrlib.errors as errors
34
 
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError, 
35
 
                           NotBranchError, DivergedBranches, NotConflicted,
36
 
                           NoSuchFile, NoWorkingTree, FileInWrongBranch)
 
25
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
 
26
from bzrlib.errors import DivergedBranches
37
27
from bzrlib.option import Option
38
28
from bzrlib.revisionspec import RevisionSpec
39
29
import bzrlib.trace
40
 
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
 
30
from bzrlib.trace import mutter, note, log_error, warning
41
31
from bzrlib.workingtree import WorkingTree
42
 
from bzrlib.log import show_one_log
43
 
 
44
 
 
45
 
def tree_files(file_list, default_branch=u'.'):
46
 
    try:
47
 
        return internal_tree_files(file_list, default_branch)
48
 
    except FileInWrongBranch, e:
49
 
        raise BzrCommandError("%s is not in the same branch as %s" %
50
 
                             (e.path, file_list[0]))
51
 
 
52
 
def internal_tree_files(file_list, default_branch=u'.'):
53
 
    """\
54
 
    Return a branch and list of branch-relative paths.
55
 
    If supplied file_list is empty or None, the branch default will be used,
56
 
    and returned file_list will match the original.
57
 
    """
58
 
    if file_list is None or len(file_list) == 0:
59
 
        return WorkingTree.open_containing(default_branch)[0], file_list
60
 
    tree = WorkingTree.open_containing(file_list[0])[0]
61
 
    new_list = []
62
 
    for filename in file_list:
63
 
        try:
64
 
            new_list.append(tree.relpath(filename))
65
 
        except errors.PathNotChild:
66
 
            raise FileInWrongBranch(tree.branch, filename)
67
 
    return tree, new_list
68
 
 
69
 
 
70
 
# TODO: Make sure no commands unconditionally use the working directory as a
71
 
# branch.  If a filename argument is used, the first of them should be used to
72
 
# specify the branch.  (Perhaps this can be factored out into some kind of
73
 
# Argument class, representing a file in a branch, where the first occurrence
74
 
# opens the branch?)
 
32
 
75
33
 
76
34
class cmd_status(Command):
77
35
    """Display status summary.
112
70
    If a revision argument is given, the status is calculated against
113
71
    that revision, or between two revisions if two are provided.
114
72
    """
115
 
    
116
 
    # TODO: --no-recurse, --recurse options
117
 
    
 
73
    # XXX: FIXME: bzr status should accept a -r option to show changes
 
74
    # relative to a revision, or between revisions
 
75
 
118
76
    takes_args = ['file*']
119
 
    takes_options = ['all', 'show-ids', 'revision']
 
77
    takes_options = ['all', 'show-ids']
120
78
    aliases = ['st', 'stat']
121
79
    
122
 
    @display_command
123
80
    def run(self, all=False, show_ids=False, file_list=None, revision=None):
124
 
        tree, file_list = tree_files(file_list)
 
81
        if file_list:
 
82
            b = Branch.open_containing(file_list[0])
 
83
            tree = WorkingTree(b.base, b)
 
84
            file_list = [tree.relpath(x) for x in file_list]
 
85
            # special case: only one path was given and it's the root
 
86
            # of the branch
 
87
            if file_list == ['']:
 
88
                file_list = None
 
89
        else:
 
90
            b = Branch.open_containing('.')
125
91
            
126
92
        from bzrlib.status import show_status
127
 
        show_status(tree.branch, show_unchanged=all, show_ids=show_ids,
 
93
        show_status(b, show_unchanged=all, show_ids=show_ids,
128
94
                    specific_files=file_list, revision=revision)
129
95
 
130
96
 
139
105
    takes_args = ['revision_id?']
140
106
    takes_options = ['revision']
141
107
    
142
 
    @display_command
143
108
    def run(self, revision_id=None, revision=None):
144
109
 
145
110
        if revision_id is not None and revision is not None:
146
111
            raise BzrCommandError('You can only supply one of revision_id or --revision')
147
112
        if revision_id is None and revision is None:
148
113
            raise BzrCommandError('You must supply either --revision or a revision_id')
149
 
        b = WorkingTree.open_containing(u'.')[0].branch
 
114
        b = Branch.open_containing('.')
150
115
        if revision_id is not None:
151
 
            sys.stdout.write(b.get_revision_xml(revision_id))
 
116
            sys.stdout.write(b.get_revision_xml_file(revision_id).read())
152
117
        elif revision is not None:
153
118
            for rev in revision:
154
119
                if rev is None:
155
120
                    raise BzrCommandError('You cannot specify a NULL revision.')
156
121
                revno, rev_id = rev.in_history(b)
157
 
                sys.stdout.write(b.get_revision_xml(rev_id))
 
122
                sys.stdout.write(b.get_revision_xml_file(rev_id).read())
158
123
    
159
124
 
160
125
class cmd_revno(Command):
161
126
    """Show current revision number.
162
127
 
163
128
    This is equal to the number of revisions on this branch."""
164
 
    takes_args = ['location?']
165
 
    @display_command
166
 
    def run(self, location=u'.'):
167
 
        print Branch.open_containing(location)[0].revno()
 
129
    def run(self):
 
130
        print Branch.open_containing('.').revno()
168
131
 
169
132
 
170
133
class cmd_revision_info(Command):
173
136
    hidden = True
174
137
    takes_args = ['revision_info*']
175
138
    takes_options = ['revision']
176
 
    @display_command
177
139
    def run(self, revision=None, revision_info_list=[]):
178
140
 
179
141
        revs = []
185
147
        if len(revs) == 0:
186
148
            raise BzrCommandError('You must supply a revision identifier')
187
149
 
188
 
        b = WorkingTree.open_containing(u'.')[0].branch
 
150
        b = Branch.open_containing('.')
189
151
 
190
152
        for rev in revs:
191
153
            revinfo = rev.in_history(b)
217
179
    implicitly add the parent, and so on up to the root. This means
218
180
    you should never need to explictly add a directory, they'll just
219
181
    get added when you add a file in the directory.
220
 
 
221
 
    --dry-run will show which files would be added, but not actually 
222
 
    add them.
223
182
    """
224
183
    takes_args = ['file*']
225
 
    takes_options = ['no-recurse', 'dry-run', 'verbose']
226
 
 
227
 
    def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
228
 
        import bzrlib.add
229
 
 
230
 
        if dry_run:
231
 
            if is_quiet():
232
 
                # This is pointless, but I'd rather not raise an error
233
 
                action = bzrlib.add.add_action_null
234
 
            else:
235
 
                action = bzrlib.add.add_action_print
236
 
        elif is_quiet():
237
 
            action = bzrlib.add.add_action_add
 
184
    takes_options = ['no-recurse', 'quiet']
 
185
    
 
186
    def run(self, file_list, no_recurse=False, quiet=False):
 
187
        from bzrlib.add import smart_add, add_reporter_print, add_reporter_null
 
188
        if quiet:
 
189
            reporter = add_reporter_null
238
190
        else:
239
 
            action = bzrlib.add.add_action_add_and_print
240
 
 
241
 
        added, ignored = bzrlib.add.smart_add(file_list, not no_recurse, 
242
 
                                              action)
243
 
        if len(ignored) > 0:
244
 
            for glob in sorted(ignored.keys()):
245
 
                match_len = len(ignored[glob])
246
 
                if verbose:
247
 
                    for path in ignored[glob]:
248
 
                        print "ignored %s matching \"%s\"" % (path, glob)
249
 
                else:
250
 
                    print "ignored %d file(s) matching \"%s\"" % (match_len,
251
 
                                                              glob)
252
 
            print "If you wish to add some of these files, please add them"\
253
 
                " by name."
 
191
            reporter = add_reporter_print
 
192
        smart_add(file_list, not no_recurse, reporter)
254
193
 
255
194
 
256
195
class cmd_mkdir(Command):
261
200
    takes_args = ['dir+']
262
201
 
263
202
    def run(self, dir_list):
 
203
        b = None
 
204
        
264
205
        for d in dir_list:
265
206
            os.mkdir(d)
266
 
            wt, dd = WorkingTree.open_containing(d)
267
 
            wt.add([dd])
 
207
            if not b:
 
208
                b = Branch.open_containing(d)
 
209
            b.add([d])
268
210
            print 'added', d
269
211
 
270
212
 
273
215
    takes_args = ['filename']
274
216
    hidden = True
275
217
    
276
 
    @display_command
277
218
    def run(self, filename):
278
 
        tree, relpath = WorkingTree.open_containing(filename)
279
 
        print relpath
 
219
        branch = Branch.open_containing(filename)
 
220
        print WorkingTree(branch.base, branch).relpath(filename)
280
221
 
281
222
 
282
223
class cmd_inventory(Command):
283
 
    """Show inventory of the current working copy or a revision.
284
 
 
285
 
    It is possible to limit the output to a particular entry
286
 
    type using the --kind option.  For example; --kind file.
287
 
    """
288
 
    takes_options = ['revision', 'show-ids', 'kind']
 
224
    """Show inventory of the current working copy or a revision."""
 
225
    takes_options = ['revision', 'show-ids']
289
226
    
290
 
    @display_command
291
 
    def run(self, revision=None, show_ids=False, kind=None):
292
 
        if kind and kind not in ['file', 'directory', 'symlink']:
293
 
            raise BzrCommandError('invalid kind specified')
294
 
        tree = WorkingTree.open_containing(u'.')[0]
 
227
    def run(self, revision=None, show_ids=False):
 
228
        b = Branch.open_containing('.')
295
229
        if revision is None:
296
 
            inv = tree.read_working_inventory()
 
230
            inv = b.read_working_inventory()
297
231
        else:
298
232
            if len(revision) > 1:
299
233
                raise BzrCommandError('bzr inventory --revision takes'
300
234
                    ' exactly one revision identifier')
301
 
            inv = tree.branch.get_revision_inventory(
302
 
                revision[0].in_history(tree.branch).rev_id)
 
235
            inv = b.get_revision_inventory(revision[0].in_history(b).rev_id)
303
236
 
304
237
        for path, entry in inv.entries():
305
 
            if kind and kind != entry.kind:
306
 
                continue
307
238
            if show_ids:
308
239
                print '%-50s %s' % (path, entry.file_id)
309
240
            else:
320
251
    """
321
252
    takes_args = ['source$', 'dest']
322
253
    def run(self, source_list, dest):
323
 
        tree, source_list = tree_files(source_list)
 
254
        b = Branch.open_containing('.')
 
255
 
324
256
        # TODO: glob expansion on windows?
325
 
        tree.move(source_list, tree.relpath(dest))
 
257
        tree = WorkingTree(b.base, b)
 
258
        b.move([tree.relpath(s) for s in source_list], tree.relpath(dest))
326
259
 
327
260
 
328
261
class cmd_rename(Command):
342
275
    takes_args = ['from_name', 'to_name']
343
276
    
344
277
    def run(self, from_name, to_name):
345
 
        tree, (from_name, to_name) = tree_files((from_name, to_name))
346
 
        tree.rename_one(from_name, to_name)
 
278
        b = Branch.open_containing('.')
 
279
        tree = WorkingTree(b.base, b)
 
280
        b.rename_one(tree.relpath(from_name), tree.relpath(to_name))
347
281
 
348
282
 
349
283
class cmd_mv(Command):
363
297
    def run(self, names_list):
364
298
        if len(names_list) < 2:
365
299
            raise BzrCommandError("missing file argument")
366
 
        tree, rel_names = tree_files(names_list)
 
300
        b = Branch.open_containing(names_list[0])
 
301
        tree = WorkingTree(b.base, b)
 
302
        rel_names = [tree.relpath(x) for x in names_list]
367
303
        
368
304
        if os.path.isdir(names_list[-1]):
369
305
            # move into existing directory
370
 
            for pair in tree.move(rel_names[:-1], rel_names[-1]):
 
306
            for pair in b.move(rel_names[:-1], rel_names[-1]):
371
307
                print "%s => %s" % pair
372
308
        else:
373
309
            if len(names_list) != 2:
374
310
                raise BzrCommandError('to mv multiple files the destination '
375
311
                                      'must be a versioned directory')
376
 
            tree.rename_one(rel_names[0], rel_names[1])
 
312
            b.rename_one(rel_names[0], rel_names[1])
377
313
            print "%s => %s" % (rel_names[0], rel_names[1])
378
314
            
379
315
    
 
316
 
 
317
 
380
318
class cmd_pull(Command):
381
319
    """Pull any changes from another branch into the current one.
382
320
 
383
 
    If there is no default location set, the first pull will set it.  After
384
 
    that, you can omit the location to use the default.  To change the
385
 
    default, use --remember.
 
321
    If the location is omitted, the last-used location will be used.
 
322
    Both the revision history and the working directory will be
 
323
    updated.
386
324
 
387
325
    This command only works on branches that have not diverged.  Branches are
388
326
    considered diverged if both branches have had commits without first
389
327
    pulling from the other.
390
328
 
391
329
    If branches have diverged, you can use 'bzr merge' to pull the text changes
392
 
    from one into the other.  Once one branch has merged, the other should
393
 
    be able to pull it again.
394
 
 
395
 
    If you want to forget your local changes and just update your branch to
396
 
    match the remote one, use --overwrite.
 
330
    from one into the other.
397
331
    """
398
 
    takes_options = ['remember', 'overwrite', 'verbose']
 
332
    takes_options = ['remember']
399
333
    takes_args = ['location?']
400
334
 
401
 
    def run(self, location=None, remember=False, overwrite=False, verbose=False):
 
335
    def run(self, location=None, remember=False):
402
336
        from bzrlib.merge import merge
 
337
        import tempfile
403
338
        from shutil import rmtree
404
339
        import errno
405
 
        # FIXME: too much stuff is in the command class        
406
 
        tree_to = WorkingTree.open_containing(u'.')[0]
407
 
        stored_loc = tree_to.branch.get_parent()
 
340
        
 
341
        br_to = Branch.open_containing('.')
 
342
        stored_loc = br_to.get_parent()
408
343
        if location is None:
409
344
            if stored_loc is None:
410
345
                raise BzrCommandError("No pull location known or specified.")
411
346
            else:
412
347
                print "Using saved location: %s" % stored_loc
413
348
                location = stored_loc
414
 
 
 
349
        cache_root = tempfile.mkdtemp()
415
350
        br_from = Branch.open(location)
416
 
        br_to = tree_to.branch
417
 
 
418
 
        old_rh = br_to.revision_history()
419
 
        count = tree_to.pull(br_from, overwrite)
420
 
 
421
 
        if br_to.get_parent() is None or remember:
422
 
            br_to.set_parent(location)
423
 
        note('%d revision(s) pulled.' % (count,))
424
 
 
425
 
        if verbose:
426
 
            new_rh = tree_to.branch.revision_history()
427
 
            if old_rh != new_rh:
428
 
                # Something changed
429
 
                from bzrlib.log import show_changed_revisions
430
 
                show_changed_revisions(tree_to.branch, old_rh, new_rh)
431
 
 
432
 
 
433
 
class cmd_push(Command):
434
 
    """Push this branch into another branch.
435
 
    
436
 
    The remote branch will not have its working tree populated because this
437
 
    is both expensive, and may not be supported on the remote file system.
438
 
    
439
 
    Some smart servers or protocols *may* put the working tree in place.
440
 
 
441
 
    If there is no default push location set, the first push will set it.
442
 
    After that, you can omit the location to use the default.  To change the
443
 
    default, use --remember.
444
 
 
445
 
    This command only works on branches that have not diverged.  Branches are
446
 
    considered diverged if the branch being pushed to is not an older version
447
 
    of this branch.
448
 
 
449
 
    If branches have diverged, you can use 'bzr push --overwrite' to replace
450
 
    the other branch completely.
451
 
    
452
 
    If you want to ensure you have the different changes in the other branch,
453
 
    do a merge (see bzr help merge) from the other branch, and commit that
454
 
    before doing a 'push --overwrite'.
455
 
    """
456
 
    takes_options = ['remember', 'overwrite', 
457
 
                     Option('create-prefix', 
458
 
                            help='Create the path leading up to the branch '
459
 
                                 'if it does not already exist')]
460
 
    takes_args = ['location?']
461
 
 
462
 
    def run(self, location=None, remember=False, overwrite=False,
463
 
            create_prefix=False, verbose=False):
464
 
        # FIXME: Way too big!  Put this into a function called from the
465
 
        # command.
466
 
        import errno
467
 
        from shutil import rmtree
468
 
        from bzrlib.transport import get_transport
469
 
        
470
 
        tree_from = WorkingTree.open_containing(u'.')[0]
471
 
        br_from = tree_from.branch
472
 
        stored_loc = tree_from.branch.get_push_location()
473
 
        if location is None:
474
 
            if stored_loc is None:
475
 
                raise BzrCommandError("No push location known or specified.")
476
 
            else:
477
 
                print "Using saved location: %s" % stored_loc
478
 
                location = stored_loc
479
 
        try:
480
 
            br_to = Branch.open(location)
481
 
        except NotBranchError:
482
 
            # create a branch.
483
 
            transport = get_transport(location).clone('..')
484
 
            if not create_prefix:
485
 
                try:
486
 
                    transport.mkdir(transport.relpath(location))
487
 
                except NoSuchFile:
488
 
                    raise BzrCommandError("Parent directory of %s "
489
 
                                          "does not exist." % location)
490
 
            else:
491
 
                current = transport.base
492
 
                needed = [(transport, transport.relpath(location))]
493
 
                while needed:
494
 
                    try:
495
 
                        transport, relpath = needed[-1]
496
 
                        transport.mkdir(relpath)
497
 
                        needed.pop()
498
 
                    except NoSuchFile:
499
 
                        new_transport = transport.clone('..')
500
 
                        needed.append((new_transport,
501
 
                                       new_transport.relpath(transport.base)))
502
 
                        if new_transport.base == transport.base:
503
 
                            raise BzrCommandError("Could not creeate "
504
 
                                                  "path prefix.")
505
 
            br_to = Branch.initialize(location)
506
 
        old_rh = br_to.revision_history()
507
 
        try:
 
351
        br_from.lock_read()
 
352
        try:
 
353
            br_from.setup_caching(cache_root)
 
354
            location = br_from.base
 
355
            old_revno = br_to.revno()
 
356
            old_revision_history = br_to.revision_history()
508
357
            try:
509
 
                tree_to = br_to.working_tree()
510
 
            except NoWorkingTree:
511
 
                # TODO: This should be updated for branches which don't have a
512
 
                # working tree, as opposed to ones where we just couldn't 
513
 
                # update the tree.
514
 
                warning('Unable to update the working tree of: %s' % (br_to.base,))
515
 
                count = br_to.pull(br_from, overwrite)
516
 
            else:
517
 
                count = tree_to.pull(br_from, overwrite)
518
 
        except DivergedBranches:
519
 
            raise BzrCommandError("These branches have diverged."
520
 
                                  "  Try a merge then push with overwrite.")
521
 
        if br_from.get_push_location() is None or remember:
522
 
            br_from.set_push_location(location)
523
 
        note('%d revision(s) pushed.' % (count,))
 
358
                br_to.update_revisions(br_from)
 
359
            except DivergedBranches:
 
360
                raise BzrCommandError("These branches have diverged."
 
361
                    "  Try merge.")
 
362
            new_revision_history = br_to.revision_history()
 
363
            if new_revision_history != old_revision_history:
 
364
                merge(('.', -1), ('.', old_revno), check_clean=False)
 
365
            if stored_loc is None or remember:
 
366
                br_to.set_parent(location)
 
367
        finally:
 
368
            br_from.unlock()
 
369
            rmtree(cache_root)
524
370
 
525
 
        if verbose:
526
 
            new_rh = br_to.revision_history()
527
 
            if old_rh != new_rh:
528
 
                # Something changed
529
 
                from bzrlib.log import show_changed_revisions
530
 
                show_changed_revisions(br_to, old_rh, new_rh)
531
371
 
532
372
 
533
373
class cmd_branch(Command):
549
389
 
550
390
    def run(self, from_location, to_location=None, revision=None, basis=None):
551
391
        from bzrlib.clone import copy_branch
 
392
        import tempfile
552
393
        import errno
553
394
        from shutil import rmtree
 
395
        cache_root = tempfile.mkdtemp()
554
396
        if revision is None:
555
397
            revision = [None]
556
398
        elif len(revision) > 1:
566
408
                raise
567
409
        br_from.lock_read()
568
410
        try:
 
411
            br_from.setup_caching(cache_root)
569
412
            if basis is not None:
570
 
                basis_branch = WorkingTree.open_containing(basis)[0].branch
 
413
                basis_branch = Branch.open_containing(basis)
571
414
            else:
572
415
                basis_branch = None
573
416
            if len(revision) == 1 and revision[0] is not None:
576
419
                revision_id = None
577
420
            if to_location is None:
578
421
                to_location = os.path.basename(from_location.rstrip("/\\"))
579
 
                name = None
580
 
            else:
581
 
                name = os.path.basename(to_location) + '\n'
582
422
            try:
583
423
                os.mkdir(to_location)
584
424
            except OSError, e:
594
434
                copy_branch(br_from, to_location, revision_id, basis_branch)
595
435
            except bzrlib.errors.NoSuchRevision:
596
436
                rmtree(to_location)
597
 
                msg = "The branch %s has no revision %s." % (from_location, revision[0])
 
437
                msg = "The branch %s has no revision %d." % (from_location, revision[0])
598
438
                raise BzrCommandError(msg)
599
439
            except bzrlib.errors.UnlistableBranch:
600
 
                rmtree(to_location)
601
440
                msg = "The branch %s cannot be used as a --basis"
602
 
                raise BzrCommandError(msg)
603
 
            branch = Branch.open(to_location)
604
 
            if name:
605
 
                name = StringIO(name)
606
 
                branch.put_controlfile('branch-name', name)
607
 
            note('Branched %d revision(s).' % branch.revno())
608
441
        finally:
609
442
            br_from.unlock()
 
443
            rmtree(cache_root)
610
444
 
611
445
 
612
446
class cmd_renames(Command):
617
451
    # TODO: Only show renames under dir, rather than in the whole branch.
618
452
    takes_args = ['dir?']
619
453
 
620
 
    @display_command
621
 
    def run(self, dir=u'.'):
622
 
        tree = WorkingTree.open_containing(dir)[0]
623
 
        old_inv = tree.branch.basis_tree().inventory
624
 
        new_inv = tree.read_working_inventory()
 
454
    def run(self, dir='.'):
 
455
        b = Branch.open_containing(dir)
 
456
        old_inv = b.basis_tree().inventory
 
457
        new_inv = b.read_working_inventory()
625
458
 
626
459
        renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
627
460
        renames.sort()
633
466
    """Show statistical information about a branch."""
634
467
    takes_args = ['branch?']
635
468
    
636
 
    @display_command
637
469
    def run(self, branch=None):
638
470
        import info
639
 
        b = WorkingTree.open_containing(branch)[0].branch
 
471
        b = Branch.open_containing(branch)
640
472
        info.show_info(b)
641
473
 
642
474
 
651
483
    aliases = ['rm']
652
484
    
653
485
    def run(self, file_list, verbose=False):
654
 
        tree, file_list = tree_files(file_list)
655
 
        tree.remove(file_list, verbose=verbose)
 
486
        b = Branch.open_containing(file_list[0])
 
487
        tree = WorkingTree(b.base, b)
 
488
        b.remove([tree.relpath(f) for f in file_list], verbose=verbose)
656
489
 
657
490
 
658
491
class cmd_file_id(Command):
664
497
    """
665
498
    hidden = True
666
499
    takes_args = ['filename']
667
 
    @display_command
668
500
    def run(self, filename):
669
 
        tree, relpath = WorkingTree.open_containing(filename)
670
 
        i = tree.inventory.path2id(relpath)
 
501
        b = Branch.open_containing(filename)
 
502
        tree = WorkingTree(b.base, b)
 
503
        i = b.inventory.path2id(tree.relpath(filename))
671
504
        if i == None:
672
505
            raise BzrError("%r is not a versioned file" % filename)
673
506
        else:
681
514
    starting at the branch root."""
682
515
    hidden = True
683
516
    takes_args = ['filename']
684
 
    @display_command
685
517
    def run(self, filename):
686
 
        tree, relpath = WorkingTree.open_containing(filename)
687
 
        inv = tree.inventory
688
 
        fid = inv.path2id(relpath)
 
518
        b = Branch.open_containing(filename)
 
519
        inv = b.inventory
 
520
        tree = WorkingTree(b.base, b)
 
521
        fid = inv.path2id(tree.relpath(filename))
689
522
        if fid == None:
690
523
            raise BzrError("%r is not a versioned file" % filename)
691
524
        for fip in inv.get_idpath(fid):
695
528
class cmd_revision_history(Command):
696
529
    """Display list of revision ids on this branch."""
697
530
    hidden = True
698
 
    @display_command
699
531
    def run(self):
700
 
        branch = WorkingTree.open_containing(u'.')[0].branch
701
 
        for patchid in branch.revision_history():
 
532
        for patchid in Branch.open_containing('.').revision_history():
702
533
            print patchid
703
534
 
704
535
 
705
536
class cmd_ancestry(Command):
706
537
    """List all revisions merged into this branch."""
707
538
    hidden = True
708
 
    @display_command
709
539
    def run(self):
710
 
        tree = WorkingTree.open_containing(u'.')[0]
711
 
        b = tree.branch
712
 
        # FIXME. should be tree.last_revision
 
540
        b = find_branch('.')
713
541
        for revision_id in b.get_ancestry(b.last_revision()):
714
542
            print revision_id
715
543
 
716
544
 
 
545
class cmd_directories(Command):
 
546
    """Display list of versioned directories in this branch."""
 
547
    def run(self):
 
548
        for name, ie in Branch.open_containing('.').read_working_inventory().directories():
 
549
            if name == '':
 
550
                print '.'
 
551
            else:
 
552
                print name
 
553
 
 
554
 
717
555
class cmd_init(Command):
718
556
    """Make a directory into a versioned branch.
719
557
 
723
561
    Recipe for importing a tree of files:
724
562
        cd ~/project
725
563
        bzr init
726
 
        bzr add .
 
564
        bzr add -v .
727
565
        bzr status
728
566
        bzr commit -m 'imported project'
729
567
    """
730
 
    takes_args = ['location?']
731
 
    def run(self, location=None):
732
 
        from bzrlib.branch import Branch
733
 
        if location is None:
734
 
            location = u'.'
735
 
        else:
736
 
            # The path has to exist to initialize a
737
 
            # branch inside of it.
738
 
            # Just using os.mkdir, since I don't
739
 
            # believe that we want to create a bunch of
740
 
            # locations if the user supplies an extended path
741
 
            if not os.path.exists(location):
742
 
                os.mkdir(location)
743
 
        Branch.initialize(location)
 
568
    def run(self):
 
569
        Branch.initialize('.')
744
570
 
745
571
 
746
572
class cmd_diff(Command):
772
598
    takes_options = ['revision', 'diff-options']
773
599
    aliases = ['di', 'dif']
774
600
 
775
 
    @display_command
776
601
    def run(self, revision=None, file_list=None, diff_options=None):
777
602
        from bzrlib.diff import show_diff
778
 
        try:
779
 
            tree, file_list = internal_tree_files(file_list)
780
 
            b = None
781
 
            b2 = None
782
 
        except FileInWrongBranch:
783
 
            if len(file_list) != 2:
784
 
                raise BzrCommandError("Files are in different branches")
785
 
 
786
 
            b, file1 = Branch.open_containing(file_list[0])
787
 
            b2, file2 = Branch.open_containing(file_list[1])
788
 
            if file1 != "" or file2 != "":
789
 
                # FIXME diff those two files. rbc 20051123
790
 
                raise BzrCommandError("Files are in different branches")
791
 
            file_list = None
 
603
 
 
604
        if file_list:
 
605
            b = Branch.open_containing(file_list[0])
 
606
            tree = WorkingTree(b.base, b)
 
607
            file_list = [tree.relpath(f) for f in file_list]
 
608
            if file_list == ['']:
 
609
                # just pointing to top-of-tree
 
610
                file_list = None
 
611
        else:
 
612
            b = Branch.open_containing('.')
 
613
 
792
614
        if revision is not None:
793
 
            if b2 is not None:
794
 
                raise BzrCommandError("Can't specify -r with two branches")
795
615
            if len(revision) == 1:
796
 
                return show_diff(tree.branch, revision[0], specific_files=file_list,
797
 
                                 external_diff_options=diff_options)
 
616
                show_diff(b, revision[0], specific_files=file_list,
 
617
                          external_diff_options=diff_options)
798
618
            elif len(revision) == 2:
799
 
                return show_diff(tree.branch, revision[0], specific_files=file_list,
800
 
                                 external_diff_options=diff_options,
801
 
                                 revision2=revision[1])
 
619
                show_diff(b, revision[0], specific_files=file_list,
 
620
                          external_diff_options=diff_options,
 
621
                          revision2=revision[1])
802
622
            else:
803
623
                raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
804
624
        else:
805
 
            if b is not None:
806
 
                return show_diff(b, None, specific_files=file_list,
807
 
                                 external_diff_options=diff_options, b2=b2)
808
 
            else:
809
 
                return show_diff(tree.branch, None, specific_files=file_list,
810
 
                                 external_diff_options=diff_options)
 
625
            show_diff(b, None, specific_files=file_list,
 
626
                      external_diff_options=diff_options)
 
627
 
 
628
        
811
629
 
812
630
 
813
631
class cmd_deleted(Command):
819
637
    # directories with readdir, rather than stating each one.  Same
820
638
    # level of effort but possibly much less IO.  (Or possibly not,
821
639
    # if the directories are very large...)
822
 
    @display_command
823
640
    def run(self, show_ids=False):
824
 
        tree = WorkingTree.open_containing(u'.')[0]
825
 
        old = tree.branch.basis_tree()
 
641
        b = Branch.open_containing('.')
 
642
        old = b.basis_tree()
 
643
        new = b.working_tree()
826
644
        for path, ie in old.inventory.iter_entries():
827
 
            if not tree.has_id(ie.file_id):
 
645
            if not new.has_id(ie.file_id):
828
646
                if show_ids:
829
647
                    print '%-50s %s' % (path, ie.file_id)
830
648
                else:
834
652
class cmd_modified(Command):
835
653
    """List files modified in working tree."""
836
654
    hidden = True
837
 
    @display_command
838
655
    def run(self):
839
656
        from bzrlib.delta import compare_trees
840
657
 
841
 
        tree = WorkingTree.open_containing(u'.')[0]
842
 
        td = compare_trees(tree.branch.basis_tree(), tree)
 
658
        b = Branch.open_containing('.')
 
659
        td = compare_trees(b.basis_tree(), b.working_tree())
843
660
 
844
661
        for path, id, kind, text_modified, meta_modified in td.modified:
845
662
            print path
849
666
class cmd_added(Command):
850
667
    """List files added in working tree."""
851
668
    hidden = True
852
 
    @display_command
853
669
    def run(self):
854
 
        wt = WorkingTree.open_containing(u'.')[0]
855
 
        basis_inv = wt.branch.basis_tree().inventory
 
670
        b = Branch.open_containing('.')
 
671
        wt = b.working_tree()
 
672
        basis_inv = b.basis_tree().inventory
856
673
        inv = wt.inventory
857
674
        for file_id in inv:
858
675
            if file_id in basis_inv:
870
687
    The root is the nearest enclosing directory with a .bzr control
871
688
    directory."""
872
689
    takes_args = ['filename?']
873
 
    @display_command
874
690
    def run(self, filename=None):
875
691
        """Print the branch root."""
876
 
        tree = WorkingTree.open_containing(filename)[0]
877
 
        print tree.basedir
 
692
        b = Branch.open_containing(filename)
 
693
        print b.base
878
694
 
879
695
 
880
696
class cmd_log(Command):
881
697
    """Show log of this branch.
882
698
 
883
 
    To request a range of logs, you can use the command -r begin..end
884
 
    -r revision requests a specific revision, -r ..end or -r begin.. are
 
699
    To request a range of logs, you can use the command -r begin:end
 
700
    -r revision requests a specific revision, -r :end or -r begin: are
885
701
    also valid.
886
702
    """
887
703
 
892
708
                            help='show from oldest to newest'),
893
709
                     'timezone', 'verbose', 
894
710
                     'show-ids', 'revision',
895
 
                     'line', 'long', 
 
711
                     Option('line', help='format with one line per revision'),
 
712
                     'long', 
896
713
                     Option('message',
897
714
                            help='show revisions whose message matches this regexp',
898
715
                            type=str),
899
 
                     'short',
 
716
                     Option('short', help='use moderately short format'),
900
717
                     ]
901
 
    @display_command
 
718
    
902
719
    def run(self, filename=None, timezone='original',
903
720
            verbose=False,
904
721
            show_ids=False,
915
732
        direction = (forward and 'forward') or 'reverse'
916
733
        
917
734
        if filename:
918
 
            # might be a tree:
919
 
            tree = None
920
 
            try:
921
 
                tree, fp = WorkingTree.open_containing(filename)
922
 
                b = tree.branch
923
 
                if fp != '':
924
 
                    inv = tree.read_working_inventory()
925
 
            except NotBranchError:
926
 
                pass
927
 
            if tree is None:
928
 
                b, fp = Branch.open_containing(filename)
929
 
                if fp != '':
930
 
                    inv = b.get_inventory(b.last_revision())
931
 
            if fp != '':
932
 
                file_id = inv.path2id(fp)
 
735
            b = Branch.open_containing(filename)
 
736
            tree = WorkingTree(b.base, b)
 
737
            fp = tree.relpath(filename)
 
738
            if fp:
 
739
                file_id = b.read_working_inventory().path2id(fp)
933
740
            else:
934
741
                file_id = None  # points to branch root
935
742
        else:
936
 
            tree, relpath = WorkingTree.open_containing(u'.')
937
 
            b = tree.branch
 
743
            b = Branch.open_containing('.')
938
744
            file_id = None
939
745
 
940
746
        if revision is None:
948
754
        else:
949
755
            raise BzrCommandError('bzr log --revision takes one or two values.')
950
756
 
951
 
        # By this point, the revision numbers are converted to the +ve
952
 
        # form if they were supplied in the -ve form, so we can do
953
 
        # this comparison in relative safety
954
 
        if rev1 > rev2:
955
 
            (rev2, rev1) = (rev1, rev2)
 
757
        if rev1 == 0:
 
758
            rev1 = None
 
759
        if rev2 == 0:
 
760
            rev2 = None
956
761
 
957
 
        mutter('encoding log as %r', bzrlib.user_encoding)
 
762
        mutter('encoding log as %r' % bzrlib.user_encoding)
958
763
 
959
764
        # use 'replace' so that we don't abort if trying to write out
960
765
        # in e.g. the default C locale.
961
766
        outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
962
767
 
963
 
        log_format = get_log_format(long=long, short=short, line=line)
 
768
        log_format = 'long'
 
769
        if short:
 
770
            log_format = 'short'
 
771
        if line:
 
772
            log_format = 'line'
964
773
        lf = log_formatter(log_format,
965
774
                           show_ids=show_ids,
966
775
                           to_file=outf,
975
784
                 end_revision=rev2,
976
785
                 search=message)
977
786
 
978
 
def get_log_format(long=False, short=False, line=False, default='long'):
979
 
    log_format = default
980
 
    if long:
981
 
        log_format = 'long'
982
 
    if short:
983
 
        log_format = 'short'
984
 
    if line:
985
 
        log_format = 'line'
986
 
    return log_format
987
787
 
988
788
 
989
789
class cmd_touching_revisions(Command):
992
792
    A more user-friendly interface is "bzr log FILE"."""
993
793
    hidden = True
994
794
    takes_args = ["filename"]
995
 
    @display_command
996
795
    def run(self, filename):
997
 
        tree, relpath = WorkingTree.open_containing(filename)
998
 
        b = tree.branch
999
 
        inv = tree.read_working_inventory()
1000
 
        file_id = inv.path2id(relpath)
 
796
        b = Branch.open_containing(filename)
 
797
        inv = b.read_working_inventory()
 
798
        tree = WorkingTree(b.base, b)
 
799
        file_id = inv.path2id(tree.relpath(filename))
1001
800
        for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1002
801
            print "%6d %s" % (revno, what)
1003
802
 
1007
806
    """
1008
807
    # TODO: Take a revision or remote path and list that tree instead.
1009
808
    hidden = True
1010
 
    takes_options = ['verbose', 'revision',
1011
 
                     Option('non-recursive',
1012
 
                            help='don\'t recurse into sub-directories'),
1013
 
                     Option('from-root',
1014
 
                            help='Print all paths from the root of the branch.'),
1015
 
                     Option('unknown', help='Print unknown files'),
1016
 
                     Option('versioned', help='Print versioned files'),
1017
 
                     Option('ignored', help='Print ignored files'),
1018
 
 
1019
 
                     Option('null', help='Null separate the files'),
1020
 
                    ]
1021
 
    @display_command
1022
 
    def run(self, revision=None, verbose=False, 
1023
 
            non_recursive=False, from_root=False,
1024
 
            unknown=False, versioned=False, ignored=False,
1025
 
            null=False):
1026
 
 
1027
 
        if verbose and null:
1028
 
            raise BzrCommandError('Cannot set both --verbose and --null')
1029
 
        all = not (unknown or versioned or ignored)
1030
 
 
1031
 
        selection = {'I':ignored, '?':unknown, 'V':versioned}
1032
 
 
1033
 
        tree, relpath = WorkingTree.open_containing(u'.')
1034
 
        if from_root:
1035
 
            relpath = u''
1036
 
        elif relpath:
1037
 
            relpath += '/'
1038
 
        if revision is not None:
1039
 
            tree = tree.branch.revision_tree(
1040
 
                revision[0].in_history(tree.branch).rev_id)
 
809
    def run(self, revision=None, verbose=False):
 
810
        b = Branch.open_containing('.')
 
811
        if revision == None:
 
812
            tree = b.working_tree()
 
813
        else:
 
814
            tree = b.revision_tree(revision.in_history(b).rev_id)
1041
815
        for fp, fc, kind, fid, entry in tree.list_files():
1042
 
            if fp.startswith(relpath):
1043
 
                fp = fp[len(relpath):]
1044
 
                if non_recursive and '/' in fp:
1045
 
                    continue
1046
 
                if not all and not selection[fc]:
1047
 
                    continue
1048
 
                if verbose:
1049
 
                    kindch = entry.kind_character()
1050
 
                    print '%-8s %s%s' % (fc, fp, kindch)
1051
 
                elif null:
1052
 
                    sys.stdout.write(fp)
1053
 
                    sys.stdout.write('\0')
1054
 
                    sys.stdout.flush()
1055
 
                else:
1056
 
                    print fp
 
816
            if verbose:
 
817
                kindch = entry.kind_character()
 
818
                print '%-8s %s%s' % (fc, fp, kindch)
 
819
            else:
 
820
                print fp
 
821
 
1057
822
 
1058
823
 
1059
824
class cmd_unknowns(Command):
1060
825
    """List unknown files."""
1061
 
    @display_command
1062
826
    def run(self):
1063
827
        from bzrlib.osutils import quotefn
1064
 
        for f in WorkingTree.open_containing(u'.')[0].unknowns():
 
828
        for f in Branch.open_containing('.').unknowns():
1065
829
            print quotefn(f)
1066
830
 
1067
831
 
 
832
 
1068
833
class cmd_ignore(Command):
1069
834
    """Ignore a command or pattern.
1070
835
 
1090
855
        from bzrlib.atomicfile import AtomicFile
1091
856
        import os.path
1092
857
 
1093
 
        tree, relpath = WorkingTree.open_containing(u'.')
1094
 
        ifn = tree.abspath('.bzrignore')
 
858
        b = Branch.open_containing('.')
 
859
        ifn = b.abspath('.bzrignore')
1095
860
 
1096
861
        if os.path.exists(ifn):
1097
862
            f = open(ifn, 'rt')
1116
881
        finally:
1117
882
            f.close()
1118
883
 
1119
 
        inv = tree.inventory
 
884
        inv = b.working_tree().inventory
1120
885
        if inv.path2id('.bzrignore'):
1121
886
            mutter('.bzrignore is already versioned')
1122
887
        else:
1123
888
            mutter('need to make new .bzrignore file versioned')
1124
 
            tree.add(['.bzrignore'])
 
889
            b.add(['.bzrignore'])
 
890
 
1125
891
 
1126
892
 
1127
893
class cmd_ignored(Command):
1128
894
    """List ignored files and the patterns that matched them.
1129
895
 
1130
896
    See also: bzr ignore"""
1131
 
    @display_command
1132
897
    def run(self):
1133
 
        tree = WorkingTree.open_containing(u'.')[0]
 
898
        tree = Branch.open_containing('.').working_tree()
1134
899
        for path, file_class, kind, file_id, entry in tree.list_files():
1135
900
            if file_class != 'I':
1136
901
                continue
1148
913
    hidden = True
1149
914
    takes_args = ['revno']
1150
915
    
1151
 
    @display_command
1152
916
    def run(self, revno):
1153
917
        try:
1154
918
            revno = int(revno)
1155
919
        except ValueError:
1156
920
            raise BzrCommandError("not a valid revision-number: %r" % revno)
1157
921
 
1158
 
        print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
 
922
        print Branch.open_containing('.').get_rev_id(revno)
1159
923
 
1160
924
 
1161
925
class cmd_export(Command):
1168
932
    is found exports to a directory (equivalent to --format=dir).
1169
933
 
1170
934
    Root may be the top directory for tar, tgz and tbz2 formats. If none
1171
 
    is given, the top directory will be the root name of the file.
1172
 
 
1173
 
    Note: export of tree with non-ascii filenames to zip is not supported.
1174
 
 
1175
 
    Supported formats       Autodetected by extension
1176
 
    -----------------       -------------------------
1177
 
         dir                            -
1178
 
         tar                          .tar
1179
 
         tbz2                    .tar.bz2, .tbz2
1180
 
         tgz                      .tar.gz, .tgz
1181
 
         zip                          .zip
1182
 
    """
 
935
    is given, the top directory will be the root name of the file."""
 
936
    # TODO: list known exporters
1183
937
    takes_args = ['dest']
1184
938
    takes_options = ['revision', 'format', 'root']
1185
939
    def run(self, dest, revision=None, format=None, root=None):
1186
940
        import os.path
1187
 
        from bzrlib.export import export
1188
 
        tree = WorkingTree.open_containing(u'.')[0]
1189
 
        b = tree.branch
 
941
        b = Branch.open_containing('.')
1190
942
        if revision is None:
1191
 
            # should be tree.last_revision  FIXME
1192
943
            rev_id = b.last_revision()
1193
944
        else:
1194
945
            if len(revision) != 1:
1195
946
                raise BzrError('bzr export --revision takes exactly 1 argument')
1196
947
            rev_id = revision[0].in_history(b).rev_id
1197
948
        t = b.revision_tree(rev_id)
1198
 
        try:
1199
 
            export(t, dest, format, root)
1200
 
        except errors.NoSuchExportFormat, e:
1201
 
            raise BzrCommandError('Unsupported export format: %s' % e.format)
 
949
        arg_root, ext = os.path.splitext(os.path.basename(dest))
 
950
        if ext in ('.gz', '.bz2'):
 
951
            new_root, new_ext = os.path.splitext(arg_root)
 
952
            if new_ext == '.tar':
 
953
                arg_root = new_root
 
954
                ext = new_ext + ext
 
955
        if root is None:
 
956
            root = arg_root
 
957
        if not format:
 
958
            if ext in (".tar",):
 
959
                format = "tar"
 
960
            elif ext in (".tar.gz", ".tgz"):
 
961
                format = "tgz"
 
962
            elif ext in (".tar.bz2", ".tbz2"):
 
963
                format = "tbz2"
 
964
            else:
 
965
                format = "dir"
 
966
        t.export(dest, format, root)
1202
967
 
1203
968
 
1204
969
class cmd_cat(Command):
1207
972
    takes_options = ['revision']
1208
973
    takes_args = ['filename']
1209
974
 
1210
 
    @display_command
1211
975
    def run(self, filename, revision=None):
1212
 
        if revision is not None and len(revision) != 1:
 
976
        if revision is None:
 
977
            raise BzrCommandError("bzr cat requires a revision number")
 
978
        elif len(revision) != 1:
1213
979
            raise BzrCommandError("bzr cat --revision takes exactly one number")
1214
 
        tree = None
1215
 
        try:
1216
 
            tree, relpath = WorkingTree.open_containing(filename)
1217
 
            b = tree.branch
1218
 
        except NotBranchError:
1219
 
            pass
1220
 
 
1221
 
        if tree is None:
1222
 
            b, relpath = Branch.open_containing(filename)
1223
 
        if revision is None:
1224
 
            revision_id = b.last_revision()
1225
 
        else:
1226
 
            revision_id = revision[0].in_history(b).rev_id
1227
 
        b.print_file(relpath, revision_id)
 
980
        b = Branch.open_containing('.')
 
981
        tree = WorkingTree(b.base, b)
 
982
        b.print_file(tree.relpath(filename), revision[0].in_history(b).revno)
1228
983
 
1229
984
 
1230
985
class cmd_local_time_offset(Command):
1231
986
    """Show the offset in seconds from GMT to local time."""
1232
987
    hidden = True    
1233
 
    @display_command
1234
988
    def run(self):
1235
989
        print bzrlib.osutils.local_time_offset()
1236
990
 
1251
1005
    """
1252
1006
    # TODO: Run hooks on tree to-be-committed, and after commit.
1253
1007
 
1254
 
    # TODO: Strict commit that fails if there are deleted files.
1255
 
    #       (what does "deleted files" mean ??)
1256
 
 
 
1008
    # TODO: Strict commit that fails if there are unknown or deleted files.
1257
1009
    # TODO: Give better message for -s, --summary, used by tla people
1258
1010
 
1259
1011
    # XXX: verbose currently does nothing
1265
1017
                     Option('file', type=str, 
1266
1018
                            argname='msgfile',
1267
1019
                            help='file containing commit message'),
1268
 
                     Option('strict',
1269
 
                            help="refuse to commit if there are unknown "
1270
 
                            "files in the working tree."),
1271
1020
                     ]
1272
1021
    aliases = ['ci', 'checkin']
1273
1022
 
1274
1023
    def run(self, message=None, file=None, verbose=True, selected_list=None,
1275
 
            unchanged=False, strict=False):
1276
 
        from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1277
 
                StrictCommitFailed)
1278
 
        from bzrlib.msgeditor import edit_commit_message, \
1279
 
                make_commit_message_template
 
1024
            unchanged=False):
 
1025
        from bzrlib.errors import PointlessCommit, ConflictsInTree
 
1026
        from bzrlib.msgeditor import edit_commit_message
1280
1027
        from bzrlib.status import show_status
1281
 
        from tempfile import TemporaryFile
1282
 
        import codecs
1283
 
 
1284
 
        # TODO: Need a blackbox test for invoking the external editor; may be
1285
 
        # slightly problematic to run this cross-platform.
1286
 
 
1287
 
        # TODO: do more checks that the commit will succeed before 
1288
 
        # spending the user's valuable time typing a commit message.
1289
 
        #
1290
 
        # TODO: if the commit *does* happen to fail, then save the commit 
1291
 
        # message to a temporary file where it can be recovered
1292
 
        tree, selected_list = tree_files(selected_list)
 
1028
        from cStringIO import StringIO
 
1029
 
 
1030
        b = Branch.open_containing('.')
 
1031
        tree = WorkingTree(b.base, b)
 
1032
        if selected_list:
 
1033
            selected_list = [tree.relpath(s) for s in selected_list]
1293
1034
        if message is None and not file:
1294
 
            template = make_commit_message_template(tree, selected_list)
1295
 
            message = edit_commit_message(template)
 
1035
            catcher = StringIO()
 
1036
            show_status(b, specific_files=selected_list,
 
1037
                        to_file=catcher)
 
1038
            message = edit_commit_message(catcher.getvalue())
 
1039
 
1296
1040
            if message is None:
1297
1041
                raise BzrCommandError("please specify a commit message"
1298
1042
                                      " with either --message or --file")
1307
1051
                raise BzrCommandError("empty commit message specified")
1308
1052
            
1309
1053
        try:
1310
 
            tree.commit(message, specific_files=selected_list,
1311
 
                        allow_pointless=unchanged, strict=strict)
 
1054
            b.commit(message,
 
1055
                     specific_files=selected_list,
 
1056
                     allow_pointless=unchanged)
1312
1057
        except PointlessCommit:
1313
1058
            # FIXME: This should really happen before the file is read in;
1314
1059
            # perhaps prepare the commit; get the message; then actually commit
1317
1062
        except ConflictsInTree:
1318
1063
            raise BzrCommandError("Conflicts detected in working tree.  "
1319
1064
                'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1320
 
        except StrictCommitFailed:
1321
 
            raise BzrCommandError("Commit refused because there are unknown "
1322
 
                                  "files in the working tree.")
1323
 
        note('Committed revision %d.' % (tree.branch.revno(),))
1324
1065
 
1325
1066
 
1326
1067
class cmd_check(Command):
1329
1070
    This command checks various invariants about the branch storage to
1330
1071
    detect data corruption or bzr bugs.
1331
1072
    """
1332
 
    takes_args = ['branch?']
 
1073
    takes_args = ['dir?']
1333
1074
    takes_options = ['verbose']
1334
1075
 
1335
 
    def run(self, branch=None, verbose=False):
 
1076
    def run(self, dir='.', verbose=False):
1336
1077
        from bzrlib.check import check
1337
 
        if branch is None:
1338
 
            tree = WorkingTree.open_containing()[0]
1339
 
            branch = tree.branch
1340
 
        else:
1341
 
            branch = Branch.open(branch)
1342
 
        check(branch, verbose)
 
1078
        check(Branch.open_containing(dir), verbose)
1343
1079
 
1344
1080
 
1345
1081
class cmd_scan_cache(Command):
1347
1083
    def run(self):
1348
1084
        from bzrlib.hashcache import HashCache
1349
1085
 
1350
 
        c = HashCache(u'.')
 
1086
        c = HashCache('.')
1351
1087
        c.read()
1352
1088
        c.scan()
1353
1089
            
1373
1109
    """
1374
1110
    takes_args = ['dir?']
1375
1111
 
1376
 
    def run(self, dir=u'.'):
 
1112
    def run(self, dir='.'):
1377
1113
        from bzrlib.upgrade import upgrade
1378
1114
        upgrade(dir)
1379
1115
 
1382
1118
    """Show bzr user id."""
1383
1119
    takes_options = ['email']
1384
1120
    
1385
 
    @display_command
1386
1121
    def run(self, email=False):
1387
1122
        try:
1388
 
            b = WorkingTree.open_containing(u'.')[0].branch
 
1123
            b = bzrlib.branch.Branch.open_containing('.')
1389
1124
            config = bzrlib.config.BranchConfig(b)
1390
1125
        except NotBranchError:
1391
1126
            config = bzrlib.config.GlobalConfig()
1395
1130
        else:
1396
1131
            print config.username()
1397
1132
 
1398
 
class cmd_nick(Command):
1399
 
    """\
1400
 
    Print or set the branch nickname.  
1401
 
    If unset, the tree root directory name is used as the nickname
1402
 
    To print the current nickname, execute with no argument.  
1403
 
    """
1404
 
    takes_args = ['nickname?']
1405
 
    def run(self, nickname=None):
1406
 
        branch = Branch.open_containing(u'.')[0]
1407
 
        if nickname is None:
1408
 
            self.printme(branch)
1409
 
        else:
1410
 
            branch.nick = nickname
1411
 
 
1412
 
    @display_command
1413
 
    def printme(self, branch):
1414
 
        print branch.nick 
1415
1133
 
1416
1134
class cmd_selftest(Command):
1417
1135
    """Run internal test suite.
1419
1137
    This creates temporary test directories in the working directory,
1420
1138
    but not existing data is affected.  These directories are deleted
1421
1139
    if the tests pass, or left behind to help in debugging if they
1422
 
    fail and --keep-output is specified.
 
1140
    fail.
1423
1141
    
1424
1142
    If arguments are given, they are regular expressions that say
1425
1143
    which tests should run.
1429
1147
    takes_args = ['testspecs*']
1430
1148
    takes_options = ['verbose', 
1431
1149
                     Option('one', help='stop when one test fails'),
1432
 
                     Option('keep-output', 
1433
 
                            help='keep output directories when tests fail')
1434
1150
                    ]
1435
1151
 
1436
 
    def run(self, testspecs_list=None, verbose=False, one=False,
1437
 
            keep_output=False):
 
1152
    def run(self, testspecs_list=None, verbose=False, one=False):
1438
1153
        import bzrlib.ui
1439
 
        from bzrlib.tests import selftest
 
1154
        from bzrlib.selftest import selftest
1440
1155
        # we don't want progress meters from the tests to go to the
1441
1156
        # real output; and we don't want log messages cluttering up
1442
1157
        # the real logs.
1450
1165
                pattern = ".*"
1451
1166
            result = selftest(verbose=verbose, 
1452
1167
                              pattern=pattern,
1453
 
                              stop_on_failure=one, 
1454
 
                              keep_output=keep_output)
 
1168
                              stop_on_failure=one)
1455
1169
            if result:
1456
1170
                bzrlib.trace.info('tests passed')
1457
1171
            else:
1477
1191
 
1478
1192
class cmd_version(Command):
1479
1193
    """Show version of bzr."""
1480
 
    @display_command
1481
1194
    def run(self):
1482
1195
        show_version()
1483
1196
 
1484
1197
class cmd_rocks(Command):
1485
1198
    """Statement of optimism."""
1486
1199
    hidden = True
1487
 
    @display_command
1488
1200
    def run(self):
1489
1201
        print "it sure does!"
1490
1202
 
1497
1209
    takes_args = ['branch', 'other']
1498
1210
    hidden = True
1499
1211
    
1500
 
    @display_command
1501
1212
    def run(self, branch, other):
1502
1213
        from bzrlib.revision import common_ancestor, MultipleRevisionSources
1503
1214
        
1504
 
        branch1 = Branch.open_containing(branch)[0]
1505
 
        branch2 = Branch.open_containing(other)[0]
 
1215
        branch1 = Branch.open_containing(branch)
 
1216
        branch2 = Branch.open_containing(other)
1506
1217
 
1507
1218
        history_1 = branch1.revision_history()
1508
1219
        history_2 = branch2.revision_history()
1557
1268
    --force is given.
1558
1269
    """
1559
1270
    takes_args = ['branch?']
1560
 
    takes_options = ['revision', 'force', 'merge-type', 'reprocess',
1561
 
                     Option('show-base', help="Show base revision text in "
1562
 
                            "conflicts")]
 
1271
    takes_options = ['revision', 'force', 'merge-type']
1563
1272
 
1564
 
    def run(self, branch=None, revision=None, force=False, merge_type=None,
1565
 
            show_base=False, reprocess=False):
 
1273
    def run(self, branch=None, revision=None, force=False, 
 
1274
            merge_type=None):
1566
1275
        from bzrlib.merge import merge
1567
1276
        from bzrlib.merge_core import ApplyMerge3
1568
1277
        if merge_type is None:
1569
1278
            merge_type = ApplyMerge3
1570
1279
        if branch is None:
1571
 
            branch = WorkingTree.open_containing(u'.')[0].branch.get_parent()
 
1280
            branch = Branch.open_containing('.').get_parent()
1572
1281
            if branch is None:
1573
1282
                raise BzrCommandError("No merge location known or specified.")
1574
1283
            else:
1579
1288
        else:
1580
1289
            if len(revision) == 1:
1581
1290
                base = [None, None]
1582
 
                other_branch = Branch.open_containing(branch)[0]
1583
 
                revno = revision[0].in_history(other_branch).revno
1584
 
                other = [branch, revno]
 
1291
                other = [branch, revision[0].in_history(branch).revno]
1585
1292
            else:
1586
1293
                assert len(revision) == 2
1587
1294
                if None in revision:
1588
1295
                    raise BzrCommandError(
1589
1296
                        "Merge doesn't permit that revision specifier.")
1590
 
                b = Branch.open_containing(branch)[0]
 
1297
                b = Branch.open(branch)
1591
1298
 
1592
1299
                base = [branch, revision[0].in_history(b).revno]
1593
1300
                other = [branch, revision[1].in_history(b).revno]
1594
1301
 
1595
1302
        try:
1596
 
            conflict_count = merge(other, base, check_clean=(not force),
1597
 
                                   merge_type=merge_type, reprocess=reprocess,
1598
 
                                   show_base=show_base)
1599
 
            if conflict_count != 0:
1600
 
                return 1
1601
 
            else:
1602
 
                return 0
 
1303
            merge(other, base, check_clean=(not force), merge_type=merge_type)
1603
1304
        except bzrlib.errors.AmbiguousBase, e:
1604
1305
            m = ("sorry, bzr can't determine the right merge base yet\n"
1605
1306
                 "candidates are:\n  "
1610
1311
            log_error(m)
1611
1312
 
1612
1313
 
1613
 
class cmd_remerge(Command):
1614
 
    """Redo a merge.
1615
 
    """
1616
 
    takes_args = ['file*']
1617
 
    takes_options = ['merge-type', 'reprocess',
1618
 
                     Option('show-base', help="Show base revision text in "
1619
 
                            "conflicts")]
1620
 
 
1621
 
    def run(self, file_list=None, merge_type=None, show_base=False,
1622
 
            reprocess=False):
1623
 
        from bzrlib.merge import merge_inner, transform_tree
1624
 
        from bzrlib.merge_core import ApplyMerge3
1625
 
        if merge_type is None:
1626
 
            merge_type = ApplyMerge3
1627
 
        tree, file_list = tree_files(file_list)
1628
 
        tree.lock_write()
1629
 
        try:
1630
 
            pending_merges = tree.pending_merges() 
1631
 
            if len(pending_merges) != 1:
1632
 
                raise BzrCommandError("Sorry, remerge only works after normal"
1633
 
                                      + " merges.  Not cherrypicking or"
1634
 
                                      + "multi-merges.")
1635
 
            base_revision = common_ancestor(tree.branch.last_revision(), 
1636
 
                                            pending_merges[0], tree.branch)
1637
 
            base_tree = tree.branch.revision_tree(base_revision)
1638
 
            other_tree = tree.branch.revision_tree(pending_merges[0])
1639
 
            interesting_ids = None
1640
 
            if file_list is not None:
1641
 
                interesting_ids = set()
1642
 
                for filename in file_list:
1643
 
                    file_id = tree.path2id(filename)
1644
 
                    interesting_ids.add(file_id)
1645
 
                    if tree.kind(file_id) != "directory":
1646
 
                        continue
1647
 
                    
1648
 
                    for name, ie in tree.inventory.iter_entries(file_id):
1649
 
                        interesting_ids.add(ie.file_id)
1650
 
            transform_tree(tree, tree.branch.basis_tree(), interesting_ids)
1651
 
            if file_list is None:
1652
 
                restore_files = list(tree.iter_conflicts())
1653
 
            else:
1654
 
                restore_files = file_list
1655
 
            for filename in restore_files:
1656
 
                try:
1657
 
                    restore(tree.abspath(filename))
1658
 
                except NotConflicted:
1659
 
                    pass
1660
 
            conflicts =  merge_inner(tree.branch, other_tree, base_tree, 
1661
 
                                     interesting_ids = interesting_ids, 
1662
 
                                     other_rev_id=pending_merges[0], 
1663
 
                                     merge_type=merge_type, 
1664
 
                                     show_base=show_base,
1665
 
                                     reprocess=reprocess)
1666
 
        finally:
1667
 
            tree.unlock()
1668
 
        if conflicts > 0:
1669
 
            return 1
1670
 
        else:
1671
 
            return 0
1672
 
 
1673
1314
class cmd_revert(Command):
1674
1315
    """Reverse all changes since the last commit.
1675
1316
 
1682
1323
    aliases = ['merge-revert']
1683
1324
 
1684
1325
    def run(self, revision=None, no_backup=False, file_list=None):
1685
 
        from bzrlib.merge import merge_inner
 
1326
        from bzrlib.merge import merge
1686
1327
        from bzrlib.commands import parse_spec
 
1328
 
1687
1329
        if file_list is not None:
1688
1330
            if len(file_list) == 0:
1689
1331
                raise BzrCommandError("No files specified")
1690
 
        else:
1691
 
            file_list = []
1692
1332
        if revision is None:
1693
1333
            revno = -1
1694
 
            tree = WorkingTree.open_containing(u'.')[0]
1695
 
            # FIXME should be tree.last_revision
1696
 
            rev_id = tree.branch.last_revision()
1697
1334
        elif len(revision) != 1:
1698
1335
            raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1699
1336
        else:
1700
 
            tree, file_list = tree_files(file_list)
1701
 
            rev_id = revision[0].in_history(tree.branch).rev_id
1702
 
        tree.revert(file_list, tree.branch.revision_tree(rev_id),
1703
 
                                not no_backup)
 
1337
            b = Branch.open_containing('.')
 
1338
            revno = revision[0].in_history(b).revno
 
1339
        merge(('.', revno), parse_spec('.'),
 
1340
              check_clean=False,
 
1341
              ignore_zero=True,
 
1342
              backup_files=not no_backup,
 
1343
              file_list=file_list)
 
1344
        if not file_list:
 
1345
            Branch.open_containing('.').set_pending_merges([])
1704
1346
 
1705
1347
 
1706
1348
class cmd_assert_fail(Command):
1718
1360
    takes_args = ['topic?']
1719
1361
    aliases = ['?']
1720
1362
    
1721
 
    @display_command
1722
1363
    def run(self, topic=None, long=False):
1723
1364
        import help
1724
1365
        if topic is None and long:
1734
1375
    aliases = ['s-c']
1735
1376
    hidden = True
1736
1377
    
1737
 
    @display_command
1738
1378
    def run(self, context=None):
1739
1379
        import shellcomplete
1740
1380
        shellcomplete.shellcomplete(context)
1749
1389
    def run(self, from_branch, to_branch):
1750
1390
        from bzrlib.fetch import Fetcher
1751
1391
        from bzrlib.branch import Branch
1752
 
        from_b = Branch.open(from_branch)
1753
 
        to_b = Branch.open(to_branch)
1754
 
        from_b.lock_read()
1755
 
        try:
1756
 
            to_b.lock_write()
1757
 
            try:
1758
 
                Fetcher(to_b, from_b)
1759
 
            finally:
1760
 
                to_b.unlock()
1761
 
        finally:
1762
 
            from_b.unlock()
 
1392
        from_b = Branch(from_branch)
 
1393
        to_b = Branch(to_branch)
 
1394
        Fetcher(to_b, from_b)
 
1395
        
1763
1396
 
1764
1397
 
1765
1398
class cmd_missing(Command):
1766
 
    """Show unmerged/unpulled revisions between two branches.
1767
 
 
1768
 
    OTHER_BRANCH may be local or remote."""
1769
 
    takes_args = ['other_branch?']
1770
 
    takes_options = [Option('reverse', 'Reverse the order of revisions'),
1771
 
                     Option('mine-only', 
1772
 
                            'Display changes in the local branch only'),
1773
 
                     Option('theirs-only', 
1774
 
                            'Display changes in the remote branch only'), 
1775
 
                     'line',
1776
 
                     'long', 
1777
 
                     'short',
1778
 
                     'show-ids',
1779
 
                     'verbose'
1780
 
                     ]
1781
 
 
1782
 
    def run(self, other_branch=None, reverse=False, mine_only=False,
1783
 
            theirs_only=False, long=True, short=False, line=False, 
1784
 
            show_ids=False, verbose=False):
1785
 
        from bzrlib.missing import find_unmerged, iter_log_data
1786
 
        from bzrlib.log import log_formatter
1787
 
        local_branch = bzrlib.branch.Branch.open_containing(u".")[0]
1788
 
        parent = local_branch.get_parent()
1789
 
        if other_branch is None:
1790
 
            other_branch = parent
1791
 
            if other_branch is None:
 
1399
    """What is missing in this branch relative to other branch.
 
1400
    """
 
1401
    # TODO: rewrite this in terms of ancestry so that it shows only
 
1402
    # unmerged things
 
1403
    
 
1404
    takes_args = ['remote?']
 
1405
    aliases = ['mis', 'miss']
 
1406
    # We don't have to add quiet to the list, because 
 
1407
    # unknown options are parsed as booleans
 
1408
    takes_options = ['verbose', 'quiet']
 
1409
 
 
1410
    def run(self, remote=None, verbose=False, quiet=False):
 
1411
        from bzrlib.errors import BzrCommandError
 
1412
        from bzrlib.missing import show_missing
 
1413
 
 
1414
        if verbose and quiet:
 
1415
            raise BzrCommandError('Cannot pass both quiet and verbose')
 
1416
 
 
1417
        b = Branch.open_containing('.')
 
1418
        parent = b.get_parent()
 
1419
        if remote is None:
 
1420
            if parent is None:
1792
1421
                raise BzrCommandError("No missing location known or specified.")
1793
 
            print "Using last location: " + local_branch.get_parent()
1794
 
        remote_branch = bzrlib.branch.Branch.open(other_branch)
1795
 
        local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
1796
 
        log_format = get_log_format(long=long, short=short, line=line)
1797
 
        lf = log_formatter(log_format, sys.stdout,
1798
 
                           show_ids=show_ids,
1799
 
                           show_timezone='original')
1800
 
        if reverse is False:
1801
 
            local_extra.reverse()
1802
 
            remote_extra.reverse()
1803
 
        if local_extra and not theirs_only:
1804
 
            print "You have %d extra revision(s):" % len(local_extra)
1805
 
            for data in iter_log_data(local_extra, local_branch, verbose):
1806
 
                lf.show(*data)
1807
 
            printed_local = True
1808
 
        else:
1809
 
            printed_local = False
1810
 
        if remote_extra and not mine_only:
1811
 
            if printed_local is True:
1812
 
                print "\n\n"
1813
 
            print "You are missing %d revision(s):" % len(remote_extra)
1814
 
            for data in iter_log_data(remote_extra, remote_branch, verbose):
1815
 
                lf.show(*data)
1816
 
        if not remote_extra and not local_extra:
1817
 
            status_code = 0
1818
 
            print "Branches are up to date."
1819
 
        else:
1820
 
            status_code = 1
1821
 
        if parent is None and other_branch is not None:
1822
 
            local_branch.set_parent(other_branch)
1823
 
        return status_code
 
1422
            else:
 
1423
                if not quiet:
 
1424
                    print "Using last location: %s" % parent
 
1425
                remote = parent
 
1426
        elif parent is None:
 
1427
            # We only update parent if it did not exist, missing
 
1428
            # should not change the parent
 
1429
            b.set_parent(remote)
 
1430
        br_remote = Branch.open_containing(remote)
 
1431
        return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
1824
1432
 
1825
1433
 
1826
1434
class cmd_plugins(Command):
1827
1435
    """List plugins"""
1828
1436
    hidden = True
1829
 
    @display_command
1830
1437
    def run(self):
1831
1438
        import bzrlib.plugin
1832
1439
        from inspect import getdoc
1833
 
        for name, plugin in bzrlib.plugin.all_plugins().items():
 
1440
        for plugin in bzrlib.plugin.all_plugins:
1834
1441
            if hasattr(plugin, '__path__'):
1835
1442
                print plugin.__path__[0]
1836
1443
            elif hasattr(plugin, '__file__'):
1847
1454
    """Show testament (signing-form) of a revision."""
1848
1455
    takes_options = ['revision', 'long']
1849
1456
    takes_args = ['branch?']
1850
 
    @display_command
1851
 
    def run(self, branch=u'.', revision=None, long=False):
 
1457
    def run(self, branch='.', revision=None, long=False):
1852
1458
        from bzrlib.testament import Testament
1853
 
        b = WorkingTree.open_containing(branch)[0].branch
 
1459
        b = Branch.open_containing(branch)
1854
1460
        b.lock_read()
1855
1461
        try:
1856
1462
            if revision is None:
1885
1491
                     Option('long', help='show date in annotations'),
1886
1492
                     ]
1887
1493
 
1888
 
    @display_command
1889
1494
    def run(self, filename, all=False, long=False):
1890
1495
        from bzrlib.annotate import annotate_file
1891
 
        tree, relpath = WorkingTree.open_containing(filename)
1892
 
        branch = tree.branch
1893
 
        branch.lock_read()
 
1496
        b = Branch.open_containing(filename)
 
1497
        b.lock_read()
1894
1498
        try:
1895
 
            file_id = tree.inventory.path2id(relpath)
1896
 
            tree = branch.revision_tree(branch.last_revision())
 
1499
            tree = WorkingTree(b.base, b)
 
1500
            rp = tree.relpath(filename)
 
1501
            tree = b.revision_tree(b.last_revision())
 
1502
            file_id = tree.inventory.path2id(rp)
1897
1503
            file_version = tree.inventory[file_id].revision
1898
 
            annotate_file(branch, file_version, file_id, long, all, sys.stdout)
 
1504
            annotate_file(b, file_version, file_id, long, all, sys.stdout)
1899
1505
        finally:
1900
 
            branch.unlock()
 
1506
            b.unlock()
1901
1507
 
1902
1508
 
1903
1509
class cmd_re_sign(Command):
1915
1521
            raise BzrCommandError('You can only supply one of revision_id or --revision')
1916
1522
        if revision_id is None and revision is None:
1917
1523
            raise BzrCommandError('You must supply either --revision or a revision_id')
1918
 
        b = WorkingTree.open_containing(u'.')[0].branch
 
1524
        b = Branch.open_containing('.')
1919
1525
        gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
1920
1526
        if revision_id is not None:
1921
1527
            b.sign_revision(revision_id, gpg_strategy)
1922
1528
        elif revision is not None:
1923
 
            if len(revision) == 1:
1924
 
                revno, rev_id = revision[0].in_history(b)
 
1529
            for rev in revision:
 
1530
                if rev is None:
 
1531
                    raise BzrCommandError('You cannot specify a NULL revision.')
 
1532
                revno, rev_id = rev.in_history(b)
1925
1533
                b.sign_revision(rev_id, gpg_strategy)
1926
 
            elif len(revision) == 2:
1927
 
                # are they both on rh- if so we can walk between them
1928
 
                # might be nice to have a range helper for arbitrary
1929
 
                # revision paths. hmm.
1930
 
                from_revno, from_revid = revision[0].in_history(b)
1931
 
                to_revno, to_revid = revision[1].in_history(b)
1932
 
                if to_revid is None:
1933
 
                    to_revno = b.revno()
1934
 
                if from_revno is None or to_revno is None:
1935
 
                    raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
1936
 
                for revno in range(from_revno, to_revno + 1):
1937
 
                    b.sign_revision(b.get_rev_id(revno), gpg_strategy)
1938
 
            else:
1939
 
                raise BzrCommandError('Please supply either one revision, or a range.')
1940
 
 
1941
 
 
1942
 
class cmd_uncommit(bzrlib.commands.Command):
1943
 
    """Remove the last committed revision.
1944
 
 
1945
 
    By supplying the --all flag, it will not only remove the entry 
1946
 
    from revision_history, but also remove all of the entries in the
1947
 
    stores.
1948
 
 
1949
 
    --verbose will print out what is being removed.
1950
 
    --dry-run will go through all the motions, but not actually
1951
 
    remove anything.
1952
 
    
1953
 
    In the future, uncommit will create a changeset, which can then
1954
 
    be re-applied.
1955
 
    """
1956
 
    takes_options = ['all', 'verbose', 'revision',
1957
 
                    Option('dry-run', help='Don\'t actually make changes'),
1958
 
                    Option('force', help='Say yes to all questions.')]
1959
 
    takes_args = ['location?']
1960
 
    aliases = []
1961
 
 
1962
 
    def run(self, location=None, all=False,
1963
 
            dry_run=False, verbose=False,
1964
 
            revision=None, force=False):
1965
 
        from bzrlib.branch import Branch
1966
 
        from bzrlib.log import log_formatter
1967
 
        import sys
1968
 
        from bzrlib.uncommit import uncommit
1969
 
 
1970
 
        if location is None:
1971
 
            location = u'.'
1972
 
        b, relpath = Branch.open_containing(location)
1973
 
 
1974
 
        if revision is None:
1975
 
            revno = b.revno()
1976
 
            rev_id = b.last_revision()
1977
 
        else:
1978
 
            revno, rev_id = revision[0].in_history(b)
1979
 
        if rev_id is None:
1980
 
            print 'No revisions to uncommit.'
1981
 
 
1982
 
        for r in range(revno, b.revno()+1):
1983
 
            rev_id = b.get_rev_id(r)
1984
 
            lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
1985
 
            lf.show(r, b.get_revision(rev_id), None)
1986
 
 
1987
 
        if dry_run:
1988
 
            print 'Dry-run, pretending to remove the above revisions.'
1989
 
            if not force:
1990
 
                val = raw_input('Press <enter> to continue')
1991
 
        else:
1992
 
            print 'The above revision(s) will be removed.'
1993
 
            if not force:
1994
 
                val = raw_input('Are you sure [y/N]? ')
1995
 
                if val.lower() not in ('y', 'yes'):
1996
 
                    print 'Canceled'
1997
 
                    return 0
1998
 
 
1999
 
        uncommit(b, remove_files=all,
2000
 
                dry_run=dry_run, verbose=verbose,
2001
 
                revno=revno)
2002
1534
 
2003
1535
 
2004
1536
# these get imported and then picked up by the scan for cmd_*
2005
1537
# TODO: Some more consistent way to split command definitions across files;
2006
1538
# we do need to load at least some information about them to know of 
2007
1539
# aliases.
2008
 
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
 
1540
from bzrlib.conflicts import cmd_resolve, cmd_conflicts