← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

sync with bzr.dev mainline

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
 
 
 
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
18
25
import sys
19
26
import os
20
27
 
21
28
import bzrlib
 
29
from bzrlib import BZRDIR
 
30
from bzrlib.commands import Command, display_command
 
31
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)
 
37
from bzrlib.option import Option
 
38
from bzrlib.revisionspec import RevisionSpec
22
39
import bzrlib.trace
23
 
from bzrlib.trace import mutter, note, log_error, warning
24
 
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
25
 
from bzrlib.errors import DivergedBranches
26
 
from bzrlib.branch import Branch
27
 
from bzrlib import BZRDIR
28
 
from bzrlib.commands import Command
29
 
 
 
40
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
 
41
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?)
30
75
 
31
76
class cmd_status(Command):
32
77
    """Display status summary.
67
112
    If a revision argument is given, the status is calculated against
68
113
    that revision, or between two revisions if two are provided.
69
114
    """
70
 
    # XXX: FIXME: bzr status should accept a -r option to show changes
71
 
    # relative to a revision, or between revisions
72
 
 
 
115
    
 
116
    # TODO: --no-recurse, --recurse options
 
117
    
73
118
    takes_args = ['file*']
74
 
    takes_options = ['all', 'show-ids']
 
119
    takes_options = ['all', 'show-ids', 'revision']
75
120
    aliases = ['st', 'stat']
76
121
    
 
122
    @display_command
77
123
    def run(self, all=False, show_ids=False, file_list=None, revision=None):
78
 
        if file_list:
79
 
            b = Branch.open_containing(file_list[0])
80
 
            file_list = [b.relpath(x) for x in file_list]
81
 
            # special case: only one path was given and it's the root
82
 
            # of the branch
83
 
            if file_list == ['']:
84
 
                file_list = None
85
 
        else:
86
 
            b = Branch.open_containing('.')
 
124
        tree, file_list = tree_files(file_list)
87
125
            
88
126
        from bzrlib.status import show_status
89
 
        show_status(b, show_unchanged=all, show_ids=show_ids,
 
127
        show_status(tree.branch, show_unchanged=all, show_ids=show_ids,
90
128
                    specific_files=file_list, revision=revision)
91
129
 
92
130
 
101
139
    takes_args = ['revision_id?']
102
140
    takes_options = ['revision']
103
141
    
 
142
    @display_command
104
143
    def run(self, revision_id=None, revision=None):
105
 
        from bzrlib.revisionspec import RevisionSpec
106
144
 
107
145
        if revision_id is not None and revision is not None:
108
146
            raise BzrCommandError('You can only supply one of revision_id or --revision')
109
147
        if revision_id is None and revision is None:
110
148
            raise BzrCommandError('You must supply either --revision or a revision_id')
111
 
        b = Branch.open_containing('.')
 
149
        b = WorkingTree.open_containing(u'.')[0].branch
112
150
        if revision_id is not None:
113
 
            sys.stdout.write(b.get_revision_xml_file(revision_id).read())
 
151
            sys.stdout.write(b.get_revision_xml(revision_id))
114
152
        elif revision is not None:
115
153
            for rev in revision:
116
154
                if rev is None:
117
155
                    raise BzrCommandError('You cannot specify a NULL revision.')
118
156
                revno, rev_id = rev.in_history(b)
119
 
                sys.stdout.write(b.get_revision_xml_file(rev_id).read())
 
157
                sys.stdout.write(b.get_revision_xml(rev_id))
120
158
    
121
159
 
122
160
class cmd_revno(Command):
123
161
    """Show current revision number.
124
162
 
125
163
    This is equal to the number of revisions on this branch."""
126
 
    def run(self):
127
 
        print Branch.open_containing('.').revno()
 
164
    takes_args = ['location?']
 
165
    @display_command
 
166
    def run(self, location=u'.'):
 
167
        print Branch.open_containing(location)[0].revno()
128
168
 
129
169
 
130
170
class cmd_revision_info(Command):
133
173
    hidden = True
134
174
    takes_args = ['revision_info*']
135
175
    takes_options = ['revision']
 
176
    @display_command
136
177
    def run(self, revision=None, revision_info_list=[]):
137
 
        from bzrlib.revisionspec import RevisionSpec
138
178
 
139
179
        revs = []
140
180
        if revision is not None:
145
185
        if len(revs) == 0:
146
186
            raise BzrCommandError('You must supply a revision identifier')
147
187
 
148
 
        b = Branch.open_containing('.')
 
188
        b = WorkingTree.open_containing(u'.')[0].branch
149
189
 
150
190
        for rev in revs:
151
191
            revinfo = rev.in_history(b)
177
217
    implicitly add the parent, and so on up to the root. This means
178
218
    you should never need to explictly add a directory, they'll just
179
219
    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.
180
223
    """
181
224
    takes_args = ['file*']
182
 
    takes_options = ['no-recurse', 'quiet']
183
 
    
184
 
    def run(self, file_list, no_recurse=False, quiet=False):
185
 
        from bzrlib.add import smart_add, add_reporter_print, add_reporter_null
186
 
        if quiet:
187
 
            reporter = add_reporter_null
 
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
188
238
        else:
189
 
            reporter = add_reporter_print
190
 
        smart_add(file_list, not no_recurse, reporter)
 
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
254
 
192
255
 
193
256
class cmd_mkdir(Command):
198
261
    takes_args = ['dir+']
199
262
 
200
263
    def run(self, dir_list):
201
 
        b = None
202
 
        
203
264
        for d in dir_list:
204
265
            os.mkdir(d)
205
 
            if not b:
206
 
                b = Branch.open_containing(d)
207
 
            b.add([d])
 
266
            wt, dd = WorkingTree.open_containing(d)
 
267
            wt.add([dd])
208
268
            print 'added', d
209
269
 
210
270
 
213
273
    takes_args = ['filename']
214
274
    hidden = True
215
275
    
 
276
    @display_command
216
277
    def run(self, filename):
217
 
        print Branch.open_containing(filename).relpath(filename)
218
 
 
 
278
        tree, relpath = WorkingTree.open_containing(filename)
 
279
        print relpath
219
280
 
220
281
 
221
282
class cmd_inventory(Command):
222
 
    """Show inventory of the current working copy or a revision."""
223
 
    takes_options = ['revision', 'show-ids']
 
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
289
    
225
 
    def run(self, revision=None, show_ids=False):
226
 
        b = Branch.open_containing('.')
 
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
295
        if revision is None:
228
 
            inv = b.read_working_inventory()
 
296
            inv = tree.read_working_inventory()
229
297
        else:
230
298
            if len(revision) > 1:
231
299
                raise BzrCommandError('bzr inventory --revision takes'
232
300
                    ' exactly one revision identifier')
233
 
            inv = b.get_revision_inventory(revision[0].in_history(b).rev_id)
 
301
            inv = tree.branch.get_revision_inventory(
 
302
                revision[0].in_history(tree.branch).rev_id)
234
303
 
235
304
        for path, entry in inv.entries():
 
305
            if kind and kind != entry.kind:
 
306
                continue
236
307
            if show_ids:
237
308
                print '%-50s %s' % (path, entry.file_id)
238
309
            else:
249
320
    """
250
321
    takes_args = ['source$', 'dest']
251
322
    def run(self, source_list, dest):
252
 
        b = Branch.open_containing('.')
253
 
 
 
323
        tree, source_list = tree_files(source_list)
254
324
        # TODO: glob expansion on windows?
255
 
        b.move([b.relpath(s) for s in source_list], b.relpath(dest))
 
325
        tree.move(source_list, tree.relpath(dest))
256
326
 
257
327
 
258
328
class cmd_rename(Command):
272
342
    takes_args = ['from_name', 'to_name']
273
343
    
274
344
    def run(self, from_name, to_name):
275
 
        b = Branch.open_containing('.')
276
 
        b.rename_one(b.relpath(from_name), b.relpath(to_name))
277
 
 
 
345
        tree, (from_name, to_name) = tree_files((from_name, to_name))
 
346
        tree.rename_one(from_name, to_name)
278
347
 
279
348
 
280
349
class cmd_mv(Command):
294
363
    def run(self, names_list):
295
364
        if len(names_list) < 2:
296
365
            raise BzrCommandError("missing file argument")
297
 
        b = Branch.open_containing(names_list[0])
298
 
 
299
 
        rel_names = [b.relpath(x) for x in names_list]
 
366
        tree, rel_names = tree_files(names_list)
300
367
        
301
368
        if os.path.isdir(names_list[-1]):
302
369
            # move into existing directory
303
 
            for pair in b.move(rel_names[:-1], rel_names[-1]):
 
370
            for pair in tree.move(rel_names[:-1], rel_names[-1]):
304
371
                print "%s => %s" % pair
305
372
        else:
306
373
            if len(names_list) != 2:
307
374
                raise BzrCommandError('to mv multiple files the destination '
308
375
                                      'must be a versioned directory')
309
 
            b.rename_one(rel_names[0], rel_names[1])
 
376
            tree.rename_one(rel_names[0], rel_names[1])
310
377
            print "%s => %s" % (rel_names[0], rel_names[1])
311
378
            
312
379
    
313
 
 
314
 
 
315
380
class cmd_pull(Command):
316
381
    """Pull any changes from another branch into the current one.
317
382
 
318
 
    If the location is omitted, the last-used location will be used.
319
 
    Both the revision history and the working directory will be
320
 
    updated.
 
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
386
 
322
387
    This command only works on branches that have not diverged.  Branches are
323
388
    considered diverged if both branches have had commits without first
324
389
    pulling from the other.
325
390
 
326
391
    If branches have diverged, you can use 'bzr merge' to pull the text changes
327
 
    from one into the other.
 
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.
328
397
    """
329
 
    takes_options = ['remember']
 
398
    takes_options = ['remember', 'overwrite', 'verbose']
330
399
    takes_args = ['location?']
331
400
 
332
 
    def run(self, location=None, remember=False):
 
401
    def run(self, location=None, remember=False, overwrite=False, verbose=False):
333
402
        from bzrlib.merge import merge
334
 
        import tempfile
335
403
        from shutil import rmtree
336
404
        import errno
337
 
        
338
 
        br_to = Branch.open_containing('.')
339
 
        stored_loc = br_to.get_parent()
 
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
408
        if location is None:
341
409
            if stored_loc is None:
342
410
                raise BzrCommandError("No pull location known or specified.")
343
411
            else:
344
412
                print "Using saved location: %s" % stored_loc
345
413
                location = stored_loc
346
 
        cache_root = tempfile.mkdtemp()
 
414
 
347
415
        br_from = Branch.open(location)
348
 
        br_from.lock_read()
349
 
        try:
350
 
            br_from.setup_caching(cache_root)
351
 
            location = br_from.base
352
 
            old_revno = br_to.revno()
353
 
            old_revision_history = br_to.revision_history()
 
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:
354
508
            try:
355
 
                br_to.update_revisions(br_from)
356
 
            except DivergedBranches:
357
 
                raise BzrCommandError("These branches have diverged."
358
 
                    "  Try merge.")
359
 
            new_revision_history = br_to.revision_history()
360
 
            if new_revision_history != old_revision_history:
361
 
                merge(('.', -1), ('.', old_revno), check_clean=False)
362
 
            if stored_loc is None or remember:
363
 
                br_to.set_parent(location)
364
 
        finally:
365
 
            br_from.unlock()
366
 
            rmtree(cache_root)
 
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,))
367
524
 
 
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)
368
531
 
369
532
 
370
533
class cmd_branch(Command):
386
549
 
387
550
    def run(self, from_location, to_location=None, revision=None, basis=None):
388
551
        from bzrlib.clone import copy_branch
389
 
        import tempfile
390
552
        import errno
391
553
        from shutil import rmtree
392
 
        cache_root = tempfile.mkdtemp()
393
554
        if revision is None:
394
555
            revision = [None]
395
556
        elif len(revision) > 1:
405
566
                raise
406
567
        br_from.lock_read()
407
568
        try:
408
 
            br_from.setup_caching(cache_root)
409
569
            if basis is not None:
410
 
                basis_branch = Branch.open_containing(basis)
 
570
                basis_branch = WorkingTree.open_containing(basis)[0].branch
411
571
            else:
412
572
                basis_branch = None
413
573
            if len(revision) == 1 and revision[0] is not None:
416
576
                revision_id = None
417
577
            if to_location is None:
418
578
                to_location = os.path.basename(from_location.rstrip("/\\"))
 
579
                name = None
 
580
            else:
 
581
                name = os.path.basename(to_location) + '\n'
419
582
            try:
420
583
                os.mkdir(to_location)
421
584
            except OSError, e:
431
594
                copy_branch(br_from, to_location, revision_id, basis_branch)
432
595
            except bzrlib.errors.NoSuchRevision:
433
596
                rmtree(to_location)
434
 
                msg = "The branch %s has no revision %d." % (from_location, revision[0])
 
597
                msg = "The branch %s has no revision %s." % (from_location, revision[0])
435
598
                raise BzrCommandError(msg)
436
599
            except bzrlib.errors.UnlistableBranch:
 
600
                rmtree(to_location)
437
601
                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())
438
608
        finally:
439
609
            br_from.unlock()
440
 
            rmtree(cache_root)
441
610
 
442
611
 
443
612
class cmd_renames(Command):
448
617
    # TODO: Only show renames under dir, rather than in the whole branch.
449
618
    takes_args = ['dir?']
450
619
 
451
 
    def run(self, dir='.'):
452
 
        b = Branch.open_containing(dir)
453
 
        old_inv = b.basis_tree().inventory
454
 
        new_inv = b.read_working_inventory()
 
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()
455
625
 
456
626
        renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
457
627
        renames.sort()
463
633
    """Show statistical information about a branch."""
464
634
    takes_args = ['branch?']
465
635
    
 
636
    @display_command
466
637
    def run(self, branch=None):
467
638
        import info
468
 
        b = Branch.open_containing(branch)
 
639
        b = WorkingTree.open_containing(branch)[0].branch
469
640
        info.show_info(b)
470
641
 
471
642
 
480
651
    aliases = ['rm']
481
652
    
482
653
    def run(self, file_list, verbose=False):
483
 
        b = Branch.open_containing(file_list[0])
484
 
        b.remove([b.relpath(f) for f in file_list], verbose=verbose)
 
654
        tree, file_list = tree_files(file_list)
 
655
        tree.remove(file_list, verbose=verbose)
485
656
 
486
657
 
487
658
class cmd_file_id(Command):
493
664
    """
494
665
    hidden = True
495
666
    takes_args = ['filename']
 
667
    @display_command
496
668
    def run(self, filename):
497
 
        b = Branch.open_containing(filename)
498
 
        i = b.inventory.path2id(b.relpath(filename))
 
669
        tree, relpath = WorkingTree.open_containing(filename)
 
670
        i = tree.inventory.path2id(relpath)
499
671
        if i == None:
500
672
            raise BzrError("%r is not a versioned file" % filename)
501
673
        else:
509
681
    starting at the branch root."""
510
682
    hidden = True
511
683
    takes_args = ['filename']
 
684
    @display_command
512
685
    def run(self, filename):
513
 
        b = Branch.open_containing(filename)
514
 
        inv = b.inventory
515
 
        fid = inv.path2id(b.relpath(filename))
 
686
        tree, relpath = WorkingTree.open_containing(filename)
 
687
        inv = tree.inventory
 
688
        fid = inv.path2id(relpath)
516
689
        if fid == None:
517
690
            raise BzrError("%r is not a versioned file" % filename)
518
691
        for fip in inv.get_idpath(fid):
522
695
class cmd_revision_history(Command):
523
696
    """Display list of revision ids on this branch."""
524
697
    hidden = True
 
698
    @display_command
525
699
    def run(self):
526
 
        for patchid in Branch.open_containing('.').revision_history():
 
700
        branch = WorkingTree.open_containing(u'.')[0].branch
 
701
        for patchid in branch.revision_history():
527
702
            print patchid
528
703
 
529
704
 
530
705
class cmd_ancestry(Command):
531
706
    """List all revisions merged into this branch."""
532
707
    hidden = True
 
708
    @display_command
533
709
    def run(self):
534
 
        b = find_branch('.')
 
710
        tree = WorkingTree.open_containing(u'.')[0]
 
711
        b = tree.branch
 
712
        # FIXME. should be tree.last_revision
535
713
        for revision_id in b.get_ancestry(b.last_revision()):
536
714
            print revision_id
537
715
 
538
716
 
539
 
class cmd_directories(Command):
540
 
    """Display list of versioned directories in this branch."""
541
 
    def run(self):
542
 
        for name, ie in Branch.open_containing('.').read_working_inventory().directories():
543
 
            if name == '':
544
 
                print '.'
545
 
            else:
546
 
                print name
547
 
 
548
 
 
549
717
class cmd_init(Command):
550
718
    """Make a directory into a versioned branch.
551
719
 
555
723
    Recipe for importing a tree of files:
556
724
        cd ~/project
557
725
        bzr init
558
 
        bzr add -v .
 
726
        bzr add .
559
727
        bzr status
560
728
        bzr commit -m 'imported project'
561
729
    """
562
 
    def run(self):
563
 
        Branch.initialize('.')
 
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)
564
744
 
565
745
 
566
746
class cmd_diff(Command):
592
772
    takes_options = ['revision', 'diff-options']
593
773
    aliases = ['di', 'dif']
594
774
 
 
775
    @display_command
595
776
    def run(self, revision=None, file_list=None, diff_options=None):
596
777
        from bzrlib.diff import show_diff
597
 
 
598
 
        if file_list:
599
 
            b = Branch.open_containing(file_list[0])
600
 
            file_list = [b.relpath(f) for f in file_list]
601
 
            if file_list == ['']:
602
 
                # just pointing to top-of-tree
603
 
                file_list = None
604
 
        else:
605
 
            b = Branch.open_containing('.')
606
 
 
 
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
607
792
        if revision is not None:
 
793
            if b2 is not None:
 
794
                raise BzrCommandError("Can't specify -r with two branches")
608
795
            if len(revision) == 1:
609
 
                show_diff(b, revision[0], specific_files=file_list,
610
 
                          external_diff_options=diff_options)
 
796
                return show_diff(tree.branch, revision[0], specific_files=file_list,
 
797
                                 external_diff_options=diff_options)
611
798
            elif len(revision) == 2:
612
 
                show_diff(b, revision[0], specific_files=file_list,
613
 
                          external_diff_options=diff_options,
614
 
                          revision2=revision[1])
 
799
                return show_diff(tree.branch, revision[0], specific_files=file_list,
 
800
                                 external_diff_options=diff_options,
 
801
                                 revision2=revision[1])
615
802
            else:
616
803
                raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
617
804
        else:
618
 
            show_diff(b, None, specific_files=file_list,
619
 
                      external_diff_options=diff_options)
620
 
 
621
 
        
 
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)
622
811
 
623
812
 
624
813
class cmd_deleted(Command):
630
819
    # directories with readdir, rather than stating each one.  Same
631
820
    # level of effort but possibly much less IO.  (Or possibly not,
632
821
    # if the directories are very large...)
 
822
    @display_command
633
823
    def run(self, show_ids=False):
634
 
        b = Branch.open_containing('.')
635
 
        old = b.basis_tree()
636
 
        new = b.working_tree()
 
824
        tree = WorkingTree.open_containing(u'.')[0]
 
825
        old = tree.branch.basis_tree()
637
826
        for path, ie in old.inventory.iter_entries():
638
 
            if not new.has_id(ie.file_id):
 
827
            if not tree.has_id(ie.file_id):
639
828
                if show_ids:
640
829
                    print '%-50s %s' % (path, ie.file_id)
641
830
                else:
645
834
class cmd_modified(Command):
646
835
    """List files modified in working tree."""
647
836
    hidden = True
 
837
    @display_command
648
838
    def run(self):
649
839
        from bzrlib.delta import compare_trees
650
840
 
651
 
        b = Branch.open_containing('.')
652
 
        td = compare_trees(b.basis_tree(), b.working_tree())
 
841
        tree = WorkingTree.open_containing(u'.')[0]
 
842
        td = compare_trees(tree.branch.basis_tree(), tree)
653
843
 
654
844
        for path, id, kind, text_modified, meta_modified in td.modified:
655
845
            print path
659
849
class cmd_added(Command):
660
850
    """List files added in working tree."""
661
851
    hidden = True
 
852
    @display_command
662
853
    def run(self):
663
 
        b = Branch.open_containing('.')
664
 
        wt = b.working_tree()
665
 
        basis_inv = b.basis_tree().inventory
 
854
        wt = WorkingTree.open_containing(u'.')[0]
 
855
        basis_inv = wt.branch.basis_tree().inventory
666
856
        inv = wt.inventory
667
857
        for file_id in inv:
668
858
            if file_id in basis_inv:
680
870
    The root is the nearest enclosing directory with a .bzr control
681
871
    directory."""
682
872
    takes_args = ['filename?']
 
873
    @display_command
683
874
    def run(self, filename=None):
684
875
        """Print the branch root."""
685
 
        b = Branch.open_containing(filename)
686
 
        print b.base
 
876
        tree = WorkingTree.open_containing(filename)[0]
 
877
        print tree.basedir
687
878
 
688
879
 
689
880
class cmd_log(Command):
690
881
    """Show log of this branch.
691
882
 
692
 
    To request a range of logs, you can use the command -r begin:end
693
 
    -r revision requests a specific revision, -r :end or -r begin: are
 
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
694
885
    also valid.
695
 
 
696
 
    --message allows you to give a regular expression, which will be evaluated
697
 
    so that only matching entries will be displayed.
698
886
    """
699
887
 
700
888
    # TODO: Make --revision support uuid: and hash: [future tag:] notation.
701
889
 
702
890
    takes_args = ['filename?']
703
 
    takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
704
 
                     'long', 'message', 'short',]
705
 
    
 
891
    takes_options = [Option('forward', 
 
892
                            help='show from oldest to newest'),
 
893
                     'timezone', 'verbose', 
 
894
                     'show-ids', 'revision',
 
895
                     'line', 'long', 
 
896
                     Option('message',
 
897
                            help='show revisions whose message matches this regexp',
 
898
                            type=str),
 
899
                     'short',
 
900
                     ]
 
901
    @display_command
706
902
    def run(self, filename=None, timezone='original',
707
903
            verbose=False,
708
904
            show_ids=False,
710
906
            revision=None,
711
907
            message=None,
712
908
            long=False,
713
 
            short=False):
 
909
            short=False,
 
910
            line=False):
714
911
        from bzrlib.log import log_formatter, show_log
715
912
        import codecs
716
 
 
 
913
        assert message is None or isinstance(message, basestring), \
 
914
            "invalid message argument %r" % message
717
915
        direction = (forward and 'forward') or 'reverse'
718
916
        
719
917
        if filename:
720
 
            b = Branch.open_containing(filename)
721
 
            fp = b.relpath(filename)
722
 
            if fp:
723
 
                file_id = b.read_working_inventory().path2id(fp)
 
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)
724
933
            else:
725
934
                file_id = None  # points to branch root
726
935
        else:
727
 
            b = Branch.open_containing('.')
 
936
            tree, relpath = WorkingTree.open_containing(u'.')
 
937
            b = tree.branch
728
938
            file_id = None
729
939
 
730
940
        if revision is None:
738
948
        else:
739
949
            raise BzrCommandError('bzr log --revision takes one or two values.')
740
950
 
741
 
        if rev1 == 0:
742
 
            rev1 = None
743
 
        if rev2 == 0:
744
 
            rev2 = None
 
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)
745
956
 
746
 
        mutter('encoding log as %r' % bzrlib.user_encoding)
 
957
        mutter('encoding log as %r', bzrlib.user_encoding)
747
958
 
748
959
        # use 'replace' so that we don't abort if trying to write out
749
960
        # in e.g. the default C locale.
750
961
        outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
751
962
 
752
 
        if not short:
753
 
            log_format = 'long'
754
 
        else:
755
 
            log_format = 'short'
 
963
        log_format = get_log_format(long=long, short=short, line=line)
756
964
        lf = log_formatter(log_format,
757
965
                           show_ids=show_ids,
758
966
                           to_file=outf,
767
975
                 end_revision=rev2,
768
976
                 search=message)
769
977
 
 
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
770
987
 
771
988
 
772
989
class cmd_touching_revisions(Command):
775
992
    A more user-friendly interface is "bzr log FILE"."""
776
993
    hidden = True
777
994
    takes_args = ["filename"]
 
995
    @display_command
778
996
    def run(self, filename):
779
 
        b = Branch.open_containing(filename)
780
 
        inv = b.read_working_inventory()
781
 
        file_id = inv.path2id(b.relpath(filename))
 
997
        tree, relpath = WorkingTree.open_containing(filename)
 
998
        b = tree.branch
 
999
        inv = tree.read_working_inventory()
 
1000
        file_id = inv.path2id(relpath)
782
1001
        for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
783
1002
            print "%6d %s" % (revno, what)
784
1003
 
788
1007
    """
789
1008
    # TODO: Take a revision or remote path and list that tree instead.
790
1009
    hidden = True
791
 
    def run(self, revision=None, verbose=False):
792
 
        b = Branch.open_containing('.')
793
 
        if revision == None:
794
 
            tree = b.working_tree()
795
 
        else:
796
 
            tree = b.revision_tree(revision.in_history(b).rev_id)
 
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)
797
1041
        for fp, fc, kind, fid, entry in tree.list_files():
798
 
            if verbose:
799
 
                kindch = entry.kind_character()
800
 
                print '%-8s %s%s' % (fc, fp, kindch)
801
 
            else:
802
 
                print fp
803
 
 
 
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
804
1057
 
805
1058
 
806
1059
class cmd_unknowns(Command):
807
1060
    """List unknown files."""
 
1061
    @display_command
808
1062
    def run(self):
809
1063
        from bzrlib.osutils import quotefn
810
 
        for f in Branch.open_containing('.').unknowns():
 
1064
        for f in WorkingTree.open_containing(u'.')[0].unknowns():
811
1065
            print quotefn(f)
812
1066
 
813
1067
 
814
 
 
815
1068
class cmd_ignore(Command):
816
1069
    """Ignore a command or pattern.
817
1070
 
837
1090
        from bzrlib.atomicfile import AtomicFile
838
1091
        import os.path
839
1092
 
840
 
        b = Branch.open_containing('.')
841
 
        ifn = b.abspath('.bzrignore')
 
1093
        tree, relpath = WorkingTree.open_containing(u'.')
 
1094
        ifn = tree.abspath('.bzrignore')
842
1095
 
843
1096
        if os.path.exists(ifn):
844
1097
            f = open(ifn, 'rt')
863
1116
        finally:
864
1117
            f.close()
865
1118
 
866
 
        inv = b.working_tree().inventory
 
1119
        inv = tree.inventory
867
1120
        if inv.path2id('.bzrignore'):
868
1121
            mutter('.bzrignore is already versioned')
869
1122
        else:
870
1123
            mutter('need to make new .bzrignore file versioned')
871
 
            b.add(['.bzrignore'])
872
 
 
 
1124
            tree.add(['.bzrignore'])
873
1125
 
874
1126
 
875
1127
class cmd_ignored(Command):
876
1128
    """List ignored files and the patterns that matched them.
877
1129
 
878
1130
    See also: bzr ignore"""
 
1131
    @display_command
879
1132
    def run(self):
880
 
        tree = Branch.open_containing('.').working_tree()
 
1133
        tree = WorkingTree.open_containing(u'.')[0]
881
1134
        for path, file_class, kind, file_id, entry in tree.list_files():
882
1135
            if file_class != 'I':
883
1136
                continue
895
1148
    hidden = True
896
1149
    takes_args = ['revno']
897
1150
    
 
1151
    @display_command
898
1152
    def run(self, revno):
899
1153
        try:
900
1154
            revno = int(revno)
901
1155
        except ValueError:
902
1156
            raise BzrCommandError("not a valid revision-number: %r" % revno)
903
1157
 
904
 
        print Branch.open_containing('.').get_rev_id(revno)
 
1158
        print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
905
1159
 
906
1160
 
907
1161
class cmd_export(Command):
914
1168
    is found exports to a directory (equivalent to --format=dir).
915
1169
 
916
1170
    Root may be the top directory for tar, tgz and tbz2 formats. If none
917
 
    is given, the top directory will be the root name of the file."""
918
 
    # TODO: list known exporters
 
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
    """
919
1183
    takes_args = ['dest']
920
1184
    takes_options = ['revision', 'format', 'root']
921
1185
    def run(self, dest, revision=None, format=None, root=None):
922
1186
        import os.path
923
 
        b = Branch.open_containing('.')
 
1187
        from bzrlib.export import export
 
1188
        tree = WorkingTree.open_containing(u'.')[0]
 
1189
        b = tree.branch
924
1190
        if revision is None:
 
1191
            # should be tree.last_revision  FIXME
925
1192
            rev_id = b.last_revision()
926
1193
        else:
927
1194
            if len(revision) != 1:
928
1195
                raise BzrError('bzr export --revision takes exactly 1 argument')
929
1196
            rev_id = revision[0].in_history(b).rev_id
930
1197
        t = b.revision_tree(rev_id)
931
 
        arg_root, ext = os.path.splitext(os.path.basename(dest))
932
 
        if ext in ('.gz', '.bz2'):
933
 
            new_root, new_ext = os.path.splitext(arg_root)
934
 
            if new_ext == '.tar':
935
 
                arg_root = new_root
936
 
                ext = new_ext + ext
937
 
        if root is None:
938
 
            root = arg_root
939
 
        if not format:
940
 
            if ext in (".tar",):
941
 
                format = "tar"
942
 
            elif ext in (".tar.gz", ".tgz"):
943
 
                format = "tgz"
944
 
            elif ext in (".tar.bz2", ".tbz2"):
945
 
                format = "tbz2"
946
 
            else:
947
 
                format = "dir"
948
 
        t.export(dest, format, root)
 
1198
        try:
 
1199
            export(t, dest, format, root)
 
1200
        except errors.NoSuchExportFormat, e:
 
1201
            raise BzrCommandError('Unsupported export format: %s' % e.format)
949
1202
 
950
1203
 
951
1204
class cmd_cat(Command):
954
1207
    takes_options = ['revision']
955
1208
    takes_args = ['filename']
956
1209
 
 
1210
    @display_command
957
1211
    def run(self, filename, revision=None):
958
 
        if revision is None:
959
 
            raise BzrCommandError("bzr cat requires a revision number")
960
 
        elif len(revision) != 1:
 
1212
        if revision is not None and len(revision) != 1:
961
1213
            raise BzrCommandError("bzr cat --revision takes exactly one number")
962
 
        b = Branch.open_containing('.')
963
 
        b.print_file(b.relpath(filename), revision[0].in_history(b).revno)
 
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)
964
1228
 
965
1229
 
966
1230
class cmd_local_time_offset(Command):
967
1231
    """Show the offset in seconds from GMT to local time."""
968
1232
    hidden = True    
 
1233
    @display_command
969
1234
    def run(self):
970
1235
        print bzrlib.osutils.local_time_offset()
971
1236
 
986
1251
    """
987
1252
    # TODO: Run hooks on tree to-be-committed, and after commit.
988
1253
 
989
 
    # TODO: Strict commit that fails if there are unknown or deleted files.
 
1254
    # TODO: Strict commit that fails if there are deleted files.
 
1255
    #       (what does "deleted files" mean ??)
 
1256
 
990
1257
    # TODO: Give better message for -s, --summary, used by tla people
991
1258
 
992
1259
    # XXX: verbose currently does nothing
993
1260
 
994
1261
    takes_args = ['selected*']
995
 
    takes_options = ['message', 'file', 'verbose', 'unchanged']
 
1262
    takes_options = ['message', 'verbose', 
 
1263
                     Option('unchanged',
 
1264
                            help='commit even if nothing has changed'),
 
1265
                     Option('file', type=str, 
 
1266
                            argname='msgfile',
 
1267
                            help='file containing commit message'),
 
1268
                     Option('strict',
 
1269
                            help="refuse to commit if there are unknown "
 
1270
                            "files in the working tree."),
 
1271
                     ]
996
1272
    aliases = ['ci', 'checkin']
997
1273
 
998
1274
    def run(self, message=None, file=None, verbose=True, selected_list=None,
999
 
            unchanged=False):
1000
 
        from bzrlib.errors import PointlessCommit, ConflictsInTree
1001
 
        from bzrlib.msgeditor import edit_commit_message
 
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
1002
1280
        from bzrlib.status import show_status
1003
 
        from cStringIO import StringIO
1004
 
 
1005
 
        b = Branch.open_containing('.')
1006
 
        if selected_list:
1007
 
            selected_list = [b.relpath(s) for s in selected_list]
1008
 
 
1009
 
            
 
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)
1010
1293
        if message is None and not file:
1011
 
            catcher = StringIO()
1012
 
            show_status(b, specific_files=selected_list,
1013
 
                        to_file=catcher)
1014
 
            message = edit_commit_message(catcher.getvalue())
1015
 
 
 
1294
            template = make_commit_message_template(tree, selected_list)
 
1295
            message = edit_commit_message(template)
1016
1296
            if message is None:
1017
1297
                raise BzrCommandError("please specify a commit message"
1018
1298
                                      " with either --message or --file")
1027
1307
                raise BzrCommandError("empty commit message specified")
1028
1308
            
1029
1309
        try:
1030
 
            b.commit(message,
1031
 
                     specific_files=selected_list,
1032
 
                     allow_pointless=unchanged)
 
1310
            tree.commit(message, specific_files=selected_list,
 
1311
                        allow_pointless=unchanged, strict=strict)
1033
1312
        except PointlessCommit:
1034
1313
            # FIXME: This should really happen before the file is read in;
1035
1314
            # perhaps prepare the commit; get the message; then actually commit
1038
1317
        except ConflictsInTree:
1039
1318
            raise BzrCommandError("Conflicts detected in working tree.  "
1040
1319
                '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(),))
1041
1324
 
1042
1325
 
1043
1326
class cmd_check(Command):
1046
1329
    This command checks various invariants about the branch storage to
1047
1330
    detect data corruption or bzr bugs.
1048
1331
    """
1049
 
    takes_args = ['dir?']
 
1332
    takes_args = ['branch?']
 
1333
    takes_options = ['verbose']
1050
1334
 
1051
 
    def run(self, dir='.'):
 
1335
    def run(self, branch=None, verbose=False):
1052
1336
        from bzrlib.check import check
1053
 
 
1054
 
        check(Branch.open_containing(dir))
 
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)
1055
1343
 
1056
1344
 
1057
1345
class cmd_scan_cache(Command):
1059
1347
    def run(self):
1060
1348
        from bzrlib.hashcache import HashCache
1061
1349
 
1062
 
        c = HashCache('.')
 
1350
        c = HashCache(u'.')
1063
1351
        c.read()
1064
1352
        c.scan()
1065
1353
            
1085
1373
    """
1086
1374
    takes_args = ['dir?']
1087
1375
 
1088
 
    def run(self, dir='.'):
 
1376
    def run(self, dir=u'.'):
1089
1377
        from bzrlib.upgrade import upgrade
1090
1378
        upgrade(dir)
1091
1379
 
1094
1382
    """Show bzr user id."""
1095
1383
    takes_options = ['email']
1096
1384
    
 
1385
    @display_command
1097
1386
    def run(self, email=False):
1098
1387
        try:
1099
 
            b = bzrlib.branch.Branch.open_containing('.')
 
1388
            b = WorkingTree.open_containing(u'.')[0].branch
 
1389
            config = bzrlib.config.BranchConfig(b)
1100
1390
        except NotBranchError:
1101
 
            b = None
 
1391
            config = bzrlib.config.GlobalConfig()
1102
1392
        
1103
1393
        if email:
1104
 
            print bzrlib.config.user_email(b)
1105
 
        else:
1106
 
            print bzrlib.config.username(b)
1107
 
 
 
1394
            print config.user_email()
 
1395
        else:
 
1396
            print config.username()
 
1397
 
 
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 
1108
1415
 
1109
1416
class cmd_selftest(Command):
1110
1417
    """Run internal test suite.
1112
1419
    This creates temporary test directories in the working directory,
1113
1420
    but not existing data is affected.  These directories are deleted
1114
1421
    if the tests pass, or left behind to help in debugging if they
1115
 
    fail.
 
1422
    fail and --keep-output is specified.
1116
1423
    
1117
1424
    If arguments are given, they are regular expressions that say
1118
 
    which tests should run."""
 
1425
    which tests should run.
 
1426
    """
1119
1427
    # TODO: --list should give a list of all available tests
1120
1428
    hidden = True
1121
1429
    takes_args = ['testspecs*']
1122
 
    takes_options = ['verbose']
1123
 
    def run(self, testspecs_list=None, verbose=False):
 
1430
    takes_options = ['verbose', 
 
1431
                     Option('one', help='stop when one test fails'),
 
1432
                     Option('keep-output', 
 
1433
                            help='keep output directories when tests fail')
 
1434
                    ]
 
1435
 
 
1436
    def run(self, testspecs_list=None, verbose=False, one=False,
 
1437
            keep_output=False):
1124
1438
        import bzrlib.ui
1125
 
        from bzrlib.selftest import selftest
 
1439
        from bzrlib.tests import selftest
1126
1440
        # we don't want progress meters from the tests to go to the
1127
1441
        # real output; and we don't want log messages cluttering up
1128
1442
        # the real logs.
1135
1449
            else:
1136
1450
                pattern = ".*"
1137
1451
            result = selftest(verbose=verbose, 
1138
 
                              pattern=pattern)
 
1452
                              pattern=pattern,
 
1453
                              stop_on_failure=one, 
 
1454
                              keep_output=keep_output)
1139
1455
            if result:
1140
1456
                bzrlib.trace.info('tests passed')
1141
1457
            else:
1145
1461
            bzrlib.ui.ui_factory = save_ui
1146
1462
 
1147
1463
 
 
1464
def _get_bzr_branch():
 
1465
    """If bzr is run from a branch, return Branch or None"""
 
1466
    import bzrlib.errors
 
1467
    from bzrlib.branch import Branch
 
1468
    from bzrlib.osutils import abspath
 
1469
    from os.path import dirname
 
1470
    
 
1471
    try:
 
1472
        branch = Branch.open(dirname(abspath(dirname(__file__))))
 
1473
        return branch
 
1474
    except bzrlib.errors.BzrError:
 
1475
        return None
 
1476
    
 
1477
 
1148
1478
def show_version():
1149
1479
    print "bzr (bazaar-ng) %s" % bzrlib.__version__
1150
1480
    # is bzrlib itself in a branch?
1151
 
    bzrrev = bzrlib.get_bzr_revision()
1152
 
    if bzrrev:
1153
 
        print "  (bzr checkout, revision %d {%s})" % bzrrev
 
1481
    branch = _get_bzr_branch()
 
1482
    if branch:
 
1483
        rh = branch.revision_history()
 
1484
        revno = len(rh)
 
1485
        print "  bzr checkout, revision %d" % (revno,)
 
1486
        print "  nick: %s" % (branch.nick,)
 
1487
        if rh:
 
1488
            print "  revid: %s" % (rh[-1],)
1154
1489
    print bzrlib.__copyright__
1155
1490
    print "http://bazaar-ng.org/"
1156
1491
    print
1161
1496
 
1162
1497
class cmd_version(Command):
1163
1498
    """Show version of bzr."""
 
1499
    @display_command
1164
1500
    def run(self):
1165
1501
        show_version()
1166
1502
 
1167
1503
class cmd_rocks(Command):
1168
1504
    """Statement of optimism."""
1169
1505
    hidden = True
 
1506
    @display_command
1170
1507
    def run(self):
1171
1508
        print "it sure does!"
1172
1509
 
1179
1516
    takes_args = ['branch', 'other']
1180
1517
    hidden = True
1181
1518
    
 
1519
    @display_command
1182
1520
    def run(self, branch, other):
1183
1521
        from bzrlib.revision import common_ancestor, MultipleRevisionSources
1184
1522
        
1185
 
        branch1 = Branch.open_containing(branch)
1186
 
        branch2 = Branch.open_containing(other)
 
1523
        branch1 = Branch.open_containing(branch)[0]
 
1524
        branch2 = Branch.open_containing(other)[0]
1187
1525
 
1188
1526
        history_1 = branch1.revision_history()
1189
1527
        history_2 = branch2.revision_history()
1238
1576
    --force is given.
1239
1577
    """
1240
1578
    takes_args = ['branch?']
1241
 
    takes_options = ['revision', 'force', 'merge-type']
 
1579
    takes_options = ['revision', 'force', 'merge-type', 'reprocess',
 
1580
                     Option('show-base', help="Show base revision text in "
 
1581
                            "conflicts")]
1242
1582
 
1243
 
    def run(self, branch=None, revision=None, force=False, 
1244
 
            merge_type=None):
 
1583
    def run(self, branch=None, revision=None, force=False, merge_type=None,
 
1584
            show_base=False, reprocess=False):
1245
1585
        from bzrlib.merge import merge
1246
1586
        from bzrlib.merge_core import ApplyMerge3
1247
1587
        if merge_type is None:
1248
1588
            merge_type = ApplyMerge3
1249
1589
        if branch is None:
1250
 
            branch = Branch.open_containing('.').get_parent()
 
1590
            branch = WorkingTree.open_containing(u'.')[0].branch.get_parent()
1251
1591
            if branch is None:
1252
1592
                raise BzrCommandError("No merge location known or specified.")
1253
1593
            else:
1258
1598
        else:
1259
1599
            if len(revision) == 1:
1260
1600
                base = [None, None]
1261
 
                other = [branch, revision[0].in_history(branch).revno]
 
1601
                other_branch = Branch.open_containing(branch)[0]
 
1602
                revno = revision[0].in_history(other_branch).revno
 
1603
                other = [branch, revno]
1262
1604
            else:
1263
1605
                assert len(revision) == 2
1264
1606
                if None in revision:
1265
1607
                    raise BzrCommandError(
1266
1608
                        "Merge doesn't permit that revision specifier.")
1267
 
                b = Branch.open(branch)
 
1609
                b = Branch.open_containing(branch)[0]
1268
1610
 
1269
1611
                base = [branch, revision[0].in_history(b).revno]
1270
1612
                other = [branch, revision[1].in_history(b).revno]
1271
1613
 
1272
1614
        try:
1273
 
            merge(other, base, check_clean=(not force), merge_type=merge_type)
 
1615
            conflict_count = merge(other, base, check_clean=(not force),
 
1616
                                   merge_type=merge_type, reprocess=reprocess,
 
1617
                                   show_base=show_base)
 
1618
            if conflict_count != 0:
 
1619
                return 1
 
1620
            else:
 
1621
                return 0
1274
1622
        except bzrlib.errors.AmbiguousBase, e:
1275
1623
            m = ("sorry, bzr can't determine the right merge base yet\n"
1276
1624
                 "candidates are:\n  "
1281
1629
            log_error(m)
1282
1630
 
1283
1631
 
 
1632
class cmd_remerge(Command):
 
1633
    """Redo a merge.
 
1634
    """
 
1635
    takes_args = ['file*']
 
1636
    takes_options = ['merge-type', 'reprocess',
 
1637
                     Option('show-base', help="Show base revision text in "
 
1638
                            "conflicts")]
 
1639
 
 
1640
    def run(self, file_list=None, merge_type=None, show_base=False,
 
1641
            reprocess=False):
 
1642
        from bzrlib.merge import merge_inner, transform_tree
 
1643
        from bzrlib.merge_core import ApplyMerge3
 
1644
        if merge_type is None:
 
1645
            merge_type = ApplyMerge3
 
1646
        tree, file_list = tree_files(file_list)
 
1647
        tree.lock_write()
 
1648
        try:
 
1649
            pending_merges = tree.pending_merges() 
 
1650
            if len(pending_merges) != 1:
 
1651
                raise BzrCommandError("Sorry, remerge only works after normal"
 
1652
                                      + " merges.  Not cherrypicking or"
 
1653
                                      + "multi-merges.")
 
1654
            base_revision = common_ancestor(tree.branch.last_revision(), 
 
1655
                                            pending_merges[0], tree.branch)
 
1656
            base_tree = tree.branch.revision_tree(base_revision)
 
1657
            other_tree = tree.branch.revision_tree(pending_merges[0])
 
1658
            interesting_ids = None
 
1659
            if file_list is not None:
 
1660
                interesting_ids = set()
 
1661
                for filename in file_list:
 
1662
                    file_id = tree.path2id(filename)
 
1663
                    interesting_ids.add(file_id)
 
1664
                    if tree.kind(file_id) != "directory":
 
1665
                        continue
 
1666
                    
 
1667
                    for name, ie in tree.inventory.iter_entries(file_id):
 
1668
                        interesting_ids.add(ie.file_id)
 
1669
            transform_tree(tree, tree.branch.basis_tree(), interesting_ids)
 
1670
            if file_list is None:
 
1671
                restore_files = list(tree.iter_conflicts())
 
1672
            else:
 
1673
                restore_files = file_list
 
1674
            for filename in restore_files:
 
1675
                try:
 
1676
                    restore(tree.abspath(filename))
 
1677
                except NotConflicted:
 
1678
                    pass
 
1679
            conflicts =  merge_inner(tree.branch, other_tree, base_tree, 
 
1680
                                     interesting_ids = interesting_ids, 
 
1681
                                     other_rev_id=pending_merges[0], 
 
1682
                                     merge_type=merge_type, 
 
1683
                                     show_base=show_base,
 
1684
                                     reprocess=reprocess)
 
1685
        finally:
 
1686
            tree.unlock()
 
1687
        if conflicts > 0:
 
1688
            return 1
 
1689
        else:
 
1690
            return 0
 
1691
 
1284
1692
class cmd_revert(Command):
1285
1693
    """Reverse all changes since the last commit.
1286
1694
 
1293
1701
    aliases = ['merge-revert']
1294
1702
 
1295
1703
    def run(self, revision=None, no_backup=False, file_list=None):
1296
 
        from bzrlib.merge import merge
 
1704
        from bzrlib.merge import merge_inner
1297
1705
        from bzrlib.commands import parse_spec
1298
 
 
1299
1706
        if file_list is not None:
1300
1707
            if len(file_list) == 0:
1301
1708
                raise BzrCommandError("No files specified")
 
1709
        else:
 
1710
            file_list = []
1302
1711
        if revision is None:
1303
1712
            revno = -1
 
1713
            tree = WorkingTree.open_containing(u'.')[0]
 
1714
            # FIXME should be tree.last_revision
 
1715
            rev_id = tree.branch.last_revision()
1304
1716
        elif len(revision) != 1:
1305
1717
            raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1306
1718
        else:
1307
 
            b = Branch.open_containing('.')
1308
 
            revno = revision[0].in_history(b).revno
1309
 
        merge(('.', revno), parse_spec('.'),
1310
 
              check_clean=False,
1311
 
              ignore_zero=True,
1312
 
              backup_files=not no_backup,
1313
 
              file_list=file_list)
1314
 
        if not file_list:
1315
 
            Branch.open_containing('.').set_pending_merges([])
 
1719
            tree, file_list = tree_files(file_list)
 
1720
            rev_id = revision[0].in_history(tree.branch).rev_id
 
1721
        tree.revert(file_list, tree.branch.revision_tree(rev_id),
 
1722
                                not no_backup)
1316
1723
 
1317
1724
 
1318
1725
class cmd_assert_fail(Command):
1330
1737
    takes_args = ['topic?']
1331
1738
    aliases = ['?']
1332
1739
    
 
1740
    @display_command
1333
1741
    def run(self, topic=None, long=False):
1334
1742
        import help
1335
1743
        if topic is None and long:
1345
1753
    aliases = ['s-c']
1346
1754
    hidden = True
1347
1755
    
 
1756
    @display_command
1348
1757
    def run(self, context=None):
1349
1758
        import shellcomplete
1350
1759
        shellcomplete.shellcomplete(context)
1359
1768
    def run(self, from_branch, to_branch):
1360
1769
        from bzrlib.fetch import Fetcher
1361
1770
        from bzrlib.branch import Branch
1362
 
        from_b = Branch(from_branch)
1363
 
        to_b = Branch(to_branch)
1364
 
        Fetcher(to_b, from_b)
1365
 
        
 
1771
        from_b = Branch.open(from_branch)
 
1772
        to_b = Branch.open(to_branch)
 
1773
        from_b.lock_read()
 
1774
        try:
 
1775
            to_b.lock_write()
 
1776
            try:
 
1777
                Fetcher(to_b, from_b)
 
1778
            finally:
 
1779
                to_b.unlock()
 
1780
        finally:
 
1781
            from_b.unlock()
1366
1782
 
1367
1783
 
1368
1784
class cmd_missing(Command):
1369
 
    """What is missing in this branch relative to other branch.
1370
 
    """
1371
 
    # TODO: rewrite this in terms of ancestry so that it shows only
1372
 
    # unmerged things
1373
 
    
1374
 
    takes_args = ['remote?']
1375
 
    aliases = ['mis', 'miss']
1376
 
    # We don't have to add quiet to the list, because 
1377
 
    # unknown options are parsed as booleans
1378
 
    takes_options = ['verbose', 'quiet']
1379
 
 
1380
 
    def run(self, remote=None, verbose=False, quiet=False):
1381
 
        from bzrlib.errors import BzrCommandError
1382
 
        from bzrlib.missing import show_missing
1383
 
 
1384
 
        if verbose and quiet:
1385
 
            raise BzrCommandError('Cannot pass both quiet and verbose')
1386
 
 
1387
 
        b = Branch.open_containing('.')
1388
 
        parent = b.get_parent()
1389
 
        if remote is None:
1390
 
            if parent is None:
 
1785
    """Show unmerged/unpulled revisions between two branches.
 
1786
 
 
1787
    OTHER_BRANCH may be local or remote."""
 
1788
    takes_args = ['other_branch?']
 
1789
    takes_options = [Option('reverse', 'Reverse the order of revisions'),
 
1790
                     Option('mine-only', 
 
1791
                            'Display changes in the local branch only'),
 
1792
                     Option('theirs-only', 
 
1793
                            'Display changes in the remote branch only'), 
 
1794
                     'line',
 
1795
                     'long', 
 
1796
                     'short',
 
1797
                     'show-ids',
 
1798
                     'verbose'
 
1799
                     ]
 
1800
 
 
1801
    def run(self, other_branch=None, reverse=False, mine_only=False,
 
1802
            theirs_only=False, long=True, short=False, line=False, 
 
1803
            show_ids=False, verbose=False):
 
1804
        from bzrlib.missing import find_unmerged, iter_log_data
 
1805
        from bzrlib.log import log_formatter
 
1806
        local_branch = bzrlib.branch.Branch.open_containing(u".")[0]
 
1807
        parent = local_branch.get_parent()
 
1808
        if other_branch is None:
 
1809
            other_branch = parent
 
1810
            if other_branch is None:
1391
1811
                raise BzrCommandError("No missing location known or specified.")
1392
 
            else:
1393
 
                if not quiet:
1394
 
                    print "Using last location: %s" % parent
1395
 
                remote = parent
1396
 
        elif parent is None:
1397
 
            # We only update parent if it did not exist, missing
1398
 
            # should not change the parent
1399
 
            b.set_parent(remote)
1400
 
        br_remote = Branch.open_containing(remote)
1401
 
        return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
 
1812
            print "Using last location: " + local_branch.get_parent()
 
1813
        remote_branch = bzrlib.branch.Branch.open(other_branch)
 
1814
        local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
 
1815
        log_format = get_log_format(long=long, short=short, line=line)
 
1816
        lf = log_formatter(log_format, sys.stdout,
 
1817
                           show_ids=show_ids,
 
1818
                           show_timezone='original')
 
1819
        if reverse is False:
 
1820
            local_extra.reverse()
 
1821
            remote_extra.reverse()
 
1822
        if local_extra and not theirs_only:
 
1823
            print "You have %d extra revision(s):" % len(local_extra)
 
1824
            for data in iter_log_data(local_extra, local_branch, verbose):
 
1825
                lf.show(*data)
 
1826
            printed_local = True
 
1827
        else:
 
1828
            printed_local = False
 
1829
        if remote_extra and not mine_only:
 
1830
            if printed_local is True:
 
1831
                print "\n\n"
 
1832
            print "You are missing %d revision(s):" % len(remote_extra)
 
1833
            for data in iter_log_data(remote_extra, remote_branch, verbose):
 
1834
                lf.show(*data)
 
1835
        if not remote_extra and not local_extra:
 
1836
            status_code = 0
 
1837
            print "Branches are up to date."
 
1838
        else:
 
1839
            status_code = 1
 
1840
        if parent is None and other_branch is not None:
 
1841
            local_branch.set_parent(other_branch)
 
1842
        return status_code
1402
1843
 
1403
1844
 
1404
1845
class cmd_plugins(Command):
1405
1846
    """List plugins"""
1406
1847
    hidden = True
 
1848
    @display_command
1407
1849
    def run(self):
1408
1850
        import bzrlib.plugin
1409
1851
        from inspect import getdoc
1410
 
        for plugin in bzrlib.plugin.all_plugins:
 
1852
        for name, plugin in bzrlib.plugin.all_plugins().items():
1411
1853
            if hasattr(plugin, '__path__'):
1412
1854
                print plugin.__path__[0]
1413
1855
            elif hasattr(plugin, '__file__'):
1424
1866
    """Show testament (signing-form) of a revision."""
1425
1867
    takes_options = ['revision', 'long']
1426
1868
    takes_args = ['branch?']
1427
 
    def run(self, branch='.', revision=None, long=False):
 
1869
    @display_command
 
1870
    def run(self, branch=u'.', revision=None, long=False):
1428
1871
        from bzrlib.testament import Testament
1429
 
        b = Branch.open_containing(branch)
 
1872
        b = WorkingTree.open_containing(branch)[0].branch
1430
1873
        b.lock_read()
1431
1874
        try:
1432
1875
            if revision is None:
1445
1888
class cmd_annotate(Command):
1446
1889
    """Show the origin of each line in a file.
1447
1890
 
1448
 
    This prints out the given file with an annotation on the 
1449
 
    left side indicating which revision, author and date introduced the 
1450
 
    change.
 
1891
    This prints out the given file with an annotation on the left side
 
1892
    indicating which revision, author and date introduced the change.
 
1893
 
 
1894
    If the origin is the same for a run of consecutive lines, it is 
 
1895
    shown only at the top, unless the --all option is given.
1451
1896
    """
1452
1897
    # TODO: annotate directories; showing when each file was last changed
1453
1898
    # TODO: annotate a previous version of a file
 
1899
    # TODO: if the working copy is modified, show annotations on that 
 
1900
    #       with new uncommitted lines marked
1454
1901
    aliases = ['blame', 'praise']
1455
1902
    takes_args = ['filename']
 
1903
    takes_options = [Option('all', help='show annotations on all lines'),
 
1904
                     Option('long', help='show date in annotations'),
 
1905
                     ]
1456
1906
 
1457
 
    def run(self, filename):
 
1907
    @display_command
 
1908
    def run(self, filename, all=False, long=False):
1458
1909
        from bzrlib.annotate import annotate_file
1459
 
        b = Branch.open_containing(filename)
1460
 
        b.lock_read()
 
1910
        tree, relpath = WorkingTree.open_containing(filename)
 
1911
        branch = tree.branch
 
1912
        branch.lock_read()
1461
1913
        try:
1462
 
            rp = b.relpath(filename)
1463
 
            tree = b.revision_tree(b.last_revision())
1464
 
            file_id = tree.inventory.path2id(rp)
 
1914
            file_id = tree.inventory.path2id(relpath)
 
1915
            tree = branch.revision_tree(branch.last_revision())
1465
1916
            file_version = tree.inventory[file_id].revision
1466
 
            annotate_file(b, file_version, file_id, sys.stdout)
 
1917
            annotate_file(branch, file_version, file_id, long, all, sys.stdout)
1467
1918
        finally:
1468
 
            b.unlock()
 
1919
            branch.unlock()
 
1920
 
 
1921
 
 
1922
class cmd_re_sign(Command):
 
1923
    """Create a digital signature for an existing revision."""
 
1924
    # TODO be able to replace existing ones.
 
1925
 
 
1926
    hidden = True # is this right ?
 
1927
    takes_args = ['revision_id?']
 
1928
    takes_options = ['revision']
 
1929
    
 
1930
    def run(self, revision_id=None, revision=None):
 
1931
        import bzrlib.config as config
 
1932
        import bzrlib.gpg as gpg
 
1933
        if revision_id is not None and revision is not None:
 
1934
            raise BzrCommandError('You can only supply one of revision_id or --revision')
 
1935
        if revision_id is None and revision is None:
 
1936
            raise BzrCommandError('You must supply either --revision or a revision_id')
 
1937
        b = WorkingTree.open_containing(u'.')[0].branch
 
1938
        gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
 
1939
        if revision_id is not None:
 
1940
            b.sign_revision(revision_id, gpg_strategy)
 
1941
        elif revision is not None:
 
1942
            if len(revision) == 1:
 
1943
                revno, rev_id = revision[0].in_history(b)
 
1944
                b.sign_revision(rev_id, gpg_strategy)
 
1945
            elif len(revision) == 2:
 
1946
                # are they both on rh- if so we can walk between them
 
1947
                # might be nice to have a range helper for arbitrary
 
1948
                # revision paths. hmm.
 
1949
                from_revno, from_revid = revision[0].in_history(b)
 
1950
                to_revno, to_revid = revision[1].in_history(b)
 
1951
                if to_revid is None:
 
1952
                    to_revno = b.revno()
 
1953
                if from_revno is None or to_revno is None:
 
1954
                    raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
 
1955
                for revno in range(from_revno, to_revno + 1):
 
1956
                    b.sign_revision(b.get_rev_id(revno), gpg_strategy)
 
1957
            else:
 
1958
                raise BzrCommandError('Please supply either one revision, or a range.')
 
1959
 
 
1960
 
 
1961
class cmd_uncommit(bzrlib.commands.Command):
 
1962
    """Remove the last committed revision.
 
1963
 
 
1964
    By supplying the --all flag, it will not only remove the entry 
 
1965
    from revision_history, but also remove all of the entries in the
 
1966
    stores.
 
1967
 
 
1968
    --verbose will print out what is being removed.
 
1969
    --dry-run will go through all the motions, but not actually
 
1970
    remove anything.
 
1971
    
 
1972
    In the future, uncommit will create a changeset, which can then
 
1973
    be re-applied.
 
1974
    """
 
1975
    takes_options = ['all', 'verbose', 'revision',
 
1976
                    Option('dry-run', help='Don\'t actually make changes'),
 
1977
                    Option('force', help='Say yes to all questions.')]
 
1978
    takes_args = ['location?']
 
1979
    aliases = []
 
1980
 
 
1981
    def run(self, location=None, all=False,
 
1982
            dry_run=False, verbose=False,
 
1983
            revision=None, force=False):
 
1984
        from bzrlib.branch import Branch
 
1985
        from bzrlib.log import log_formatter
 
1986
        import sys
 
1987
        from bzrlib.uncommit import uncommit
 
1988
 
 
1989
        if location is None:
 
1990
            location = u'.'
 
1991
        b, relpath = Branch.open_containing(location)
 
1992
 
 
1993
        if revision is None:
 
1994
            revno = b.revno()
 
1995
            rev_id = b.last_revision()
 
1996
        else:
 
1997
            revno, rev_id = revision[0].in_history(b)
 
1998
        if rev_id is None:
 
1999
            print 'No revisions to uncommit.'
 
2000
 
 
2001
        for r in range(revno, b.revno()+1):
 
2002
            rev_id = b.get_rev_id(r)
 
2003
            lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
 
2004
            lf.show(r, b.get_revision(rev_id), None)
 
2005
 
 
2006
        if dry_run:
 
2007
            print 'Dry-run, pretending to remove the above revisions.'
 
2008
            if not force:
 
2009
                val = raw_input('Press <enter> to continue')
 
2010
        else:
 
2011
            print 'The above revision(s) will be removed.'
 
2012
            if not force:
 
2013
                val = raw_input('Are you sure [y/N]? ')
 
2014
                if val.lower() not in ('y', 'yes'):
 
2015
                    print 'Canceled'
 
2016
                    return 0
 
2017
 
 
2018
        uncommit(b, remove_files=all,
 
2019
                dry_run=dry_run, verbose=verbose,
 
2020
                revno=revno)
 
2021
 
1469
2022
 
1470
2023
# these get imported and then picked up by the scan for cmd_*
1471
2024
# TODO: Some more consistent way to split command definitions across files;
1472
2025
# we do need to load at least some information about them to know of 
1473
2026
# aliases.
1474
 
from bzrlib.conflicts import cmd_resolve, cmd_conflicts
 
2027
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore