/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

Switched from actual, expected to expected, actual, for John.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/builtins.py
 
1
# Copyright (C) 2004, 2005, 2006 by Canonical Ltd
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
"""builtin bzr commands"""
 
18
 
 
19
 
 
20
import codecs
 
21
import errno
 
22
import os
 
23
import sys
 
24
 
 
25
import bzrlib
 
26
from bzrlib.branch import Branch, BranchReferenceFormat
 
27
from bzrlib import (bundle, branch, bzrdir, errors, osutils, ui, config,
 
28
    repository, log)
 
29
from bzrlib.bundle import read_bundle_from_url
 
30
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
 
31
from bzrlib.conflicts import ConflictList
 
32
from bzrlib.commands import Command, display_command
 
33
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError, 
 
34
                           NotBranchError, DivergedBranches, NotConflicted,
 
35
                           NoSuchFile, NoWorkingTree, FileInWrongBranch,
 
36
                           NotVersionedError, NotABundle)
 
37
from bzrlib.merge import Merge3Merger
 
38
from bzrlib.option import Option
 
39
from bzrlib.progress import DummyProgress, ProgressPhase
 
40
from bzrlib.revision import common_ancestor
 
41
from bzrlib.revisionspec import RevisionSpec
 
42
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
 
43
from bzrlib.transport.local import LocalTransport
 
44
import bzrlib.urlutils as urlutils
 
45
from bzrlib.workingtree import WorkingTree
 
46
 
 
47
 
 
48
def tree_files(file_list, default_branch=u'.'):
 
49
    try:
 
50
        return internal_tree_files(file_list, default_branch)
 
51
    except FileInWrongBranch, e:
 
52
        raise BzrCommandError("%s is not in the same branch as %s" %
 
53
                             (e.path, file_list[0]))
 
54
 
 
55
 
 
56
# XXX: Bad function name; should possibly also be a class method of
 
57
# WorkingTree rather than a function.
 
58
def internal_tree_files(file_list, default_branch=u'.'):
 
59
    """Convert command-line paths to a WorkingTree and relative paths.
 
60
 
 
61
    This is typically used for command-line processors that take one or
 
62
    more filenames, and infer the workingtree that contains them.
 
63
 
 
64
    The filenames given are not required to exist.
 
65
 
 
66
    :param file_list: Filenames to convert.  
 
67
 
 
68
    :param default_branch: Fallback tree path to use if file_list is empty or None.
 
69
 
 
70
    :return: workingtree, [relative_paths]
 
71
    """
 
72
    if file_list is None or len(file_list) == 0:
 
73
        return WorkingTree.open_containing(default_branch)[0], file_list
 
74
    tree = WorkingTree.open_containing(file_list[0])[0]
 
75
    new_list = []
 
76
    for filename in file_list:
 
77
        try:
 
78
            new_list.append(tree.relpath(filename))
 
79
        except errors.PathNotChild:
 
80
            raise FileInWrongBranch(tree.branch, filename)
 
81
    return tree, new_list
 
82
 
 
83
 
 
84
def get_format_type(typestring):
 
85
    """Parse and return a format specifier."""
 
86
    if typestring == "weave":
 
87
        return bzrdir.BzrDirFormat6()
 
88
    if typestring == "default":
 
89
        return bzrdir.BzrDirMetaFormat1()
 
90
    if typestring == "metaweave":
 
91
        format = bzrdir.BzrDirMetaFormat1()
 
92
        format.repository_format = repository.RepositoryFormat7()
 
93
        return format
 
94
    if typestring == "knit":
 
95
        format = bzrdir.BzrDirMetaFormat1()
 
96
        format.repository_format = repository.RepositoryFormatKnit1()
 
97
        return format
 
98
    msg = "Unknown bzr format %s. Current formats are: default, knit,\n" \
 
99
          "metaweave and weave" % typestring
 
100
    raise BzrCommandError(msg)
 
101
 
 
102
 
 
103
# TODO: Make sure no commands unconditionally use the working directory as a
 
104
# branch.  If a filename argument is used, the first of them should be used to
 
105
# specify the branch.  (Perhaps this can be factored out into some kind of
 
106
# Argument class, representing a file in a branch, where the first occurrence
 
107
# opens the branch?)
 
108
 
 
109
class cmd_status(Command):
 
110
    """Display status summary.
 
111
 
 
112
    This reports on versioned and unknown files, reporting them
 
113
    grouped by state.  Possible states are:
 
114
 
 
115
    added
 
116
        Versioned in the working copy but not in the previous revision.
 
117
 
 
118
    removed
 
119
        Versioned in the previous revision but removed or deleted
 
120
        in the working copy.
 
121
 
 
122
    renamed
 
123
        Path of this file changed from the previous revision;
 
124
        the text may also have changed.  This includes files whose
 
125
        parent directory was renamed.
 
126
 
 
127
    modified
 
128
        Text has changed since the previous revision.
 
129
 
 
130
    unknown
 
131
        Not versioned and not matching an ignore pattern.
 
132
 
 
133
    To see ignored files use 'bzr ignored'.  For details in the
 
134
    changes to file texts, use 'bzr diff'.
 
135
 
 
136
    If no arguments are specified, the status of the entire working
 
137
    directory is shown.  Otherwise, only the status of the specified
 
138
    files or directories is reported.  If a directory is given, status
 
139
    is reported for everything inside that directory.
 
140
 
 
141
    If a revision argument is given, the status is calculated against
 
142
    that revision, or between two revisions if two are provided.
 
143
    """
 
144
    
 
145
    # TODO: --no-recurse, --recurse options
 
146
    
 
147
    takes_args = ['file*']
 
148
    takes_options = ['show-ids', 'revision']
 
149
    aliases = ['st', 'stat']
 
150
 
 
151
    encoding_type = 'replace'
 
152
    
 
153
    @display_command
 
154
    def run(self, show_ids=False, file_list=None, revision=None):
 
155
        from bzrlib.status import show_tree_status
 
156
 
 
157
        tree, file_list = tree_files(file_list)
 
158
            
 
159
        show_tree_status(tree, show_ids=show_ids,
 
160
                         specific_files=file_list, revision=revision,
 
161
                         to_file=self.outf)
 
162
 
 
163
 
 
164
class cmd_cat_revision(Command):
 
165
    """Write out metadata for a revision.
 
166
    
 
167
    The revision to print can either be specified by a specific
 
168
    revision identifier, or you can use --revision.
 
169
    """
 
170
 
 
171
    hidden = True
 
172
    takes_args = ['revision_id?']
 
173
    takes_options = ['revision']
 
174
    # cat-revision is more for frontends so should be exact
 
175
    encoding = 'strict'
 
176
    
 
177
    @display_command
 
178
    def run(self, revision_id=None, revision=None):
 
179
 
 
180
        if revision_id is not None and revision is not None:
 
181
            raise BzrCommandError('You can only supply one of revision_id or --revision')
 
182
        if revision_id is None and revision is None:
 
183
            raise BzrCommandError('You must supply either --revision or a revision_id')
 
184
        b = WorkingTree.open_containing(u'.')[0].branch
 
185
 
 
186
        # TODO: jam 20060112 should cat-revision always output utf-8?
 
187
        if revision_id is not None:
 
188
            self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
 
189
        elif revision is not None:
 
190
            for rev in revision:
 
191
                if rev is None:
 
192
                    raise BzrCommandError('You cannot specify a NULL revision.')
 
193
                revno, rev_id = rev.in_history(b)
 
194
                self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
 
195
    
 
196
 
 
197
class cmd_revno(Command):
 
198
    """Show current revision number.
 
199
 
 
200
    This is equal to the number of revisions on this branch.
 
201
    """
 
202
 
 
203
    takes_args = ['location?']
 
204
 
 
205
    @display_command
 
206
    def run(self, location=u'.'):
 
207
        self.outf.write(str(Branch.open_containing(location)[0].revno()))
 
208
        self.outf.write('\n')
 
209
 
 
210
 
 
211
class cmd_revision_info(Command):
 
212
    """Show revision number and revision id for a given revision identifier.
 
213
    """
 
214
    hidden = True
 
215
    takes_args = ['revision_info*']
 
216
    takes_options = ['revision']
 
217
 
 
218
    @display_command
 
219
    def run(self, revision=None, revision_info_list=[]):
 
220
 
 
221
        revs = []
 
222
        if revision is not None:
 
223
            revs.extend(revision)
 
224
        if revision_info_list is not None:
 
225
            for rev in revision_info_list:
 
226
                revs.append(RevisionSpec(rev))
 
227
        if len(revs) == 0:
 
228
            raise BzrCommandError('You must supply a revision identifier')
 
229
 
 
230
        b = WorkingTree.open_containing(u'.')[0].branch
 
231
 
 
232
        for rev in revs:
 
233
            revinfo = rev.in_history(b)
 
234
            if revinfo.revno is None:
 
235
                print '     %s' % revinfo.rev_id
 
236
            else:
 
237
                print '%4d %s' % (revinfo.revno, revinfo.rev_id)
 
238
 
 
239
    
 
240
class cmd_add(Command):
 
241
    """Add specified files or directories.
 
242
 
 
243
    In non-recursive mode, all the named items are added, regardless
 
244
    of whether they were previously ignored.  A warning is given if
 
245
    any of the named files are already versioned.
 
246
 
 
247
    In recursive mode (the default), files are treated the same way
 
248
    but the behaviour for directories is different.  Directories that
 
249
    are already versioned do not give a warning.  All directories,
 
250
    whether already versioned or not, are searched for files or
 
251
    subdirectories that are neither versioned or ignored, and these
 
252
    are added.  This search proceeds recursively into versioned
 
253
    directories.  If no names are given '.' is assumed.
 
254
 
 
255
    Therefore simply saying 'bzr add' will version all files that
 
256
    are currently unknown.
 
257
 
 
258
    Adding a file whose parent directory is not versioned will
 
259
    implicitly add the parent, and so on up to the root. This means
 
260
    you should never need to explicitly add a directory, they'll just
 
261
    get added when you add a file in the directory.
 
262
 
 
263
    --dry-run will show which files would be added, but not actually 
 
264
    add them.
 
265
    """
 
266
    takes_args = ['file*']
 
267
    takes_options = ['no-recurse', 'dry-run', 'verbose']
 
268
    encoding_type = 'replace'
 
269
 
 
270
    def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
 
271
        import bzrlib.add
 
272
 
 
273
        action = bzrlib.add.AddAction(to_file=self.outf,
 
274
            should_print=(not is_quiet()))
 
275
 
 
276
        added, ignored = bzrlib.add.smart_add(file_list, not no_recurse, 
 
277
                                              action=action, save=not dry_run)
 
278
        if len(ignored) > 0:
 
279
            if verbose:
 
280
                for glob in sorted(ignored.keys()):
 
281
                    for path in ignored[glob]:
 
282
                        self.outf.write("ignored %s matching \"%s\"\n" 
 
283
                                        % (path, glob))
 
284
            else:
 
285
                match_len = 0
 
286
                for glob, paths in ignored.items():
 
287
                    match_len += len(paths)
 
288
                self.outf.write("ignored %d file(s).\n" % match_len)
 
289
            self.outf.write("If you wish to add some of these files,"
 
290
                            " please add them by name.\n")
 
291
 
 
292
 
 
293
class cmd_mkdir(Command):
 
294
    """Create a new versioned directory.
 
295
 
 
296
    This is equivalent to creating the directory and then adding it.
 
297
    """
 
298
 
 
299
    takes_args = ['dir+']
 
300
    encoding_type = 'replace'
 
301
 
 
302
    def run(self, dir_list):
 
303
        for d in dir_list:
 
304
            os.mkdir(d)
 
305
            wt, dd = WorkingTree.open_containing(d)
 
306
            wt.add([dd])
 
307
            self.outf.write('added %s\n' % d)
 
308
 
 
309
 
 
310
class cmd_relpath(Command):
 
311
    """Show path of a file relative to root"""
 
312
 
 
313
    takes_args = ['filename']
 
314
    hidden = True
 
315
    
 
316
    @display_command
 
317
    def run(self, filename):
 
318
        # TODO: jam 20050106 Can relpath return a munged path if
 
319
        #       sys.stdout encoding cannot represent it?
 
320
        tree, relpath = WorkingTree.open_containing(filename)
 
321
        self.outf.write(relpath)
 
322
        self.outf.write('\n')
 
323
 
 
324
 
 
325
class cmd_inventory(Command):
 
326
    """Show inventory of the current working copy or a revision.
 
327
 
 
328
    It is possible to limit the output to a particular entry
 
329
    type using the --kind option.  For example; --kind file.
 
330
    """
 
331
 
 
332
    takes_options = ['revision', 'show-ids', 'kind']
 
333
    
 
334
    @display_command
 
335
    def run(self, revision=None, show_ids=False, kind=None):
 
336
        if kind and kind not in ['file', 'directory', 'symlink']:
 
337
            raise BzrCommandError('invalid kind specified')
 
338
        tree = WorkingTree.open_containing(u'.')[0]
 
339
        if revision is None:
 
340
            inv = tree.read_working_inventory()
 
341
        else:
 
342
            if len(revision) > 1:
 
343
                raise BzrCommandError('bzr inventory --revision takes'
 
344
                    ' exactly one revision identifier')
 
345
            inv = tree.branch.repository.get_revision_inventory(
 
346
                revision[0].in_history(tree.branch).rev_id)
 
347
 
 
348
        for path, entry in inv.entries():
 
349
            if kind and kind != entry.kind:
 
350
                continue
 
351
            if show_ids:
 
352
                self.outf.write('%-50s %s\n' % (path, entry.file_id))
 
353
            else:
 
354
                self.outf.write(path)
 
355
                self.outf.write('\n')
 
356
 
 
357
 
 
358
class cmd_mv(Command):
 
359
    """Move or rename a file.
 
360
 
 
361
    usage:
 
362
        bzr mv OLDNAME NEWNAME
 
363
        bzr mv SOURCE... DESTINATION
 
364
 
 
365
    If the last argument is a versioned directory, all the other names
 
366
    are moved into it.  Otherwise, there must be exactly two arguments
 
367
    and the file is changed to a new name, which must not already exist.
 
368
 
 
369
    Files cannot be moved between branches.
 
370
    """
 
371
 
 
372
    takes_args = ['names*']
 
373
    aliases = ['move', 'rename']
 
374
    encoding_type = 'replace'
 
375
 
 
376
    def run(self, names_list):
 
377
        if len(names_list) < 2:
 
378
            raise BzrCommandError("missing file argument")
 
379
        tree, rel_names = tree_files(names_list)
 
380
        
 
381
        if os.path.isdir(names_list[-1]):
 
382
            # move into existing directory
 
383
            for pair in tree.move(rel_names[:-1], rel_names[-1]):
 
384
                self.outf.write("%s => %s\n" % pair)
 
385
        else:
 
386
            if len(names_list) != 2:
 
387
                raise BzrCommandError('to mv multiple files the destination '
 
388
                                      'must be a versioned directory')
 
389
            tree.rename_one(rel_names[0], rel_names[1])
 
390
            self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
 
391
            
 
392
    
 
393
class cmd_pull(Command):
 
394
    """Turn this branch into a mirror of another branch.
 
395
 
 
396
    This command only works on branches that have not diverged.  Branches are
 
397
    considered diverged if the destination branch's most recent commit is one
 
398
    that has not been merged (directly or indirectly) into the parent.
 
399
 
 
400
    If branches have diverged, you can use 'bzr merge' to integrate the changes
 
401
    from one into the other.  Once one branch has merged, the other should
 
402
    be able to pull it again.
 
403
 
 
404
    If you want to forget your local changes and just update your branch to
 
405
    match the remote one, use pull --overwrite.
 
406
 
 
407
    If there is no default location set, the first pull will set it.  After
 
408
    that, you can omit the location to use the default.  To change the
 
409
    default, use --remember. The value will only be saved if the remote
 
410
    location can be accessed.
 
411
    """
 
412
 
 
413
    takes_options = ['remember', 'overwrite', 'revision', 'verbose']
 
414
    takes_args = ['location?']
 
415
    encoding_type = 'replace'
 
416
 
 
417
    def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
 
418
        # FIXME: too much stuff is in the command class
 
419
        try:
 
420
            tree_to = WorkingTree.open_containing(u'.')[0]
 
421
            branch_to = tree_to.branch
 
422
        except NoWorkingTree:
 
423
            tree_to = None
 
424
            branch_to = Branch.open_containing(u'.')[0]
 
425
 
 
426
        reader = None
 
427
        if location is not None:
 
428
            try:
 
429
                reader = bundle.read_bundle_from_url(location)
 
430
            except NotABundle:
 
431
                pass # Continue on considering this url a Branch
 
432
 
 
433
        stored_loc = branch_to.get_parent()
 
434
        if location is None:
 
435
            if stored_loc is None:
 
436
                raise BzrCommandError("No pull location known or specified.")
 
437
            else:
 
438
                display_url = urlutils.unescape_for_display(stored_loc,
 
439
                        self.outf.encoding)
 
440
                self.outf.write("Using saved location: %s\n" % display_url)
 
441
                location = stored_loc
 
442
 
 
443
 
 
444
        if reader is not None:
 
445
            install_bundle(branch_to.repository, reader)
 
446
            branch_from = branch_to
 
447
        else:
 
448
            branch_from = Branch.open(location)
 
449
 
 
450
            if branch_to.get_parent() is None or remember:
 
451
                branch_to.set_parent(branch_from.base)
 
452
 
 
453
        rev_id = None
 
454
        if revision is None:
 
455
            if reader is not None:
 
456
                rev_id = reader.target
 
457
        elif len(revision) == 1:
 
458
            rev_id = revision[0].in_history(branch_from).rev_id
 
459
        else:
 
460
            raise BzrCommandError('bzr pull --revision takes one value.')
 
461
 
 
462
        old_rh = branch_to.revision_history()
 
463
        if tree_to is not None:
 
464
            count = tree_to.pull(branch_from, overwrite, rev_id)
 
465
        else:
 
466
            count = branch_to.pull(branch_from, overwrite, rev_id)
 
467
        note('%d revision(s) pulled.' % (count,))
 
468
 
 
469
        if verbose:
 
470
            new_rh = branch_to.revision_history()
 
471
            if old_rh != new_rh:
 
472
                # Something changed
 
473
                from bzrlib.log import show_changed_revisions
 
474
                show_changed_revisions(branch_to, old_rh, new_rh,
 
475
                                       to_file=self.outf)
 
476
 
 
477
 
 
478
class cmd_push(Command):
 
479
    """Update a mirror of this branch.
 
480
    
 
481
    The target branch will not have its working tree populated because this
 
482
    is both expensive, and is not supported on remote file systems.
 
483
    
 
484
    Some smart servers or protocols *may* put the working tree in place in
 
485
    the future.
 
486
 
 
487
    This command only works on branches that have not diverged.  Branches are
 
488
    considered diverged if the destination branch's most recent commit is one
 
489
    that has not been merged (directly or indirectly) by the source branch.
 
490
 
 
491
    If branches have diverged, you can use 'bzr push --overwrite' to replace
 
492
    the other branch completely, discarding its unmerged changes.
 
493
    
 
494
    If you want to ensure you have the different changes in the other branch,
 
495
    do a merge (see bzr help merge) from the other branch, and commit that.
 
496
    After that you will be able to do a push without '--overwrite'.
 
497
 
 
498
    If there is no default push location set, the first push will set it.
 
499
    After that, you can omit the location to use the default.  To change the
 
500
    default, use --remember. The value will only be saved if the remote
 
501
    location can be accessed.
 
502
    """
 
503
 
 
504
    takes_options = ['remember', 'overwrite', 'verbose',
 
505
                     Option('create-prefix', 
 
506
                            help='Create the path leading up to the branch '
 
507
                                 'if it does not already exist')]
 
508
    takes_args = ['location?']
 
509
    encoding_type = 'replace'
 
510
 
 
511
    def run(self, location=None, remember=False, overwrite=False,
 
512
            create_prefix=False, verbose=False):
 
513
        # FIXME: Way too big!  Put this into a function called from the
 
514
        # command.
 
515
        from bzrlib.transport import get_transport
 
516
        
 
517
        br_from = Branch.open_containing('.')[0]
 
518
        stored_loc = br_from.get_push_location()
 
519
        if location is None:
 
520
            if stored_loc is None:
 
521
                raise BzrCommandError("No push location known or specified.")
 
522
            else:
 
523
                display_url = urlutils.unescape_for_display(stored_loc,
 
524
                        self.outf.encoding)
 
525
                self.outf.write("Using saved location: %s\n" % display_url)
 
526
                location = stored_loc
 
527
 
 
528
        transport = get_transport(location)
 
529
        location_url = transport.base
 
530
 
 
531
        old_rh = []
 
532
        try:
 
533
            dir_to = bzrdir.BzrDir.open(location_url)
 
534
            br_to = dir_to.open_branch()
 
535
        except NotBranchError:
 
536
            # create a branch.
 
537
            transport = transport.clone('..')
 
538
            if not create_prefix:
 
539
                try:
 
540
                    relurl = transport.relpath(location_url)
 
541
                    mutter('creating directory %s => %s', location_url, relurl)
 
542
                    transport.mkdir(relurl)
 
543
                except NoSuchFile:
 
544
                    raise BzrCommandError("Parent directory of %s "
 
545
                                          "does not exist." % location)
 
546
            else:
 
547
                current = transport.base
 
548
                needed = [(transport, transport.relpath(location_url))]
 
549
                while needed:
 
550
                    try:
 
551
                        transport, relpath = needed[-1]
 
552
                        transport.mkdir(relpath)
 
553
                        needed.pop()
 
554
                    except NoSuchFile:
 
555
                        new_transport = transport.clone('..')
 
556
                        needed.append((new_transport,
 
557
                                       new_transport.relpath(transport.base)))
 
558
                        if new_transport.base == transport.base:
 
559
                            raise BzrCommandError("Could not create "
 
560
                                                  "path prefix.")
 
561
            dir_to = br_from.bzrdir.clone(location_url,
 
562
                revision_id=br_from.last_revision())
 
563
            br_to = dir_to.open_branch()
 
564
            count = len(br_to.revision_history())
 
565
            # We successfully created the target, remember it
 
566
            if br_from.get_push_location() is None or remember:
 
567
                br_from.set_push_location(br_to.base)
 
568
        else:
 
569
            # We were able to connect to the remote location, so remember it
 
570
            # we don't need to successfully push because of possible divergence.
 
571
            if br_from.get_push_location() is None or remember:
 
572
                br_from.set_push_location(br_to.base)
 
573
            old_rh = br_to.revision_history()
 
574
            try:
 
575
                try:
 
576
                    tree_to = dir_to.open_workingtree()
 
577
                except errors.NotLocalUrl:
 
578
                    warning('This transport does not update the working '
 
579
                            'tree of: %s' % (br_to.base,))
 
580
                    count = br_to.pull(br_from, overwrite)
 
581
                except NoWorkingTree:
 
582
                    count = br_to.pull(br_from, overwrite)
 
583
                else:
 
584
                    count = tree_to.pull(br_from, overwrite)
 
585
            except DivergedBranches:
 
586
                raise BzrCommandError("These branches have diverged."
 
587
                                      "  Try a merge then push with overwrite.")
 
588
        note('%d revision(s) pushed.' % (count,))
 
589
 
 
590
        if verbose:
 
591
            new_rh = br_to.revision_history()
 
592
            if old_rh != new_rh:
 
593
                # Something changed
 
594
                from bzrlib.log import show_changed_revisions
 
595
                show_changed_revisions(br_to, old_rh, new_rh,
 
596
                                       to_file=self.outf)
 
597
 
 
598
 
 
599
class cmd_branch(Command):
 
600
    """Create a new copy of a branch.
 
601
 
 
602
    If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
 
603
    be used.  In other words, "branch ../foo/bar" will attempt to create ./bar.
 
604
 
 
605
    To retrieve the branch as of a particular revision, supply the --revision
 
606
    parameter, as in "branch foo/bar -r 5".
 
607
 
 
608
    --basis is to speed up branching from remote branches.  When specified, it
 
609
    copies all the file-contents, inventory and revision data from the basis
 
610
    branch before copying anything from the remote branch.
 
611
    """
 
612
    takes_args = ['from_location', 'to_location?']
 
613
    takes_options = ['revision', 'basis']
 
614
    aliases = ['get', 'clone']
 
615
 
 
616
    def run(self, from_location, to_location=None, revision=None, basis=None):
 
617
        from bzrlib.transport import get_transport
 
618
        if revision is None:
 
619
            revision = [None]
 
620
        elif len(revision) > 1:
 
621
            raise BzrCommandError(
 
622
                'bzr branch --revision takes exactly 1 revision value')
 
623
        try:
 
624
            br_from = Branch.open(from_location)
 
625
        except OSError, e:
 
626
            if e.errno == errno.ENOENT:
 
627
                raise BzrCommandError('Source location "%s" does not'
 
628
                                      ' exist.' % to_location)
 
629
            else:
 
630
                raise
 
631
        br_from.lock_read()
 
632
        try:
 
633
            if basis is not None:
 
634
                basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
 
635
            else:
 
636
                basis_dir = None
 
637
            if len(revision) == 1 and revision[0] is not None:
 
638
                revision_id = revision[0].in_history(br_from)[1]
 
639
            else:
 
640
                # FIXME - wt.last_revision, fallback to branch, fall back to
 
641
                # None or perhaps NULL_REVISION to mean copy nothing
 
642
                # RBC 20060209
 
643
                revision_id = br_from.last_revision()
 
644
            if to_location is None:
 
645
                to_location = os.path.basename(from_location.rstrip("/\\"))
 
646
                name = None
 
647
            else:
 
648
                name = os.path.basename(to_location) + '\n'
 
649
 
 
650
            to_transport = get_transport(to_location)
 
651
            try:
 
652
                to_transport.mkdir('.')
 
653
            except errors.FileExists:
 
654
                raise BzrCommandError('Target directory "%s" already'
 
655
                                      ' exists.' % to_location)
 
656
            except errors.NoSuchFile:
 
657
                raise BzrCommandError('Parent of "%s" does not exist.' %
 
658
                                      to_location)
 
659
            try:
 
660
                # preserve whatever source format we have.
 
661
                dir = br_from.bzrdir.sprout(to_transport.base,
 
662
                        revision_id, basis_dir)
 
663
                branch = dir.open_branch()
 
664
            except errors.NoSuchRevision:
 
665
                to_transport.delete_tree('.')
 
666
                msg = "The branch %s has no revision %s." % (from_location, revision[0])
 
667
                raise BzrCommandError(msg)
 
668
            except errors.UnlistableBranch:
 
669
                osutils.rmtree(to_location)
 
670
                msg = "The branch %s cannot be used as a --basis" % (basis,)
 
671
                raise BzrCommandError(msg)
 
672
            if name:
 
673
                branch.control_files.put_utf8('branch-name', name)
 
674
            note('Branched %d revision(s).' % branch.revno())
 
675
        finally:
 
676
            br_from.unlock()
 
677
 
 
678
 
 
679
class cmd_checkout(Command):
 
680
    """Create a new checkout of an existing branch.
 
681
 
 
682
    If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
 
683
    the branch found in '.'. This is useful if you have removed the working tree
 
684
    or if it was never created - i.e. if you pushed the branch to its current
 
685
    location using SFTP.
 
686
    
 
687
    If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
 
688
    be used.  In other words, "checkout ../foo/bar" will attempt to create ./bar.
 
689
 
 
690
    To retrieve the branch as of a particular revision, supply the --revision
 
691
    parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
 
692
    out of date [so you cannot commit] but it may be useful (i.e. to examine old
 
693
    code.)
 
694
 
 
695
    --basis is to speed up checking out from remote branches.  When specified, it
 
696
    uses the inventory and file contents from the basis branch in preference to the
 
697
    branch being checked out.
 
698
    """
 
699
    takes_args = ['branch_location?', 'to_location?']
 
700
    takes_options = ['revision', # , 'basis']
 
701
                     Option('lightweight',
 
702
                            help="perform a lightweight checkout. Lightweight "
 
703
                                 "checkouts depend on access to the branch for "
 
704
                                 "every operation. Normal checkouts can perform "
 
705
                                 "common operations like diff and status without "
 
706
                                 "such access, and also support local commits."
 
707
                            ),
 
708
                     ]
 
709
    aliases = ['co']
 
710
 
 
711
    def run(self, branch_location=None, to_location=None, revision=None, basis=None,
 
712
            lightweight=False):
 
713
        if revision is None:
 
714
            revision = [None]
 
715
        elif len(revision) > 1:
 
716
            raise BzrCommandError(
 
717
                'bzr checkout --revision takes exactly 1 revision value')
 
718
        if branch_location is None:
 
719
            branch_location = osutils.getcwd()
 
720
            to_location = branch_location
 
721
        source = Branch.open(branch_location)
 
722
        if len(revision) == 1 and revision[0] is not None:
 
723
            revision_id = revision[0].in_history(source)[1]
 
724
        else:
 
725
            revision_id = None
 
726
        if to_location is None:
 
727
            to_location = os.path.basename(branch_location.rstrip("/\\"))
 
728
        # if the source and to_location are the same, 
 
729
        # and there is no working tree,
 
730
        # then reconstitute a branch
 
731
        if (osutils.abspath(to_location) == 
 
732
            osutils.abspath(branch_location)):
 
733
            try:
 
734
                source.bzrdir.open_workingtree()
 
735
            except errors.NoWorkingTree:
 
736
                source.bzrdir.create_workingtree()
 
737
                return
 
738
        try:
 
739
            os.mkdir(to_location)
 
740
        except OSError, e:
 
741
            if e.errno == errno.EEXIST:
 
742
                raise BzrCommandError('Target directory "%s" already'
 
743
                                      ' exists.' % to_location)
 
744
            if e.errno == errno.ENOENT:
 
745
                raise BzrCommandError('Parent of "%s" does not exist.' %
 
746
                                      to_location)
 
747
            else:
 
748
                raise
 
749
        old_format = bzrdir.BzrDirFormat.get_default_format()
 
750
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
 
751
        try:
 
752
            if lightweight:
 
753
                checkout = bzrdir.BzrDirMetaFormat1().initialize(to_location)
 
754
                branch.BranchReferenceFormat().initialize(checkout, source)
 
755
            else:
 
756
                checkout_branch =  bzrdir.BzrDir.create_branch_convenience(
 
757
                    to_location, force_new_tree=False)
 
758
                checkout = checkout_branch.bzrdir
 
759
                checkout_branch.bind(source)
 
760
                if revision_id is not None:
 
761
                    rh = checkout_branch.revision_history()
 
762
                    checkout_branch.set_revision_history(rh[:rh.index(revision_id) + 1])
 
763
            checkout.create_workingtree(revision_id)
 
764
        finally:
 
765
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
766
 
 
767
 
 
768
class cmd_renames(Command):
 
769
    """Show list of renamed files.
 
770
    """
 
771
    # TODO: Option to show renames between two historical versions.
 
772
 
 
773
    # TODO: Only show renames under dir, rather than in the whole branch.
 
774
    takes_args = ['dir?']
 
775
 
 
776
    @display_command
 
777
    def run(self, dir=u'.'):
 
778
        from bzrlib.tree import find_renames
 
779
        tree = WorkingTree.open_containing(dir)[0]
 
780
        old_inv = tree.basis_tree().inventory
 
781
        new_inv = tree.read_working_inventory()
 
782
        renames = list(find_renames(old_inv, new_inv))
 
783
        renames.sort()
 
784
        for old_name, new_name in renames:
 
785
            self.outf.write("%s => %s\n" % (old_name, new_name))
 
786
 
 
787
 
 
788
class cmd_update(Command):
 
789
    """Update a tree to have the latest code committed to its branch.
 
790
    
 
791
    This will perform a merge into the working tree, and may generate
 
792
    conflicts. If you have any local changes, you will still 
 
793
    need to commit them after the update for the update to be complete.
 
794
    
 
795
    If you want to discard your local changes, you can just do a 
 
796
    'bzr revert' instead of 'bzr commit' after the update.
 
797
    """
 
798
    takes_args = ['dir?']
 
799
 
 
800
    def run(self, dir='.'):
 
801
        tree = WorkingTree.open_containing(dir)[0]
 
802
        tree.lock_write()
 
803
        try:
 
804
            if tree.last_revision() == tree.branch.last_revision():
 
805
                # may be up to date, check master too.
 
806
                master = tree.branch.get_master_branch()
 
807
                if master is None or master.last_revision == tree.last_revision():
 
808
                    note("Tree is up to date.")
 
809
                    return
 
810
            conflicts = tree.update()
 
811
            note('Updated to revision %d.' %
 
812
                 (tree.branch.revision_id_to_revno(tree.last_revision()),))
 
813
            if conflicts != 0:
 
814
                return 1
 
815
            else:
 
816
                return 0
 
817
        finally:
 
818
            tree.unlock()
 
819
 
 
820
 
 
821
class cmd_info(Command):
 
822
    """Show information about a working tree, branch or repository.
 
823
 
 
824
    This command will show all known locations and formats associated to the
 
825
    tree, branch or repository.  Statistical information is included with
 
826
    each report.
 
827
 
 
828
    Branches and working trees will also report any missing revisions.
 
829
    """
 
830
    takes_args = ['location?']
 
831
    takes_options = ['verbose']
 
832
 
 
833
    @display_command
 
834
    def run(self, location=None, verbose=False):
 
835
        from bzrlib.info import show_bzrdir_info
 
836
        show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
 
837
                         verbose=verbose)
 
838
 
 
839
 
 
840
class cmd_remove(Command):
 
841
    """Make a file unversioned.
 
842
 
 
843
    This makes bzr stop tracking changes to a versioned file.  It does
 
844
    not delete the working copy.
 
845
 
 
846
    You can specify one or more files, and/or --new.  If you specify --new,
 
847
    only 'added' files will be removed.  If you specify both, then new files
 
848
    in the specified directories will be removed.  If the directories are
 
849
    also new, they will also be removed.
 
850
    """
 
851
    takes_args = ['file*']
 
852
    takes_options = ['verbose', Option('new', help='remove newly-added files')]
 
853
    aliases = ['rm']
 
854
    encoding_type = 'replace'
 
855
    
 
856
    def run(self, file_list, verbose=False, new=False):
 
857
        tree, file_list = tree_files(file_list)
 
858
        if new is False:
 
859
            if file_list is None:
 
860
                raise BzrCommandError('Specify one or more files to remove, or'
 
861
                                      ' use --new.')
 
862
        else:
 
863
            from bzrlib.delta import compare_trees
 
864
            added = [compare_trees(tree.basis_tree(), tree,
 
865
                                   specific_files=file_list).added]
 
866
            file_list = sorted([f[0] for f in added[0]], reverse=True)
 
867
            if len(file_list) == 0:
 
868
                raise BzrCommandError('No matching files.')
 
869
        tree.remove(file_list, verbose=verbose, to_file=self.outf)
 
870
 
 
871
 
 
872
class cmd_file_id(Command):
 
873
    """Print file_id of a particular file or directory.
 
874
 
 
875
    The file_id is assigned when the file is first added and remains the
 
876
    same through all revisions where the file exists, even when it is
 
877
    moved or renamed.
 
878
    """
 
879
 
 
880
    hidden = True
 
881
    takes_args = ['filename']
 
882
 
 
883
    @display_command
 
884
    def run(self, filename):
 
885
        tree, relpath = WorkingTree.open_containing(filename)
 
886
        i = tree.inventory.path2id(relpath)
 
887
        if i == None:
 
888
            raise BzrError("%r is not a versioned file" % filename)
 
889
        else:
 
890
            self.outf.write(i + '\n')
 
891
 
 
892
 
 
893
class cmd_file_path(Command):
 
894
    """Print path of file_ids to a file or directory.
 
895
 
 
896
    This prints one line for each directory down to the target,
 
897
    starting at the branch root.
 
898
    """
 
899
 
 
900
    hidden = True
 
901
    takes_args = ['filename']
 
902
 
 
903
    @display_command
 
904
    def run(self, filename):
 
905
        tree, relpath = WorkingTree.open_containing(filename)
 
906
        inv = tree.inventory
 
907
        fid = inv.path2id(relpath)
 
908
        if fid == None:
 
909
            raise BzrError("%r is not a versioned file" % filename)
 
910
        for fip in inv.get_idpath(fid):
 
911
            self.outf.write(fip + '\n')
 
912
 
 
913
 
 
914
class cmd_reconcile(Command):
 
915
    """Reconcile bzr metadata in a branch.
 
916
 
 
917
    This can correct data mismatches that may have been caused by
 
918
    previous ghost operations or bzr upgrades. You should only
 
919
    need to run this command if 'bzr check' or a bzr developer 
 
920
    advises you to run it.
 
921
 
 
922
    If a second branch is provided, cross-branch reconciliation is
 
923
    also attempted, which will check that data like the tree root
 
924
    id which was not present in very early bzr versions is represented
 
925
    correctly in both branches.
 
926
 
 
927
    At the same time it is run it may recompress data resulting in 
 
928
    a potential saving in disk space or performance gain.
 
929
 
 
930
    The branch *MUST* be on a listable system such as local disk or sftp.
 
931
    """
 
932
    takes_args = ['branch?']
 
933
 
 
934
    def run(self, branch="."):
 
935
        from bzrlib.reconcile import reconcile
 
936
        dir = bzrdir.BzrDir.open(branch)
 
937
        reconcile(dir)
 
938
 
 
939
 
 
940
class cmd_revision_history(Command):
 
941
    """Display the list of revision ids on a branch."""
 
942
    takes_args = ['location?']
 
943
 
 
944
    hidden = True
 
945
 
 
946
    @display_command
 
947
    def run(self, location="."):
 
948
        branch = Branch.open_containing(location)[0]
 
949
        for revid in branch.revision_history():
 
950
            self.outf.write(revid)
 
951
            self.outf.write('\n')
 
952
 
 
953
 
 
954
class cmd_ancestry(Command):
 
955
    """List all revisions merged into this branch."""
 
956
    takes_args = ['location?']
 
957
 
 
958
    hidden = True
 
959
 
 
960
    @display_command
 
961
    def run(self, location="."):
 
962
        try:
 
963
            wt = WorkingTree.open_containing(location)[0]
 
964
        except errors.NoWorkingTree:
 
965
            b = Branch.open(location)
 
966
            last_revision = b.last_revision()
 
967
        else:
 
968
            b = wt.branch
 
969
            last_revision = wt.last_revision()
 
970
 
 
971
        revision_ids = b.repository.get_ancestry(last_revision)
 
972
        assert revision_ids[0] == None
 
973
        revision_ids.pop(0)
 
974
        for revision_id in revision_ids:
 
975
            self.outf.write(revision_id + '\n')
 
976
 
 
977
 
 
978
class cmd_init(Command):
 
979
    """Make a directory into a versioned branch.
 
980
 
 
981
    Use this to create an empty branch, or before importing an
 
982
    existing project.
 
983
 
 
984
    If there is a repository in a parent directory of the location, then 
 
985
    the history of the branch will be stored in the repository.  Otherwise
 
986
    init creates a standalone branch which carries its own history in 
 
987
    .bzr.
 
988
 
 
989
    If there is already a branch at the location but it has no working tree,
 
990
    the tree can be populated with 'bzr checkout'.
 
991
 
 
992
    Recipe for importing a tree of files:
 
993
        cd ~/project
 
994
        bzr init
 
995
        bzr add .
 
996
        bzr status
 
997
        bzr commit -m 'imported project'
 
998
    """
 
999
    takes_args = ['location?']
 
1000
    takes_options = [
 
1001
                     Option('format', 
 
1002
                            help='Specify a format for this branch. Current'
 
1003
                                 ' formats are: default, knit, metaweave and'
 
1004
                                 ' weave. Default is knit; metaweave and'
 
1005
                                 ' weave are deprecated',
 
1006
                            type=get_format_type),
 
1007
                     ]
 
1008
    def run(self, location=None, format=None):
 
1009
        if format is None:
 
1010
            format = get_format_type('default')
 
1011
        if location is None:
 
1012
            location = u'.'
 
1013
        else:
 
1014
            # The path has to exist to initialize a
 
1015
            # branch inside of it.
 
1016
            # Just using os.mkdir, since I don't
 
1017
            # believe that we want to create a bunch of
 
1018
            # locations if the user supplies an extended path
 
1019
            if not os.path.exists(location):
 
1020
                os.mkdir(location)
 
1021
        try:
 
1022
            existing_bzrdir = bzrdir.BzrDir.open(location)
 
1023
        except NotBranchError:
 
1024
            # really a NotBzrDir error...
 
1025
            bzrdir.BzrDir.create_branch_convenience(location, format=format)
 
1026
        else:
 
1027
            if existing_bzrdir.has_branch():
 
1028
                if existing_bzrdir.has_workingtree():
 
1029
                    raise errors.AlreadyBranchError(location)
 
1030
                else:
 
1031
                    raise errors.BranchExistsWithoutWorkingTree(location)
 
1032
            else:
 
1033
                existing_bzrdir.create_branch()
 
1034
                existing_bzrdir.create_workingtree()
 
1035
 
 
1036
 
 
1037
class cmd_init_repository(Command):
 
1038
    """Create a shared repository to hold branches.
 
1039
 
 
1040
    New branches created under the repository directory will store their revisions
 
1041
    in the repository, not in the branch directory, if the branch format supports
 
1042
    shared storage.
 
1043
 
 
1044
    example:
 
1045
        bzr init-repo repo
 
1046
        bzr init repo/trunk
 
1047
        bzr checkout --lightweight repo/trunk trunk-checkout
 
1048
        cd trunk-checkout
 
1049
        (add files here)
 
1050
    """
 
1051
    takes_args = ["location"] 
 
1052
    takes_options = [Option('format', 
 
1053
                            help='Specify a format for this repository.'
 
1054
                                 ' Current formats are: default, knit,'
 
1055
                                 ' metaweave and weave. Default is knit;'
 
1056
                                 ' metaweave and weave are deprecated',
 
1057
                            type=get_format_type),
 
1058
                     Option('trees',
 
1059
                             help='Allows branches in repository to have'
 
1060
                             ' a working tree')]
 
1061
    aliases = ["init-repo"]
 
1062
    def run(self, location, format=None, trees=False):
 
1063
        from bzrlib.transport import get_transport
 
1064
        if format is None:
 
1065
            format = get_format_type('default')
 
1066
        transport = get_transport(location)
 
1067
        if not transport.has('.'):
 
1068
            transport.mkdir('')
 
1069
        newdir = format.initialize_on_transport(transport)
 
1070
        repo = newdir.create_repository(shared=True)
 
1071
        repo.set_make_working_trees(trees)
 
1072
 
 
1073
 
 
1074
class cmd_diff(Command):
 
1075
    """Show differences in working tree.
 
1076
    
 
1077
    If files are listed, only the changes in those files are listed.
 
1078
    Otherwise, all changes for the tree are listed.
 
1079
 
 
1080
    "bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
 
1081
    produces patches suitable for "patch -p1".
 
1082
 
 
1083
    examples:
 
1084
        bzr diff
 
1085
        bzr diff -r1
 
1086
        bzr diff -r1..2
 
1087
        bzr diff --diff-prefix old/:new/
 
1088
        bzr diff bzr.mine bzr.dev
 
1089
        bzr diff foo.c
 
1090
    """
 
1091
    # TODO: Option to use external diff command; could be GNU diff, wdiff,
 
1092
    #       or a graphical diff.
 
1093
 
 
1094
    # TODO: Python difflib is not exactly the same as unidiff; should
 
1095
    #       either fix it up or prefer to use an external diff.
 
1096
 
 
1097
    # TODO: Selected-file diff is inefficient and doesn't show you
 
1098
    #       deleted files.
 
1099
 
 
1100
    # TODO: This probably handles non-Unix newlines poorly.
 
1101
    
 
1102
    takes_args = ['file*']
 
1103
    takes_options = ['revision', 'diff-options', 'prefix']
 
1104
    aliases = ['di', 'dif']
 
1105
    encoding_type = 'exact'
 
1106
 
 
1107
    @display_command
 
1108
    def run(self, revision=None, file_list=None, diff_options=None,
 
1109
            prefix=None):
 
1110
        from bzrlib.diff import diff_cmd_helper, show_diff_trees
 
1111
 
 
1112
        if (prefix is None) or (prefix == '0'):
 
1113
            # diff -p0 format
 
1114
            old_label = ''
 
1115
            new_label = ''
 
1116
        elif prefix == '1':
 
1117
            old_label = 'old/'
 
1118
            new_label = 'new/'
 
1119
        else:
 
1120
            if not ':' in prefix:
 
1121
                 raise BzrError("--diff-prefix expects two values separated by a colon")
 
1122
            old_label, new_label = prefix.split(":")
 
1123
        
 
1124
        try:
 
1125
            tree1, file_list = internal_tree_files(file_list)
 
1126
            tree2 = None
 
1127
            b = None
 
1128
            b2 = None
 
1129
        except FileInWrongBranch:
 
1130
            if len(file_list) != 2:
 
1131
                raise BzrCommandError("Files are in different branches")
 
1132
 
 
1133
            tree1, file1 = WorkingTree.open_containing(file_list[0])
 
1134
            tree2, file2 = WorkingTree.open_containing(file_list[1])
 
1135
            if file1 != "" or file2 != "":
 
1136
                # FIXME diff those two files. rbc 20051123
 
1137
                raise BzrCommandError("Files are in different branches")
 
1138
            file_list = None
 
1139
        if revision is not None:
 
1140
            if tree2 is not None:
 
1141
                raise BzrCommandError("Can't specify -r with two branches")
 
1142
            if (len(revision) == 1) or (revision[1].spec is None):
 
1143
                return diff_cmd_helper(tree1, file_list, diff_options,
 
1144
                                       revision[0], 
 
1145
                                       old_label=old_label, new_label=new_label)
 
1146
            elif len(revision) == 2:
 
1147
                return diff_cmd_helper(tree1, file_list, diff_options,
 
1148
                                       revision[0], revision[1],
 
1149
                                       old_label=old_label, new_label=new_label)
 
1150
            else:
 
1151
                raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
 
1152
        else:
 
1153
            if tree2 is not None:
 
1154
                return show_diff_trees(tree1, tree2, sys.stdout, 
 
1155
                                       specific_files=file_list,
 
1156
                                       external_diff_options=diff_options,
 
1157
                                       old_label=old_label, new_label=new_label)
 
1158
            else:
 
1159
                return diff_cmd_helper(tree1, file_list, diff_options,
 
1160
                                       old_label=old_label, new_label=new_label)
 
1161
 
 
1162
 
 
1163
class cmd_deleted(Command):
 
1164
    """List files deleted in the working tree.
 
1165
    """
 
1166
    # TODO: Show files deleted since a previous revision, or
 
1167
    # between two revisions.
 
1168
    # TODO: Much more efficient way to do this: read in new
 
1169
    # directories with readdir, rather than stating each one.  Same
 
1170
    # level of effort but possibly much less IO.  (Or possibly not,
 
1171
    # if the directories are very large...)
 
1172
    takes_options = ['show-ids']
 
1173
 
 
1174
    @display_command
 
1175
    def run(self, show_ids=False):
 
1176
        tree = WorkingTree.open_containing(u'.')[0]
 
1177
        old = tree.basis_tree()
 
1178
        for path, ie in old.inventory.iter_entries():
 
1179
            if not tree.has_id(ie.file_id):
 
1180
                self.outf.write(path)
 
1181
                if show_ids:
 
1182
                    self.outf.write(' ')
 
1183
                    self.outf.write(ie.file_id)
 
1184
                self.outf.write('\n')
 
1185
 
 
1186
 
 
1187
class cmd_modified(Command):
 
1188
    """List files modified in working tree."""
 
1189
    hidden = True
 
1190
    @display_command
 
1191
    def run(self):
 
1192
        from bzrlib.delta import compare_trees
 
1193
 
 
1194
        tree = WorkingTree.open_containing(u'.')[0]
 
1195
        td = compare_trees(tree.basis_tree(), tree)
 
1196
 
 
1197
        for path, id, kind, text_modified, meta_modified in td.modified:
 
1198
            self.outf.write(path + '\n')
 
1199
 
 
1200
 
 
1201
class cmd_added(Command):
 
1202
    """List files added in working tree."""
 
1203
    hidden = True
 
1204
    @display_command
 
1205
    def run(self):
 
1206
        wt = WorkingTree.open_containing(u'.')[0]
 
1207
        basis_inv = wt.basis_tree().inventory
 
1208
        inv = wt.inventory
 
1209
        for file_id in inv:
 
1210
            if file_id in basis_inv:
 
1211
                continue
 
1212
            path = inv.id2path(file_id)
 
1213
            if not os.access(osutils.abspath(path), os.F_OK):
 
1214
                continue
 
1215
            self.outf.write(path + '\n')
 
1216
 
 
1217
 
 
1218
class cmd_root(Command):
 
1219
    """Show the tree root directory.
 
1220
 
 
1221
    The root is the nearest enclosing directory with a .bzr control
 
1222
    directory."""
 
1223
    takes_args = ['filename?']
 
1224
    @display_command
 
1225
    def run(self, filename=None):
 
1226
        """Print the branch root."""
 
1227
        tree = WorkingTree.open_containing(filename)[0]
 
1228
        self.outf.write(tree.basedir + '\n')
 
1229
 
 
1230
 
 
1231
class cmd_log(Command):
 
1232
    """Show log of a branch, file, or directory.
 
1233
 
 
1234
    By default show the log of the branch containing the working directory.
 
1235
 
 
1236
    To request a range of logs, you can use the command -r begin..end
 
1237
    -r revision requests a specific revision, -r ..end or -r begin.. are
 
1238
    also valid.
 
1239
 
 
1240
    examples:
 
1241
        bzr log
 
1242
        bzr log foo.c
 
1243
        bzr log -r -10.. http://server/branch
 
1244
    """
 
1245
 
 
1246
    # TODO: Make --revision support uuid: and hash: [future tag:] notation.
 
1247
 
 
1248
    takes_args = ['location?']
 
1249
    takes_options = [Option('forward', 
 
1250
                            help='show from oldest to newest'),
 
1251
                     'timezone', 
 
1252
                     Option('verbose', 
 
1253
                             help='show files changed in each revision'),
 
1254
                     'show-ids', 'revision',
 
1255
                     'log-format',
 
1256
                     'line', 'long', 
 
1257
                     Option('message',
 
1258
                            help='show revisions whose message matches this regexp',
 
1259
                            type=str),
 
1260
                     'short',
 
1261
                     ]
 
1262
    encoding_type = 'replace'
 
1263
 
 
1264
    @display_command
 
1265
    def run(self, location=None, timezone='original',
 
1266
            verbose=False,
 
1267
            show_ids=False,
 
1268
            forward=False,
 
1269
            revision=None,
 
1270
            log_format=None,
 
1271
            message=None,
 
1272
            long=False,
 
1273
            short=False,
 
1274
            line=False):
 
1275
        from bzrlib.log import log_formatter, show_log
 
1276
        assert message is None or isinstance(message, basestring), \
 
1277
            "invalid message argument %r" % message
 
1278
        direction = (forward and 'forward') or 'reverse'
 
1279
        
 
1280
        # log everything
 
1281
        file_id = None
 
1282
        if location:
 
1283
            # find the file id to log:
 
1284
 
 
1285
            dir, fp = bzrdir.BzrDir.open_containing(location)
 
1286
            b = dir.open_branch()
 
1287
            if fp != '':
 
1288
                try:
 
1289
                    # might be a tree:
 
1290
                    inv = dir.open_workingtree().inventory
 
1291
                except (errors.NotBranchError, errors.NotLocalUrl):
 
1292
                    # either no tree, or is remote.
 
1293
                    inv = b.basis_tree().inventory
 
1294
                file_id = inv.path2id(fp)
 
1295
        else:
 
1296
            # local dir only
 
1297
            # FIXME ? log the current subdir only RBC 20060203 
 
1298
            dir, relpath = bzrdir.BzrDir.open_containing('.')
 
1299
            b = dir.open_branch()
 
1300
 
 
1301
        if revision is None:
 
1302
            rev1 = None
 
1303
            rev2 = None
 
1304
        elif len(revision) == 1:
 
1305
            rev1 = rev2 = revision[0].in_history(b).revno
 
1306
        elif len(revision) == 2:
 
1307
            if revision[0].spec is None:
 
1308
                # missing begin-range means first revision
 
1309
                rev1 = 1
 
1310
            else:
 
1311
                rev1 = revision[0].in_history(b).revno
 
1312
 
 
1313
            if revision[1].spec is None:
 
1314
                # missing end-range means last known revision
 
1315
                rev2 = b.revno()
 
1316
            else:
 
1317
                rev2 = revision[1].in_history(b).revno
 
1318
        else:
 
1319
            raise BzrCommandError('bzr log --revision takes one or two values.')
 
1320
 
 
1321
        # By this point, the revision numbers are converted to the +ve
 
1322
        # form if they were supplied in the -ve form, so we can do
 
1323
        # this comparison in relative safety
 
1324
        if rev1 > rev2:
 
1325
            (rev2, rev1) = (rev1, rev2)
 
1326
 
 
1327
        if (log_format == None):
 
1328
            default = b.get_config().log_format()
 
1329
            log_format = get_log_format(long=long, short=short, line=line, 
 
1330
                                        default=default)
 
1331
        lf = log_formatter(log_format,
 
1332
                           show_ids=show_ids,
 
1333
                           to_file=self.outf,
 
1334
                           show_timezone=timezone)
 
1335
 
 
1336
        show_log(b,
 
1337
                 lf,
 
1338
                 file_id,
 
1339
                 verbose=verbose,
 
1340
                 direction=direction,
 
1341
                 start_revision=rev1,
 
1342
                 end_revision=rev2,
 
1343
                 search=message)
 
1344
 
 
1345
 
 
1346
def get_log_format(long=False, short=False, line=False, default='long'):
 
1347
    log_format = default
 
1348
    if long:
 
1349
        log_format = 'long'
 
1350
    if short:
 
1351
        log_format = 'short'
 
1352
    if line:
 
1353
        log_format = 'line'
 
1354
    return log_format
 
1355
 
 
1356
 
 
1357
class cmd_touching_revisions(Command):
 
1358
    """Return revision-ids which affected a particular file.
 
1359
 
 
1360
    A more user-friendly interface is "bzr log FILE".
 
1361
    """
 
1362
 
 
1363
    hidden = True
 
1364
    takes_args = ["filename"]
 
1365
 
 
1366
    @display_command
 
1367
    def run(self, filename):
 
1368
        tree, relpath = WorkingTree.open_containing(filename)
 
1369
        b = tree.branch
 
1370
        inv = tree.read_working_inventory()
 
1371
        file_id = inv.path2id(relpath)
 
1372
        for revno, revision_id, what in log.find_touching_revisions(b, file_id):
 
1373
            self.outf.write("%6d %s\n" % (revno, what))
 
1374
 
 
1375
 
 
1376
class cmd_ls(Command):
 
1377
    """List files in a tree.
 
1378
    """
 
1379
    # TODO: Take a revision or remote path and list that tree instead.
 
1380
    hidden = True
 
1381
    takes_options = ['verbose', 'revision',
 
1382
                     Option('non-recursive',
 
1383
                            help='don\'t recurse into sub-directories'),
 
1384
                     Option('from-root',
 
1385
                            help='Print all paths from the root of the branch.'),
 
1386
                     Option('unknown', help='Print unknown files'),
 
1387
                     Option('versioned', help='Print versioned files'),
 
1388
                     Option('ignored', help='Print ignored files'),
 
1389
 
 
1390
                     Option('null', help='Null separate the files'),
 
1391
                    ]
 
1392
    @display_command
 
1393
    def run(self, revision=None, verbose=False, 
 
1394
            non_recursive=False, from_root=False,
 
1395
            unknown=False, versioned=False, ignored=False,
 
1396
            null=False):
 
1397
 
 
1398
        if verbose and null:
 
1399
            raise BzrCommandError('Cannot set both --verbose and --null')
 
1400
        all = not (unknown or versioned or ignored)
 
1401
 
 
1402
        selection = {'I':ignored, '?':unknown, 'V':versioned}
 
1403
 
 
1404
        tree, relpath = WorkingTree.open_containing(u'.')
 
1405
        if from_root:
 
1406
            relpath = u''
 
1407
        elif relpath:
 
1408
            relpath += '/'
 
1409
        if revision is not None:
 
1410
            tree = tree.branch.repository.revision_tree(
 
1411
                revision[0].in_history(tree.branch).rev_id)
 
1412
 
 
1413
        for fp, fc, kind, fid, entry in tree.list_files():
 
1414
            if fp.startswith(relpath):
 
1415
                fp = fp[len(relpath):]
 
1416
                if non_recursive and '/' in fp:
 
1417
                    continue
 
1418
                if not all and not selection[fc]:
 
1419
                    continue
 
1420
                if verbose:
 
1421
                    kindch = entry.kind_character()
 
1422
                    self.outf.write('%-8s %s%s\n' % (fc, fp, kindch))
 
1423
                elif null:
 
1424
                    self.outf.write(fp + '\0')
 
1425
                    self.outf.flush()
 
1426
                else:
 
1427
                    self.outf.write(fp + '\n')
 
1428
 
 
1429
 
 
1430
class cmd_unknowns(Command):
 
1431
    """List unknown files."""
 
1432
    @display_command
 
1433
    def run(self):
 
1434
        for f in WorkingTree.open_containing(u'.')[0].unknowns():
 
1435
            self.outf.write(osutils.quotefn(f) + '\n')
 
1436
 
 
1437
 
 
1438
class cmd_ignore(Command):
 
1439
    """Ignore a command or pattern.
 
1440
 
 
1441
    To remove patterns from the ignore list, edit the .bzrignore file.
 
1442
 
 
1443
    If the pattern contains a slash, it is compared to the whole path
 
1444
    from the branch root.  Otherwise, it is compared to only the last
 
1445
    component of the path.  To match a file only in the root directory,
 
1446
    prepend './'.
 
1447
 
 
1448
    Ignore patterns are case-insensitive on case-insensitive systems.
 
1449
 
 
1450
    Note: wildcards must be quoted from the shell on Unix.
 
1451
 
 
1452
    examples:
 
1453
        bzr ignore ./Makefile
 
1454
        bzr ignore '*.class'
 
1455
    """
 
1456
    # TODO: Complain if the filename is absolute
 
1457
    takes_args = ['name_pattern']
 
1458
    
 
1459
    def run(self, name_pattern):
 
1460
        from bzrlib.atomicfile import AtomicFile
 
1461
        import os.path
 
1462
 
 
1463
        tree, relpath = WorkingTree.open_containing(u'.')
 
1464
        ifn = tree.abspath('.bzrignore')
 
1465
 
 
1466
        if os.path.exists(ifn):
 
1467
            f = open(ifn, 'rt')
 
1468
            try:
 
1469
                igns = f.read().decode('utf-8')
 
1470
            finally:
 
1471
                f.close()
 
1472
        else:
 
1473
            igns = ''
 
1474
 
 
1475
        # TODO: If the file already uses crlf-style termination, maybe
 
1476
        # we should use that for the newly added lines?
 
1477
 
 
1478
        if igns and igns[-1] != '\n':
 
1479
            igns += '\n'
 
1480
        igns += name_pattern + '\n'
 
1481
 
 
1482
        f = AtomicFile(ifn, 'wt')
 
1483
        try:
 
1484
            f.write(igns.encode('utf-8'))
 
1485
            f.commit()
 
1486
        finally:
 
1487
            f.close()
 
1488
 
 
1489
        inv = tree.inventory
 
1490
        if inv.path2id('.bzrignore'):
 
1491
            mutter('.bzrignore is already versioned')
 
1492
        else:
 
1493
            mutter('need to make new .bzrignore file versioned')
 
1494
            tree.add(['.bzrignore'])
 
1495
 
 
1496
 
 
1497
class cmd_ignored(Command):
 
1498
    """List ignored files and the patterns that matched them.
 
1499
 
 
1500
    See also: bzr ignore"""
 
1501
    @display_command
 
1502
    def run(self):
 
1503
        tree = WorkingTree.open_containing(u'.')[0]
 
1504
        for path, file_class, kind, file_id, entry in tree.list_files():
 
1505
            if file_class != 'I':
 
1506
                continue
 
1507
            ## XXX: Slightly inefficient since this was already calculated
 
1508
            pat = tree.is_ignored(path)
 
1509
            print '%-50s %s' % (path, pat)
 
1510
 
 
1511
 
 
1512
class cmd_lookup_revision(Command):
 
1513
    """Lookup the revision-id from a revision-number
 
1514
 
 
1515
    example:
 
1516
        bzr lookup-revision 33
 
1517
    """
 
1518
    hidden = True
 
1519
    takes_args = ['revno']
 
1520
    
 
1521
    @display_command
 
1522
    def run(self, revno):
 
1523
        try:
 
1524
            revno = int(revno)
 
1525
        except ValueError:
 
1526
            raise BzrCommandError("not a valid revision-number: %r" % revno)
 
1527
 
 
1528
        print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
 
1529
 
 
1530
 
 
1531
class cmd_export(Command):
 
1532
    """Export past revision to destination directory.
 
1533
 
 
1534
    If no revision is specified this exports the last committed revision.
 
1535
 
 
1536
    Format may be an "exporter" name, such as tar, tgz, tbz2.  If none is
 
1537
    given, try to find the format with the extension. If no extension
 
1538
    is found exports to a directory (equivalent to --format=dir).
 
1539
 
 
1540
    Root may be the top directory for tar, tgz and tbz2 formats. If none
 
1541
    is given, the top directory will be the root name of the file.
 
1542
 
 
1543
    Note: export of tree with non-ascii filenames to zip is not supported.
 
1544
 
 
1545
     Supported formats       Autodetected by extension
 
1546
     -----------------       -------------------------
 
1547
         dir                            -
 
1548
         tar                          .tar
 
1549
         tbz2                    .tar.bz2, .tbz2
 
1550
         tgz                      .tar.gz, .tgz
 
1551
         zip                          .zip
 
1552
    """
 
1553
    takes_args = ['dest']
 
1554
    takes_options = ['revision', 'format', 'root']
 
1555
    def run(self, dest, revision=None, format=None, root=None):
 
1556
        import os.path
 
1557
        from bzrlib.export import export
 
1558
        tree = WorkingTree.open_containing(u'.')[0]
 
1559
        b = tree.branch
 
1560
        if revision is None:
 
1561
            # should be tree.last_revision  FIXME
 
1562
            rev_id = b.last_revision()
 
1563
        else:
 
1564
            if len(revision) != 1:
 
1565
                raise BzrError('bzr export --revision takes exactly 1 argument')
 
1566
            rev_id = revision[0].in_history(b).rev_id
 
1567
        t = b.repository.revision_tree(rev_id)
 
1568
        try:
 
1569
            export(t, dest, format, root)
 
1570
        except errors.NoSuchExportFormat, e:
 
1571
            raise BzrCommandError('Unsupported export format: %s' % e.format)
 
1572
 
 
1573
 
 
1574
class cmd_cat(Command):
 
1575
    """Write a file's text from a previous revision."""
 
1576
 
 
1577
    takes_options = ['revision']
 
1578
    takes_args = ['filename']
 
1579
 
 
1580
    @display_command
 
1581
    def run(self, filename, revision=None):
 
1582
        if revision is not None and len(revision) != 1:
 
1583
            raise BzrCommandError("bzr cat --revision takes exactly one number")
 
1584
        tree = None
 
1585
        try:
 
1586
            tree, relpath = WorkingTree.open_containing(filename)
 
1587
            b = tree.branch
 
1588
        except NotBranchError:
 
1589
            pass
 
1590
 
 
1591
        if tree is None:
 
1592
            b, relpath = Branch.open_containing(filename)
 
1593
        if revision is None:
 
1594
            revision_id = b.last_revision()
 
1595
        else:
 
1596
            revision_id = revision[0].in_history(b).rev_id
 
1597
        b.print_file(relpath, revision_id)
 
1598
 
 
1599
 
 
1600
class cmd_local_time_offset(Command):
 
1601
    """Show the offset in seconds from GMT to local time."""
 
1602
    hidden = True    
 
1603
    @display_command
 
1604
    def run(self):
 
1605
        print osutils.local_time_offset()
 
1606
 
 
1607
 
 
1608
 
 
1609
class cmd_commit(Command):
 
1610
    """Commit changes into a new revision.
 
1611
    
 
1612
    If no arguments are given, the entire tree is committed.
 
1613
 
 
1614
    If selected files are specified, only changes to those files are
 
1615
    committed.  If a directory is specified then the directory and everything 
 
1616
    within it is committed.
 
1617
 
 
1618
    A selected-file commit may fail in some cases where the committed
 
1619
    tree would be invalid, such as trying to commit a file in a
 
1620
    newly-added directory that is not itself committed.
 
1621
    """
 
1622
    # TODO: Run hooks on tree to-be-committed, and after commit.
 
1623
 
 
1624
    # TODO: Strict commit that fails if there are deleted files.
 
1625
    #       (what does "deleted files" mean ??)
 
1626
 
 
1627
    # TODO: Give better message for -s, --summary, used by tla people
 
1628
 
 
1629
    # XXX: verbose currently does nothing
 
1630
 
 
1631
    takes_args = ['selected*']
 
1632
    takes_options = ['message', 'verbose', 
 
1633
                     Option('unchanged',
 
1634
                            help='commit even if nothing has changed'),
 
1635
                     Option('file', type=str, 
 
1636
                            argname='msgfile',
 
1637
                            help='file containing commit message'),
 
1638
                     Option('strict',
 
1639
                            help="refuse to commit if there are unknown "
 
1640
                            "files in the working tree."),
 
1641
                     Option('local',
 
1642
                            help="perform a local only commit in a bound "
 
1643
                                 "branch. Such commits are not pushed to "
 
1644
                                 "the master branch until a normal commit "
 
1645
                                 "is performed."
 
1646
                            ),
 
1647
                     ]
 
1648
    aliases = ['ci', 'checkin']
 
1649
 
 
1650
    def run(self, message=None, file=None, verbose=True, selected_list=None,
 
1651
            unchanged=False, strict=False, local=False):
 
1652
        from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
 
1653
        from bzrlib.errors import (PointlessCommit, ConflictsInTree,
 
1654
                StrictCommitFailed)
 
1655
        from bzrlib.msgeditor import edit_commit_message, \
 
1656
                make_commit_message_template
 
1657
        from tempfile import TemporaryFile
 
1658
 
 
1659
        # TODO: Need a blackbox test for invoking the external editor; may be
 
1660
        # slightly problematic to run this cross-platform.
 
1661
 
 
1662
        # TODO: do more checks that the commit will succeed before 
 
1663
        # spending the user's valuable time typing a commit message.
 
1664
        #
 
1665
        # TODO: if the commit *does* happen to fail, then save the commit 
 
1666
        # message to a temporary file where it can be recovered
 
1667
        tree, selected_list = tree_files(selected_list)
 
1668
        if selected_list == ['']:
 
1669
            # workaround - commit of root of tree should be exactly the same
 
1670
            # as just default commit in that tree, and succeed even though
 
1671
            # selected-file merge commit is not done yet
 
1672
            selected_list = []
 
1673
 
 
1674
        if local and not tree.branch.get_bound_location():
 
1675
            raise errors.LocalRequiresBoundBranch()
 
1676
        if message is None and not file:
 
1677
            template = make_commit_message_template(tree, selected_list)
 
1678
            message = edit_commit_message(template)
 
1679
            if message is None:
 
1680
                raise BzrCommandError("please specify a commit message"
 
1681
                                      " with either --message or --file")
 
1682
        elif message and file:
 
1683
            raise BzrCommandError("please specify either --message or --file")
 
1684
        
 
1685
        if file:
 
1686
            message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
 
1687
 
 
1688
        if message == "":
 
1689
            raise BzrCommandError("empty commit message specified")
 
1690
        
 
1691
        if verbose:
 
1692
            reporter = ReportCommitToLog()
 
1693
        else:
 
1694
            reporter = NullCommitReporter()
 
1695
        
 
1696
        try:
 
1697
            tree.commit(message, specific_files=selected_list,
 
1698
                        allow_pointless=unchanged, strict=strict, local=local,
 
1699
                        reporter=reporter)
 
1700
        except PointlessCommit:
 
1701
            # FIXME: This should really happen before the file is read in;
 
1702
            # perhaps prepare the commit; get the message; then actually commit
 
1703
            raise BzrCommandError("no changes to commit."
 
1704
                                  " use --unchanged to commit anyhow")
 
1705
        except ConflictsInTree:
 
1706
            raise BzrCommandError("Conflicts detected in working tree.  "
 
1707
                'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
 
1708
        except StrictCommitFailed:
 
1709
            raise BzrCommandError("Commit refused because there are unknown "
 
1710
                                  "files in the working tree.")
 
1711
        except errors.BoundBranchOutOfDate, e:
 
1712
            raise BzrCommandError(str(e)
 
1713
                                  + ' Either unbind, update, or'
 
1714
                                    ' pass --local to commit.')
 
1715
 
 
1716
 
 
1717
class cmd_check(Command):
 
1718
    """Validate consistency of branch history.
 
1719
 
 
1720
    This command checks various invariants about the branch storage to
 
1721
    detect data corruption or bzr bugs.
 
1722
    """
 
1723
    takes_args = ['branch?']
 
1724
    takes_options = ['verbose']
 
1725
 
 
1726
    def run(self, branch=None, verbose=False):
 
1727
        from bzrlib.check import check
 
1728
        if branch is None:
 
1729
            tree = WorkingTree.open_containing()[0]
 
1730
            branch = tree.branch
 
1731
        else:
 
1732
            branch = Branch.open(branch)
 
1733
        check(branch, verbose)
 
1734
 
 
1735
 
 
1736
class cmd_scan_cache(Command):
 
1737
    hidden = True
 
1738
    def run(self):
 
1739
        from bzrlib.hashcache import HashCache
 
1740
 
 
1741
        c = HashCache(u'.')
 
1742
        c.read()
 
1743
        c.scan()
 
1744
            
 
1745
        print '%6d stats' % c.stat_count
 
1746
        print '%6d in hashcache' % len(c._cache)
 
1747
        print '%6d files removed from cache' % c.removed_count
 
1748
        print '%6d hashes updated' % c.update_count
 
1749
        print '%6d files changed too recently to cache' % c.danger_count
 
1750
 
 
1751
        if c.needs_write:
 
1752
            c.write()
 
1753
 
 
1754
 
 
1755
class cmd_upgrade(Command):
 
1756
    """Upgrade branch storage to current format.
 
1757
 
 
1758
    The check command or bzr developers may sometimes advise you to run
 
1759
    this command. When the default format has changed you may also be warned
 
1760
    during other operations to upgrade.
 
1761
    """
 
1762
    takes_args = ['url?']
 
1763
    takes_options = [
 
1764
                     Option('format', 
 
1765
                            help='Upgrade to a specific format. Current formats'
 
1766
                                 ' are: default, knit, metaweave and weave.'
 
1767
                                 ' Default is knit; metaweave and weave are'
 
1768
                                 ' deprecated',
 
1769
                            type=get_format_type),
 
1770
                    ]
 
1771
 
 
1772
 
 
1773
    def run(self, url='.', format=None):
 
1774
        from bzrlib.upgrade import upgrade
 
1775
        if format is None:
 
1776
            format = get_format_type('default')
 
1777
        upgrade(url, format)
 
1778
 
 
1779
 
 
1780
class cmd_whoami(Command):
 
1781
    """Show bzr user id."""
 
1782
    takes_options = ['email']
 
1783
    
 
1784
    @display_command
 
1785
    def run(self, email=False):
 
1786
        try:
 
1787
            c = WorkingTree.open_containing(u'.')[0].branch.get_config()
 
1788
        except NotBranchError:
 
1789
            c = config.GlobalConfig()
 
1790
        if email:
 
1791
            print c.user_email()
 
1792
        else:
 
1793
            print c.username()
 
1794
 
 
1795
 
 
1796
class cmd_nick(Command):
 
1797
    """Print or set the branch nickname.  
 
1798
 
 
1799
    If unset, the tree root directory name is used as the nickname
 
1800
    To print the current nickname, execute with no argument.  
 
1801
    """
 
1802
    takes_args = ['nickname?']
 
1803
    def run(self, nickname=None):
 
1804
        branch = Branch.open_containing(u'.')[0]
 
1805
        if nickname is None:
 
1806
            self.printme(branch)
 
1807
        else:
 
1808
            branch.nick = nickname
 
1809
 
 
1810
    @display_command
 
1811
    def printme(self, branch):
 
1812
        print branch.nick 
 
1813
 
 
1814
 
 
1815
class cmd_selftest(Command):
 
1816
    """Run internal test suite.
 
1817
    
 
1818
    This creates temporary test directories in the working directory,
 
1819
    but not existing data is affected.  These directories are deleted
 
1820
    if the tests pass, or left behind to help in debugging if they
 
1821
    fail and --keep-output is specified.
 
1822
    
 
1823
    If arguments are given, they are regular expressions that say
 
1824
    which tests should run.
 
1825
 
 
1826
    If the global option '--no-plugins' is given, plugins are not loaded
 
1827
    before running the selftests.  This has two effects: features provided or
 
1828
    modified by plugins will not be tested, and tests provided by plugins will
 
1829
    not be run.
 
1830
 
 
1831
    examples:
 
1832
        bzr selftest ignore
 
1833
        bzr --no-plugins selftest -v
 
1834
    """
 
1835
    # TODO: --list should give a list of all available tests
 
1836
 
 
1837
    # NB: this is used from the class without creating an instance, which is
 
1838
    # why it does not have a self parameter.
 
1839
    def get_transport_type(typestring):
 
1840
        """Parse and return a transport specifier."""
 
1841
        if typestring == "sftp":
 
1842
            from bzrlib.transport.sftp import SFTPAbsoluteServer
 
1843
            return SFTPAbsoluteServer
 
1844
        if typestring == "memory":
 
1845
            from bzrlib.transport.memory import MemoryServer
 
1846
            return MemoryServer
 
1847
        if typestring == "fakenfs":
 
1848
            from bzrlib.transport.fakenfs import FakeNFSServer
 
1849
            return FakeNFSServer
 
1850
        msg = "No known transport type %s. Supported types are: sftp\n" %\
 
1851
            (typestring)
 
1852
        raise BzrCommandError(msg)
 
1853
 
 
1854
    hidden = True
 
1855
    takes_args = ['testspecs*']
 
1856
    takes_options = ['verbose',
 
1857
                     Option('one', help='stop when one test fails'),
 
1858
                     Option('keep-output', 
 
1859
                            help='keep output directories when tests fail'),
 
1860
                     Option('transport', 
 
1861
                            help='Use a different transport by default '
 
1862
                                 'throughout the test suite.',
 
1863
                            type=get_transport_type),
 
1864
                     Option('benchmark', help='run the bzr bencharks.'),
 
1865
                     Option('lsprof-timed',
 
1866
                            help='generate lsprof output for benchmarked'
 
1867
                                 ' sections of code.'),
 
1868
                     ]
 
1869
 
 
1870
    def run(self, testspecs_list=None, verbose=None, one=False,
 
1871
            keep_output=False, transport=None, benchmark=None,
 
1872
            lsprof_timed=None):
 
1873
        import bzrlib.ui
 
1874
        from bzrlib.tests import selftest
 
1875
        import bzrlib.benchmarks as benchmarks
 
1876
        # we don't want progress meters from the tests to go to the
 
1877
        # real output; and we don't want log messages cluttering up
 
1878
        # the real logs.
 
1879
        save_ui = ui.ui_factory
 
1880
        print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
 
1881
        print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
 
1882
        print
 
1883
        info('running tests...')
 
1884
        try:
 
1885
            ui.ui_factory = ui.SilentUIFactory()
 
1886
            if testspecs_list is not None:
 
1887
                pattern = '|'.join(testspecs_list)
 
1888
            else:
 
1889
                pattern = ".*"
 
1890
            if benchmark:
 
1891
                test_suite_factory = benchmarks.test_suite
 
1892
                if verbose is None:
 
1893
                    verbose = True
 
1894
            else:
 
1895
                test_suite_factory = None
 
1896
                if verbose is None:
 
1897
                    verbose = False
 
1898
            result = selftest(verbose=verbose, 
 
1899
                              pattern=pattern,
 
1900
                              stop_on_failure=one, 
 
1901
                              keep_output=keep_output,
 
1902
                              transport=transport,
 
1903
                              test_suite_factory=test_suite_factory,
 
1904
                              lsprof_timed=lsprof_timed)
 
1905
            if result:
 
1906
                info('tests passed')
 
1907
            else:
 
1908
                info('tests failed')
 
1909
            return int(not result)
 
1910
        finally:
 
1911
            ui.ui_factory = save_ui
 
1912
 
 
1913
 
 
1914
def _get_bzr_branch():
 
1915
    """If bzr is run from a branch, return Branch or None"""
 
1916
    from os.path import dirname
 
1917
    
 
1918
    try:
 
1919
        branch = Branch.open(dirname(osutils.abspath(dirname(__file__))))
 
1920
        return branch
 
1921
    except errors.BzrError:
 
1922
        return None
 
1923
    
 
1924
 
 
1925
def show_version():
 
1926
    import bzrlib
 
1927
    print "bzr (bazaar-ng) %s" % bzrlib.__version__
 
1928
    # is bzrlib itself in a branch?
 
1929
    branch = _get_bzr_branch()
 
1930
    if branch:
 
1931
        rh = branch.revision_history()
 
1932
        revno = len(rh)
 
1933
        print "  bzr checkout, revision %d" % (revno,)
 
1934
        print "  nick: %s" % (branch.nick,)
 
1935
        if rh:
 
1936
            print "  revid: %s" % (rh[-1],)
 
1937
    print "Using python interpreter:", sys.executable
 
1938
    import site
 
1939
    print "Using python standard library:", os.path.dirname(site.__file__)
 
1940
    print "Using bzrlib:",
 
1941
    if len(bzrlib.__path__) > 1:
 
1942
        # print repr, which is a good enough way of making it clear it's
 
1943
        # more than one element (eg ['/foo/bar', '/foo/bzr'])
 
1944
        print repr(bzrlib.__path__)
 
1945
    else:
 
1946
        print bzrlib.__path__[0]
 
1947
 
 
1948
    print
 
1949
    print bzrlib.__copyright__
 
1950
    print "http://bazaar-vcs.org/"
 
1951
    print
 
1952
    print "bzr comes with ABSOLUTELY NO WARRANTY.  bzr is free software, and"
 
1953
    print "you may use, modify and redistribute it under the terms of the GNU"
 
1954
    print "General Public License version 2 or later."
 
1955
 
 
1956
 
 
1957
class cmd_version(Command):
 
1958
    """Show version of bzr."""
 
1959
    @display_command
 
1960
    def run(self):
 
1961
        show_version()
 
1962
 
 
1963
class cmd_rocks(Command):
 
1964
    """Statement of optimism."""
 
1965
    hidden = True
 
1966
    @display_command
 
1967
    def run(self):
 
1968
        print "it sure does!"
 
1969
 
 
1970
 
 
1971
class cmd_find_merge_base(Command):
 
1972
    """Find and print a base revision for merging two branches.
 
1973
    """
 
1974
    # TODO: Options to specify revisions on either side, as if
 
1975
    #       merging only part of the history.
 
1976
    takes_args = ['branch', 'other']
 
1977
    hidden = True
 
1978
    
 
1979
    @display_command
 
1980
    def run(self, branch, other):
 
1981
        from bzrlib.revision import common_ancestor, MultipleRevisionSources
 
1982
        
 
1983
        branch1 = Branch.open_containing(branch)[0]
 
1984
        branch2 = Branch.open_containing(other)[0]
 
1985
 
 
1986
        history_1 = branch1.revision_history()
 
1987
        history_2 = branch2.revision_history()
 
1988
 
 
1989
        last1 = branch1.last_revision()
 
1990
        last2 = branch2.last_revision()
 
1991
 
 
1992
        source = MultipleRevisionSources(branch1.repository, 
 
1993
                                         branch2.repository)
 
1994
        
 
1995
        base_rev_id = common_ancestor(last1, last2, source)
 
1996
 
 
1997
        print 'merge base is revision %s' % base_rev_id
 
1998
 
 
1999
 
 
2000
class cmd_merge(Command):
 
2001
    """Perform a three-way merge.
 
2002
    
 
2003
    The branch is the branch you will merge from.  By default, it will merge
 
2004
    the latest revision.  If you specify a revision, that revision will be
 
2005
    merged.  If you specify two revisions, the first will be used as a BASE,
 
2006
    and the second one as OTHER.  Revision numbers are always relative to the
 
2007
    specified branch.
 
2008
 
 
2009
    By default, bzr will try to merge in all new work from the other
 
2010
    branch, automatically determining an appropriate base.  If this
 
2011
    fails, you may need to give an explicit base.
 
2012
    
 
2013
    Merge will do its best to combine the changes in two branches, but there
 
2014
    are some kinds of problems only a human can fix.  When it encounters those,
 
2015
    it will mark a conflict.  A conflict means that you need to fix something,
 
2016
    before you should commit.
 
2017
 
 
2018
    Use bzr resolve when you have fixed a problem.  See also bzr conflicts.
 
2019
 
 
2020
    If there is no default branch set, the first merge will set it. After
 
2021
    that, you can omit the branch to use the default.  To change the
 
2022
    default, use --remember. The value will only be saved if the remote
 
2023
    location can be accessed.
 
2024
 
 
2025
    Examples:
 
2026
 
 
2027
    To merge the latest revision from bzr.dev
 
2028
    bzr merge ../bzr.dev
 
2029
 
 
2030
    To merge changes up to and including revision 82 from bzr.dev
 
2031
    bzr merge -r 82 ../bzr.dev
 
2032
 
 
2033
    To merge the changes introduced by 82, without previous changes:
 
2034
    bzr merge -r 81..82 ../bzr.dev
 
2035
    
 
2036
    merge refuses to run if there are any uncommitted changes, unless
 
2037
    --force is given.
 
2038
 
 
2039
    The following merge types are available:
 
2040
    """
 
2041
    takes_args = ['branch?']
 
2042
    takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
 
2043
                     Option('show-base', help="Show base revision text in "
 
2044
                            "conflicts")]
 
2045
 
 
2046
    def help(self):
 
2047
        from merge import merge_type_help
 
2048
        from inspect import getdoc
 
2049
        return getdoc(self) + '\n' + merge_type_help() 
 
2050
 
 
2051
    def run(self, branch=None, revision=None, force=False, merge_type=None,
 
2052
            show_base=False, reprocess=False, remember=False):
 
2053
        if merge_type is None:
 
2054
            merge_type = Merge3Merger
 
2055
 
 
2056
        tree = WorkingTree.open_containing(u'.')[0]
 
2057
 
 
2058
        if branch is not None:
 
2059
            try:
 
2060
                reader = bundle.read_bundle_from_url(branch)
 
2061
            except NotABundle:
 
2062
                pass # Continue on considering this url a Branch
 
2063
            else:
 
2064
                conflicts = merge_bundle(reader, tree, not force, merge_type,
 
2065
                                            reprocess, show_base)
 
2066
                if conflicts == 0:
 
2067
                    return 0
 
2068
                else:
 
2069
                    return 1
 
2070
 
 
2071
        branch = self._get_remembered_parent(tree, branch, 'Merging from')
 
2072
 
 
2073
        if revision is None or len(revision) < 1:
 
2074
            base = [None, None]
 
2075
            other = [branch, -1]
 
2076
            other_branch, path = Branch.open_containing(branch)
 
2077
        else:
 
2078
            if len(revision) == 1:
 
2079
                base = [None, None]
 
2080
                other_branch, path = Branch.open_containing(branch)
 
2081
                revno = revision[0].in_history(other_branch).revno
 
2082
                other = [branch, revno]
 
2083
            else:
 
2084
                assert len(revision) == 2
 
2085
                if None in revision:
 
2086
                    raise BzrCommandError(
 
2087
                        "Merge doesn't permit that revision specifier.")
 
2088
                other_branch, path = Branch.open_containing(branch)
 
2089
 
 
2090
                base = [branch, revision[0].in_history(other_branch).revno]
 
2091
                other = [branch, revision[1].in_history(other_branch).revno]
 
2092
 
 
2093
        if tree.branch.get_parent() is None or remember:
 
2094
            tree.branch.set_parent(other_branch.base)
 
2095
 
 
2096
        if path != "":
 
2097
            interesting_files = [path]
 
2098
        else:
 
2099
            interesting_files = None
 
2100
        pb = ui.ui_factory.nested_progress_bar()
 
2101
        try:
 
2102
            try:
 
2103
                conflict_count = merge(other, base, check_clean=(not force),
 
2104
                                       merge_type=merge_type,
 
2105
                                       reprocess=reprocess,
 
2106
                                       show_base=show_base,
 
2107
                                       pb=pb, file_list=interesting_files)
 
2108
            finally:
 
2109
                pb.finished()
 
2110
            if conflict_count != 0:
 
2111
                return 1
 
2112
            else:
 
2113
                return 0
 
2114
        except errors.AmbiguousBase, e:
 
2115
            m = ("sorry, bzr can't determine the right merge base yet\n"
 
2116
                 "candidates are:\n  "
 
2117
                 + "\n  ".join(e.bases)
 
2118
                 + "\n"
 
2119
                 "please specify an explicit base with -r,\n"
 
2120
                 "and (if you want) report this to the bzr developers\n")
 
2121
            log_error(m)
 
2122
 
 
2123
    # TODO: move up to common parent; this isn't merge-specific anymore. 
 
2124
    def _get_remembered_parent(self, tree, supplied_location, verb_string):
 
2125
        """Use tree.branch's parent if none was supplied.
 
2126
 
 
2127
        Report if the remembered location was used.
 
2128
        """
 
2129
        if supplied_location is not None:
 
2130
            return supplied_location
 
2131
        stored_location = tree.branch.get_parent()
 
2132
        mutter("%s", stored_location)
 
2133
        if stored_location is None:
 
2134
            raise BzrCommandError("No location specified or remembered")
 
2135
        display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
 
2136
        self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
 
2137
        return stored_location
 
2138
 
 
2139
 
 
2140
class cmd_remerge(Command):
 
2141
    """Redo a merge.
 
2142
 
 
2143
    Use this if you want to try a different merge technique while resolving
 
2144
    conflicts.  Some merge techniques are better than others, and remerge 
 
2145
    lets you try different ones on different files.
 
2146
 
 
2147
    The options for remerge have the same meaning and defaults as the ones for
 
2148
    merge.  The difference is that remerge can (only) be run when there is a
 
2149
    pending merge, and it lets you specify particular files.
 
2150
 
 
2151
    Examples:
 
2152
    $ bzr remerge --show-base
 
2153
        Re-do the merge of all conflicted files, and show the base text in
 
2154
        conflict regions, in addition to the usual THIS and OTHER texts.
 
2155
 
 
2156
    $ bzr remerge --merge-type weave --reprocess foobar
 
2157
        Re-do the merge of "foobar", using the weave merge algorithm, with
 
2158
        additional processing to reduce the size of conflict regions.
 
2159
    
 
2160
    The following merge types are available:"""
 
2161
    takes_args = ['file*']
 
2162
    takes_options = ['merge-type', 'reprocess',
 
2163
                     Option('show-base', help="Show base revision text in "
 
2164
                            "conflicts")]
 
2165
 
 
2166
    def help(self):
 
2167
        from merge import merge_type_help
 
2168
        from inspect import getdoc
 
2169
        return getdoc(self) + '\n' + merge_type_help() 
 
2170
 
 
2171
    def run(self, file_list=None, merge_type=None, show_base=False,
 
2172
            reprocess=False):
 
2173
        from bzrlib.merge import merge_inner, transform_tree
 
2174
        if merge_type is None:
 
2175
            merge_type = Merge3Merger
 
2176
        tree, file_list = tree_files(file_list)
 
2177
        tree.lock_write()
 
2178
        try:
 
2179
            pending_merges = tree.pending_merges() 
 
2180
            if len(pending_merges) != 1:
 
2181
                raise BzrCommandError("Sorry, remerge only works after normal"
 
2182
                                      " merges.  Not cherrypicking or"
 
2183
                                      " multi-merges.")
 
2184
            repository = tree.branch.repository
 
2185
            base_revision = common_ancestor(tree.branch.last_revision(), 
 
2186
                                            pending_merges[0], repository)
 
2187
            base_tree = repository.revision_tree(base_revision)
 
2188
            other_tree = repository.revision_tree(pending_merges[0])
 
2189
            interesting_ids = None
 
2190
            new_conflicts = []
 
2191
            conflicts = tree.conflicts()
 
2192
            if file_list is not None:
 
2193
                interesting_ids = set()
 
2194
                for filename in file_list:
 
2195
                    file_id = tree.path2id(filename)
 
2196
                    if file_id is None:
 
2197
                        raise NotVersionedError(filename)
 
2198
                    interesting_ids.add(file_id)
 
2199
                    if tree.kind(file_id) != "directory":
 
2200
                        continue
 
2201
                    
 
2202
                    for name, ie in tree.inventory.iter_entries(file_id):
 
2203
                        interesting_ids.add(ie.file_id)
 
2204
                new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
 
2205
            transform_tree(tree, tree.basis_tree(), interesting_ids)
 
2206
            tree.set_conflicts(ConflictList(new_conflicts))
 
2207
            if file_list is None:
 
2208
                restore_files = list(tree.iter_conflicts())
 
2209
            else:
 
2210
                restore_files = file_list
 
2211
            for filename in restore_files:
 
2212
                try:
 
2213
                    restore(tree.abspath(filename))
 
2214
                except NotConflicted:
 
2215
                    pass
 
2216
            conflicts = merge_inner(tree.branch, other_tree, base_tree,
 
2217
                                    this_tree=tree,
 
2218
                                    interesting_ids=interesting_ids, 
 
2219
                                    other_rev_id=pending_merges[0], 
 
2220
                                    merge_type=merge_type, 
 
2221
                                    show_base=show_base,
 
2222
                                    reprocess=reprocess)
 
2223
        finally:
 
2224
            tree.unlock()
 
2225
        if conflicts > 0:
 
2226
            return 1
 
2227
        else:
 
2228
            return 0
 
2229
 
 
2230
class cmd_revert(Command):
 
2231
    """Reverse all changes since the last commit.
 
2232
 
 
2233
    Only versioned files are affected.  Specify filenames to revert only 
 
2234
    those files.  By default, any files that are changed will be backed up
 
2235
    first.  Backup files have a '~' appended to their name.
 
2236
    """
 
2237
    takes_options = ['revision', 'no-backup']
 
2238
    takes_args = ['file*']
 
2239
    aliases = ['merge-revert']
 
2240
 
 
2241
    def run(self, revision=None, no_backup=False, file_list=None):
 
2242
        from bzrlib.commands import parse_spec
 
2243
        if file_list is not None:
 
2244
            if len(file_list) == 0:
 
2245
                raise BzrCommandError("No files specified")
 
2246
        else:
 
2247
            file_list = []
 
2248
        
 
2249
        tree, file_list = tree_files(file_list)
 
2250
        if revision is None:
 
2251
            # FIXME should be tree.last_revision
 
2252
            rev_id = tree.last_revision()
 
2253
        elif len(revision) != 1:
 
2254
            raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
 
2255
        else:
 
2256
            rev_id = revision[0].in_history(tree.branch).rev_id
 
2257
        pb = ui.ui_factory.nested_progress_bar()
 
2258
        try:
 
2259
            tree.revert(file_list, 
 
2260
                        tree.branch.repository.revision_tree(rev_id),
 
2261
                        not no_backup, pb)
 
2262
        finally:
 
2263
            pb.finished()
 
2264
 
 
2265
 
 
2266
class cmd_assert_fail(Command):
 
2267
    """Test reporting of assertion failures"""
 
2268
    hidden = True
 
2269
    def run(self):
 
2270
        assert False, "always fails"
 
2271
 
 
2272
 
 
2273
class cmd_help(Command):
 
2274
    """Show help on a command or other topic.
 
2275
 
 
2276
    For a list of all available commands, say 'bzr help commands'."""
 
2277
    takes_options = [Option('long', 'show help on all commands')]
 
2278
    takes_args = ['topic?']
 
2279
    aliases = ['?', '--help', '-?', '-h']
 
2280
    
 
2281
    @display_command
 
2282
    def run(self, topic=None, long=False):
 
2283
        import help
 
2284
        if topic is None and long:
 
2285
            topic = "commands"
 
2286
        help.help(topic)
 
2287
 
 
2288
 
 
2289
class cmd_shell_complete(Command):
 
2290
    """Show appropriate completions for context.
 
2291
 
 
2292
    For a list of all available commands, say 'bzr shell-complete'."""
 
2293
    takes_args = ['context?']
 
2294
    aliases = ['s-c']
 
2295
    hidden = True
 
2296
    
 
2297
    @display_command
 
2298
    def run(self, context=None):
 
2299
        import shellcomplete
 
2300
        shellcomplete.shellcomplete(context)
 
2301
 
 
2302
 
 
2303
class cmd_fetch(Command):
 
2304
    """Copy in history from another branch but don't merge it.
 
2305
 
 
2306
    This is an internal method used for pull and merge."""
 
2307
    hidden = True
 
2308
    takes_args = ['from_branch', 'to_branch']
 
2309
    def run(self, from_branch, to_branch):
 
2310
        from bzrlib.fetch import Fetcher
 
2311
        from_b = Branch.open(from_branch)
 
2312
        to_b = Branch.open(to_branch)
 
2313
        Fetcher(to_b, from_b)
 
2314
 
 
2315
 
 
2316
class cmd_missing(Command):
 
2317
    """Show unmerged/unpulled revisions between two branches.
 
2318
 
 
2319
    OTHER_BRANCH may be local or remote."""
 
2320
    takes_args = ['other_branch?']
 
2321
    takes_options = [Option('reverse', 'Reverse the order of revisions'),
 
2322
                     Option('mine-only', 
 
2323
                            'Display changes in the local branch only'),
 
2324
                     Option('theirs-only', 
 
2325
                            'Display changes in the remote branch only'), 
 
2326
                     'log-format',
 
2327
                     'line',
 
2328
                     'long', 
 
2329
                     'short',
 
2330
                     'show-ids',
 
2331
                     'verbose'
 
2332
                     ]
 
2333
    encoding_type = 'replace'
 
2334
 
 
2335
    @display_command
 
2336
    def run(self, other_branch=None, reverse=False, mine_only=False,
 
2337
            theirs_only=False, log_format=None, long=False, short=False, line=False, 
 
2338
            show_ids=False, verbose=False):
 
2339
        from bzrlib.missing import find_unmerged, iter_log_data
 
2340
        from bzrlib.log import log_formatter
 
2341
        local_branch = Branch.open_containing(u".")[0]
 
2342
        parent = local_branch.get_parent()
 
2343
        if other_branch is None:
 
2344
            other_branch = parent
 
2345
            if other_branch is None:
 
2346
                raise BzrCommandError("No missing location known or specified.")
 
2347
            print "Using last location: " + local_branch.get_parent()
 
2348
        remote_branch = Branch.open(other_branch)
 
2349
        if remote_branch.base == local_branch.base:
 
2350
            remote_branch = local_branch
 
2351
        local_branch.lock_read()
 
2352
        try:
 
2353
            remote_branch.lock_read()
 
2354
            try:
 
2355
                local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
 
2356
                if (log_format == None):
 
2357
                    default = local_branch.get_config().log_format()
 
2358
                    log_format = get_log_format(long=long, short=short, 
 
2359
                                                line=line, default=default)
 
2360
                lf = log_formatter(log_format,
 
2361
                                   to_file=self.outf,
 
2362
                                   show_ids=show_ids,
 
2363
                                   show_timezone='original')
 
2364
                if reverse is False:
 
2365
                    local_extra.reverse()
 
2366
                    remote_extra.reverse()
 
2367
                if local_extra and not theirs_only:
 
2368
                    print "You have %d extra revision(s):" % len(local_extra)
 
2369
                    for data in iter_log_data(local_extra, local_branch.repository,
 
2370
                                              verbose):
 
2371
                        lf.show(*data)
 
2372
                    printed_local = True
 
2373
                else:
 
2374
                    printed_local = False
 
2375
                if remote_extra and not mine_only:
 
2376
                    if printed_local is True:
 
2377
                        print "\n\n"
 
2378
                    print "You are missing %d revision(s):" % len(remote_extra)
 
2379
                    for data in iter_log_data(remote_extra, remote_branch.repository, 
 
2380
                                              verbose):
 
2381
                        lf.show(*data)
 
2382
                if not remote_extra and not local_extra:
 
2383
                    status_code = 0
 
2384
                    print "Branches are up to date."
 
2385
                else:
 
2386
                    status_code = 1
 
2387
            finally:
 
2388
                remote_branch.unlock()
 
2389
        finally:
 
2390
            local_branch.unlock()
 
2391
        if not status_code and parent is None and other_branch is not None:
 
2392
            local_branch.lock_write()
 
2393
            try:
 
2394
                # handle race conditions - a parent might be set while we run.
 
2395
                if local_branch.get_parent() is None:
 
2396
                    local_branch.set_parent(remote_branch.base)
 
2397
            finally:
 
2398
                local_branch.unlock()
 
2399
        return status_code
 
2400
 
 
2401
 
 
2402
class cmd_plugins(Command):
 
2403
    """List plugins"""
 
2404
    hidden = True
 
2405
    @display_command
 
2406
    def run(self):
 
2407
        import bzrlib.plugin
 
2408
        from inspect import getdoc
 
2409
        for name, plugin in bzrlib.plugin.all_plugins().items():
 
2410
            if hasattr(plugin, '__path__'):
 
2411
                print plugin.__path__[0]
 
2412
            elif hasattr(plugin, '__file__'):
 
2413
                print plugin.__file__
 
2414
            else:
 
2415
                print `plugin`
 
2416
                
 
2417
            d = getdoc(plugin)
 
2418
            if d:
 
2419
                print '\t', d.split('\n')[0]
 
2420
 
 
2421
 
 
2422
class cmd_testament(Command):
 
2423
    """Show testament (signing-form) of a revision."""
 
2424
    takes_options = ['revision', 'long', 
 
2425
                     Option('strict', help='Produce a strict-format'
 
2426
                            ' testament')]
 
2427
    takes_args = ['branch?']
 
2428
    @display_command
 
2429
    def run(self, branch=u'.', revision=None, long=False, strict=False):
 
2430
        from bzrlib.testament import Testament, StrictTestament
 
2431
        if strict is True:
 
2432
            testament_class = StrictTestament
 
2433
        else:
 
2434
            testament_class = Testament
 
2435
        b = WorkingTree.open_containing(branch)[0].branch
 
2436
        b.lock_read()
 
2437
        try:
 
2438
            if revision is None:
 
2439
                rev_id = b.last_revision()
 
2440
            else:
 
2441
                rev_id = revision[0].in_history(b).rev_id
 
2442
            t = testament_class.from_revision(b.repository, rev_id)
 
2443
            if long:
 
2444
                sys.stdout.writelines(t.as_text_lines())
 
2445
            else:
 
2446
                sys.stdout.write(t.as_short_text())
 
2447
        finally:
 
2448
            b.unlock()
 
2449
 
 
2450
 
 
2451
class cmd_annotate(Command):
 
2452
    """Show the origin of each line in a file.
 
2453
 
 
2454
    This prints out the given file with an annotation on the left side
 
2455
    indicating which revision, author and date introduced the change.
 
2456
 
 
2457
    If the origin is the same for a run of consecutive lines, it is 
 
2458
    shown only at the top, unless the --all option is given.
 
2459
    """
 
2460
    # TODO: annotate directories; showing when each file was last changed
 
2461
    # TODO: if the working copy is modified, show annotations on that 
 
2462
    #       with new uncommitted lines marked
 
2463
    aliases = ['ann', 'blame', 'praise']
 
2464
    takes_args = ['filename']
 
2465
    takes_options = [Option('all', help='show annotations on all lines'),
 
2466
                     Option('long', help='show date in annotations'),
 
2467
                     'revision'
 
2468
                     ]
 
2469
 
 
2470
    @display_command
 
2471
    def run(self, filename, all=False, long=False, revision=None):
 
2472
        from bzrlib.annotate import annotate_file
 
2473
        tree, relpath = WorkingTree.open_containing(filename)
 
2474
        branch = tree.branch
 
2475
        branch.lock_read()
 
2476
        try:
 
2477
            if revision is None:
 
2478
                revision_id = branch.last_revision()
 
2479
            elif len(revision) != 1:
 
2480
                raise BzrCommandError('bzr annotate --revision takes exactly 1 argument')
 
2481
            else:
 
2482
                revision_id = revision[0].in_history(branch).rev_id
 
2483
            file_id = tree.inventory.path2id(relpath)
 
2484
            tree = branch.repository.revision_tree(revision_id)
 
2485
            file_version = tree.inventory[file_id].revision
 
2486
            annotate_file(branch, file_version, file_id, long, all, sys.stdout)
 
2487
        finally:
 
2488
            branch.unlock()
 
2489
 
 
2490
 
 
2491
class cmd_re_sign(Command):
 
2492
    """Create a digital signature for an existing revision."""
 
2493
    # TODO be able to replace existing ones.
 
2494
 
 
2495
    hidden = True # is this right ?
 
2496
    takes_args = ['revision_id*']
 
2497
    takes_options = ['revision']
 
2498
    
 
2499
    def run(self, revision_id_list=None, revision=None):
 
2500
        import bzrlib.gpg as gpg
 
2501
        if revision_id_list is not None and revision is not None:
 
2502
            raise BzrCommandError('You can only supply one of revision_id or --revision')
 
2503
        if revision_id_list is None and revision is None:
 
2504
            raise BzrCommandError('You must supply either --revision or a revision_id')
 
2505
        b = WorkingTree.open_containing(u'.')[0].branch
 
2506
        gpg_strategy = gpg.GPGStrategy(b.get_config())
 
2507
        if revision_id_list is not None:
 
2508
            for revision_id in revision_id_list:
 
2509
                b.repository.sign_revision(revision_id, gpg_strategy)
 
2510
        elif revision is not None:
 
2511
            if len(revision) == 1:
 
2512
                revno, rev_id = revision[0].in_history(b)
 
2513
                b.repository.sign_revision(rev_id, gpg_strategy)
 
2514
            elif len(revision) == 2:
 
2515
                # are they both on rh- if so we can walk between them
 
2516
                # might be nice to have a range helper for arbitrary
 
2517
                # revision paths. hmm.
 
2518
                from_revno, from_revid = revision[0].in_history(b)
 
2519
                to_revno, to_revid = revision[1].in_history(b)
 
2520
                if to_revid is None:
 
2521
                    to_revno = b.revno()
 
2522
                if from_revno is None or to_revno is None:
 
2523
                    raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
 
2524
                for revno in range(from_revno, to_revno + 1):
 
2525
                    b.repository.sign_revision(b.get_rev_id(revno), 
 
2526
                                               gpg_strategy)
 
2527
            else:
 
2528
                raise BzrCommandError('Please supply either one revision, or a range.')
 
2529
 
 
2530
 
 
2531
class cmd_bind(Command):
 
2532
    """Bind the current branch to a master branch.
 
2533
 
 
2534
    After binding, commits must succeed on the master branch
 
2535
    before they are executed on the local one.
 
2536
    """
 
2537
 
 
2538
    takes_args = ['location']
 
2539
    takes_options = []
 
2540
 
 
2541
    def run(self, location=None):
 
2542
        b, relpath = Branch.open_containing(u'.')
 
2543
        b_other = Branch.open(location)
 
2544
        try:
 
2545
            b.bind(b_other)
 
2546
        except DivergedBranches:
 
2547
            raise BzrCommandError('These branches have diverged.'
 
2548
                                  ' Try merging, and then bind again.')
 
2549
 
 
2550
 
 
2551
class cmd_unbind(Command):
 
2552
    """Unbind the current branch from its master branch.
 
2553
 
 
2554
    After unbinding, the local branch is considered independent.
 
2555
    All subsequent commits will be local.
 
2556
    """
 
2557
 
 
2558
    takes_args = []
 
2559
    takes_options = []
 
2560
 
 
2561
    def run(self):
 
2562
        b, relpath = Branch.open_containing(u'.')
 
2563
        if not b.unbind():
 
2564
            raise BzrCommandError('Local branch is not bound')
 
2565
 
 
2566
 
 
2567
class cmd_uncommit(Command):
 
2568
    """Remove the last committed revision.
 
2569
 
 
2570
    --verbose will print out what is being removed.
 
2571
    --dry-run will go through all the motions, but not actually
 
2572
    remove anything.
 
2573
    
 
2574
    In the future, uncommit will create a revision bundle, which can then
 
2575
    be re-applied.
 
2576
    """
 
2577
 
 
2578
    # TODO: jam 20060108 Add an option to allow uncommit to remove
 
2579
    # unreferenced information in 'branch-as-repository' branches.
 
2580
    # TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
 
2581
    # information in shared branches as well.
 
2582
    takes_options = ['verbose', 'revision',
 
2583
                    Option('dry-run', help='Don\'t actually make changes'),
 
2584
                    Option('force', help='Say yes to all questions.')]
 
2585
    takes_args = ['location?']
 
2586
    aliases = []
 
2587
 
 
2588
    def run(self, location=None, 
 
2589
            dry_run=False, verbose=False,
 
2590
            revision=None, force=False):
 
2591
        from bzrlib.log import log_formatter
 
2592
        import sys
 
2593
        from bzrlib.uncommit import uncommit
 
2594
 
 
2595
        if location is None:
 
2596
            location = u'.'
 
2597
        control, relpath = bzrdir.BzrDir.open_containing(location)
 
2598
        try:
 
2599
            tree = control.open_workingtree()
 
2600
            b = tree.branch
 
2601
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
2602
            tree = None
 
2603
            b = control.open_branch()
 
2604
 
 
2605
        if revision is None:
 
2606
            revno = b.revno()
 
2607
            rev_id = b.last_revision()
 
2608
        else:
 
2609
            revno, rev_id = revision[0].in_history(b)
 
2610
        if rev_id is None:
 
2611
            print 'No revisions to uncommit.'
 
2612
 
 
2613
        for r in range(revno, b.revno()+1):
 
2614
            rev_id = b.get_rev_id(r)
 
2615
            lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
 
2616
            lf.show(r, b.repository.get_revision(rev_id), None)
 
2617
 
 
2618
        if dry_run:
 
2619
            print 'Dry-run, pretending to remove the above revisions.'
 
2620
            if not force:
 
2621
                val = raw_input('Press <enter> to continue')
 
2622
        else:
 
2623
            print 'The above revision(s) will be removed.'
 
2624
            if not force:
 
2625
                val = raw_input('Are you sure [y/N]? ')
 
2626
                if val.lower() not in ('y', 'yes'):
 
2627
                    print 'Canceled'
 
2628
                    return 0
 
2629
 
 
2630
        uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
 
2631
                revno=revno)
 
2632
 
 
2633
 
 
2634
class cmd_break_lock(Command):
 
2635
    """Break a dead lock on a repository, branch or working directory.
 
2636
 
 
2637
    CAUTION: Locks should only be broken when you are sure that the process
 
2638
    holding the lock has been stopped.
 
2639
 
 
2640
    You can get information on what locks are open via the 'bzr info' command.
 
2641
    
 
2642
    example:
 
2643
        bzr break-lock
 
2644
    """
 
2645
    takes_args = ['location?']
 
2646
 
 
2647
    def run(self, location=None, show=False):
 
2648
        if location is None:
 
2649
            location = u'.'
 
2650
        control, relpath = bzrdir.BzrDir.open_containing(location)
 
2651
        try:
 
2652
            control.break_lock()
 
2653
        except NotImplementedError:
 
2654
            pass
 
2655
        
 
2656
 
 
2657
 
 
2658
# command-line interpretation helper for merge-related commands
 
2659
def merge(other_revision, base_revision,
 
2660
          check_clean=True, ignore_zero=False,
 
2661
          this_dir=None, backup_files=False, merge_type=Merge3Merger,
 
2662
          file_list=None, show_base=False, reprocess=False,
 
2663
          pb=DummyProgress()):
 
2664
    """Merge changes into a tree.
 
2665
 
 
2666
    base_revision
 
2667
        list(path, revno) Base for three-way merge.  
 
2668
        If [None, None] then a base will be automatically determined.
 
2669
    other_revision
 
2670
        list(path, revno) Other revision for three-way merge.
 
2671
    this_dir
 
2672
        Directory to merge changes into; '.' by default.
 
2673
    check_clean
 
2674
        If true, this_dir must have no uncommitted changes before the
 
2675
        merge begins.
 
2676
    ignore_zero - If true, suppress the "zero conflicts" message when 
 
2677
        there are no conflicts; should be set when doing something we expect
 
2678
        to complete perfectly.
 
2679
    file_list - If supplied, merge only changes to selected files.
 
2680
 
 
2681
    All available ancestors of other_revision and base_revision are
 
2682
    automatically pulled into the branch.
 
2683
 
 
2684
    The revno may be -1 to indicate the last revision on the branch, which is
 
2685
    the typical case.
 
2686
 
 
2687
    This function is intended for use from the command line; programmatic
 
2688
    clients might prefer to call merge.merge_inner(), which has less magic 
 
2689
    behavior.
 
2690
    """
 
2691
    from bzrlib.merge import Merger
 
2692
    if this_dir is None:
 
2693
        this_dir = u'.'
 
2694
    this_tree = WorkingTree.open_containing(this_dir)[0]
 
2695
    if show_base and not merge_type is Merge3Merger:
 
2696
        raise BzrCommandError("Show-base is not supported for this merge"
 
2697
                              " type. %s" % merge_type)
 
2698
    if reprocess and not merge_type.supports_reprocess:
 
2699
        raise BzrCommandError("Conflict reduction is not supported for merge"
 
2700
                              " type %s." % merge_type)
 
2701
    if reprocess and show_base:
 
2702
        raise BzrCommandError("Cannot do conflict reduction and show base.")
 
2703
    try:
 
2704
        merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
 
2705
        merger.pp = ProgressPhase("Merge phase", 5, pb)
 
2706
        merger.pp.next_phase()
 
2707
        merger.check_basis(check_clean)
 
2708
        merger.set_other(other_revision)
 
2709
        merger.pp.next_phase()
 
2710
        merger.set_base(base_revision)
 
2711
        if merger.base_rev_id == merger.other_rev_id:
 
2712
            note('Nothing to do.')
 
2713
            return 0
 
2714
        merger.backup_files = backup_files
 
2715
        merger.merge_type = merge_type 
 
2716
        merger.set_interesting_files(file_list)
 
2717
        merger.show_base = show_base 
 
2718
        merger.reprocess = reprocess
 
2719
        conflicts = merger.do_merge()
 
2720
        if file_list is None:
 
2721
            merger.set_pending()
 
2722
    finally:
 
2723
        pb.clear()
 
2724
    return conflicts
 
2725
 
 
2726
 
 
2727
# these get imported and then picked up by the scan for cmd_*
 
2728
# TODO: Some more consistent way to split command definitions across files;
 
2729
# we do need to load at least some information about them to know of 
 
2730
# aliases.  ideally we would avoid loading the implementation until the
 
2731
# details were needed.
 
2732
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
 
2733
from bzrlib.bundle.commands import cmd_bundle_revisions
 
2734
from bzrlib.sign_my_commits import cmd_sign_my_commits
 
2735
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
 
2736
        cmd_weave_plan_merge, cmd_weave_merge_text