← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

Lalo Martins remotebranch patch

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
 
# DO NOT change this to cStringIO - it results in control files 
18
 
# written as UCS4
19
 
# FIXIT! (Only deal with byte streams OR unicode at any one layer.)
20
 
# RBC 20051018
21
 
from StringIO import StringIO
 
17
 
22
18
import sys
23
19
import os
24
20
 
25
21
import bzrlib
 
22
import bzrlib.trace
 
23
from bzrlib.trace import mutter, note, log_error, warning
 
24
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
 
25
from bzrlib.branch import find_branch
26
26
from bzrlib import BZRDIR
27
 
from bzrlib.commands import Command, display_command
28
 
from bzrlib.branch import Branch
29
 
from bzrlib.revision import common_ancestor
30
 
import bzrlib.errors as errors
31
 
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError, 
32
 
                           NotBranchError, DivergedBranches, NotConflicted,
33
 
                           NoSuchFile, NoWorkingTree, FileInWrongBranch)
34
 
from bzrlib.option import Option
35
 
from bzrlib.revisionspec import RevisionSpec
36
 
import bzrlib.trace
37
 
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
38
 
from bzrlib.workingtree import WorkingTree
39
 
 
40
 
 
41
 
def tree_files(file_list, default_branch=u'.'):
42
 
    try:
43
 
        return internal_tree_files(file_list, default_branch)
44
 
    except FileInWrongBranch, e:
45
 
        raise BzrCommandError("%s is not in the same branch as %s" %
46
 
                             (e.path, file_list[0]))
47
 
 
48
 
def internal_tree_files(file_list, default_branch=u'.'):
49
 
    """\
50
 
    Return a branch and list of branch-relative paths.
51
 
    If supplied file_list is empty or None, the branch default will be used,
52
 
    and returned file_list will match the original.
53
 
    """
54
 
    if file_list is None or len(file_list) == 0:
55
 
        return WorkingTree.open_containing(default_branch)[0], file_list
56
 
    tree = WorkingTree.open_containing(file_list[0])[0]
57
 
    new_list = []
58
 
    for filename in file_list:
59
 
        try:
60
 
            new_list.append(tree.relpath(filename))
61
 
        except NotBranchError:
62
 
            raise FileInWrongBranch(tree.branch, filename)
63
 
    return tree, new_list
64
 
 
65
 
 
66
 
# TODO: Make sure no commands unconditionally use the working directory as a
67
 
# branch.  If a filename argument is used, the first of them should be used to
68
 
# specify the branch.  (Perhaps this can be factored out into some kind of
69
 
# Argument class, representing a file in a branch, where the first occurrence
70
 
# opens the branch?)
 
27
from bzrlib.commands import Command
 
28
 
71
29
 
72
30
class cmd_status(Command):
73
31
    """Display status summary.
104
62
    directory is shown.  Otherwise, only the status of the specified
105
63
    files or directories is reported.  If a directory is given, status
106
64
    is reported for everything inside that directory.
 
65
    """
 
66
    # XXX: FIXME: bzr status should accept a -r option to show changes
 
67
    # relative to a revision, or between revisions
107
68
 
108
 
    If a revision argument is given, the status is calculated against
109
 
    that revision, or between two revisions if two are provided.
110
 
    """
111
 
    
112
 
    # TODO: --no-recurse, --recurse options
113
 
    
114
69
    takes_args = ['file*']
115
 
    takes_options = ['all', 'show-ids', 'revision']
 
70
    takes_options = ['all', 'show-ids']
116
71
    aliases = ['st', 'stat']
117
72
    
118
 
    @display_command
119
 
    def run(self, all=False, show_ids=False, file_list=None, revision=None):
120
 
        tree, file_list = tree_files(file_list)
 
73
    def run(self, all=False, show_ids=False, file_list=None):
 
74
        if file_list:
 
75
            b = find_branch(file_list[0])
 
76
            file_list = [b.relpath(x) for x in file_list]
 
77
            # special case: only one path was given and it's the root
 
78
            # of the branch
 
79
            if file_list == ['']:
 
80
                file_list = None
 
81
        else:
 
82
            b = find_branch('.')
121
83
            
122
84
        from bzrlib.status import show_status
123
 
        show_status(tree.branch, show_unchanged=all, show_ids=show_ids,
124
 
                    specific_files=file_list, revision=revision)
 
85
        show_status(b, show_unchanged=all, show_ids=show_ids,
 
86
                    specific_files=file_list)
125
87
 
126
88
 
127
89
class cmd_cat_revision(Command):
128
 
    """Write out metadata for a revision.
129
 
    
130
 
    The revision to print can either be specified by a specific
131
 
    revision identifier, or you can use --revision.
132
 
    """
 
90
    """Write out metadata for a revision."""
133
91
 
134
92
    hidden = True
135
 
    takes_args = ['revision_id?']
136
 
    takes_options = ['revision']
 
93
    takes_args = ['revision_id']
137
94
    
138
 
    @display_command
139
 
    def run(self, revision_id=None, revision=None):
 
95
    def run(self, revision_id):
 
96
        b = find_branch('.')
 
97
        sys.stdout.write(b.get_revision_xml_file(revision_id).read())
140
98
 
141
 
        if revision_id is not None and revision is not None:
142
 
            raise BzrCommandError('You can only supply one of revision_id or --revision')
143
 
        if revision_id is None and revision is None:
144
 
            raise BzrCommandError('You must supply either --revision or a revision_id')
145
 
        b = WorkingTree.open_containing(u'.')[0].branch
146
 
        if revision_id is not None:
147
 
            sys.stdout.write(b.get_revision_xml(revision_id))
148
 
        elif revision is not None:
149
 
            for rev in revision:
150
 
                if rev is None:
151
 
                    raise BzrCommandError('You cannot specify a NULL revision.')
152
 
                revno, rev_id = rev.in_history(b)
153
 
                sys.stdout.write(b.get_revision_xml(rev_id))
154
 
    
155
99
 
156
100
class cmd_revno(Command):
157
101
    """Show current revision number.
158
102
 
159
103
    This is equal to the number of revisions on this branch."""
160
 
    @display_command
161
104
    def run(self):
162
 
        print Branch.open_containing(u'.')[0].revno()
 
105
        print find_branch('.').revno()
163
106
 
164
107
 
165
108
class cmd_revision_info(Command):
168
111
    hidden = True
169
112
    takes_args = ['revision_info*']
170
113
    takes_options = ['revision']
171
 
    @display_command
172
 
    def run(self, revision=None, revision_info_list=[]):
 
114
    def run(self, revision=None, revision_info_list=None):
 
115
        from bzrlib.branch import find_branch
173
116
 
174
117
        revs = []
175
118
        if revision is not None:
176
119
            revs.extend(revision)
177
120
        if revision_info_list is not None:
178
 
            for rev in revision_info_list:
179
 
                revs.append(RevisionSpec(rev))
 
121
            revs.extend(revision_info_list)
180
122
        if len(revs) == 0:
181
123
            raise BzrCommandError('You must supply a revision identifier')
182
124
 
183
 
        b = WorkingTree.open_containing(u'.')[0].branch
 
125
        b = find_branch('.')
184
126
 
185
127
        for rev in revs:
186
 
            revinfo = rev.in_history(b)
187
 
            if revinfo.revno is None:
188
 
                print '     %s' % revinfo.rev_id
189
 
            else:
190
 
                print '%4d %s' % (revinfo.revno, revinfo.rev_id)
 
128
            print '%4d %s' % b.get_revision_info(rev)
191
129
 
192
130
    
193
131
class cmd_add(Command):
214
152
    get added when you add a file in the directory.
215
153
    """
216
154
    takes_args = ['file*']
217
 
    takes_options = ['no-recurse']
 
155
    takes_options = ['verbose', 'no-recurse']
218
156
    
219
 
    def run(self, file_list, no_recurse=False):
220
 
        from bzrlib.add import smart_add, add_reporter_print, add_reporter_null
221
 
        if is_quiet():
222
 
            reporter = add_reporter_null
223
 
        else:
224
 
            reporter = add_reporter_print
225
 
        smart_add(file_list, not no_recurse, reporter)
 
157
    def run(self, file_list, verbose=False, no_recurse=False):
 
158
        # verbose currently has no effect
 
159
        from bzrlib.add import smart_add, add_reporter_print
 
160
        smart_add(file_list, not no_recurse, add_reporter_print)
 
161
 
226
162
 
227
163
 
228
164
class cmd_mkdir(Command):
233
169
    takes_args = ['dir+']
234
170
 
235
171
    def run(self, dir_list):
 
172
        b = None
 
173
        
236
174
        for d in dir_list:
237
175
            os.mkdir(d)
238
 
            wt, dd = WorkingTree.open_containing(d)
239
 
            wt.add([dd])
 
176
            if not b:
 
177
                b = find_branch(d)
 
178
            b.add([d])
240
179
            print 'added', d
241
180
 
242
181
 
245
184
    takes_args = ['filename']
246
185
    hidden = True
247
186
    
248
 
    @display_command
249
187
    def run(self, filename):
250
 
        tree, relpath = WorkingTree.open_containing(filename)
251
 
        print relpath
 
188
        print find_branch(filename).relpath(filename)
 
189
 
252
190
 
253
191
 
254
192
class cmd_inventory(Command):
255
 
    """Show inventory of the current working copy or a revision.
256
 
 
257
 
    It is possible to limit the output to a particular entry
258
 
    type using the --kind option.  For example; --kind file.
259
 
    """
260
 
    takes_options = ['revision', 'show-ids', 'kind']
 
193
    """Show inventory of the current working copy or a revision."""
 
194
    takes_options = ['revision', 'show-ids']
261
195
    
262
 
    @display_command
263
 
    def run(self, revision=None, show_ids=False, kind=None):
264
 
        if kind and kind not in ['file', 'directory', 'symlink']:
265
 
            raise BzrCommandError('invalid kind specified')
266
 
        tree = WorkingTree.open_containing(u'.')[0]
267
 
        if revision is None:
268
 
            inv = tree.read_working_inventory()
 
196
    def run(self, revision=None, show_ids=False):
 
197
        b = find_branch('.')
 
198
        if revision == None:
 
199
            inv = b.read_working_inventory()
269
200
        else:
270
201
            if len(revision) > 1:
271
202
                raise BzrCommandError('bzr inventory --revision takes'
272
203
                    ' exactly one revision identifier')
273
 
            inv = tree.branch.get_revision_inventory(
274
 
                revision[0].in_history(tree.branch).rev_id)
 
204
            inv = b.get_revision_inventory(b.lookup_revision(revision[0]))
275
205
 
276
206
        for path, entry in inv.entries():
277
 
            if kind and kind != entry.kind:
278
 
                continue
279
207
            if show_ids:
280
208
                print '%-50s %s' % (path, entry.file_id)
281
209
            else:
292
220
    """
293
221
    takes_args = ['source$', 'dest']
294
222
    def run(self, source_list, dest):
295
 
        tree, source_list = tree_files(source_list)
 
223
        b = find_branch('.')
 
224
 
296
225
        # TODO: glob expansion on windows?
297
 
        tree.move(source_list, tree.relpath(dest))
 
226
        b.move([b.relpath(s) for s in source_list], b.relpath(dest))
298
227
 
299
228
 
300
229
class cmd_rename(Command):
308
237
 
309
238
    See also the 'move' command, which moves files into a different
310
239
    directory without changing their name.
311
 
    """
312
 
    # TODO: Some way to rename multiple files without invoking 
313
 
    # bzr for each one?"""
 
240
 
 
241
    TODO: Some way to rename multiple files without invoking bzr for each
 
242
    one?"""
314
243
    takes_args = ['from_name', 'to_name']
315
244
    
316
245
    def run(self, from_name, to_name):
317
 
        tree, (from_name, to_name) = tree_files((from_name, to_name))
318
 
        tree.rename_one(from_name, to_name)
 
246
        b = find_branch('.')
 
247
        b.rename_one(b.relpath(from_name), b.relpath(to_name))
 
248
 
319
249
 
320
250
 
321
251
class cmd_mv(Command):
335
265
    def run(self, names_list):
336
266
        if len(names_list) < 2:
337
267
            raise BzrCommandError("missing file argument")
338
 
        tree, rel_names = tree_files(names_list)
 
268
        b = find_branch(names_list[0])
 
269
 
 
270
        rel_names = [b.relpath(x) for x in names_list]
339
271
        
340
272
        if os.path.isdir(names_list[-1]):
341
273
            # move into existing directory
342
 
            for pair in tree.move(rel_names[:-1], rel_names[-1]):
 
274
            for pair in b.move(rel_names[:-1], rel_names[-1]):
343
275
                print "%s => %s" % pair
344
276
        else:
345
277
            if len(names_list) != 2:
346
278
                raise BzrCommandError('to mv multiple files the destination '
347
279
                                      'must be a versioned directory')
348
 
            tree.rename_one(rel_names[0], rel_names[1])
 
280
            b.rename_one(rel_names[0], rel_names[1])
349
281
            print "%s => %s" % (rel_names[0], rel_names[1])
350
282
            
351
283
    
 
284
 
 
285
 
352
286
class cmd_pull(Command):
353
287
    """Pull any changes from another branch into the current one.
354
288
 
355
 
    If there is no default location set, the first pull will set it.  After
356
 
    that, you can omit the location to use the default.  To change the
357
 
    default, use --remember.
 
289
    If the location is omitted, the last-used location will be used.
 
290
    Both the revision history and the working directory will be
 
291
    updated.
358
292
 
359
293
    This command only works on branches that have not diverged.  Branches are
360
294
    considered diverged if both branches have had commits without first
361
295
    pulling from the other.
362
296
 
363
297
    If branches have diverged, you can use 'bzr merge' to pull the text changes
364
 
    from one into the other.  Once one branch has merged, the other should
365
 
    be able to pull it again.
366
 
 
367
 
    If you want to forget your local changes and just update your branch to
368
 
    match the remote one, use --overwrite.
 
298
    from one into the other.
369
299
    """
370
 
    takes_options = ['remember', 'overwrite', 'verbose']
371
300
    takes_args = ['location?']
372
301
 
373
 
    def run(self, location=None, remember=False, overwrite=False, verbose=False):
 
302
    def run(self, location=None):
374
303
        from bzrlib.merge import merge
 
304
        import tempfile
375
305
        from shutil import rmtree
376
306
        import errno
377
 
        # FIXME: too much stuff is in the command class        
378
 
        tree_to = WorkingTree.open_containing(u'.')[0]
379
 
        stored_loc = tree_to.branch.get_parent()
 
307
        
 
308
        br_to = find_branch('.')
 
309
        stored_loc = br_to.get_parent()
380
310
        if location is None:
381
311
            if stored_loc is None:
382
312
                raise BzrCommandError("No pull location known or specified.")
383
313
            else:
384
 
                print "Using saved location: %s" % stored_loc
385
 
                location = stored_loc
386
 
        br_from = Branch.open(location)
387
 
        br_to = tree_to.branch
388
 
        try:
389
 
            old_rh = br_to.revision_history()
390
 
            count = tree_to.pull(br_from, overwrite)
391
 
        except DivergedBranches:
392
 
            # FIXME: Just make DivergedBranches display the right message
393
 
            # itself.
394
 
            raise BzrCommandError("These branches have diverged."
395
 
                                  "  Try merge.")
396
 
        if br_to.get_parent() is None or remember:
397
 
            br_to.set_parent(location)
398
 
        note('%d revision(s) pulled.' % (count,))
399
 
 
400
 
        if verbose:
401
 
            new_rh = tree_to.branch.revision_history()
402
 
            if old_rh != new_rh:
403
 
                # Something changed
404
 
                from bzrlib.log import show_changed_revisions
405
 
                show_changed_revisions(tree_to.branch, old_rh, new_rh)
406
 
 
407
 
 
408
 
class cmd_push(Command):
409
 
    """Push this branch into another branch.
410
 
    
411
 
    The remote branch will not have its working tree populated because this
412
 
    is both expensive, and may not be supported on the remote file system.
413
 
    
414
 
    Some smart servers or protocols *may* put the working tree in place.
415
 
 
416
 
    If there is no default push location set, the first push will set it.
417
 
    After that, you can omit the location to use the default.  To change the
418
 
    default, use --remember.
419
 
 
420
 
    This command only works on branches that have not diverged.  Branches are
421
 
    considered diverged if the branch being pushed to is not an older version
422
 
    of this branch.
423
 
 
424
 
    If branches have diverged, you can use 'bzr push --overwrite' to replace
425
 
    the other branch completely.
426
 
    
427
 
    If you want to ensure you have the different changes in the other branch,
428
 
    do a merge (see bzr help merge) from the other branch, and commit that
429
 
    before doing a 'push --overwrite'.
430
 
    """
431
 
    takes_options = ['remember', 'overwrite', 
432
 
                     Option('create-prefix', 
433
 
                            help='Create the path leading up to the branch '
434
 
                                 'if it does not already exist')]
435
 
    takes_args = ['location?']
436
 
 
437
 
    def run(self, location=None, remember=False, overwrite=False,
438
 
            create_prefix=False, verbose=False):
439
 
        # FIXME: Way too big!  Put this into a function called from the
440
 
        # command.
441
 
        import errno
442
 
        from shutil import rmtree
443
 
        from bzrlib.transport import get_transport
444
 
        
445
 
        tree_from = WorkingTree.open_containing(u'.')[0]
446
 
        br_from = tree_from.branch
447
 
        stored_loc = tree_from.branch.get_push_location()
448
 
        if location is None:
449
 
            if stored_loc is None:
450
 
                raise BzrCommandError("No push location known or specified.")
451
 
            else:
452
 
                print "Using saved location: %s" % stored_loc
453
 
                location = stored_loc
454
 
        try:
455
 
            br_to = Branch.open(location)
456
 
        except NotBranchError:
457
 
            # create a branch.
458
 
            transport = get_transport(location).clone('..')
459
 
            if not create_prefix:
460
 
                try:
461
 
                    transport.mkdir(transport.relpath(location))
462
 
                except NoSuchFile:
463
 
                    raise BzrCommandError("Parent directory of %s "
464
 
                                          "does not exist." % location)
465
 
            else:
466
 
                current = transport.base
467
 
                needed = [(transport, transport.relpath(location))]
468
 
                while needed:
469
 
                    try:
470
 
                        transport, relpath = needed[-1]
471
 
                        transport.mkdir(relpath)
472
 
                        needed.pop()
473
 
                    except NoSuchFile:
474
 
                        new_transport = transport.clone('..')
475
 
                        needed.append((new_transport,
476
 
                                       new_transport.relpath(transport.base)))
477
 
                        if new_transport.base == transport.base:
478
 
                            raise BzrCommandError("Could not creeate "
479
 
                                                  "path prefix.")
480
 
            br_to = Branch.initialize(location)
481
 
        try:
482
 
            old_rh = br_to.revision_history()
483
 
            count = br_to.pull(br_from, overwrite)
484
 
        except DivergedBranches:
485
 
            raise BzrCommandError("These branches have diverged."
486
 
                                  "  Try a merge then push with overwrite.")
487
 
        if br_from.get_push_location() is None or remember:
488
 
            br_from.set_push_location(location)
489
 
        note('%d revision(s) pushed.' % (count,))
490
 
 
491
 
        if verbose:
492
 
            new_rh = br_to.revision_history()
493
 
            if old_rh != new_rh:
494
 
                # Something changed
495
 
                from bzrlib.log import show_changed_revisions
496
 
                show_changed_revisions(br_to, old_rh, new_rh)
 
314
                print "Using last location: %s" % stored_loc
 
315
                location = stored_loc
 
316
        cache_root = tempfile.mkdtemp()
 
317
        from bzrlib.branch import DivergedBranches
 
318
        br_from = find_branch(location)
 
319
        location = br_from.base
 
320
        old_revno = br_to.revno()
 
321
        try:
 
322
            from branch import find_cached_branch, DivergedBranches
 
323
            br_from = find_cached_branch(location, cache_root)
 
324
            location = br_from.base
 
325
            old_revno = br_to.revno()
 
326
            try:
 
327
                br_to.update_revisions(br_from)
 
328
            except DivergedBranches:
 
329
                raise BzrCommandError("These branches have diverged."
 
330
                    "  Try merge.")
 
331
                
 
332
            merge(('.', -1), ('.', old_revno), check_clean=False)
 
333
            if location != stored_loc:
 
334
                br_to.set_parent(location)
 
335
        finally:
 
336
            rmtree(cache_root)
 
337
 
497
338
 
498
339
 
499
340
class cmd_branch(Command):
504
345
 
505
346
    To retrieve the branch as of a particular revision, supply the --revision
506
347
    parameter, as in "branch foo/bar -r 5".
507
 
 
508
 
    --basis is to speed up branching from remote branches.  When specified, it
509
 
    copies all the file-contents, inventory and revision data from the basis
510
 
    branch before copying anything from the remote branch.
511
348
    """
512
349
    takes_args = ['from_location', 'to_location?']
513
 
    takes_options = ['revision', 'basis']
 
350
    takes_options = ['revision']
514
351
    aliases = ['get', 'clone']
515
352
 
516
 
    def run(self, from_location, to_location=None, revision=None, basis=None):
517
 
        from bzrlib.clone import copy_branch
 
353
    def run(self, from_location, to_location=None, revision=None):
 
354
        from bzrlib.branch import copy_branch, find_cached_branch
 
355
        import tempfile
518
356
        import errno
519
357
        from shutil import rmtree
520
 
        if revision is None:
521
 
            revision = [None]
522
 
        elif len(revision) > 1:
523
 
            raise BzrCommandError(
524
 
                'bzr branch --revision takes exactly 1 revision value')
525
 
        try:
526
 
            br_from = Branch.open(from_location)
527
 
        except OSError, e:
528
 
            if e.errno == errno.ENOENT:
529
 
                raise BzrCommandError('Source location "%s" does not'
530
 
                                      ' exist.' % to_location)
531
 
            else:
532
 
                raise
533
 
        br_from.lock_read()
534
 
        try:
535
 
            if basis is not None:
536
 
                basis_branch = WorkingTree.open_containing(basis)[0].branch
537
 
            else:
538
 
                basis_branch = None
539
 
            if len(revision) == 1 and revision[0] is not None:
540
 
                revision_id = revision[0].in_history(br_from)[1]
541
 
            else:
542
 
                revision_id = None
 
358
        cache_root = tempfile.mkdtemp()
 
359
        try:
 
360
            if revision is None:
 
361
                revision = [None]
 
362
            elif len(revision) > 1:
 
363
                raise BzrCommandError(
 
364
                    'bzr branch --revision takes exactly 1 revision value')
 
365
            try:
 
366
                br_from = find_cached_branch(from_location, cache_root)
 
367
            except OSError, e:
 
368
                if e.errno == errno.ENOENT:
 
369
                    raise BzrCommandError('Source location "%s" does not'
 
370
                                          ' exist.' % to_location)
 
371
                else:
 
372
                    raise
543
373
            if to_location is None:
544
374
                to_location = os.path.basename(from_location.rstrip("/\\"))
545
 
                name = None
546
 
            else:
547
 
                name = os.path.basename(to_location) + '\n'
548
375
            try:
549
376
                os.mkdir(to_location)
550
377
            except OSError, e:
557
384
                else:
558
385
                    raise
559
386
            try:
560
 
                copy_branch(br_from, to_location, revision_id, basis_branch)
 
387
                copy_branch(br_from, to_location, revision[0])
561
388
            except bzrlib.errors.NoSuchRevision:
562
389
                rmtree(to_location)
563
 
                msg = "The branch %s has no revision %s." % (from_location, revision[0])
564
 
                raise BzrCommandError(msg)
565
 
            except bzrlib.errors.UnlistableBranch:
566
 
                rmtree(to_location)
567
 
                msg = "The branch %s cannot be used as a --basis"
568
 
                raise BzrCommandError(msg)
569
 
            branch = Branch.open(to_location)
570
 
            if name:
571
 
                name = StringIO(name)
572
 
                branch.put_controlfile('branch-name', name)
573
 
            note('Branched %d revision(s).' % branch.revno())
 
390
                msg = "The branch %s has no revision %d." % (from_location, revision[0])
 
391
                raise BzrCommandError(msg)
574
392
        finally:
575
 
            br_from.unlock()
 
393
            rmtree(cache_root)
576
394
 
577
395
 
578
396
class cmd_renames(Command):
579
397
    """Show list of renamed files.
 
398
 
 
399
    TODO: Option to show renames between two historical versions.
 
400
 
 
401
    TODO: Only show renames under dir, rather than in the whole branch.
580
402
    """
581
 
    # TODO: Option to show renames between two historical versions.
582
 
 
583
 
    # TODO: Only show renames under dir, rather than in the whole branch.
584
403
    takes_args = ['dir?']
585
404
 
586
 
    @display_command
587
 
    def run(self, dir=u'.'):
588
 
        tree = WorkingTree.open_containing(dir)[0]
589
 
        old_inv = tree.branch.basis_tree().inventory
590
 
        new_inv = tree.read_working_inventory()
 
405
    def run(self, dir='.'):
 
406
        b = find_branch(dir)
 
407
        old_inv = b.basis_tree().inventory
 
408
        new_inv = b.read_working_inventory()
591
409
 
592
410
        renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
593
411
        renames.sort()
599
417
    """Show statistical information about a branch."""
600
418
    takes_args = ['branch?']
601
419
    
602
 
    @display_command
603
420
    def run(self, branch=None):
604
421
        import info
605
 
        b = WorkingTree.open_containing(branch)[0].branch
 
422
 
 
423
        b = find_branch(branch)
606
424
        info.show_info(b)
607
425
 
608
426
 
614
432
    """
615
433
    takes_args = ['file+']
616
434
    takes_options = ['verbose']
617
 
    aliases = ['rm']
618
435
    
619
436
    def run(self, file_list, verbose=False):
620
 
        tree, file_list = tree_files(file_list)
621
 
        tree.remove(file_list, verbose=verbose)
 
437
        b = find_branch(file_list[0])
 
438
        b.remove([b.relpath(f) for f in file_list], verbose=verbose)
622
439
 
623
440
 
624
441
class cmd_file_id(Command):
630
447
    """
631
448
    hidden = True
632
449
    takes_args = ['filename']
633
 
    @display_command
634
450
    def run(self, filename):
635
 
        tree, relpath = WorkingTree.open_containing(filename)
636
 
        i = tree.inventory.path2id(relpath)
 
451
        b = find_branch(filename)
 
452
        i = b.inventory.path2id(b.relpath(filename))
637
453
        if i == None:
638
454
            raise BzrError("%r is not a versioned file" % filename)
639
455
        else:
647
463
    starting at the branch root."""
648
464
    hidden = True
649
465
    takes_args = ['filename']
650
 
    @display_command
651
466
    def run(self, filename):
652
 
        tree, relpath = WorkingTree.open_containing(filename)
653
 
        inv = tree.inventory
654
 
        fid = inv.path2id(relpath)
 
467
        b = find_branch(filename)
 
468
        inv = b.inventory
 
469
        fid = inv.path2id(b.relpath(filename))
655
470
        if fid == None:
656
471
            raise BzrError("%r is not a versioned file" % filename)
657
472
        for fip in inv.get_idpath(fid):
661
476
class cmd_revision_history(Command):
662
477
    """Display list of revision ids on this branch."""
663
478
    hidden = True
664
 
    @display_command
665
479
    def run(self):
666
 
        branch = WorkingTree.open_containing(u'.')[0].branch
667
 
        for patchid in branch.revision_history():
 
480
        for patchid in find_branch('.').revision_history():
668
481
            print patchid
669
482
 
670
483
 
671
 
class cmd_ancestry(Command):
672
 
    """List all revisions merged into this branch."""
673
 
    hidden = True
674
 
    @display_command
 
484
class cmd_directories(Command):
 
485
    """Display list of versioned directories in this branch."""
675
486
    def run(self):
676
 
        tree = WorkingTree.open_containing(u'.')[0]
677
 
        b = tree.branch
678
 
        # FIXME. should be tree.last_revision
679
 
        for revision_id in b.get_ancestry(b.last_revision()):
680
 
            print revision_id
 
487
        for name, ie in find_branch('.').read_working_inventory().directories():
 
488
            if name == '':
 
489
                print '.'
 
490
            else:
 
491
                print name
681
492
 
682
493
 
683
494
class cmd_init(Command):
689
500
    Recipe for importing a tree of files:
690
501
        cd ~/project
691
502
        bzr init
692
 
        bzr add .
 
503
        bzr add -v .
693
504
        bzr status
694
505
        bzr commit -m 'imported project'
695
506
    """
696
 
    takes_args = ['location?']
697
 
    def run(self, location=None):
 
507
    def run(self):
698
508
        from bzrlib.branch import Branch
699
 
        if location is None:
700
 
            location = u'.'
701
 
        else:
702
 
            # The path has to exist to initialize a
703
 
            # branch inside of it.
704
 
            # Just using os.mkdir, since I don't
705
 
            # believe that we want to create a bunch of
706
 
            # locations if the user supplies an extended path
707
 
            if not os.path.exists(location):
708
 
                os.mkdir(location)
709
 
        Branch.initialize(location)
 
509
        Branch('.', init=True)
710
510
 
711
511
 
712
512
class cmd_diff(Command):
715
515
    If files are listed, only the changes in those files are listed.
716
516
    Otherwise, all changes for the tree are listed.
717
517
 
 
518
    TODO: Allow diff across branches.
 
519
 
 
520
    TODO: Option to use external diff command; could be GNU diff, wdiff,
 
521
          or a graphical diff.
 
522
 
 
523
    TODO: Python difflib is not exactly the same as unidiff; should
 
524
          either fix it up or prefer to use an external diff.
 
525
 
 
526
    TODO: If a directory is given, diff everything under that.
 
527
 
 
528
    TODO: Selected-file diff is inefficient and doesn't show you
 
529
          deleted files.
 
530
 
 
531
    TODO: This probably handles non-Unix newlines poorly.
 
532
 
718
533
    examples:
719
534
        bzr diff
720
535
        bzr diff -r1
721
536
        bzr diff -r1..2
722
537
    """
723
 
    # TODO: Allow diff across branches.
724
 
    # TODO: Option to use external diff command; could be GNU diff, wdiff,
725
 
    #       or a graphical diff.
726
 
 
727
 
    # TODO: Python difflib is not exactly the same as unidiff; should
728
 
    #       either fix it up or prefer to use an external diff.
729
 
 
730
 
    # TODO: If a directory is given, diff everything under that.
731
 
 
732
 
    # TODO: Selected-file diff is inefficient and doesn't show you
733
 
    #       deleted files.
734
 
 
735
 
    # TODO: This probably handles non-Unix newlines poorly.
736
538
    
737
539
    takes_args = ['file*']
738
540
    takes_options = ['revision', 'diff-options']
739
541
    aliases = ['di', 'dif']
740
542
 
741
 
    @display_command
742
543
    def run(self, revision=None, file_list=None, diff_options=None):
743
544
        from bzrlib.diff import show_diff
744
 
        try:
745
 
            tree, file_list = internal_tree_files(file_list)
746
 
            b = None
747
 
            b2 = None
748
 
        except FileInWrongBranch:
749
 
            if len(file_list) != 2:
750
 
                raise BzrCommandError("Files are in different branches")
751
 
 
752
 
            b, file1 = Branch.open_containing(file_list[0])
753
 
            b2, file2 = Branch.open_containing(file_list[1])
754
 
            if file1 != "" or file2 != "":
755
 
                # FIXME diff those two files. rbc 20051123
756
 
                raise BzrCommandError("Files are in different branches")
757
 
            file_list = None
 
545
 
 
546
        if file_list:
 
547
            b = find_branch(file_list[0])
 
548
            file_list = [b.relpath(f) for f in file_list]
 
549
            if file_list == ['']:
 
550
                # just pointing to top-of-tree
 
551
                file_list = None
 
552
        else:
 
553
            b = find_branch('.')
 
554
 
758
555
        if revision is not None:
759
 
            if b2 is not None:
760
 
                raise BzrCommandError("Can't specify -r with two branches")
761
556
            if len(revision) == 1:
762
 
                return show_diff(tree.branch, revision[0], specific_files=file_list,
763
 
                                 external_diff_options=diff_options)
 
557
                show_diff(b, revision[0], specific_files=file_list,
 
558
                          external_diff_options=diff_options)
764
559
            elif len(revision) == 2:
765
 
                return show_diff(tree.branch, revision[0], specific_files=file_list,
766
 
                                 external_diff_options=diff_options,
767
 
                                 revision2=revision[1])
 
560
                show_diff(b, revision[0], specific_files=file_list,
 
561
                          external_diff_options=diff_options,
 
562
                          revision2=revision[1])
768
563
            else:
769
564
                raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
770
565
        else:
771
 
            if b is not None:
772
 
                return show_diff(b, None, specific_files=file_list,
773
 
                                 external_diff_options=diff_options, b2=b2)
774
 
            else:
775
 
                return show_diff(tree.branch, None, specific_files=file_list,
776
 
                                 external_diff_options=diff_options)
 
566
            show_diff(b, None, specific_files=file_list,
 
567
                      external_diff_options=diff_options)
 
568
 
 
569
        
777
570
 
778
571
 
779
572
class cmd_deleted(Command):
780
573
    """List files deleted in the working tree.
 
574
 
 
575
    TODO: Show files deleted since a previous revision, or between two revisions.
781
576
    """
782
 
    # TODO: Show files deleted since a previous revision, or
783
 
    # between two revisions.
784
 
    # TODO: Much more efficient way to do this: read in new
785
 
    # directories with readdir, rather than stating each one.  Same
786
 
    # level of effort but possibly much less IO.  (Or possibly not,
787
 
    # if the directories are very large...)
788
 
    @display_command
789
577
    def run(self, show_ids=False):
790
 
        tree = WorkingTree.open_containing(u'.')[0]
791
 
        old = tree.branch.basis_tree()
 
578
        b = find_branch('.')
 
579
        old = b.basis_tree()
 
580
        new = b.working_tree()
 
581
 
 
582
        ## TODO: Much more efficient way to do this: read in new
 
583
        ## directories with readdir, rather than stating each one.  Same
 
584
        ## level of effort but possibly much less IO.  (Or possibly not,
 
585
        ## if the directories are very large...)
 
586
 
792
587
        for path, ie in old.inventory.iter_entries():
793
 
            if not tree.has_id(ie.file_id):
 
588
            if not new.has_id(ie.file_id):
794
589
                if show_ids:
795
590
                    print '%-50s %s' % (path, ie.file_id)
796
591
                else:
800
595
class cmd_modified(Command):
801
596
    """List files modified in working tree."""
802
597
    hidden = True
803
 
    @display_command
804
598
    def run(self):
805
599
        from bzrlib.delta import compare_trees
806
600
 
807
 
        tree = WorkingTree.open_containing(u'.')[0]
808
 
        td = compare_trees(tree.branch.basis_tree(), tree)
 
601
        b = find_branch('.')
 
602
        td = compare_trees(b.basis_tree(), b.working_tree())
809
603
 
810
 
        for path, id, kind, text_modified, meta_modified in td.modified:
 
604
        for path, id, kind in td.modified:
811
605
            print path
812
606
 
813
607
 
815
609
class cmd_added(Command):
816
610
    """List files added in working tree."""
817
611
    hidden = True
818
 
    @display_command
819
612
    def run(self):
820
 
        wt = WorkingTree.open_containing(u'.')[0]
821
 
        basis_inv = wt.branch.basis_tree().inventory
 
613
        b = find_branch('.')
 
614
        wt = b.working_tree()
 
615
        basis_inv = b.basis_tree().inventory
822
616
        inv = wt.inventory
823
617
        for file_id in inv:
824
618
            if file_id in basis_inv:
836
630
    The root is the nearest enclosing directory with a .bzr control
837
631
    directory."""
838
632
    takes_args = ['filename?']
839
 
    @display_command
840
633
    def run(self, filename=None):
841
634
        """Print the branch root."""
842
 
        tree = WorkingTree.open_containing(filename)[0]
843
 
        print tree.basedir
 
635
        b = find_branch(filename)
 
636
        print b.base
844
637
 
845
638
 
846
639
class cmd_log(Command):
847
640
    """Show log of this branch.
848
641
 
849
 
    To request a range of logs, you can use the command -r begin..end
850
 
    -r revision requests a specific revision, -r ..end or -r begin.. are
 
642
    To request a range of logs, you can use the command -r begin:end
 
643
    -r revision requests a specific revision, -r :end or -r begin: are
851
644
    also valid.
 
645
 
 
646
    --message allows you to give a regular expression, which will be evaluated
 
647
    so that only matching entries will be displayed.
 
648
 
 
649
    TODO: Make --revision support uuid: and hash: [future tag:] notation.
 
650
  
852
651
    """
853
652
 
854
 
    # TODO: Make --revision support uuid: and hash: [future tag:] notation.
855
 
 
856
653
    takes_args = ['filename?']
857
 
    takes_options = [Option('forward', 
858
 
                            help='show from oldest to newest'),
859
 
                     'timezone', 'verbose', 
860
 
                     'show-ids', 'revision',
861
 
                     Option('line', help='format with one line per revision'),
862
 
                     'long', 
863
 
                     Option('message',
864
 
                            help='show revisions whose message matches this regexp',
865
 
                            type=str),
866
 
                     Option('short', help='use moderately short format'),
867
 
                     ]
868
 
    @display_command
 
654
    takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
 
655
                     'long', 'message', 'short',]
 
656
    
869
657
    def run(self, filename=None, timezone='original',
870
658
            verbose=False,
871
659
            show_ids=False,
873
661
            revision=None,
874
662
            message=None,
875
663
            long=False,
876
 
            short=False,
877
 
            line=False):
 
664
            short=False):
878
665
        from bzrlib.log import log_formatter, show_log
879
666
        import codecs
880
 
        assert message is None or isinstance(message, basestring), \
881
 
            "invalid message argument %r" % message
 
667
 
882
668
        direction = (forward and 'forward') or 'reverse'
883
669
        
884
670
        if filename:
885
 
            # might be a tree:
886
 
            tree = None
887
 
            try:
888
 
                tree, fp = WorkingTree.open_containing(filename)
889
 
                b = tree.branch
890
 
                if fp != '':
891
 
                    inv = tree.read_working_inventory()
892
 
            except NotBranchError:
893
 
                pass
894
 
            if tree is None:
895
 
                b, fp = Branch.open_containing(filename)
896
 
                if fp != '':
897
 
                    inv = b.get_inventory(b.last_revision())
898
 
            if fp != '':
899
 
                file_id = inv.path2id(fp)
 
671
            b = find_branch(filename)
 
672
            fp = b.relpath(filename)
 
673
            if fp:
 
674
                file_id = b.read_working_inventory().path2id(fp)
900
675
            else:
901
676
                file_id = None  # points to branch root
902
677
        else:
903
 
            tree, relpath = WorkingTree.open_containing(u'.')
904
 
            b = tree.branch
 
678
            b = find_branch('.')
905
679
            file_id = None
906
680
 
907
681
        if revision is None:
908
682
            rev1 = None
909
683
            rev2 = None
910
684
        elif len(revision) == 1:
911
 
            rev1 = rev2 = revision[0].in_history(b).revno
 
685
            rev1 = rev2 = b.get_revision_info(revision[0])[0]
912
686
        elif len(revision) == 2:
913
 
            rev1 = revision[0].in_history(b).revno
914
 
            rev2 = revision[1].in_history(b).revno
 
687
            rev1 = b.get_revision_info(revision[0])[0]
 
688
            rev2 = b.get_revision_info(revision[1])[0]
915
689
        else:
916
690
            raise BzrCommandError('bzr log --revision takes one or two values.')
917
691
 
918
 
        # By this point, the revision numbers are converted to the +ve
919
 
        # form if they were supplied in the -ve form, so we can do
920
 
        # this comparison in relative safety
921
 
        if rev1 > rev2:
922
 
            (rev2, rev1) = (rev1, rev2)
 
692
        if rev1 == 0:
 
693
            rev1 = None
 
694
        if rev2 == 0:
 
695
            rev2 = None
923
696
 
924
 
        mutter('encoding log as %r', bzrlib.user_encoding)
 
697
        mutter('encoding log as %r' % bzrlib.user_encoding)
925
698
 
926
699
        # use 'replace' so that we don't abort if trying to write out
927
700
        # in e.g. the default C locale.
928
701
        outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
929
702
 
930
 
        log_format = 'long'
931
 
        if short:
 
703
        if not short:
 
704
            log_format = 'long'
 
705
        else:
932
706
            log_format = 'short'
933
 
        if line:
934
 
            log_format = 'line'
935
707
        lf = log_formatter(log_format,
936
708
                           show_ids=show_ids,
937
709
                           to_file=outf,
954
726
    A more user-friendly interface is "bzr log FILE"."""
955
727
    hidden = True
956
728
    takes_args = ["filename"]
957
 
    @display_command
958
729
    def run(self, filename):
959
 
        tree, relpath = WorkingTree.open_containing(filename)
960
 
        b = tree.branch
961
 
        inv = tree.read_working_inventory()
962
 
        file_id = inv.path2id(relpath)
 
730
        b = find_branch(filename)
 
731
        inv = b.read_working_inventory()
 
732
        file_id = inv.path2id(b.relpath(filename))
963
733
        for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
964
734
            print "%6d %s" % (revno, what)
965
735
 
966
736
 
967
737
class cmd_ls(Command):
968
738
    """List files in a tree.
 
739
 
 
740
    TODO: Take a revision or remote path and list that tree instead.
969
741
    """
970
 
    # TODO: Take a revision or remote path and list that tree instead.
971
742
    hidden = True
972
 
    takes_options = ['verbose', 'revision',
973
 
                     Option('non-recursive',
974
 
                            help='don\'t recurse into sub-directories'),
975
 
                     Option('from-root',
976
 
                            help='Print all paths from the root of the branch.'),
977
 
                     Option('unknown', help='Print unknown files'),
978
 
                     Option('versioned', help='Print versioned files'),
979
 
                     Option('ignored', help='Print ignored files'),
980
 
 
981
 
                     Option('null', help='Null separate the files'),
982
 
                    ]
983
 
    @display_command
984
 
    def run(self, revision=None, verbose=False, 
985
 
            non_recursive=False, from_root=False,
986
 
            unknown=False, versioned=False, ignored=False,
987
 
            null=False):
988
 
 
989
 
        if verbose and null:
990
 
            raise BzrCommandError('Cannot set both --verbose and --null')
991
 
        all = not (unknown or versioned or ignored)
992
 
 
993
 
        selection = {'I':ignored, '?':unknown, 'V':versioned}
994
 
 
995
 
        tree, relpath = WorkingTree.open_containing(u'.')
996
 
        if from_root:
997
 
            relpath = u''
998
 
        elif relpath:
999
 
            relpath += '/'
1000
 
        if revision is not None:
1001
 
            tree = tree.branch.revision_tree(
1002
 
                revision[0].in_history(tree.branch).rev_id)
1003
 
        for fp, fc, kind, fid, entry in tree.list_files():
1004
 
            if fp.startswith(relpath):
1005
 
                fp = fp[len(relpath):]
1006
 
                if non_recursive and '/' in fp:
1007
 
                    continue
1008
 
                if not all and not selection[fc]:
1009
 
                    continue
1010
 
                if verbose:
1011
 
                    kindch = entry.kind_character()
1012
 
                    print '%-8s %s%s' % (fc, fp, kindch)
1013
 
                elif null:
1014
 
                    sys.stdout.write(fp)
1015
 
                    sys.stdout.write('\0')
1016
 
                    sys.stdout.flush()
 
743
    def run(self, revision=None, verbose=False):
 
744
        b = find_branch('.')
 
745
        if revision == None:
 
746
            tree = b.working_tree()
 
747
        else:
 
748
            tree = b.revision_tree(b.lookup_revision(revision))
 
749
 
 
750
        for fp, fc, kind, fid in tree.list_files():
 
751
            if verbose:
 
752
                if kind == 'directory':
 
753
                    kindch = '/'
 
754
                elif kind == 'file':
 
755
                    kindch = ''
1017
756
                else:
1018
 
                    print fp
 
757
                    kindch = '???'
 
758
 
 
759
                print '%-8s %s%s' % (fc, fp, kindch)
 
760
            else:
 
761
                print fp
 
762
 
1019
763
 
1020
764
 
1021
765
class cmd_unknowns(Command):
1022
766
    """List unknown files."""
1023
 
    @display_command
1024
767
    def run(self):
1025
768
        from bzrlib.osutils import quotefn
1026
 
        for f in WorkingTree.open_containing(u'.')[0].unknowns():
 
769
        for f in find_branch('.').unknowns():
1027
770
            print quotefn(f)
1028
771
 
1029
772
 
 
773
 
1030
774
class cmd_ignore(Command):
1031
775
    """Ignore a command or pattern.
1032
776
 
1033
777
    To remove patterns from the ignore list, edit the .bzrignore file.
1034
778
 
1035
779
    If the pattern contains a slash, it is compared to the whole path
1036
 
    from the branch root.  Otherwise, it is compared to only the last
1037
 
    component of the path.  To match a file only in the root directory,
1038
 
    prepend './'.
 
780
    from the branch root.  Otherwise, it is comapred to only the last
 
781
    component of the path.
1039
782
 
1040
783
    Ignore patterns are case-insensitive on case-insensitive systems.
1041
784
 
1045
788
        bzr ignore ./Makefile
1046
789
        bzr ignore '*.class'
1047
790
    """
1048
 
    # TODO: Complain if the filename is absolute
1049
791
    takes_args = ['name_pattern']
1050
792
    
1051
793
    def run(self, name_pattern):
1052
794
        from bzrlib.atomicfile import AtomicFile
1053
795
        import os.path
1054
796
 
1055
 
        tree, relpath = WorkingTree.open_containing(u'.')
1056
 
        ifn = tree.abspath('.bzrignore')
 
797
        b = find_branch('.')
 
798
        ifn = b.abspath('.bzrignore')
1057
799
 
1058
800
        if os.path.exists(ifn):
1059
801
            f = open(ifn, 'rt')
1078
820
        finally:
1079
821
            f.close()
1080
822
 
1081
 
        inv = tree.inventory
 
823
        inv = b.working_tree().inventory
1082
824
        if inv.path2id('.bzrignore'):
1083
825
            mutter('.bzrignore is already versioned')
1084
826
        else:
1085
827
            mutter('need to make new .bzrignore file versioned')
1086
 
            tree.add(['.bzrignore'])
 
828
            b.add(['.bzrignore'])
 
829
 
1087
830
 
1088
831
 
1089
832
class cmd_ignored(Command):
1090
833
    """List ignored files and the patterns that matched them.
1091
834
 
1092
835
    See also: bzr ignore"""
1093
 
    @display_command
1094
836
    def run(self):
1095
 
        tree = WorkingTree.open_containing(u'.')[0]
1096
 
        for path, file_class, kind, file_id, entry in tree.list_files():
 
837
        tree = find_branch('.').working_tree()
 
838
        for path, file_class, kind, file_id in tree.list_files():
1097
839
            if file_class != 'I':
1098
840
                continue
1099
841
            ## XXX: Slightly inefficient since this was already calculated
1110
852
    hidden = True
1111
853
    takes_args = ['revno']
1112
854
    
1113
 
    @display_command
1114
855
    def run(self, revno):
1115
856
        try:
1116
857
            revno = int(revno)
1117
858
        except ValueError:
1118
859
            raise BzrCommandError("not a valid revision-number: %r" % revno)
1119
860
 
1120
 
        print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
 
861
        print find_branch('.').lookup_revision(revno)
1121
862
 
1122
863
 
1123
864
class cmd_export(Command):
1130
871
    is found exports to a directory (equivalent to --format=dir).
1131
872
 
1132
873
    Root may be the top directory for tar, tgz and tbz2 formats. If none
1133
 
    is given, the top directory will be the root name of the file.
1134
 
 
1135
 
    Note: export of tree with non-ascii filenames to zip is not supported.
1136
 
 
1137
 
    Supported formats       Autodetected by extension
1138
 
    -----------------       -------------------------
1139
 
         dir                            -
1140
 
         tar                          .tar
1141
 
         tbz2                    .tar.bz2, .tbz2
1142
 
         tgz                      .tar.gz, .tgz
1143
 
         zip                          .zip
1144
 
    """
 
874
    is given, the top directory will be the root name of the file."""
 
875
    # TODO: list known exporters
1145
876
    takes_args = ['dest']
1146
877
    takes_options = ['revision', 'format', 'root']
1147
878
    def run(self, dest, revision=None, format=None, root=None):
1148
879
        import os.path
1149
 
        from bzrlib.export import export
1150
 
        tree = WorkingTree.open_containing(u'.')[0]
1151
 
        b = tree.branch
 
880
        b = find_branch('.')
1152
881
        if revision is None:
1153
 
            # should be tree.last_revision  FIXME
1154
 
            rev_id = b.last_revision()
 
882
            rev_id = b.last_patch()
1155
883
        else:
1156
884
            if len(revision) != 1:
1157
885
                raise BzrError('bzr export --revision takes exactly 1 argument')
1158
 
            rev_id = revision[0].in_history(b).rev_id
 
886
            revno, rev_id = b.get_revision_info(revision[0])
1159
887
        t = b.revision_tree(rev_id)
1160
 
        try:
1161
 
            export(t, dest, format, root)
1162
 
        except errors.NoSuchExportFormat, e:
1163
 
            raise BzrCommandError('Unsupported export format: %s' % e.format)
 
888
        root, ext = os.path.splitext(dest)
 
889
        if not format:
 
890
            if ext in (".tar",):
 
891
                format = "tar"
 
892
            elif ext in (".gz", ".tgz"):
 
893
                format = "tgz"
 
894
            elif ext in (".bz2", ".tbz2"):
 
895
                format = "tbz2"
 
896
            else:
 
897
                format = "dir"
 
898
        t.export(dest, format, root)
1164
899
 
1165
900
 
1166
901
class cmd_cat(Command):
1169
904
    takes_options = ['revision']
1170
905
    takes_args = ['filename']
1171
906
 
1172
 
    @display_command
1173
907
    def run(self, filename, revision=None):
1174
 
        if revision is None:
 
908
        if revision == None:
1175
909
            raise BzrCommandError("bzr cat requires a revision number")
1176
910
        elif len(revision) != 1:
1177
911
            raise BzrCommandError("bzr cat --revision takes exactly one number")
1178
 
        tree = None
1179
 
        try:
1180
 
            tree, relpath = WorkingTree.open_containing(filename)
1181
 
            b = tree.branch
1182
 
        except NotBranchError:
1183
 
            pass
1184
 
        if tree is None:
1185
 
            b, relpath = Branch.open_containing(filename)
1186
 
        b.print_file(relpath, revision[0].in_history(b).revno)
 
912
        b = find_branch('.')
 
913
        b.print_file(b.relpath(filename), revision[0])
1187
914
 
1188
915
 
1189
916
class cmd_local_time_offset(Command):
1190
917
    """Show the offset in seconds from GMT to local time."""
1191
918
    hidden = True    
1192
 
    @display_command
1193
919
    def run(self):
1194
920
        print bzrlib.osutils.local_time_offset()
1195
921
 
1207
933
    A selected-file commit may fail in some cases where the committed
1208
934
    tree would be invalid, such as trying to commit a file in a
1209
935
    newly-added directory that is not itself committed.
 
936
 
 
937
    TODO: Run hooks on tree to-be-committed, and after commit.
 
938
 
 
939
    TODO: Strict commit that fails if there are unknown or deleted files.
1210
940
    """
1211
 
    # TODO: Run hooks on tree to-be-committed, and after commit.
1212
 
 
1213
 
    # TODO: Strict commit that fails if there are deleted files.
1214
 
    #       (what does "deleted files" mean ??)
1215
 
 
1216
 
    # TODO: Give better message for -s, --summary, used by tla people
1217
 
 
1218
 
    # XXX: verbose currently does nothing
1219
 
 
1220
941
    takes_args = ['selected*']
1221
 
    takes_options = ['message', 'verbose', 
1222
 
                     Option('unchanged',
1223
 
                            help='commit even if nothing has changed'),
1224
 
                     Option('file', type=str, 
1225
 
                            argname='msgfile',
1226
 
                            help='file containing commit message'),
1227
 
                     Option('strict',
1228
 
                            help="refuse to commit if there are unknown "
1229
 
                            "files in the working tree."),
1230
 
                     ]
 
942
    takes_options = ['message', 'file', 'verbose', 'unchanged']
1231
943
    aliases = ['ci', 'checkin']
1232
944
 
 
945
    # TODO: Give better message for -s, --summary, used by tla people
 
946
    
1233
947
    def run(self, message=None, file=None, verbose=True, selected_list=None,
1234
 
            unchanged=False, strict=False):
1235
 
        from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1236
 
                StrictCommitFailed)
 
948
            unchanged=False):
 
949
        from bzrlib.errors import PointlessCommit
1237
950
        from bzrlib.msgeditor import edit_commit_message
1238
951
        from bzrlib.status import show_status
1239
 
        from tempfile import TemporaryFile
1240
 
        import codecs
 
952
        from cStringIO import StringIO
1241
953
 
1242
 
        # TODO: do more checks that the commit will succeed before 
1243
 
        # spending the user's valuable time typing a commit message.
1244
 
        #
1245
 
        # TODO: if the commit *does* happen to fail, then save the commit 
1246
 
        # message to a temporary file where it can be recovered
1247
 
        tree, selected_list = tree_files(selected_list)
1248
 
        if message is None and not file:
1249
 
            template = make_commit_message_template(tree)
1250
 
            message = edit_commit_message(template)
 
954
        b = find_branch('.')
 
955
        if selected_list:
 
956
            selected_list = [b.relpath(s) for s in selected_list]
 
957
            
 
958
        if not message and not file:
 
959
            catcher = StringIO()
 
960
            show_status(b, specific_files=selected_list,
 
961
                        to_file=catcher)
 
962
            message = edit_commit_message(catcher.getvalue())
 
963
            
1251
964
            if message is None:
1252
965
                raise BzrCommandError("please specify a commit message"
1253
966
                                      " with either --message or --file")
1258
971
            import codecs
1259
972
            message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1260
973
 
1261
 
        if message == "":
1262
 
                raise BzrCommandError("empty commit message specified")
1263
 
            
1264
974
        try:
1265
 
            tree.commit(message, specific_files=selected_list,
1266
 
                        allow_pointless=unchanged, strict=strict)
 
975
            b.commit(message, verbose=verbose,
 
976
                     specific_files=selected_list,
 
977
                     allow_pointless=unchanged)
1267
978
        except PointlessCommit:
1268
979
            # FIXME: This should really happen before the file is read in;
1269
980
            # perhaps prepare the commit; get the message; then actually commit
1270
981
            raise BzrCommandError("no changes to commit",
1271
982
                                  ["use --unchanged to commit anyhow"])
1272
 
        except ConflictsInTree:
1273
 
            raise BzrCommandError("Conflicts detected in working tree.  "
1274
 
                'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1275
 
        except StrictCommitFailed:
1276
 
            raise BzrCommandError("Commit refused because there are unknown "
1277
 
                                  "files in the working tree.")
1278
 
        note('Committed revision %d.' % (tree.branch.revno(),))
1279
983
 
1280
984
 
1281
985
class cmd_check(Command):
1284
988
    This command checks various invariants about the branch storage to
1285
989
    detect data corruption or bzr bugs.
1286
990
    """
1287
 
    takes_args = ['branch?']
1288
 
    takes_options = ['verbose']
 
991
    takes_args = ['dir?']
1289
992
 
1290
 
    def run(self, branch=None, verbose=False):
 
993
    def run(self, dir='.'):
1291
994
        from bzrlib.check import check
1292
 
        if branch is None:
1293
 
            tree = WorkingTree.open_containing()[0]
1294
 
            branch = tree.branch
1295
 
        else:
1296
 
            branch = Branch.open(branch)
1297
 
        check(branch, verbose)
 
995
 
 
996
        check(find_branch(dir))
1298
997
 
1299
998
 
1300
999
class cmd_scan_cache(Command):
1302
1001
    def run(self):
1303
1002
        from bzrlib.hashcache import HashCache
1304
1003
 
1305
 
        c = HashCache(u'.')
 
1004
        c = HashCache('.')
1306
1005
        c.read()
1307
1006
        c.scan()
1308
1007
            
1322
1021
 
1323
1022
    The check command or bzr developers may sometimes advise you to run
1324
1023
    this command.
1325
 
 
1326
 
    This version of this command upgrades from the full-text storage
1327
 
    used by bzr 0.0.8 and earlier to the weave format (v5).
1328
1024
    """
1329
1025
    takes_args = ['dir?']
1330
1026
 
1331
 
    def run(self, dir=u'.'):
 
1027
    def run(self, dir='.'):
1332
1028
        from bzrlib.upgrade import upgrade
1333
 
        upgrade(dir)
 
1029
        upgrade(find_branch(dir))
 
1030
 
1334
1031
 
1335
1032
 
1336
1033
class cmd_whoami(Command):
1337
1034
    """Show bzr user id."""
1338
1035
    takes_options = ['email']
1339
1036
    
1340
 
    @display_command
1341
1037
    def run(self, email=False):
1342
1038
        try:
1343
 
            b = WorkingTree.open_containing(u'.')[0].branch
1344
 
            config = bzrlib.config.BranchConfig(b)
1345
 
        except NotBranchError:
1346
 
            config = bzrlib.config.GlobalConfig()
 
1039
            b = bzrlib.branch.find_branch('.')
 
1040
        except:
 
1041
            b = None
1347
1042
        
1348
1043
        if email:
1349
 
            print config.user_email()
1350
 
        else:
1351
 
            print config.username()
1352
 
 
1353
 
class cmd_nick(Command):
1354
 
    """\
1355
 
    Print or set the branch nickname.  
1356
 
    If unset, the tree root directory name is used as the nickname
1357
 
    To print the current nickname, execute with no argument.  
1358
 
    """
1359
 
    takes_args = ['nickname?']
1360
 
    def run(self, nickname=None):
1361
 
        branch = Branch.open_containing(u'.')[0]
1362
 
        if nickname is None:
1363
 
            self.printme(branch)
1364
 
        else:
1365
 
            branch.nick = nickname
1366
 
 
1367
 
    @display_command
1368
 
    def printme(self, branch):
1369
 
        print branch.nick 
 
1044
            print bzrlib.osutils.user_email(b)
 
1045
        else:
 
1046
            print bzrlib.osutils.username(b)
 
1047
 
1370
1048
 
1371
1049
class cmd_selftest(Command):
1372
 
    """Run internal test suite.
1373
 
    
1374
 
    This creates temporary test directories in the working directory,
1375
 
    but not existing data is affected.  These directories are deleted
1376
 
    if the tests pass, or left behind to help in debugging if they
1377
 
    fail and --keep-output is specified.
1378
 
    
1379
 
    If arguments are given, they are regular expressions that say
1380
 
    which tests should run.
1381
 
    """
1382
 
    # TODO: --list should give a list of all available tests
 
1050
    """Run internal test suite"""
1383
1051
    hidden = True
1384
 
    takes_args = ['testspecs*']
1385
 
    takes_options = ['verbose', 
1386
 
                     Option('one', help='stop when one test fails'),
1387
 
                     Option('keep-output', 
1388
 
                            help='keep output directories when tests fail')
1389
 
                    ]
1390
 
 
1391
 
    def run(self, testspecs_list=None, verbose=False, one=False,
1392
 
            keep_output=False):
 
1052
    takes_options = ['verbose', 'pattern']
 
1053
    def run(self, verbose=False, pattern=".*"):
1393
1054
        import bzrlib.ui
1394
 
        from bzrlib.tests import selftest
 
1055
        from bzrlib.selftest import selftest
1395
1056
        # we don't want progress meters from the tests to go to the
1396
1057
        # real output; and we don't want log messages cluttering up
1397
1058
        # the real logs.
1399
1060
        bzrlib.trace.info('running tests...')
1400
1061
        try:
1401
1062
            bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1402
 
            if testspecs_list is not None:
1403
 
                pattern = '|'.join(testspecs_list)
1404
 
            else:
1405
 
                pattern = ".*"
1406
 
            result = selftest(verbose=verbose, 
1407
 
                              pattern=pattern,
1408
 
                              stop_on_failure=one, 
1409
 
                              keep_output=keep_output)
 
1063
            result = selftest(verbose=verbose, pattern=pattern)
1410
1064
            if result:
1411
1065
                bzrlib.trace.info('tests passed')
1412
1066
            else:
1432
1086
 
1433
1087
class cmd_version(Command):
1434
1088
    """Show version of bzr."""
1435
 
    @display_command
1436
1089
    def run(self):
1437
1090
        show_version()
1438
1091
 
1439
1092
class cmd_rocks(Command):
1440
1093
    """Statement of optimism."""
1441
1094
    hidden = True
1442
 
    @display_command
1443
1095
    def run(self):
1444
1096
        print "it sure does!"
1445
1097
 
1446
1098
 
1447
1099
class cmd_find_merge_base(Command):
1448
1100
    """Find and print a base revision for merging two branches.
 
1101
 
 
1102
    TODO: Options to specify revisions on either side, as if
 
1103
          merging only part of the history.
1449
1104
    """
1450
 
    # TODO: Options to specify revisions on either side, as if
1451
 
    #       merging only part of the history.
1452
1105
    takes_args = ['branch', 'other']
1453
1106
    hidden = True
1454
1107
    
1455
 
    @display_command
1456
1108
    def run(self, branch, other):
1457
1109
        from bzrlib.revision import common_ancestor, MultipleRevisionSources
1458
1110
        
1459
 
        branch1 = Branch.open_containing(branch)[0]
1460
 
        branch2 = Branch.open_containing(other)[0]
 
1111
        branch1 = find_branch(branch)
 
1112
        branch2 = find_branch(other)
1461
1113
 
1462
1114
        history_1 = branch1.revision_history()
1463
1115
        history_2 = branch2.revision_history()
1464
1116
 
1465
 
        last1 = branch1.last_revision()
1466
 
        last2 = branch2.last_revision()
 
1117
        last1 = branch1.last_patch()
 
1118
        last2 = branch2.last_patch()
1467
1119
 
1468
1120
        source = MultipleRevisionSources(branch1, branch2)
1469
1121
        
1512
1164
    --force is given.
1513
1165
    """
1514
1166
    takes_args = ['branch?']
1515
 
    takes_options = ['revision', 'force', 'merge-type', 'reprocess',
1516
 
                     Option('show-base', help="Show base revision text in "
1517
 
                            "conflicts")]
 
1167
    takes_options = ['revision', 'force', 'merge-type']
1518
1168
 
1519
 
    def run(self, branch=None, revision=None, force=False, merge_type=None,
1520
 
            show_base=False, reprocess=False):
 
1169
    def run(self, branch='.', revision=None, force=False, 
 
1170
            merge_type=None):
1521
1171
        from bzrlib.merge import merge
1522
1172
        from bzrlib.merge_core import ApplyMerge3
1523
1173
        if merge_type is None:
1524
1174
            merge_type = ApplyMerge3
1525
 
        if branch is None:
1526
 
            branch = WorkingTree.open_containing(u'.')[0].branch.get_parent()
1527
 
            if branch is None:
1528
 
                raise BzrCommandError("No merge location known or specified.")
1529
 
            else:
1530
 
                print "Using saved location: %s" % branch 
 
1175
 
1531
1176
        if revision is None or len(revision) < 1:
1532
1177
            base = [None, None]
1533
1178
            other = [branch, -1]
1534
1179
        else:
1535
1180
            if len(revision) == 1:
 
1181
                other = [branch, revision[0]]
1536
1182
                base = [None, None]
1537
 
                other_branch = Branch.open_containing(branch)[0]
1538
 
                revno = revision[0].in_history(other_branch).revno
1539
 
                other = [branch, revno]
1540
1183
            else:
1541
1184
                assert len(revision) == 2
1542
1185
                if None in revision:
1543
1186
                    raise BzrCommandError(
1544
1187
                        "Merge doesn't permit that revision specifier.")
1545
 
                b = Branch.open_containing(branch)[0]
1546
 
 
1547
 
                base = [branch, revision[0].in_history(b).revno]
1548
 
                other = [branch, revision[1].in_history(b).revno]
 
1188
                base = [branch, revision[0]]
 
1189
                other = [branch, revision[1]]
1549
1190
 
1550
1191
        try:
1551
 
            conflict_count = merge(other, base, check_clean=(not force),
1552
 
                                   merge_type=merge_type, reprocess=reprocess,
1553
 
                                   show_base=show_base)
1554
 
            if conflict_count != 0:
1555
 
                return 1
1556
 
            else:
1557
 
                return 0
 
1192
            merge(other, base, check_clean=(not force), merge_type=merge_type)
1558
1193
        except bzrlib.errors.AmbiguousBase, e:
1559
1194
            m = ("sorry, bzr can't determine the right merge base yet\n"
1560
1195
                 "candidates are:\n  "
1565
1200
            log_error(m)
1566
1201
 
1567
1202
 
1568
 
class cmd_remerge(Command):
1569
 
    """Redo a merge.
1570
 
    """
1571
 
    takes_args = ['file*']
1572
 
    takes_options = ['merge-type', 'reprocess',
1573
 
                     Option('show-base', help="Show base revision text in "
1574
 
                            "conflicts")]
1575
 
 
1576
 
    def run(self, file_list=None, merge_type=None, show_base=False,
1577
 
            reprocess=False):
1578
 
        from bzrlib.merge import merge_inner, transform_tree
1579
 
        from bzrlib.merge_core import ApplyMerge3
1580
 
        if merge_type is None:
1581
 
            merge_type = ApplyMerge3
1582
 
        tree, file_list = tree_files(file_list)
1583
 
        tree.lock_write()
1584
 
        try:
1585
 
            pending_merges = tree.pending_merges() 
1586
 
            if len(pending_merges) != 1:
1587
 
                raise BzrCommandError("Sorry, remerge only works after normal"
1588
 
                                      + " merges.  Not cherrypicking or"
1589
 
                                      + "multi-merges.")
1590
 
            base_revision = common_ancestor(tree.branch.last_revision(), 
1591
 
                                            pending_merges[0], tree.branch)
1592
 
            base_tree = tree.branch.revision_tree(base_revision)
1593
 
            other_tree = tree.branch.revision_tree(pending_merges[0])
1594
 
            interesting_ids = None
1595
 
            if file_list is not None:
1596
 
                interesting_ids = set()
1597
 
                for filename in file_list:
1598
 
                    file_id = tree.path2id(filename)
1599
 
                    interesting_ids.add(file_id)
1600
 
                    if tree.kind(file_id) != "directory":
1601
 
                        continue
1602
 
                    
1603
 
                    for name, ie in tree.inventory.iter_entries(file_id):
1604
 
                        interesting_ids.add(ie.file_id)
1605
 
            transform_tree(tree, tree.branch.basis_tree(), interesting_ids)
1606
 
            if file_list is None:
1607
 
                restore_files = list(tree.iter_conflicts())
1608
 
            else:
1609
 
                restore_files = file_list
1610
 
            for filename in restore_files:
1611
 
                try:
1612
 
                    restore(tree.abspath(filename))
1613
 
                except NotConflicted:
1614
 
                    pass
1615
 
            conflicts =  merge_inner(tree.branch, other_tree, base_tree, 
1616
 
                                     interesting_ids = interesting_ids, 
1617
 
                                     other_rev_id=pending_merges[0], 
1618
 
                                     merge_type=merge_type, 
1619
 
                                     show_base=show_base,
1620
 
                                     reprocess=reprocess)
1621
 
        finally:
1622
 
            tree.unlock()
1623
 
        if conflicts > 0:
1624
 
            return 1
1625
 
        else:
1626
 
            return 0
1627
 
 
1628
1203
class cmd_revert(Command):
1629
1204
    """Reverse all changes since the last commit.
1630
1205
 
1637
1212
    aliases = ['merge-revert']
1638
1213
 
1639
1214
    def run(self, revision=None, no_backup=False, file_list=None):
1640
 
        from bzrlib.merge import merge_inner
 
1215
        from bzrlib.merge import merge
 
1216
        from bzrlib.branch import Branch
1641
1217
        from bzrlib.commands import parse_spec
 
1218
 
1642
1219
        if file_list is not None:
1643
1220
            if len(file_list) == 0:
1644
1221
                raise BzrCommandError("No files specified")
1645
 
        else:
1646
 
            file_list = []
1647
1222
        if revision is None:
1648
 
            revno = -1
1649
 
            tree = WorkingTree.open_containing(u'.')[0]
1650
 
            # FIXME should be tree.last_revision
1651
 
            rev_id = tree.branch.last_revision()
 
1223
            revision = [-1]
1652
1224
        elif len(revision) != 1:
1653
1225
            raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1654
 
        else:
1655
 
            tree, file_list = tree_files(file_list)
1656
 
            rev_id = revision[0].in_history(tree.branch).rev_id
1657
 
        tree.revert(file_list, tree.branch.revision_tree(rev_id),
1658
 
                                not no_backup)
 
1226
        merge(('.', revision[0]), parse_spec('.'),
 
1227
              check_clean=False,
 
1228
              ignore_zero=True,
 
1229
              backup_files=not no_backup,
 
1230
              file_list=file_list)
 
1231
        if not file_list:
 
1232
            Branch('.').set_pending_merges([])
1659
1233
 
1660
1234
 
1661
1235
class cmd_assert_fail(Command):
1673
1247
    takes_args = ['topic?']
1674
1248
    aliases = ['?']
1675
1249
    
1676
 
    @display_command
1677
1250
    def run(self, topic=None, long=False):
1678
1251
        import help
1679
1252
        if topic is None and long:
1689
1262
    aliases = ['s-c']
1690
1263
    hidden = True
1691
1264
    
1692
 
    @display_command
1693
1265
    def run(self, context=None):
1694
1266
        import shellcomplete
1695
1267
        shellcomplete.shellcomplete(context)
1696
1268
 
1697
1269
 
1698
 
class cmd_fetch(Command):
1699
 
    """Copy in history from another branch but don't merge it.
1700
 
 
1701
 
    This is an internal method used for pull and merge."""
1702
 
    hidden = True
1703
 
    takes_args = ['from_branch', 'to_branch']
1704
 
    def run(self, from_branch, to_branch):
1705
 
        from bzrlib.fetch import Fetcher
1706
 
        from bzrlib.branch import Branch
1707
 
        from_b = Branch.open(from_branch)
1708
 
        to_b = Branch.open(to_branch)
1709
 
        from_b.lock_read()
1710
 
        try:
1711
 
            to_b.lock_write()
1712
 
            try:
1713
 
                Fetcher(to_b, from_b)
1714
 
            finally:
1715
 
                to_b.unlock()
1716
 
        finally:
1717
 
            from_b.unlock()
1718
 
 
1719
 
 
1720
1270
class cmd_missing(Command):
1721
1271
    """What is missing in this branch relative to other branch.
1722
1272
    """
1723
 
    # TODO: rewrite this in terms of ancestry so that it shows only
1724
 
    # unmerged things
1725
 
    
1726
1273
    takes_args = ['remote?']
1727
1274
    aliases = ['mis', 'miss']
1728
 
    takes_options = ['verbose']
 
1275
    # We don't have to add quiet to the list, because 
 
1276
    # unknown options are parsed as booleans
 
1277
    takes_options = ['verbose', 'quiet']
1729
1278
 
1730
 
    @display_command
1731
 
    def run(self, remote=None, verbose=False):
 
1279
    def run(self, remote=None, verbose=False, quiet=False):
1732
1280
        from bzrlib.errors import BzrCommandError
1733
1281
        from bzrlib.missing import show_missing
1734
1282
 
1735
 
        if verbose and is_quiet():
 
1283
        if verbose and quiet:
1736
1284
            raise BzrCommandError('Cannot pass both quiet and verbose')
1737
1285
 
1738
 
        tree = WorkingTree.open_containing(u'.')[0]
1739
 
        parent = tree.branch.get_parent()
 
1286
        b = find_branch('.')
 
1287
        parent = b.get_parent()
1740
1288
        if remote is None:
1741
1289
            if parent is None:
1742
1290
                raise BzrCommandError("No missing location known or specified.")
1743
1291
            else:
1744
 
                if not is_quiet():
 
1292
                if not quiet:
1745
1293
                    print "Using last location: %s" % parent
1746
1294
                remote = parent
1747
1295
        elif parent is None:
1748
 
            # We only update parent if it did not exist, missing
1749
 
            # should not change the parent
1750
 
            tree.branch.set_parent(remote)
1751
 
        br_remote = Branch.open_containing(remote)[0]
1752
 
        return show_missing(tree.branch, br_remote, verbose=verbose, 
1753
 
                            quiet=is_quiet())
 
1296
            # We only update parent if it did not exist, missing should not change the parent
 
1297
            b.set_parent(remote)
 
1298
        br_remote = find_branch(remote)
 
1299
 
 
1300
        return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
 
1301
 
1754
1302
 
1755
1303
 
1756
1304
class cmd_plugins(Command):
1757
1305
    """List plugins"""
1758
1306
    hidden = True
1759
 
    @display_command
1760
1307
    def run(self):
1761
1308
        import bzrlib.plugin
1762
1309
        from inspect import getdoc
1773
1320
                print '\t', d.split('\n')[0]
1774
1321
 
1775
1322
 
1776
 
class cmd_testament(Command):
1777
 
    """Show testament (signing-form) of a revision."""
1778
 
    takes_options = ['revision', 'long']
1779
 
    takes_args = ['branch?']
1780
 
    @display_command
1781
 
    def run(self, branch=u'.', revision=None, long=False):
1782
 
        from bzrlib.testament import Testament
1783
 
        b = WorkingTree.open_containing(branch)[0].branch
1784
 
        b.lock_read()
1785
 
        try:
1786
 
            if revision is None:
1787
 
                rev_id = b.last_revision()
1788
 
            else:
1789
 
                rev_id = revision[0].in_history(b).rev_id
1790
 
            t = Testament.from_revision(b, rev_id)
1791
 
            if long:
1792
 
                sys.stdout.writelines(t.as_text_lines())
1793
 
            else:
1794
 
                sys.stdout.write(t.as_short_text())
1795
 
        finally:
1796
 
            b.unlock()
1797
 
 
1798
 
 
1799
 
class cmd_annotate(Command):
1800
 
    """Show the origin of each line in a file.
1801
 
 
1802
 
    This prints out the given file with an annotation on the left side
1803
 
    indicating which revision, author and date introduced the change.
1804
 
 
1805
 
    If the origin is the same for a run of consecutive lines, it is 
1806
 
    shown only at the top, unless the --all option is given.
1807
 
    """
1808
 
    # TODO: annotate directories; showing when each file was last changed
1809
 
    # TODO: annotate a previous version of a file
1810
 
    # TODO: if the working copy is modified, show annotations on that 
1811
 
    #       with new uncommitted lines marked
1812
 
    aliases = ['blame', 'praise']
1813
 
    takes_args = ['filename']
1814
 
    takes_options = [Option('all', help='show annotations on all lines'),
1815
 
                     Option('long', help='show date in annotations'),
1816
 
                     ]
1817
 
 
1818
 
    @display_command
1819
 
    def run(self, filename, all=False, long=False):
1820
 
        from bzrlib.annotate import annotate_file
1821
 
        tree, relpath = WorkingTree.open_containing(filename)
1822
 
        branch = tree.branch
1823
 
        branch.lock_read()
1824
 
        try:
1825
 
            file_id = tree.inventory.path2id(relpath)
1826
 
            tree = branch.revision_tree(branch.last_revision())
1827
 
            file_version = tree.inventory[file_id].revision
1828
 
            annotate_file(branch, file_version, file_id, long, all, sys.stdout)
1829
 
        finally:
1830
 
            branch.unlock()
1831
 
 
1832
 
 
1833
 
class cmd_re_sign(Command):
1834
 
    """Create a digital signature for an existing revision."""
1835
 
    # TODO be able to replace existing ones.
1836
 
 
1837
 
    hidden = True # is this right ?
1838
 
    takes_args = ['revision_id?']
1839
 
    takes_options = ['revision']
1840
 
    
1841
 
    def run(self, revision_id=None, revision=None):
1842
 
        import bzrlib.config as config
1843
 
        import bzrlib.gpg as gpg
1844
 
        if revision_id is not None and revision is not None:
1845
 
            raise BzrCommandError('You can only supply one of revision_id or --revision')
1846
 
        if revision_id is None and revision is None:
1847
 
            raise BzrCommandError('You must supply either --revision or a revision_id')
1848
 
        b = WorkingTree.open_containing(u'.')[0].branch
1849
 
        gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
1850
 
        if revision_id is not None:
1851
 
            b.sign_revision(revision_id, gpg_strategy)
1852
 
        elif revision is not None:
1853
 
            if len(revision) == 1:
1854
 
                revno, rev_id = revision[0].in_history(b)
1855
 
                b.sign_revision(rev_id, gpg_strategy)
1856
 
            elif len(revision) == 2:
1857
 
                # are they both on rh- if so we can walk between them
1858
 
                # might be nice to have a range helper for arbitrary
1859
 
                # revision paths. hmm.
1860
 
                from_revno, from_revid = revision[0].in_history(b)
1861
 
                to_revno, to_revid = revision[1].in_history(b)
1862
 
                if to_revid is None:
1863
 
                    to_revno = b.revno()
1864
 
                if from_revno is None or to_revno is None:
1865
 
                    raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
1866
 
                for revno in range(from_revno, to_revno + 1):
1867
 
                    b.sign_revision(b.get_rev_id(revno), gpg_strategy)
1868
 
            else:
1869
 
                raise BzrCommandError('Please supply either one revision, or a range.')
1870
 
 
1871
 
 
1872
 
class cmd_uncommit(bzrlib.commands.Command):
1873
 
    """Remove the last committed revision.
1874
 
 
1875
 
    By supplying the --all flag, it will not only remove the entry 
1876
 
    from revision_history, but also remove all of the entries in the
1877
 
    stores.
1878
 
 
1879
 
    --verbose will print out what is being removed.
1880
 
    --dry-run will go through all the motions, but not actually
1881
 
    remove anything.
1882
 
    
1883
 
    In the future, uncommit will create a changeset, which can then
1884
 
    be re-applied.
1885
 
    """
1886
 
    takes_options = ['all', 'verbose', 'revision',
1887
 
                    Option('dry-run', help='Don\'t actually make changes'),
1888
 
                    Option('force', help='Say yes to all questions.')]
1889
 
    takes_args = ['location?']
1890
 
    aliases = []
1891
 
 
1892
 
    def run(self, location=None, all=False,
1893
 
            dry_run=False, verbose=False,
1894
 
            revision=None, force=False):
1895
 
        from bzrlib.branch import Branch
1896
 
        from bzrlib.log import log_formatter
1897
 
        import sys
1898
 
        from bzrlib.uncommit import uncommit
1899
 
 
1900
 
        if location is None:
1901
 
            location = u'.'
1902
 
        b, relpath = Branch.open_containing(location)
1903
 
 
1904
 
        if revision is None:
1905
 
            revno = b.revno()
1906
 
            rev_id = b.last_revision()
1907
 
        else:
1908
 
            revno, rev_id = revision[0].in_history(b)
1909
 
        if rev_id is None:
1910
 
            print 'No revisions to uncommit.'
1911
 
 
1912
 
        for r in range(revno, b.revno()+1):
1913
 
            rev_id = b.get_rev_id(r)
1914
 
            lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
1915
 
            lf.show(r, b.get_revision(rev_id), None)
1916
 
 
1917
 
        if dry_run:
1918
 
            print 'Dry-run, pretending to remove the above revisions.'
1919
 
            if not force:
1920
 
                val = raw_input('Press <enter> to continue')
1921
 
        else:
1922
 
            print 'The above revision(s) will be removed.'
1923
 
            if not force:
1924
 
                val = raw_input('Are you sure [y/N]? ')
1925
 
                if val.lower() not in ('y', 'yes'):
1926
 
                    print 'Canceled'
1927
 
                    return 0
1928
 
 
1929
 
        uncommit(b, remove_files=all,
1930
 
                dry_run=dry_run, verbose=verbose,
1931
 
                revno=revno)
1932
 
 
1933
 
 
1934
 
# these get imported and then picked up by the scan for cmd_*
1935
 
# TODO: Some more consistent way to split command definitions across files;
1936
 
# we do need to load at least some information about them to know of 
1937
 
# aliases.
1938
 
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore