/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

  • Committer: John Arbash Meinel
  • Date: 2006-06-19 14:40:19 UTC
  • mto: This revision was merged to the branch mainline in revision 1794.
  • Revision ID: john@arbash-meinel.com-20060619144019-873a4a8d252f7896
Refactor import stuff into separate functions. Update news

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