/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

[merge] bzr.dev 1821

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