/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: Robert Collins
  • Date: 2008-09-26 04:57:33 UTC
  • mto: This revision was merged to the branch mainline in revision 3741.
  • Revision ID: robertc@robertcollins.net-20080926045733-5m88mampn9ulch82
Fix name lookups for python iter_changes on dirstate.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/builtins.py
 
1
# Copyright (C) 2004, 2005, 2006, 2007, 2008 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
import os
 
20
from StringIO import StringIO
 
21
 
 
22
from bzrlib.lazy_import import lazy_import
 
23
lazy_import(globals(), """
 
24
import codecs
 
25
import sys
 
26
import time
 
27
 
 
28
import bzrlib
 
29
from bzrlib import (
 
30
    bugtracker,
 
31
    bundle,
 
32
    bzrdir,
 
33
    delta,
 
34
    config,
 
35
    errors,
 
36
    globbing,
 
37
    ignores,
 
38
    log,
 
39
    merge as _mod_merge,
 
40
    merge_directive,
 
41
    osutils,
 
42
    reconfigure,
 
43
    revision as _mod_revision,
 
44
    symbol_versioning,
 
45
    transport,
 
46
    tree as _mod_tree,
 
47
    ui,
 
48
    urlutils,
 
49
    )
 
50
from bzrlib.branch import Branch
 
51
from bzrlib.conflicts import ConflictList
 
52
from bzrlib.revisionspec import RevisionSpec
 
53
from bzrlib.smtp_connection import SMTPConnection
 
54
from bzrlib.workingtree import WorkingTree
 
55
""")
 
56
 
 
57
from bzrlib.commands import Command, display_command
 
58
from bzrlib.option import ListOption, Option, RegistryOption, custom_help
 
59
from bzrlib.trace import mutter, note, warning, is_quiet, info
 
60
 
 
61
 
 
62
def tree_files(file_list, default_branch=u'.'):
 
63
    try:
 
64
        return internal_tree_files(file_list, default_branch)
 
65
    except errors.FileInWrongBranch, e:
 
66
        raise errors.BzrCommandError("%s is not in the same branch as %s" %
 
67
                                     (e.path, file_list[0]))
 
68
 
 
69
 
 
70
def _get_one_revision_tree(command_name, revisions, branch=None, tree=None):
 
71
    if branch is None:
 
72
        branch = tree.branch
 
73
    if revisions is None:
 
74
        if tree is not None:
 
75
            rev_tree = tree.basis_tree()
 
76
        else:
 
77
            rev_tree = branch.basis_tree()
 
78
    else:
 
79
        if len(revisions) != 1:
 
80
            raise errors.BzrCommandError(
 
81
                'bzr %s --revision takes exactly one revision identifier' % (
 
82
                    command_name,))
 
83
        rev_tree = revisions[0].as_tree(branch)
 
84
    return rev_tree
 
85
 
 
86
 
 
87
# XXX: Bad function name; should possibly also be a class method of
 
88
# WorkingTree rather than a function.
 
89
def internal_tree_files(file_list, default_branch=u'.'):
 
90
    """Convert command-line paths to a WorkingTree and relative paths.
 
91
 
 
92
    This is typically used for command-line processors that take one or
 
93
    more filenames, and infer the workingtree that contains them.
 
94
 
 
95
    The filenames given are not required to exist.
 
96
 
 
97
    :param file_list: Filenames to convert.  
 
98
 
 
99
    :param default_branch: Fallback tree path to use if file_list is empty or
 
100
        None.
 
101
 
 
102
    :return: workingtree, [relative_paths]
 
103
    """
 
104
    if file_list is None or len(file_list) == 0:
 
105
        return WorkingTree.open_containing(default_branch)[0], file_list
 
106
    tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
 
107
    return tree, safe_relpath_files(tree, file_list)
 
108
 
 
109
 
 
110
def safe_relpath_files(tree, file_list):
 
111
    """Convert file_list into a list of relpaths in tree.
 
112
 
 
113
    :param tree: A tree to operate on.
 
114
    :param file_list: A list of user provided paths or None.
 
115
    :return: A list of relative paths.
 
116
    :raises errors.PathNotChild: When a provided path is in a different tree
 
117
        than tree.
 
118
    """
 
119
    if file_list is None:
 
120
        return None
 
121
    new_list = []
 
122
    for filename in file_list:
 
123
        try:
 
124
            new_list.append(tree.relpath(osutils.dereference_path(filename)))
 
125
        except errors.PathNotChild:
 
126
            raise errors.FileInWrongBranch(tree.branch, filename)
 
127
    return new_list
 
128
 
 
129
 
 
130
# TODO: Make sure no commands unconditionally use the working directory as a
 
131
# branch.  If a filename argument is used, the first of them should be used to
 
132
# specify the branch.  (Perhaps this can be factored out into some kind of
 
133
# Argument class, representing a file in a branch, where the first occurrence
 
134
# opens the branch?)
 
135
 
 
136
class cmd_status(Command):
 
137
    """Display status summary.
 
138
 
 
139
    This reports on versioned and unknown files, reporting them
 
140
    grouped by state.  Possible states are:
 
141
 
 
142
    added
 
143
        Versioned in the working copy but not in the previous revision.
 
144
 
 
145
    removed
 
146
        Versioned in the previous revision but removed or deleted
 
147
        in the working copy.
 
148
 
 
149
    renamed
 
150
        Path of this file changed from the previous revision;
 
151
        the text may also have changed.  This includes files whose
 
152
        parent directory was renamed.
 
153
 
 
154
    modified
 
155
        Text has changed since the previous revision.
 
156
 
 
157
    kind changed
 
158
        File kind has been changed (e.g. from file to directory).
 
159
 
 
160
    unknown
 
161
        Not versioned and not matching an ignore pattern.
 
162
 
 
163
    To see ignored files use 'bzr ignored'.  For details on the
 
164
    changes to file texts, use 'bzr diff'.
 
165
    
 
166
    Note that --short or -S gives status flags for each item, similar
 
167
    to Subversion's status command. To get output similar to svn -q,
 
168
    use bzr status -SV.
 
169
 
 
170
    If no arguments are specified, the status of the entire working
 
171
    directory is shown.  Otherwise, only the status of the specified
 
172
    files or directories is reported.  If a directory is given, status
 
173
    is reported for everything inside that directory.
 
174
 
 
175
    If a revision argument is given, the status is calculated against
 
176
    that revision, or between two revisions if two are provided.
 
177
    """
 
178
    
 
179
    # TODO: --no-recurse, --recurse options
 
180
    
 
181
    takes_args = ['file*']
 
182
    takes_options = ['show-ids', 'revision', 'change',
 
183
                     Option('short', help='Use short status indicators.',
 
184
                            short_name='S'),
 
185
                     Option('versioned', help='Only show versioned files.',
 
186
                            short_name='V'),
 
187
                     Option('no-pending', help='Don\'t show pending merges.',
 
188
                           ),
 
189
                     ]
 
190
    aliases = ['st', 'stat']
 
191
 
 
192
    encoding_type = 'replace'
 
193
    _see_also = ['diff', 'revert', 'status-flags']
 
194
    
 
195
    @display_command
 
196
    def run(self, show_ids=False, file_list=None, revision=None, short=False,
 
197
            versioned=False, no_pending=False):
 
198
        from bzrlib.status import show_tree_status
 
199
 
 
200
        if revision and len(revision) > 2:
 
201
            raise errors.BzrCommandError('bzr status --revision takes exactly'
 
202
                                         ' one or two revision specifiers')
 
203
 
 
204
        tree, relfile_list = tree_files(file_list)
 
205
        # Avoid asking for specific files when that is not needed.
 
206
        if relfile_list == ['']:
 
207
            relfile_list = None
 
208
            # Don't disable pending merges for full trees other than '.'.
 
209
            if file_list == ['.']:
 
210
                no_pending = True
 
211
        # A specific path within a tree was given.
 
212
        elif relfile_list is not None:
 
213
            no_pending = True
 
214
        show_tree_status(tree, show_ids=show_ids,
 
215
                         specific_files=relfile_list, revision=revision,
 
216
                         to_file=self.outf, short=short, versioned=versioned,
 
217
                         show_pending=(not no_pending))
 
218
 
 
219
 
 
220
class cmd_cat_revision(Command):
 
221
    """Write out metadata for a revision.
 
222
    
 
223
    The revision to print can either be specified by a specific
 
224
    revision identifier, or you can use --revision.
 
225
    """
 
226
 
 
227
    hidden = True
 
228
    takes_args = ['revision_id?']
 
229
    takes_options = ['revision']
 
230
    # cat-revision is more for frontends so should be exact
 
231
    encoding = 'strict'
 
232
    
 
233
    @display_command
 
234
    def run(self, revision_id=None, revision=None):
 
235
        if revision_id is not None and revision is not None:
 
236
            raise errors.BzrCommandError('You can only supply one of'
 
237
                                         ' revision_id or --revision')
 
238
        if revision_id is None and revision is None:
 
239
            raise errors.BzrCommandError('You must supply either'
 
240
                                         ' --revision or a revision_id')
 
241
        b = WorkingTree.open_containing(u'.')[0].branch
 
242
 
 
243
        # TODO: jam 20060112 should cat-revision always output utf-8?
 
244
        if revision_id is not None:
 
245
            revision_id = osutils.safe_revision_id(revision_id, warn=False)
 
246
            try:
 
247
                self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
 
248
            except errors.NoSuchRevision:
 
249
                msg = "The repository %s contains no revision %s." % (b.repository.base,
 
250
                    revision_id)
 
251
                raise errors.BzrCommandError(msg)
 
252
        elif revision is not None:
 
253
            for rev in revision:
 
254
                if rev is None:
 
255
                    raise errors.BzrCommandError('You cannot specify a NULL'
 
256
                                                 ' revision.')
 
257
                rev_id = rev.as_revision_id(b)
 
258
                self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
 
259
    
 
260
 
 
261
class cmd_remove_tree(Command):
 
262
    """Remove the working tree from a given branch/checkout.
 
263
 
 
264
    Since a lightweight checkout is little more than a working tree
 
265
    this will refuse to run against one.
 
266
 
 
267
    To re-create the working tree, use "bzr checkout".
 
268
    """
 
269
    _see_also = ['checkout', 'working-trees']
 
270
    takes_args = ['location?']
 
271
    takes_options = [
 
272
        Option('force',
 
273
               help='Remove the working tree even if it has '
 
274
                    'uncommitted changes.'),
 
275
        ]
 
276
 
 
277
    def run(self, location='.', force=False):
 
278
        d = bzrdir.BzrDir.open(location)
 
279
        
 
280
        try:
 
281
            working = d.open_workingtree()
 
282
        except errors.NoWorkingTree:
 
283
            raise errors.BzrCommandError("No working tree to remove")
 
284
        except errors.NotLocalUrl:
 
285
            raise errors.BzrCommandError("You cannot remove the working tree of a "
 
286
                                         "remote path")
 
287
        if not force:
 
288
            changes = working.changes_from(working.basis_tree())
 
289
            if changes.has_changed():
 
290
                raise errors.UncommittedChanges(working)
 
291
 
 
292
        working_path = working.bzrdir.root_transport.base
 
293
        branch_path = working.branch.bzrdir.root_transport.base
 
294
        if working_path != branch_path:
 
295
            raise errors.BzrCommandError("You cannot remove the working tree from "
 
296
                                         "a lightweight checkout")
 
297
        
 
298
        d.destroy_workingtree()
 
299
        
 
300
 
 
301
class cmd_revno(Command):
 
302
    """Show current revision number.
 
303
 
 
304
    This is equal to the number of revisions on this branch.
 
305
    """
 
306
 
 
307
    _see_also = ['info']
 
308
    takes_args = ['location?']
 
309
 
 
310
    @display_command
 
311
    def run(self, location=u'.'):
 
312
        self.outf.write(str(Branch.open_containing(location)[0].revno()))
 
313
        self.outf.write('\n')
 
314
 
 
315
 
 
316
class cmd_revision_info(Command):
 
317
    """Show revision number and revision id for a given revision identifier.
 
318
    """
 
319
    hidden = True
 
320
    takes_args = ['revision_info*']
 
321
    takes_options = ['revision']
 
322
 
 
323
    @display_command
 
324
    def run(self, revision=None, revision_info_list=[]):
 
325
 
 
326
        revs = []
 
327
        if revision is not None:
 
328
            revs.extend(revision)
 
329
        if revision_info_list is not None:
 
330
            for rev in revision_info_list:
 
331
                revs.append(RevisionSpec.from_string(rev))
 
332
 
 
333
        b = Branch.open_containing(u'.')[0]
 
334
 
 
335
        if len(revs) == 0:
 
336
            revs.append(RevisionSpec.from_string('-1'))
 
337
 
 
338
        for rev in revs:
 
339
            revision_id = rev.as_revision_id(b)
 
340
            try:
 
341
                revno = '%4d' % (b.revision_id_to_revno(revision_id))
 
342
            except errors.NoSuchRevision:
 
343
                dotted_map = b.get_revision_id_to_revno_map()
 
344
                revno = '.'.join(str(i) for i in dotted_map[revision_id])
 
345
            print '%s %s' % (revno, revision_id)
 
346
 
 
347
    
 
348
class cmd_add(Command):
 
349
    """Add specified files or directories.
 
350
 
 
351
    In non-recursive mode, all the named items are added, regardless
 
352
    of whether they were previously ignored.  A warning is given if
 
353
    any of the named files are already versioned.
 
354
 
 
355
    In recursive mode (the default), files are treated the same way
 
356
    but the behaviour for directories is different.  Directories that
 
357
    are already versioned do not give a warning.  All directories,
 
358
    whether already versioned or not, are searched for files or
 
359
    subdirectories that are neither versioned or ignored, and these
 
360
    are added.  This search proceeds recursively into versioned
 
361
    directories.  If no names are given '.' is assumed.
 
362
 
 
363
    Therefore simply saying 'bzr add' will version all files that
 
364
    are currently unknown.
 
365
 
 
366
    Adding a file whose parent directory is not versioned will
 
367
    implicitly add the parent, and so on up to the root. This means
 
368
    you should never need to explicitly add a directory, they'll just
 
369
    get added when you add a file in the directory.
 
370
 
 
371
    --dry-run will show which files would be added, but not actually 
 
372
    add them.
 
373
 
 
374
    --file-ids-from will try to use the file ids from the supplied path.
 
375
    It looks up ids trying to find a matching parent directory with the
 
376
    same filename, and then by pure path. This option is rarely needed
 
377
    but can be useful when adding the same logical file into two
 
378
    branches that will be merged later (without showing the two different
 
379
    adds as a conflict). It is also useful when merging another project
 
380
    into a subdirectory of this one.
 
381
    """
 
382
    takes_args = ['file*']
 
383
    takes_options = [
 
384
        Option('no-recurse',
 
385
               help="Don't recursively add the contents of directories."),
 
386
        Option('dry-run',
 
387
               help="Show what would be done, but don't actually do anything."),
 
388
        'verbose',
 
389
        Option('file-ids-from',
 
390
               type=unicode,
 
391
               help='Lookup file ids from this tree.'),
 
392
        ]
 
393
    encoding_type = 'replace'
 
394
    _see_also = ['remove']
 
395
 
 
396
    def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
 
397
            file_ids_from=None):
 
398
        import bzrlib.add
 
399
 
 
400
        base_tree = None
 
401
        if file_ids_from is not None:
 
402
            try:
 
403
                base_tree, base_path = WorkingTree.open_containing(
 
404
                                            file_ids_from)
 
405
            except errors.NoWorkingTree:
 
406
                base_branch, base_path = Branch.open_containing(
 
407
                                            file_ids_from)
 
408
                base_tree = base_branch.basis_tree()
 
409
 
 
410
            action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
 
411
                          to_file=self.outf, should_print=(not is_quiet()))
 
412
        else:
 
413
            action = bzrlib.add.AddAction(to_file=self.outf,
 
414
                should_print=(not is_quiet()))
 
415
 
 
416
        if base_tree:
 
417
            base_tree.lock_read()
 
418
        try:
 
419
            file_list = self._maybe_expand_globs(file_list)
 
420
            if file_list:
 
421
                tree = WorkingTree.open_containing(file_list[0])[0]
 
422
            else:
 
423
                tree = WorkingTree.open_containing(u'.')[0]
 
424
            added, ignored = tree.smart_add(file_list, not
 
425
                no_recurse, action=action, save=not dry_run)
 
426
        finally:
 
427
            if base_tree is not None:
 
428
                base_tree.unlock()
 
429
        if len(ignored) > 0:
 
430
            if verbose:
 
431
                for glob in sorted(ignored.keys()):
 
432
                    for path in ignored[glob]:
 
433
                        self.outf.write("ignored %s matching \"%s\"\n" 
 
434
                                        % (path, glob))
 
435
            else:
 
436
                match_len = 0
 
437
                for glob, paths in ignored.items():
 
438
                    match_len += len(paths)
 
439
                self.outf.write("ignored %d file(s).\n" % match_len)
 
440
            self.outf.write("If you wish to add some of these files,"
 
441
                            " please add them by name.\n")
 
442
 
 
443
 
 
444
class cmd_mkdir(Command):
 
445
    """Create a new versioned directory.
 
446
 
 
447
    This is equivalent to creating the directory and then adding it.
 
448
    """
 
449
 
 
450
    takes_args = ['dir+']
 
451
    encoding_type = 'replace'
 
452
 
 
453
    def run(self, dir_list):
 
454
        for d in dir_list:
 
455
            os.mkdir(d)
 
456
            wt, dd = WorkingTree.open_containing(d)
 
457
            wt.add([dd])
 
458
            self.outf.write('added %s\n' % d)
 
459
 
 
460
 
 
461
class cmd_relpath(Command):
 
462
    """Show path of a file relative to root"""
 
463
 
 
464
    takes_args = ['filename']
 
465
    hidden = True
 
466
    
 
467
    @display_command
 
468
    def run(self, filename):
 
469
        # TODO: jam 20050106 Can relpath return a munged path if
 
470
        #       sys.stdout encoding cannot represent it?
 
471
        tree, relpath = WorkingTree.open_containing(filename)
 
472
        self.outf.write(relpath)
 
473
        self.outf.write('\n')
 
474
 
 
475
 
 
476
class cmd_inventory(Command):
 
477
    """Show inventory of the current working copy or a revision.
 
478
 
 
479
    It is possible to limit the output to a particular entry
 
480
    type using the --kind option.  For example: --kind file.
 
481
 
 
482
    It is also possible to restrict the list of files to a specific
 
483
    set. For example: bzr inventory --show-ids this/file
 
484
    """
 
485
 
 
486
    hidden = True
 
487
    _see_also = ['ls']
 
488
    takes_options = [
 
489
        'revision',
 
490
        'show-ids',
 
491
        Option('kind',
 
492
               help='List entries of a particular kind: file, directory, symlink.',
 
493
               type=unicode),
 
494
        ]
 
495
    takes_args = ['file*']
 
496
 
 
497
    @display_command
 
498
    def run(self, revision=None, show_ids=False, kind=None, file_list=None):
 
499
        if kind and kind not in ['file', 'directory', 'symlink']:
 
500
            raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
 
501
 
 
502
        work_tree, file_list = tree_files(file_list)
 
503
        work_tree.lock_read()
 
504
        try:
 
505
            if revision is not None:
 
506
                if len(revision) > 1:
 
507
                    raise errors.BzrCommandError(
 
508
                        'bzr inventory --revision takes exactly one revision'
 
509
                        ' identifier')
 
510
                tree = revision[0].as_tree(work_tree.branch)
 
511
 
 
512
                extra_trees = [work_tree]
 
513
                tree.lock_read()
 
514
            else:
 
515
                tree = work_tree
 
516
                extra_trees = []
 
517
 
 
518
            if file_list is not None:
 
519
                file_ids = tree.paths2ids(file_list, trees=extra_trees,
 
520
                                          require_versioned=True)
 
521
                # find_ids_across_trees may include some paths that don't
 
522
                # exist in 'tree'.
 
523
                entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
 
524
                                 for file_id in file_ids if file_id in tree)
 
525
            else:
 
526
                entries = tree.inventory.entries()
 
527
        finally:
 
528
            tree.unlock()
 
529
            if tree is not work_tree:
 
530
                work_tree.unlock()
 
531
 
 
532
        for path, entry in entries:
 
533
            if kind and kind != entry.kind:
 
534
                continue
 
535
            if show_ids:
 
536
                self.outf.write('%-50s %s\n' % (path, entry.file_id))
 
537
            else:
 
538
                self.outf.write(path)
 
539
                self.outf.write('\n')
 
540
 
 
541
 
 
542
class cmd_mv(Command):
 
543
    """Move or rename a file.
 
544
 
 
545
    :Usage:
 
546
        bzr mv OLDNAME NEWNAME
 
547
 
 
548
        bzr mv SOURCE... DESTINATION
 
549
 
 
550
    If the last argument is a versioned directory, all the other names
 
551
    are moved into it.  Otherwise, there must be exactly two arguments
 
552
    and the file is changed to a new name.
 
553
 
 
554
    If OLDNAME does not exist on the filesystem but is versioned and
 
555
    NEWNAME does exist on the filesystem but is not versioned, mv
 
556
    assumes that the file has been manually moved and only updates
 
557
    its internal inventory to reflect that change.
 
558
    The same is valid when moving many SOURCE files to a DESTINATION.
 
559
 
 
560
    Files cannot be moved between branches.
 
561
    """
 
562
 
 
563
    takes_args = ['names*']
 
564
    takes_options = [Option("after", help="Move only the bzr identifier"
 
565
        " of the file, because the file has already been moved."),
 
566
        ]
 
567
    aliases = ['move', 'rename']
 
568
    encoding_type = 'replace'
 
569
 
 
570
    def run(self, names_list, after=False):
 
571
        if names_list is None:
 
572
            names_list = []
 
573
 
 
574
        if len(names_list) < 2:
 
575
            raise errors.BzrCommandError("missing file argument")
 
576
        tree, rel_names = tree_files(names_list)
 
577
        tree.lock_write()
 
578
        try:
 
579
            self._run(tree, names_list, rel_names, after)
 
580
        finally:
 
581
            tree.unlock()
 
582
 
 
583
    def _run(self, tree, names_list, rel_names, after):
 
584
        into_existing = osutils.isdir(names_list[-1])
 
585
        if into_existing and len(names_list) == 2:
 
586
            # special cases:
 
587
            # a. case-insensitive filesystem and change case of dir
 
588
            # b. move directory after the fact (if the source used to be
 
589
            #    a directory, but now doesn't exist in the working tree
 
590
            #    and the target is an existing directory, just rename it)
 
591
            if (not tree.case_sensitive
 
592
                and rel_names[0].lower() == rel_names[1].lower()):
 
593
                into_existing = False
 
594
            else:
 
595
                inv = tree.inventory
 
596
                from_id = tree.path2id(rel_names[0])
 
597
                if (not osutils.lexists(names_list[0]) and
 
598
                    from_id and inv.get_file_kind(from_id) == "directory"):
 
599
                    into_existing = False
 
600
        # move/rename
 
601
        if into_existing:
 
602
            # move into existing directory
 
603
            for pair in tree.move(rel_names[:-1], rel_names[-1], after=after):
 
604
                self.outf.write("%s => %s\n" % pair)
 
605
        else:
 
606
            if len(names_list) != 2:
 
607
                raise errors.BzrCommandError('to mv multiple files the'
 
608
                                             ' destination must be a versioned'
 
609
                                             ' directory')
 
610
            tree.rename_one(rel_names[0], rel_names[1], after=after)
 
611
            self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
 
612
 
 
613
 
 
614
class cmd_pull(Command):
 
615
    """Turn this branch into a mirror of another branch.
 
616
 
 
617
    This command only works on branches that have not diverged.  Branches are
 
618
    considered diverged if the destination branch's most recent commit is one
 
619
    that has not been merged (directly or indirectly) into the parent.
 
620
 
 
621
    If branches have diverged, you can use 'bzr merge' to integrate the changes
 
622
    from one into the other.  Once one branch has merged, the other should
 
623
    be able to pull it again.
 
624
 
 
625
    If you want to forget your local changes and just update your branch to
 
626
    match the remote one, use pull --overwrite.
 
627
 
 
628
    If there is no default location set, the first pull will set it.  After
 
629
    that, you can omit the location to use the default.  To change the
 
630
    default, use --remember. The value will only be saved if the remote
 
631
    location can be accessed.
 
632
 
 
633
    Note: The location can be specified either in the form of a branch,
 
634
    or in the form of a path to a file containing a merge directive generated
 
635
    with bzr send.
 
636
    """
 
637
 
 
638
    _see_also = ['push', 'update', 'status-flags']
 
639
    takes_options = ['remember', 'overwrite', 'revision',
 
640
        custom_help('verbose',
 
641
            help='Show logs of pulled revisions.'),
 
642
        Option('directory',
 
643
            help='Branch to pull into, '
 
644
                 'rather than the one containing the working directory.',
 
645
            short_name='d',
 
646
            type=unicode,
 
647
            ),
 
648
        ]
 
649
    takes_args = ['location?']
 
650
    encoding_type = 'replace'
 
651
 
 
652
    def run(self, location=None, remember=False, overwrite=False,
 
653
            revision=None, verbose=False,
 
654
            directory=None):
 
655
        # FIXME: too much stuff is in the command class
 
656
        revision_id = None
 
657
        mergeable = None
 
658
        if directory is None:
 
659
            directory = u'.'
 
660
        try:
 
661
            tree_to = WorkingTree.open_containing(directory)[0]
 
662
            branch_to = tree_to.branch
 
663
        except errors.NoWorkingTree:
 
664
            tree_to = None
 
665
            branch_to = Branch.open_containing(directory)[0]
 
666
 
 
667
        possible_transports = []
 
668
        if location is not None:
 
669
            try:
 
670
                mergeable = bundle.read_mergeable_from_url(location,
 
671
                    possible_transports=possible_transports)
 
672
            except errors.NotABundle:
 
673
                mergeable = None
 
674
 
 
675
        stored_loc = branch_to.get_parent()
 
676
        if location is None:
 
677
            if stored_loc is None:
 
678
                raise errors.BzrCommandError("No pull location known or"
 
679
                                             " specified.")
 
680
            else:
 
681
                display_url = urlutils.unescape_for_display(stored_loc,
 
682
                        self.outf.encoding)
 
683
                if not is_quiet():
 
684
                    self.outf.write("Using saved parent location: %s\n" % display_url)
 
685
                location = stored_loc
 
686
 
 
687
        if mergeable is not None:
 
688
            if revision is not None:
 
689
                raise errors.BzrCommandError(
 
690
                    'Cannot use -r with merge directives or bundles')
 
691
            mergeable.install_revisions(branch_to.repository)
 
692
            base_revision_id, revision_id, verified = \
 
693
                mergeable.get_merge_request(branch_to.repository)
 
694
            branch_from = branch_to
 
695
        else:
 
696
            branch_from = Branch.open(location,
 
697
                possible_transports=possible_transports)
 
698
 
 
699
            if branch_to.get_parent() is None or remember:
 
700
                branch_to.set_parent(branch_from.base)
 
701
 
 
702
        if revision is not None:
 
703
            if len(revision) == 1:
 
704
                revision_id = revision[0].as_revision_id(branch_from)
 
705
            else:
 
706
                raise errors.BzrCommandError(
 
707
                    'bzr pull --revision takes one value.')
 
708
 
 
709
        branch_to.lock_write()
 
710
        try:
 
711
            if tree_to is not None:
 
712
                change_reporter = delta._ChangeReporter(
 
713
                    unversioned_filter=tree_to.is_ignored)
 
714
                result = tree_to.pull(branch_from, overwrite, revision_id,
 
715
                                      change_reporter,
 
716
                                      possible_transports=possible_transports)
 
717
            else:
 
718
                result = branch_to.pull(branch_from, overwrite, revision_id)
 
719
 
 
720
            result.report(self.outf)
 
721
            if verbose and result.old_revid != result.new_revid:
 
722
                old_rh = list(
 
723
                    branch_to.repository.iter_reverse_revision_history(
 
724
                    result.old_revid))
 
725
                old_rh.reverse()
 
726
                new_rh = branch_to.revision_history()
 
727
                log.show_changed_revisions(branch_to, old_rh, new_rh,
 
728
                                           to_file=self.outf)
 
729
        finally:
 
730
            branch_to.unlock()
 
731
 
 
732
 
 
733
class cmd_push(Command):
 
734
    """Update a mirror of this branch.
 
735
    
 
736
    The target branch will not have its working tree populated because this
 
737
    is both expensive, and is not supported on remote file systems.
 
738
    
 
739
    Some smart servers or protocols *may* put the working tree in place in
 
740
    the future.
 
741
 
 
742
    This command only works on branches that have not diverged.  Branches are
 
743
    considered diverged if the destination branch's most recent commit is one
 
744
    that has not been merged (directly or indirectly) by the source branch.
 
745
 
 
746
    If branches have diverged, you can use 'bzr push --overwrite' to replace
 
747
    the other branch completely, discarding its unmerged changes.
 
748
    
 
749
    If you want to ensure you have the different changes in the other branch,
 
750
    do a merge (see bzr help merge) from the other branch, and commit that.
 
751
    After that you will be able to do a push without '--overwrite'.
 
752
 
 
753
    If there is no default push location set, the first push will set it.
 
754
    After that, you can omit the location to use the default.  To change the
 
755
    default, use --remember. The value will only be saved if the remote
 
756
    location can be accessed.
 
757
    """
 
758
 
 
759
    _see_also = ['pull', 'update', 'working-trees']
 
760
    takes_options = ['remember', 'overwrite', 'verbose', 'revision',
 
761
        Option('create-prefix',
 
762
               help='Create the path leading up to the branch '
 
763
                    'if it does not already exist.'),
 
764
        Option('directory',
 
765
            help='Branch to push from, '
 
766
                 'rather than the one containing the working directory.',
 
767
            short_name='d',
 
768
            type=unicode,
 
769
            ),
 
770
        Option('use-existing-dir',
 
771
               help='By default push will fail if the target'
 
772
                    ' directory exists, but does not already'
 
773
                    ' have a control directory.  This flag will'
 
774
                    ' allow push to proceed.'),
 
775
        Option('stacked',
 
776
            help='Create a stacked branch that references the public location '
 
777
                'of the parent branch.'),
 
778
        Option('stacked-on',
 
779
            help='Create a stacked branch that refers to another branch '
 
780
                'for the commit history. Only the work not present in the '
 
781
                'referenced branch is included in the branch created.',
 
782
            type=unicode),
 
783
        ]
 
784
    takes_args = ['location?']
 
785
    encoding_type = 'replace'
 
786
 
 
787
    def run(self, location=None, remember=False, overwrite=False,
 
788
        create_prefix=False, verbose=False, revision=None,
 
789
        use_existing_dir=False, directory=None, stacked_on=None,
 
790
        stacked=False):
 
791
        from bzrlib.push import _show_push_branch
 
792
 
 
793
        # Get the source branch and revision_id
 
794
        if directory is None:
 
795
            directory = '.'
 
796
        br_from = Branch.open_containing(directory)[0]
 
797
        if revision is not None:
 
798
            if len(revision) == 1:
 
799
                revision_id = revision[0].in_history(br_from).rev_id
 
800
            else:
 
801
                raise errors.BzrCommandError(
 
802
                    'bzr push --revision takes one value.')
 
803
        else:
 
804
            revision_id = br_from.last_revision()
 
805
 
 
806
        # Get the stacked_on branch, if any
 
807
        if stacked_on is not None:
 
808
            stacked_on = urlutils.normalize_url(stacked_on)
 
809
        elif stacked:
 
810
            parent_url = br_from.get_parent()
 
811
            if parent_url:
 
812
                parent = Branch.open(parent_url)
 
813
                stacked_on = parent.get_public_branch()
 
814
                if not stacked_on:
 
815
                    # I considered excluding non-http url's here, thus forcing
 
816
                    # 'public' branches only, but that only works for some
 
817
                    # users, so it's best to just depend on the user spotting an
 
818
                    # error by the feedback given to them. RBC 20080227.
 
819
                    stacked_on = parent_url
 
820
            if not stacked_on:
 
821
                raise errors.BzrCommandError(
 
822
                    "Could not determine branch to refer to.")
 
823
 
 
824
        # Get the destination location
 
825
        if location is None:
 
826
            stored_loc = br_from.get_push_location()
 
827
            if stored_loc is None:
 
828
                raise errors.BzrCommandError(
 
829
                    "No push location known or specified.")
 
830
            else:
 
831
                display_url = urlutils.unescape_for_display(stored_loc,
 
832
                        self.outf.encoding)
 
833
                self.outf.write("Using saved push location: %s\n" % display_url)
 
834
                location = stored_loc
 
835
 
 
836
        _show_push_branch(br_from, revision_id, location, self.outf,
 
837
            verbose=verbose, overwrite=overwrite, remember=remember,
 
838
            stacked_on=stacked_on, create_prefix=create_prefix,
 
839
            use_existing_dir=use_existing_dir)
 
840
 
 
841
 
 
842
class cmd_branch(Command):
 
843
    """Create a new copy of a branch.
 
844
 
 
845
    If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
 
846
    be used.  In other words, "branch ../foo/bar" will attempt to create ./bar.
 
847
    If the FROM_LOCATION has no / or path separator embedded, the TO_LOCATION
 
848
    is derived from the FROM_LOCATION by stripping a leading scheme or drive
 
849
    identifier, if any. For example, "branch lp:foo-bar" will attempt to
 
850
    create ./foo-bar.
 
851
 
 
852
    To retrieve the branch as of a particular revision, supply the --revision
 
853
    parameter, as in "branch foo/bar -r 5".
 
854
    """
 
855
 
 
856
    _see_also = ['checkout']
 
857
    takes_args = ['from_location', 'to_location?']
 
858
    takes_options = ['revision', Option('hardlink',
 
859
        help='Hard-link working tree files where possible.'),
 
860
        Option('stacked',
 
861
            help='Create a stacked branch referring to the source branch. '
 
862
                'The new branch will depend on the availability of the source '
 
863
                'branch for all operations.'),
 
864
        Option('standalone',
 
865
               help='Do not use a shared repository, even if available.'),
 
866
        ]
 
867
    aliases = ['get', 'clone']
 
868
 
 
869
    def run(self, from_location, to_location=None, revision=None,
 
870
            hardlink=False, stacked=False, standalone=False):
 
871
        from bzrlib.tag import _merge_tags_if_possible
 
872
        if revision is None:
 
873
            revision = [None]
 
874
        elif len(revision) > 1:
 
875
            raise errors.BzrCommandError(
 
876
                'bzr branch --revision takes exactly 1 revision value')
 
877
 
 
878
        accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
 
879
            from_location)
 
880
        br_from.lock_read()
 
881
        try:
 
882
            if len(revision) == 1 and revision[0] is not None:
 
883
                revision_id = revision[0].as_revision_id(br_from)
 
884
            else:
 
885
                # FIXME - wt.last_revision, fallback to branch, fall back to
 
886
                # None or perhaps NULL_REVISION to mean copy nothing
 
887
                # RBC 20060209
 
888
                revision_id = br_from.last_revision()
 
889
            if to_location is None:
 
890
                to_location = urlutils.derive_to_location(from_location)
 
891
            to_transport = transport.get_transport(to_location)
 
892
            try:
 
893
                to_transport.mkdir('.')
 
894
            except errors.FileExists:
 
895
                raise errors.BzrCommandError('Target directory "%s" already'
 
896
                                             ' exists.' % to_location)
 
897
            except errors.NoSuchFile:
 
898
                raise errors.BzrCommandError('Parent of "%s" does not exist.'
 
899
                                             % to_location)
 
900
            try:
 
901
                # preserve whatever source format we have.
 
902
                dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
 
903
                                            possible_transports=[to_transport],
 
904
                                            accelerator_tree=accelerator_tree,
 
905
                                            hardlink=hardlink, stacked=stacked,
 
906
                                            force_new_repo=standalone)
 
907
                branch = dir.open_branch()
 
908
            except errors.NoSuchRevision:
 
909
                to_transport.delete_tree('.')
 
910
                msg = "The branch %s has no revision %s." % (from_location,
 
911
                    revision[0])
 
912
                raise errors.BzrCommandError(msg)
 
913
            _merge_tags_if_possible(br_from, branch)
 
914
            # If the source branch is stacked, the new branch may
 
915
            # be stacked whether we asked for that explicitly or not.
 
916
            # We therefore need a try/except here and not just 'if stacked:'
 
917
            try:
 
918
                note('Created new stacked branch referring to %s.' %
 
919
                    branch.get_stacked_on_url())
 
920
            except (errors.NotStacked, errors.UnstackableBranchFormat,
 
921
                errors.UnstackableRepositoryFormat), e:
 
922
                note('Branched %d revision(s).' % branch.revno())
 
923
        finally:
 
924
            br_from.unlock()
 
925
 
 
926
 
 
927
class cmd_checkout(Command):
 
928
    """Create a new checkout of an existing branch.
 
929
 
 
930
    If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
 
931
    the branch found in '.'. This is useful if you have removed the working tree
 
932
    or if it was never created - i.e. if you pushed the branch to its current
 
933
    location using SFTP.
 
934
    
 
935
    If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
 
936
    be used.  In other words, "checkout ../foo/bar" will attempt to create ./bar.
 
937
    If the BRANCH_LOCATION has no / or path separator embedded, the TO_LOCATION
 
938
    is derived from the BRANCH_LOCATION by stripping a leading scheme or drive
 
939
    identifier, if any. For example, "checkout lp:foo-bar" will attempt to
 
940
    create ./foo-bar.
 
941
 
 
942
    To retrieve the branch as of a particular revision, supply the --revision
 
943
    parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
 
944
    out of date [so you cannot commit] but it may be useful (i.e. to examine old
 
945
    code.)
 
946
    """
 
947
 
 
948
    _see_also = ['checkouts', 'branch']
 
949
    takes_args = ['branch_location?', 'to_location?']
 
950
    takes_options = ['revision',
 
951
                     Option('lightweight',
 
952
                            help="Perform a lightweight checkout.  Lightweight "
 
953
                                 "checkouts depend on access to the branch for "
 
954
                                 "every operation.  Normal checkouts can perform "
 
955
                                 "common operations like diff and status without "
 
956
                                 "such access, and also support local commits."
 
957
                            ),
 
958
                     Option('files-from', type=str,
 
959
                            help="Get file contents from this tree."),
 
960
                     Option('hardlink',
 
961
                            help='Hard-link working tree files where possible.'
 
962
                            ),
 
963
                     ]
 
964
    aliases = ['co']
 
965
 
 
966
    def run(self, branch_location=None, to_location=None, revision=None,
 
967
            lightweight=False, files_from=None, hardlink=False):
 
968
        if revision is None:
 
969
            revision = [None]
 
970
        elif len(revision) > 1:
 
971
            raise errors.BzrCommandError(
 
972
                'bzr checkout --revision takes exactly 1 revision value')
 
973
        if branch_location is None:
 
974
            branch_location = osutils.getcwd()
 
975
            to_location = branch_location
 
976
        accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
 
977
            branch_location)
 
978
        if files_from is not None:
 
979
            accelerator_tree = WorkingTree.open(files_from)
 
980
        if len(revision) == 1 and revision[0] is not None:
 
981
            revision_id = revision[0].as_revision_id(source)
 
982
        else:
 
983
            revision_id = None
 
984
        if to_location is None:
 
985
            to_location = urlutils.derive_to_location(branch_location)
 
986
        # if the source and to_location are the same, 
 
987
        # and there is no working tree,
 
988
        # then reconstitute a branch
 
989
        if (osutils.abspath(to_location) ==
 
990
            osutils.abspath(branch_location)):
 
991
            try:
 
992
                source.bzrdir.open_workingtree()
 
993
            except errors.NoWorkingTree:
 
994
                source.bzrdir.create_workingtree(revision_id)
 
995
                return
 
996
        source.create_checkout(to_location, revision_id, lightweight,
 
997
                               accelerator_tree, hardlink)
 
998
 
 
999
 
 
1000
class cmd_renames(Command):
 
1001
    """Show list of renamed files.
 
1002
    """
 
1003
    # TODO: Option to show renames between two historical versions.
 
1004
 
 
1005
    # TODO: Only show renames under dir, rather than in the whole branch.
 
1006
    _see_also = ['status']
 
1007
    takes_args = ['dir?']
 
1008
 
 
1009
    @display_command
 
1010
    def run(self, dir=u'.'):
 
1011
        tree = WorkingTree.open_containing(dir)[0]
 
1012
        tree.lock_read()
 
1013
        try:
 
1014
            new_inv = tree.inventory
 
1015
            old_tree = tree.basis_tree()
 
1016
            old_tree.lock_read()
 
1017
            try:
 
1018
                old_inv = old_tree.inventory
 
1019
                renames = list(_mod_tree.find_renames(old_inv, new_inv))
 
1020
                renames.sort()
 
1021
                for old_name, new_name in renames:
 
1022
                    self.outf.write("%s => %s\n" % (old_name, new_name))
 
1023
            finally:
 
1024
                old_tree.unlock()
 
1025
        finally:
 
1026
            tree.unlock()
 
1027
 
 
1028
 
 
1029
class cmd_update(Command):
 
1030
    """Update a tree to have the latest code committed to its branch.
 
1031
    
 
1032
    This will perform a merge into the working tree, and may generate
 
1033
    conflicts. If you have any local changes, you will still 
 
1034
    need to commit them after the update for the update to be complete.
 
1035
    
 
1036
    If you want to discard your local changes, you can just do a 
 
1037
    'bzr revert' instead of 'bzr commit' after the update.
 
1038
    """
 
1039
 
 
1040
    _see_also = ['pull', 'working-trees', 'status-flags']
 
1041
    takes_args = ['dir?']
 
1042
    aliases = ['up']
 
1043
 
 
1044
    def run(self, dir='.'):
 
1045
        tree = WorkingTree.open_containing(dir)[0]
 
1046
        possible_transports = []
 
1047
        master = tree.branch.get_master_branch(
 
1048
            possible_transports=possible_transports)
 
1049
        if master is not None:
 
1050
            tree.lock_write()
 
1051
        else:
 
1052
            tree.lock_tree_write()
 
1053
        try:
 
1054
            existing_pending_merges = tree.get_parent_ids()[1:]
 
1055
            last_rev = _mod_revision.ensure_null(tree.last_revision())
 
1056
            if last_rev == _mod_revision.ensure_null(
 
1057
                tree.branch.last_revision()):
 
1058
                # may be up to date, check master too.
 
1059
                if master is None or last_rev == _mod_revision.ensure_null(
 
1060
                    master.last_revision()):
 
1061
                    revno = tree.branch.revision_id_to_revno(last_rev)
 
1062
                    note("Tree is up to date at revision %d." % (revno,))
 
1063
                    return 0
 
1064
            conflicts = tree.update(
 
1065
                delta._ChangeReporter(unversioned_filter=tree.is_ignored),
 
1066
                possible_transports=possible_transports)
 
1067
            revno = tree.branch.revision_id_to_revno(
 
1068
                _mod_revision.ensure_null(tree.last_revision()))
 
1069
            note('Updated to revision %d.' % (revno,))
 
1070
            if tree.get_parent_ids()[1:] != existing_pending_merges:
 
1071
                note('Your local commits will now show as pending merges with '
 
1072
                     "'bzr status', and can be committed with 'bzr commit'.")
 
1073
            if conflicts != 0:
 
1074
                return 1
 
1075
            else:
 
1076
                return 0
 
1077
        finally:
 
1078
            tree.unlock()
 
1079
 
 
1080
 
 
1081
class cmd_info(Command):
 
1082
    """Show information about a working tree, branch or repository.
 
1083
 
 
1084
    This command will show all known locations and formats associated to the
 
1085
    tree, branch or repository.  Statistical information is included with
 
1086
    each report.
 
1087
 
 
1088
    Branches and working trees will also report any missing revisions.
 
1089
    """
 
1090
    _see_also = ['revno', 'working-trees', 'repositories']
 
1091
    takes_args = ['location?']
 
1092
    takes_options = ['verbose']
 
1093
    encoding_type = 'replace'
 
1094
 
 
1095
    @display_command
 
1096
    def run(self, location=None, verbose=False):
 
1097
        if verbose:
 
1098
            noise_level = 2
 
1099
        else:
 
1100
            noise_level = 0
 
1101
        from bzrlib.info import show_bzrdir_info
 
1102
        show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
 
1103
                         verbose=noise_level, outfile=self.outf)
 
1104
 
 
1105
 
 
1106
class cmd_remove(Command):
 
1107
    """Remove files or directories.
 
1108
 
 
1109
    This makes bzr stop tracking changes to the specified files. bzr will delete
 
1110
    them if they can easily be recovered using revert. If no options or
 
1111
    parameters are given bzr will scan for files that are being tracked by bzr
 
1112
    but missing in your tree and stop tracking them for you.
 
1113
    """
 
1114
    takes_args = ['file*']
 
1115
    takes_options = ['verbose',
 
1116
        Option('new', help='Only remove files that have never been committed.'),
 
1117
        RegistryOption.from_kwargs('file-deletion-strategy',
 
1118
            'The file deletion mode to be used.',
 
1119
            title='Deletion Strategy', value_switches=True, enum_switch=False,
 
1120
            safe='Only delete files if they can be'
 
1121
                 ' safely recovered (default).',
 
1122
            keep="Don't delete any files.",
 
1123
            force='Delete all the specified files, even if they can not be '
 
1124
                'recovered and even if they are non-empty directories.')]
 
1125
    aliases = ['rm', 'del']
 
1126
    encoding_type = 'replace'
 
1127
 
 
1128
    def run(self, file_list, verbose=False, new=False,
 
1129
        file_deletion_strategy='safe'):
 
1130
        tree, file_list = tree_files(file_list)
 
1131
 
 
1132
        if file_list is not None:
 
1133
            file_list = [f for f in file_list]
 
1134
 
 
1135
        tree.lock_write()
 
1136
        try:
 
1137
            # Heuristics should probably all move into tree.remove_smart or
 
1138
            # some such?
 
1139
            if new:
 
1140
                added = tree.changes_from(tree.basis_tree(),
 
1141
                    specific_files=file_list).added
 
1142
                file_list = sorted([f[0] for f in added], reverse=True)
 
1143
                if len(file_list) == 0:
 
1144
                    raise errors.BzrCommandError('No matching files.')
 
1145
            elif file_list is None:
 
1146
                # missing files show up in iter_changes(basis) as
 
1147
                # versioned-with-no-kind.
 
1148
                missing = []
 
1149
                for change in tree.iter_changes(tree.basis_tree()):
 
1150
                    # Find paths in the working tree that have no kind:
 
1151
                    if change[1][1] is not None and change[6][1] is None:
 
1152
                        missing.append(change[1][1])
 
1153
                file_list = sorted(missing, reverse=True)
 
1154
                file_deletion_strategy = 'keep'
 
1155
            tree.remove(file_list, verbose=verbose, to_file=self.outf,
 
1156
                keep_files=file_deletion_strategy=='keep',
 
1157
                force=file_deletion_strategy=='force')
 
1158
        finally:
 
1159
            tree.unlock()
 
1160
 
 
1161
 
 
1162
class cmd_file_id(Command):
 
1163
    """Print file_id of a particular file or directory.
 
1164
 
 
1165
    The file_id is assigned when the file is first added and remains the
 
1166
    same through all revisions where the file exists, even when it is
 
1167
    moved or renamed.
 
1168
    """
 
1169
 
 
1170
    hidden = True
 
1171
    _see_also = ['inventory', 'ls']
 
1172
    takes_args = ['filename']
 
1173
 
 
1174
    @display_command
 
1175
    def run(self, filename):
 
1176
        tree, relpath = WorkingTree.open_containing(filename)
 
1177
        i = tree.path2id(relpath)
 
1178
        if i is None:
 
1179
            raise errors.NotVersionedError(filename)
 
1180
        else:
 
1181
            self.outf.write(i + '\n')
 
1182
 
 
1183
 
 
1184
class cmd_file_path(Command):
 
1185
    """Print path of file_ids to a file or directory.
 
1186
 
 
1187
    This prints one line for each directory down to the target,
 
1188
    starting at the branch root.
 
1189
    """
 
1190
 
 
1191
    hidden = True
 
1192
    takes_args = ['filename']
 
1193
 
 
1194
    @display_command
 
1195
    def run(self, filename):
 
1196
        tree, relpath = WorkingTree.open_containing(filename)
 
1197
        fid = tree.path2id(relpath)
 
1198
        if fid is None:
 
1199
            raise errors.NotVersionedError(filename)
 
1200
        segments = osutils.splitpath(relpath)
 
1201
        for pos in range(1, len(segments) + 1):
 
1202
            path = osutils.joinpath(segments[:pos])
 
1203
            self.outf.write("%s\n" % tree.path2id(path))
 
1204
 
 
1205
 
 
1206
class cmd_reconcile(Command):
 
1207
    """Reconcile bzr metadata in a branch.
 
1208
 
 
1209
    This can correct data mismatches that may have been caused by
 
1210
    previous ghost operations or bzr upgrades. You should only
 
1211
    need to run this command if 'bzr check' or a bzr developer 
 
1212
    advises you to run it.
 
1213
 
 
1214
    If a second branch is provided, cross-branch reconciliation is
 
1215
    also attempted, which will check that data like the tree root
 
1216
    id which was not present in very early bzr versions is represented
 
1217
    correctly in both branches.
 
1218
 
 
1219
    At the same time it is run it may recompress data resulting in 
 
1220
    a potential saving in disk space or performance gain.
 
1221
 
 
1222
    The branch *MUST* be on a listable system such as local disk or sftp.
 
1223
    """
 
1224
 
 
1225
    _see_also = ['check']
 
1226
    takes_args = ['branch?']
 
1227
 
 
1228
    def run(self, branch="."):
 
1229
        from bzrlib.reconcile import reconcile
 
1230
        dir = bzrdir.BzrDir.open(branch)
 
1231
        reconcile(dir)
 
1232
 
 
1233
 
 
1234
class cmd_revision_history(Command):
 
1235
    """Display the list of revision ids on a branch."""
 
1236
 
 
1237
    _see_also = ['log']
 
1238
    takes_args = ['location?']
 
1239
 
 
1240
    hidden = True
 
1241
 
 
1242
    @display_command
 
1243
    def run(self, location="."):
 
1244
        branch = Branch.open_containing(location)[0]
 
1245
        for revid in branch.revision_history():
 
1246
            self.outf.write(revid)
 
1247
            self.outf.write('\n')
 
1248
 
 
1249
 
 
1250
class cmd_ancestry(Command):
 
1251
    """List all revisions merged into this branch."""
 
1252
 
 
1253
    _see_also = ['log', 'revision-history']
 
1254
    takes_args = ['location?']
 
1255
 
 
1256
    hidden = True
 
1257
 
 
1258
    @display_command
 
1259
    def run(self, location="."):
 
1260
        try:
 
1261
            wt = WorkingTree.open_containing(location)[0]
 
1262
        except errors.NoWorkingTree:
 
1263
            b = Branch.open(location)
 
1264
            last_revision = b.last_revision()
 
1265
        else:
 
1266
            b = wt.branch
 
1267
            last_revision = wt.last_revision()
 
1268
 
 
1269
        revision_ids = b.repository.get_ancestry(last_revision)
 
1270
        revision_ids.pop(0)
 
1271
        for revision_id in revision_ids:
 
1272
            self.outf.write(revision_id + '\n')
 
1273
 
 
1274
 
 
1275
class cmd_init(Command):
 
1276
    """Make a directory into a versioned branch.
 
1277
 
 
1278
    Use this to create an empty branch, or before importing an
 
1279
    existing project.
 
1280
 
 
1281
    If there is a repository in a parent directory of the location, then 
 
1282
    the history of the branch will be stored in the repository.  Otherwise
 
1283
    init creates a standalone branch which carries its own history
 
1284
    in the .bzr directory.
 
1285
 
 
1286
    If there is already a branch at the location but it has no working tree,
 
1287
    the tree can be populated with 'bzr checkout'.
 
1288
 
 
1289
    Recipe for importing a tree of files::
 
1290
 
 
1291
        cd ~/project
 
1292
        bzr init
 
1293
        bzr add .
 
1294
        bzr status
 
1295
        bzr commit -m "imported project"
 
1296
    """
 
1297
 
 
1298
    _see_also = ['init-repository', 'branch', 'checkout']
 
1299
    takes_args = ['location?']
 
1300
    takes_options = [
 
1301
        Option('create-prefix',
 
1302
               help='Create the path leading up to the branch '
 
1303
                    'if it does not already exist.'),
 
1304
         RegistryOption('format',
 
1305
                help='Specify a format for this branch. '
 
1306
                'See "help formats".',
 
1307
                registry=bzrdir.format_registry,
 
1308
                converter=bzrdir.format_registry.make_bzrdir,
 
1309
                value_switches=True,
 
1310
                title="Branch Format",
 
1311
                ),
 
1312
         Option('append-revisions-only',
 
1313
                help='Never change revnos or the existing log.'
 
1314
                '  Append revisions to it only.')
 
1315
         ]
 
1316
    def run(self, location=None, format=None, append_revisions_only=False,
 
1317
            create_prefix=False):
 
1318
        if format is None:
 
1319
            format = bzrdir.format_registry.make_bzrdir('default')
 
1320
        if location is None:
 
1321
            location = u'.'
 
1322
 
 
1323
        to_transport = transport.get_transport(location)
 
1324
 
 
1325
        # The path has to exist to initialize a
 
1326
        # branch inside of it.
 
1327
        # Just using os.mkdir, since I don't
 
1328
        # believe that we want to create a bunch of
 
1329
        # locations if the user supplies an extended path
 
1330
        try:
 
1331
            to_transport.ensure_base()
 
1332
        except errors.NoSuchFile:
 
1333
            if not create_prefix:
 
1334
                raise errors.BzrCommandError("Parent directory of %s"
 
1335
                    " does not exist."
 
1336
                    "\nYou may supply --create-prefix to create all"
 
1337
                    " leading parent directories."
 
1338
                    % location)
 
1339
            _create_prefix(to_transport)
 
1340
 
 
1341
        try:
 
1342
            a_bzrdir = bzrdir.BzrDir.open_from_transport(to_transport)
 
1343
        except errors.NotBranchError:
 
1344
            # really a NotBzrDir error...
 
1345
            create_branch = bzrdir.BzrDir.create_branch_convenience
 
1346
            branch = create_branch(to_transport.base, format=format,
 
1347
                                   possible_transports=[to_transport])
 
1348
            a_bzrdir = branch.bzrdir
 
1349
        else:
 
1350
            from bzrlib.transport.local import LocalTransport
 
1351
            if a_bzrdir.has_branch():
 
1352
                if (isinstance(to_transport, LocalTransport)
 
1353
                    and not a_bzrdir.has_workingtree()):
 
1354
                        raise errors.BranchExistsWithoutWorkingTree(location)
 
1355
                raise errors.AlreadyBranchError(location)
 
1356
            branch = a_bzrdir.create_branch()
 
1357
            a_bzrdir.create_workingtree()
 
1358
        if append_revisions_only:
 
1359
            try:
 
1360
                branch.set_append_revisions_only(True)
 
1361
            except errors.UpgradeRequired:
 
1362
                raise errors.BzrCommandError('This branch format cannot be set'
 
1363
                    ' to append-revisions-only.  Try --experimental-branch6')
 
1364
        if not is_quiet():
 
1365
            from bzrlib.info import show_bzrdir_info
 
1366
            show_bzrdir_info(a_bzrdir, verbose=0, outfile=self.outf)
 
1367
 
 
1368
 
 
1369
class cmd_init_repository(Command):
 
1370
    """Create a shared repository to hold branches.
 
1371
 
 
1372
    New branches created under the repository directory will store their
 
1373
    revisions in the repository, not in the branch directory.
 
1374
 
 
1375
    If the --no-trees option is used then the branches in the repository
 
1376
    will not have working trees by default.
 
1377
 
 
1378
    :Examples:
 
1379
        Create a shared repositories holding just branches::
 
1380
 
 
1381
            bzr init-repo --no-trees repo
 
1382
            bzr init repo/trunk
 
1383
 
 
1384
        Make a lightweight checkout elsewhere::
 
1385
 
 
1386
            bzr checkout --lightweight repo/trunk trunk-checkout
 
1387
            cd trunk-checkout
 
1388
            (add files here)
 
1389
    """
 
1390
 
 
1391
    _see_also = ['init', 'branch', 'checkout', 'repositories']
 
1392
    takes_args = ["location"]
 
1393
    takes_options = [RegistryOption('format',
 
1394
                            help='Specify a format for this repository. See'
 
1395
                                 ' "bzr help formats" for details.',
 
1396
                            registry=bzrdir.format_registry,
 
1397
                            converter=bzrdir.format_registry.make_bzrdir,
 
1398
                            value_switches=True, title='Repository format'),
 
1399
                     Option('no-trees',
 
1400
                             help='Branches in the repository will default to'
 
1401
                                  ' not having a working tree.'),
 
1402
                    ]
 
1403
    aliases = ["init-repo"]
 
1404
 
 
1405
    def run(self, location, format=None, no_trees=False):
 
1406
        if format is None:
 
1407
            format = bzrdir.format_registry.make_bzrdir('default')
 
1408
 
 
1409
        if location is None:
 
1410
            location = '.'
 
1411
 
 
1412
        to_transport = transport.get_transport(location)
 
1413
        to_transport.ensure_base()
 
1414
 
 
1415
        newdir = format.initialize_on_transport(to_transport)
 
1416
        repo = newdir.create_repository(shared=True)
 
1417
        repo.set_make_working_trees(not no_trees)
 
1418
        if not is_quiet():
 
1419
            from bzrlib.info import show_bzrdir_info
 
1420
            show_bzrdir_info(repo.bzrdir, verbose=0, outfile=self.outf)
 
1421
 
 
1422
 
 
1423
class cmd_diff(Command):
 
1424
    """Show differences in the working tree, between revisions or branches.
 
1425
    
 
1426
    If no arguments are given, all changes for the current tree are listed.
 
1427
    If files are given, only the changes in those files are listed.
 
1428
    Remote and multiple branches can be compared by using the --old and
 
1429
    --new options. If not provided, the default for both is derived from
 
1430
    the first argument, if any, or the current tree if no arguments are
 
1431
    given.
 
1432
 
 
1433
    "bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
 
1434
    produces patches suitable for "patch -p1".
 
1435
 
 
1436
    :Exit values:
 
1437
        1 - changed
 
1438
        2 - unrepresentable changes
 
1439
        3 - error
 
1440
        0 - no change
 
1441
 
 
1442
    :Examples:
 
1443
        Shows the difference in the working tree versus the last commit::
 
1444
 
 
1445
            bzr diff
 
1446
 
 
1447
        Difference between the working tree and revision 1::
 
1448
 
 
1449
            bzr diff -r1
 
1450
 
 
1451
        Difference between revision 2 and revision 1::
 
1452
 
 
1453
            bzr diff -r1..2
 
1454
 
 
1455
        Difference between revision 2 and revision 1 for branch xxx::
 
1456
 
 
1457
            bzr diff -r1..2 xxx
 
1458
 
 
1459
        Show just the differences for file NEWS::
 
1460
 
 
1461
            bzr diff NEWS
 
1462
 
 
1463
        Show the differences in working tree xxx for file NEWS::
 
1464
 
 
1465
            bzr diff xxx/NEWS
 
1466
 
 
1467
        Show the differences from branch xxx to this working tree:
 
1468
 
 
1469
            bzr diff --old xxx
 
1470
 
 
1471
        Show the differences between two branches for file NEWS::
 
1472
 
 
1473
            bzr diff --old xxx --new yyy NEWS
 
1474
 
 
1475
        Same as 'bzr diff' but prefix paths with old/ and new/::
 
1476
 
 
1477
            bzr diff --prefix old/:new/
 
1478
    """
 
1479
    _see_also = ['status']
 
1480
    takes_args = ['file*']
 
1481
    takes_options = [
 
1482
        Option('diff-options', type=str,
 
1483
               help='Pass these options to the external diff program.'),
 
1484
        Option('prefix', type=str,
 
1485
               short_name='p',
 
1486
               help='Set prefixes added to old and new filenames, as '
 
1487
                    'two values separated by a colon. (eg "old/:new/").'),
 
1488
        Option('old',
 
1489
            help='Branch/tree to compare from.',
 
1490
            type=unicode,
 
1491
            ),
 
1492
        Option('new',
 
1493
            help='Branch/tree to compare to.',
 
1494
            type=unicode,
 
1495
            ),
 
1496
        'revision',
 
1497
        'change',
 
1498
        Option('using',
 
1499
            help='Use this command to compare files.',
 
1500
            type=unicode,
 
1501
            ),
 
1502
        ]
 
1503
    aliases = ['di', 'dif']
 
1504
    encoding_type = 'exact'
 
1505
 
 
1506
    @display_command
 
1507
    def run(self, revision=None, file_list=None, diff_options=None,
 
1508
            prefix=None, old=None, new=None, using=None):
 
1509
        from bzrlib.diff import _get_trees_to_diff, show_diff_trees
 
1510
 
 
1511
        if (prefix is None) or (prefix == '0'):
 
1512
            # diff -p0 format
 
1513
            old_label = ''
 
1514
            new_label = ''
 
1515
        elif prefix == '1':
 
1516
            old_label = 'old/'
 
1517
            new_label = 'new/'
 
1518
        elif ':' in prefix:
 
1519
            old_label, new_label = prefix.split(":")
 
1520
        else:
 
1521
            raise errors.BzrCommandError(
 
1522
                '--prefix expects two values separated by a colon'
 
1523
                ' (eg "old/:new/")')
 
1524
 
 
1525
        if revision and len(revision) > 2:
 
1526
            raise errors.BzrCommandError('bzr diff --revision takes exactly'
 
1527
                                         ' one or two revision specifiers')
 
1528
 
 
1529
        old_tree, new_tree, specific_files, extra_trees = \
 
1530
                _get_trees_to_diff(file_list, revision, old, new)
 
1531
        return show_diff_trees(old_tree, new_tree, sys.stdout, 
 
1532
                               specific_files=specific_files,
 
1533
                               external_diff_options=diff_options,
 
1534
                               old_label=old_label, new_label=new_label,
 
1535
                               extra_trees=extra_trees, using=using)
 
1536
 
 
1537
 
 
1538
class cmd_deleted(Command):
 
1539
    """List files deleted in the working tree.
 
1540
    """
 
1541
    # TODO: Show files deleted since a previous revision, or
 
1542
    # between two revisions.
 
1543
    # TODO: Much more efficient way to do this: read in new
 
1544
    # directories with readdir, rather than stating each one.  Same
 
1545
    # level of effort but possibly much less IO.  (Or possibly not,
 
1546
    # if the directories are very large...)
 
1547
    _see_also = ['status', 'ls']
 
1548
    takes_options = ['show-ids']
 
1549
 
 
1550
    @display_command
 
1551
    def run(self, show_ids=False):
 
1552
        tree = WorkingTree.open_containing(u'.')[0]
 
1553
        tree.lock_read()
 
1554
        try:
 
1555
            old = tree.basis_tree()
 
1556
            old.lock_read()
 
1557
            try:
 
1558
                for path, ie in old.inventory.iter_entries():
 
1559
                    if not tree.has_id(ie.file_id):
 
1560
                        self.outf.write(path)
 
1561
                        if show_ids:
 
1562
                            self.outf.write(' ')
 
1563
                            self.outf.write(ie.file_id)
 
1564
                        self.outf.write('\n')
 
1565
            finally:
 
1566
                old.unlock()
 
1567
        finally:
 
1568
            tree.unlock()
 
1569
 
 
1570
 
 
1571
class cmd_modified(Command):
 
1572
    """List files modified in working tree.
 
1573
    """
 
1574
 
 
1575
    hidden = True
 
1576
    _see_also = ['status', 'ls']
 
1577
    takes_options = [
 
1578
            Option('null',
 
1579
                   help='Write an ascii NUL (\\0) separator '
 
1580
                   'between files rather than a newline.')
 
1581
            ]
 
1582
 
 
1583
    @display_command
 
1584
    def run(self, null=False):
 
1585
        tree = WorkingTree.open_containing(u'.')[0]
 
1586
        td = tree.changes_from(tree.basis_tree())
 
1587
        for path, id, kind, text_modified, meta_modified in td.modified:
 
1588
            if null:
 
1589
                self.outf.write(path + '\0')
 
1590
            else:
 
1591
                self.outf.write(osutils.quotefn(path) + '\n')
 
1592
 
 
1593
 
 
1594
class cmd_added(Command):
 
1595
    """List files added in working tree.
 
1596
    """
 
1597
 
 
1598
    hidden = True
 
1599
    _see_also = ['status', 'ls']
 
1600
    takes_options = [
 
1601
            Option('null',
 
1602
                   help='Write an ascii NUL (\\0) separator '
 
1603
                   'between files rather than a newline.')
 
1604
            ]
 
1605
 
 
1606
    @display_command
 
1607
    def run(self, null=False):
 
1608
        wt = WorkingTree.open_containing(u'.')[0]
 
1609
        wt.lock_read()
 
1610
        try:
 
1611
            basis = wt.basis_tree()
 
1612
            basis.lock_read()
 
1613
            try:
 
1614
                basis_inv = basis.inventory
 
1615
                inv = wt.inventory
 
1616
                for file_id in inv:
 
1617
                    if file_id in basis_inv:
 
1618
                        continue
 
1619
                    if inv.is_root(file_id) and len(basis_inv) == 0:
 
1620
                        continue
 
1621
                    path = inv.id2path(file_id)
 
1622
                    if not os.access(osutils.abspath(path), os.F_OK):
 
1623
                        continue
 
1624
                    if null:
 
1625
                        self.outf.write(path + '\0')
 
1626
                    else:
 
1627
                        self.outf.write(osutils.quotefn(path) + '\n')
 
1628
            finally:
 
1629
                basis.unlock()
 
1630
        finally:
 
1631
            wt.unlock()
 
1632
 
 
1633
 
 
1634
class cmd_root(Command):
 
1635
    """Show the tree root directory.
 
1636
 
 
1637
    The root is the nearest enclosing directory with a .bzr control
 
1638
    directory."""
 
1639
 
 
1640
    takes_args = ['filename?']
 
1641
    @display_command
 
1642
    def run(self, filename=None):
 
1643
        """Print the branch root."""
 
1644
        tree = WorkingTree.open_containing(filename)[0]
 
1645
        self.outf.write(tree.basedir + '\n')
 
1646
 
 
1647
 
 
1648
def _parse_limit(limitstring):
 
1649
    try:
 
1650
        return int(limitstring)
 
1651
    except ValueError:
 
1652
        msg = "The limit argument must be an integer."
 
1653
        raise errors.BzrCommandError(msg)
 
1654
 
 
1655
 
 
1656
class cmd_log(Command):
 
1657
    """Show log of a branch, file, or directory.
 
1658
 
 
1659
    By default show the log of the branch containing the working directory.
 
1660
 
 
1661
    To request a range of logs, you can use the command -r begin..end
 
1662
    -r revision requests a specific revision, -r ..end or -r begin.. are
 
1663
    also valid.
 
1664
 
 
1665
    :Examples:
 
1666
        Log the current branch::
 
1667
 
 
1668
            bzr log
 
1669
 
 
1670
        Log a file::
 
1671
 
 
1672
            bzr log foo.c
 
1673
 
 
1674
        Log the last 10 revisions of a branch::
 
1675
 
 
1676
            bzr log -r -10.. http://server/branch
 
1677
    """
 
1678
 
 
1679
    # TODO: Make --revision support uuid: and hash: [future tag:] notation.
 
1680
 
 
1681
    takes_args = ['location?']
 
1682
    takes_options = [
 
1683
            Option('forward',
 
1684
                   help='Show from oldest to newest.'),
 
1685
            Option('timezone',
 
1686
                   type=str,
 
1687
                   help='Display timezone as local, original, or utc.'),
 
1688
            custom_help('verbose',
 
1689
                   help='Show files changed in each revision.'),
 
1690
            'show-ids',
 
1691
            'revision',
 
1692
            'log-format',
 
1693
            Option('message',
 
1694
                   short_name='m',
 
1695
                   help='Show revisions whose message matches this '
 
1696
                        'regular expression.',
 
1697
                   type=str),
 
1698
            Option('limit',
 
1699
                   short_name='l',
 
1700
                   help='Limit the output to the first N revisions.',
 
1701
                   argname='N',
 
1702
                   type=_parse_limit),
 
1703
            ]
 
1704
    encoding_type = 'replace'
 
1705
 
 
1706
    @display_command
 
1707
    def run(self, location=None, timezone='original',
 
1708
            verbose=False,
 
1709
            show_ids=False,
 
1710
            forward=False,
 
1711
            revision=None,
 
1712
            log_format=None,
 
1713
            message=None,
 
1714
            limit=None):
 
1715
        from bzrlib.log import show_log
 
1716
        direction = (forward and 'forward') or 'reverse'
 
1717
        
 
1718
        # log everything
 
1719
        file_id = None
 
1720
        if location:
 
1721
            # find the file id to log:
 
1722
 
 
1723
            tree, b, fp = bzrdir.BzrDir.open_containing_tree_or_branch(
 
1724
                location)
 
1725
            if fp != '':
 
1726
                if tree is None:
 
1727
                    tree = b.basis_tree()
 
1728
                file_id = tree.path2id(fp)
 
1729
                if file_id is None:
 
1730
                    raise errors.BzrCommandError(
 
1731
                        "Path does not have any revision history: %s" %
 
1732
                        location)
 
1733
        else:
 
1734
            # local dir only
 
1735
            # FIXME ? log the current subdir only RBC 20060203 
 
1736
            if revision is not None \
 
1737
                    and len(revision) > 0 and revision[0].get_branch():
 
1738
                location = revision[0].get_branch()
 
1739
            else:
 
1740
                location = '.'
 
1741
            dir, relpath = bzrdir.BzrDir.open_containing(location)
 
1742
            b = dir.open_branch()
 
1743
 
 
1744
        b.lock_read()
 
1745
        try:
 
1746
            if revision is None:
 
1747
                rev1 = None
 
1748
                rev2 = None
 
1749
            elif len(revision) == 1:
 
1750
                rev1 = rev2 = revision[0].in_history(b)
 
1751
            elif len(revision) == 2:
 
1752
                if revision[1].get_branch() != revision[0].get_branch():
 
1753
                    # b is taken from revision[0].get_branch(), and
 
1754
                    # show_log will use its revision_history. Having
 
1755
                    # different branches will lead to weird behaviors.
 
1756
                    raise errors.BzrCommandError(
 
1757
                        "Log doesn't accept two revisions in different"
 
1758
                        " branches.")
 
1759
                rev1 = revision[0].in_history(b)
 
1760
                rev2 = revision[1].in_history(b)
 
1761
            else:
 
1762
                raise errors.BzrCommandError(
 
1763
                    'bzr log --revision takes one or two values.')
 
1764
 
 
1765
            if log_format is None:
 
1766
                log_format = log.log_formatter_registry.get_default(b)
 
1767
 
 
1768
            lf = log_format(show_ids=show_ids, to_file=self.outf,
 
1769
                            show_timezone=timezone)
 
1770
 
 
1771
            show_log(b,
 
1772
                     lf,
 
1773
                     file_id,
 
1774
                     verbose=verbose,
 
1775
                     direction=direction,
 
1776
                     start_revision=rev1,
 
1777
                     end_revision=rev2,
 
1778
                     search=message,
 
1779
                     limit=limit)
 
1780
        finally:
 
1781
            b.unlock()
 
1782
 
 
1783
 
 
1784
def get_log_format(long=False, short=False, line=False, default='long'):
 
1785
    log_format = default
 
1786
    if long:
 
1787
        log_format = 'long'
 
1788
    if short:
 
1789
        log_format = 'short'
 
1790
    if line:
 
1791
        log_format = 'line'
 
1792
    return log_format
 
1793
 
 
1794
 
 
1795
class cmd_touching_revisions(Command):
 
1796
    """Return revision-ids which affected a particular file.
 
1797
 
 
1798
    A more user-friendly interface is "bzr log FILE".
 
1799
    """
 
1800
 
 
1801
    hidden = True
 
1802
    takes_args = ["filename"]
 
1803
 
 
1804
    @display_command
 
1805
    def run(self, filename):
 
1806
        tree, relpath = WorkingTree.open_containing(filename)
 
1807
        b = tree.branch
 
1808
        file_id = tree.path2id(relpath)
 
1809
        for revno, revision_id, what in log.find_touching_revisions(b, file_id):
 
1810
            self.outf.write("%6d %s\n" % (revno, what))
 
1811
 
 
1812
 
 
1813
class cmd_ls(Command):
 
1814
    """List files in a tree.
 
1815
    """
 
1816
 
 
1817
    _see_also = ['status', 'cat']
 
1818
    takes_args = ['path?']
 
1819
    # TODO: Take a revision or remote path and list that tree instead.
 
1820
    takes_options = [
 
1821
            'verbose',
 
1822
            'revision',
 
1823
            Option('non-recursive',
 
1824
                   help='Don\'t recurse into subdirectories.'),
 
1825
            Option('from-root',
 
1826
                   help='Print paths relative to the root of the branch.'),
 
1827
            Option('unknown', help='Print unknown files.'),
 
1828
            Option('versioned', help='Print versioned files.',
 
1829
                   short_name='V'),
 
1830
            Option('ignored', help='Print ignored files.'),
 
1831
            Option('null',
 
1832
                   help='Write an ascii NUL (\\0) separator '
 
1833
                   'between files rather than a newline.'),
 
1834
            Option('kind',
 
1835
                   help='List entries of a particular kind: file, directory, symlink.',
 
1836
                   type=unicode),
 
1837
            'show-ids',
 
1838
            ]
 
1839
    @display_command
 
1840
    def run(self, revision=None, verbose=False,
 
1841
            non_recursive=False, from_root=False,
 
1842
            unknown=False, versioned=False, ignored=False,
 
1843
            null=False, kind=None, show_ids=False, path=None):
 
1844
 
 
1845
        if kind and kind not in ('file', 'directory', 'symlink'):
 
1846
            raise errors.BzrCommandError('invalid kind specified')
 
1847
 
 
1848
        if verbose and null:
 
1849
            raise errors.BzrCommandError('Cannot set both --verbose and --null')
 
1850
        all = not (unknown or versioned or ignored)
 
1851
 
 
1852
        selection = {'I':ignored, '?':unknown, 'V':versioned}
 
1853
 
 
1854
        if path is None:
 
1855
            fs_path = '.'
 
1856
            prefix = ''
 
1857
        else:
 
1858
            if from_root:
 
1859
                raise errors.BzrCommandError('cannot specify both --from-root'
 
1860
                                             ' and PATH')
 
1861
            fs_path = path
 
1862
            prefix = path
 
1863
        tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
 
1864
            fs_path)
 
1865
        if from_root:
 
1866
            relpath = u''
 
1867
        elif relpath:
 
1868
            relpath += '/'
 
1869
        if revision is not None or tree is None:
 
1870
            tree = _get_one_revision_tree('ls', revision, branch=branch)
 
1871
 
 
1872
        tree.lock_read()
 
1873
        try:
 
1874
            for fp, fc, fkind, fid, entry in tree.list_files(include_root=False):
 
1875
                if fp.startswith(relpath):
 
1876
                    fp = osutils.pathjoin(prefix, fp[len(relpath):])
 
1877
                    if non_recursive and '/' in fp:
 
1878
                        continue
 
1879
                    if not all and not selection[fc]:
 
1880
                        continue
 
1881
                    if kind is not None and fkind != kind:
 
1882
                        continue
 
1883
                    if verbose:
 
1884
                        kindch = entry.kind_character()
 
1885
                        outstring = '%-8s %s%s' % (fc, fp, kindch)
 
1886
                        if show_ids and fid is not None:
 
1887
                            outstring = "%-50s %s" % (outstring, fid)
 
1888
                        self.outf.write(outstring + '\n')
 
1889
                    elif null:
 
1890
                        self.outf.write(fp + '\0')
 
1891
                        if show_ids:
 
1892
                            if fid is not None:
 
1893
                                self.outf.write(fid)
 
1894
                            self.outf.write('\0')
 
1895
                        self.outf.flush()
 
1896
                    else:
 
1897
                        if fid is not None:
 
1898
                            my_id = fid
 
1899
                        else:
 
1900
                            my_id = ''
 
1901
                        if show_ids:
 
1902
                            self.outf.write('%-50s %s\n' % (fp, my_id))
 
1903
                        else:
 
1904
                            self.outf.write(fp + '\n')
 
1905
        finally:
 
1906
            tree.unlock()
 
1907
 
 
1908
 
 
1909
class cmd_unknowns(Command):
 
1910
    """List unknown files.
 
1911
    """
 
1912
 
 
1913
    hidden = True
 
1914
    _see_also = ['ls']
 
1915
 
 
1916
    @display_command
 
1917
    def run(self):
 
1918
        for f in WorkingTree.open_containing(u'.')[0].unknowns():
 
1919
            self.outf.write(osutils.quotefn(f) + '\n')
 
1920
 
 
1921
 
 
1922
class cmd_ignore(Command):
 
1923
    """Ignore specified files or patterns.
 
1924
 
 
1925
    See ``bzr help patterns`` for details on the syntax of patterns.
 
1926
 
 
1927
    To remove patterns from the ignore list, edit the .bzrignore file.
 
1928
    After adding, editing or deleting that file either indirectly by
 
1929
    using this command or directly by using an editor, be sure to commit
 
1930
    it.
 
1931
 
 
1932
    Note: ignore patterns containing shell wildcards must be quoted from 
 
1933
    the shell on Unix.
 
1934
 
 
1935
    :Examples:
 
1936
        Ignore the top level Makefile::
 
1937
 
 
1938
            bzr ignore ./Makefile
 
1939
 
 
1940
        Ignore class files in all directories::
 
1941
 
 
1942
            bzr ignore "*.class"
 
1943
 
 
1944
        Ignore .o files under the lib directory::
 
1945
 
 
1946
            bzr ignore "lib/**/*.o"
 
1947
 
 
1948
        Ignore .o files under the lib directory::
 
1949
 
 
1950
            bzr ignore "RE:lib/.*\.o"
 
1951
 
 
1952
        Ignore everything but the "debian" toplevel directory::
 
1953
 
 
1954
            bzr ignore "RE:(?!debian/).*"
 
1955
    """
 
1956
 
 
1957
    _see_also = ['status', 'ignored', 'patterns']
 
1958
    takes_args = ['name_pattern*']
 
1959
    takes_options = [
 
1960
        Option('old-default-rules',
 
1961
               help='Write out the ignore rules bzr < 0.9 always used.')
 
1962
        ]
 
1963
    
 
1964
    def run(self, name_pattern_list=None, old_default_rules=None):
 
1965
        from bzrlib import ignores
 
1966
        if old_default_rules is not None:
 
1967
            # dump the rules and exit
 
1968
            for pattern in ignores.OLD_DEFAULTS:
 
1969
                print pattern
 
1970
            return
 
1971
        if not name_pattern_list:
 
1972
            raise errors.BzrCommandError("ignore requires at least one "
 
1973
                                  "NAME_PATTERN or --old-default-rules")
 
1974
        name_pattern_list = [globbing.normalize_pattern(p) 
 
1975
                             for p in name_pattern_list]
 
1976
        for name_pattern in name_pattern_list:
 
1977
            if (name_pattern[0] == '/' or 
 
1978
                (len(name_pattern) > 1 and name_pattern[1] == ':')):
 
1979
                raise errors.BzrCommandError(
 
1980
                    "NAME_PATTERN should not be an absolute path")
 
1981
        tree, relpath = WorkingTree.open_containing(u'.')
 
1982
        ignores.tree_ignores_add_patterns(tree, name_pattern_list)
 
1983
        ignored = globbing.Globster(name_pattern_list)
 
1984
        matches = []
 
1985
        tree.lock_read()
 
1986
        for entry in tree.list_files():
 
1987
            id = entry[3]
 
1988
            if id is not None:
 
1989
                filename = entry[0]
 
1990
                if ignored.match(filename):
 
1991
                    matches.append(filename.encode('utf-8'))
 
1992
        tree.unlock()
 
1993
        if len(matches) > 0:
 
1994
            print "Warning: the following files are version controlled and" \
 
1995
                  " match your ignore pattern:\n%s" % ("\n".join(matches),)
 
1996
 
 
1997
 
 
1998
class cmd_ignored(Command):
 
1999
    """List ignored files and the patterns that matched them.
 
2000
 
 
2001
    List all the ignored files and the ignore pattern that caused the file to
 
2002
    be ignored.
 
2003
 
 
2004
    Alternatively, to list just the files::
 
2005
 
 
2006
        bzr ls --ignored
 
2007
    """
 
2008
 
 
2009
    encoding_type = 'replace'
 
2010
    _see_also = ['ignore', 'ls']
 
2011
 
 
2012
    @display_command
 
2013
    def run(self):
 
2014
        tree = WorkingTree.open_containing(u'.')[0]
 
2015
        tree.lock_read()
 
2016
        try:
 
2017
            for path, file_class, kind, file_id, entry in tree.list_files():
 
2018
                if file_class != 'I':
 
2019
                    continue
 
2020
                ## XXX: Slightly inefficient since this was already calculated
 
2021
                pat = tree.is_ignored(path)
 
2022
                self.outf.write('%-50s %s\n' % (path, pat))
 
2023
        finally:
 
2024
            tree.unlock()
 
2025
 
 
2026
 
 
2027
class cmd_lookup_revision(Command):
 
2028
    """Lookup the revision-id from a revision-number
 
2029
 
 
2030
    :Examples:
 
2031
        bzr lookup-revision 33
 
2032
    """
 
2033
    hidden = True
 
2034
    takes_args = ['revno']
 
2035
    
 
2036
    @display_command
 
2037
    def run(self, revno):
 
2038
        try:
 
2039
            revno = int(revno)
 
2040
        except ValueError:
 
2041
            raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
 
2042
 
 
2043
        print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
 
2044
 
 
2045
 
 
2046
class cmd_export(Command):
 
2047
    """Export current or past revision to a destination directory or archive.
 
2048
 
 
2049
    If no revision is specified this exports the last committed revision.
 
2050
 
 
2051
    Format may be an "exporter" name, such as tar, tgz, tbz2.  If none is
 
2052
    given, try to find the format with the extension. If no extension
 
2053
    is found exports to a directory (equivalent to --format=dir).
 
2054
 
 
2055
    If root is supplied, it will be used as the root directory inside
 
2056
    container formats (tar, zip, etc). If it is not supplied it will default
 
2057
    to the exported filename. The root option has no effect for 'dir' format.
 
2058
 
 
2059
    If branch is omitted then the branch containing the current working
 
2060
    directory will be used.
 
2061
 
 
2062
    Note: Export of tree with non-ASCII filenames to zip is not supported.
 
2063
 
 
2064
      =================       =========================
 
2065
      Supported formats       Autodetected by extension
 
2066
      =================       =========================
 
2067
         dir                         (none)
 
2068
         tar                          .tar
 
2069
         tbz2                    .tar.bz2, .tbz2
 
2070
         tgz                      .tar.gz, .tgz
 
2071
         zip                          .zip
 
2072
      =================       =========================
 
2073
    """
 
2074
    takes_args = ['dest', 'branch_or_subdir?']
 
2075
    takes_options = [
 
2076
        Option('format',
 
2077
               help="Type of file to export to.",
 
2078
               type=unicode),
 
2079
        'revision',
 
2080
        Option('root',
 
2081
               type=str,
 
2082
               help="Name of the root directory inside the exported file."),
 
2083
        ]
 
2084
    def run(self, dest, branch_or_subdir=None, revision=None, format=None,
 
2085
        root=None):
 
2086
        from bzrlib.export import export
 
2087
 
 
2088
        if branch_or_subdir is None:
 
2089
            tree = WorkingTree.open_containing(u'.')[0]
 
2090
            b = tree.branch
 
2091
            subdir = None
 
2092
        else:
 
2093
            b, subdir = Branch.open_containing(branch_or_subdir)
 
2094
            tree = None
 
2095
 
 
2096
        rev_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
 
2097
        try:
 
2098
            export(rev_tree, dest, format, root, subdir)
 
2099
        except errors.NoSuchExportFormat, e:
 
2100
            raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
 
2101
 
 
2102
 
 
2103
class cmd_cat(Command):
 
2104
    """Write the contents of a file as of a given revision to standard output.
 
2105
 
 
2106
    If no revision is nominated, the last revision is used.
 
2107
 
 
2108
    Note: Take care to redirect standard output when using this command on a
 
2109
    binary file. 
 
2110
    """
 
2111
 
 
2112
    _see_also = ['ls']
 
2113
    takes_options = [
 
2114
        Option('name-from-revision', help='The path name in the old tree.'),
 
2115
        'revision',
 
2116
        ]
 
2117
    takes_args = ['filename']
 
2118
    encoding_type = 'exact'
 
2119
 
 
2120
    @display_command
 
2121
    def run(self, filename, revision=None, name_from_revision=False):
 
2122
        if revision is not None and len(revision) != 1:
 
2123
            raise errors.BzrCommandError("bzr cat --revision takes exactly"
 
2124
                                         " one revision specifier")
 
2125
        tree, branch, relpath = \
 
2126
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
 
2127
        branch.lock_read()
 
2128
        try:
 
2129
            return self._run(tree, branch, relpath, filename, revision,
 
2130
                             name_from_revision)
 
2131
        finally:
 
2132
            branch.unlock()
 
2133
 
 
2134
    def _run(self, tree, b, relpath, filename, revision, name_from_revision):
 
2135
        if tree is None:
 
2136
            tree = b.basis_tree()
 
2137
        rev_tree = _get_one_revision_tree('cat', revision, branch=b)
 
2138
 
 
2139
        cur_file_id = tree.path2id(relpath)
 
2140
        old_file_id = rev_tree.path2id(relpath)
 
2141
 
 
2142
        if name_from_revision:
 
2143
            if old_file_id is None:
 
2144
                raise errors.BzrCommandError(
 
2145
                    "%r is not present in revision %s" % (
 
2146
                        filename, rev_tree.get_revision_id()))
 
2147
            else:
 
2148
                content = rev_tree.get_file_text(old_file_id)
 
2149
        elif cur_file_id is not None:
 
2150
            content = rev_tree.get_file_text(cur_file_id)
 
2151
        elif old_file_id is not None:
 
2152
            content = rev_tree.get_file_text(old_file_id)
 
2153
        else:
 
2154
            raise errors.BzrCommandError(
 
2155
                "%r is not present in revision %s" % (
 
2156
                    filename, rev_tree.get_revision_id()))
 
2157
        self.outf.write(content)
 
2158
 
 
2159
 
 
2160
class cmd_local_time_offset(Command):
 
2161
    """Show the offset in seconds from GMT to local time."""
 
2162
    hidden = True    
 
2163
    @display_command
 
2164
    def run(self):
 
2165
        print osutils.local_time_offset()
 
2166
 
 
2167
 
 
2168
 
 
2169
class cmd_commit(Command):
 
2170
    """Commit changes into a new revision.
 
2171
    
 
2172
    If no arguments are given, the entire tree is committed.
 
2173
 
 
2174
    If selected files are specified, only changes to those files are
 
2175
    committed.  If a directory is specified then the directory and everything 
 
2176
    within it is committed.
 
2177
 
 
2178
    When excludes are given, they take precedence over selected files.
 
2179
    For example, too commit only changes within foo, but not changes within
 
2180
    foo/bar::
 
2181
 
 
2182
      bzr commit foo -x foo/bar
 
2183
 
 
2184
    If author of the change is not the same person as the committer, you can
 
2185
    specify the author's name using the --author option. The name should be
 
2186
    in the same format as a committer-id, e.g. "John Doe <jdoe@example.com>".
 
2187
 
 
2188
    A selected-file commit may fail in some cases where the committed
 
2189
    tree would be invalid. Consider::
 
2190
 
 
2191
      bzr init foo
 
2192
      mkdir foo/bar
 
2193
      bzr add foo/bar
 
2194
      bzr commit foo -m "committing foo"
 
2195
      bzr mv foo/bar foo/baz
 
2196
      mkdir foo/bar
 
2197
      bzr add foo/bar
 
2198
      bzr commit foo/bar -m "committing bar but not baz"
 
2199
 
 
2200
    In the example above, the last commit will fail by design. This gives
 
2201
    the user the opportunity to decide whether they want to commit the
 
2202
    rename at the same time, separately first, or not at all. (As a general
 
2203
    rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
 
2204
 
 
2205
    Note: A selected-file commit after a merge is not yet supported.
 
2206
    """
 
2207
    # TODO: Run hooks on tree to-be-committed, and after commit.
 
2208
 
 
2209
    # TODO: Strict commit that fails if there are deleted files.
 
2210
    #       (what does "deleted files" mean ??)
 
2211
 
 
2212
    # TODO: Give better message for -s, --summary, used by tla people
 
2213
 
 
2214
    # XXX: verbose currently does nothing
 
2215
 
 
2216
    _see_also = ['bugs', 'uncommit']
 
2217
    takes_args = ['selected*']
 
2218
    takes_options = [
 
2219
            ListOption('exclude', type=str, short_name='x',
 
2220
                help="Do not consider changes made to a given path."),
 
2221
            Option('message', type=unicode,
 
2222
                   short_name='m',
 
2223
                   help="Description of the new revision."),
 
2224
            'verbose',
 
2225
             Option('unchanged',
 
2226
                    help='Commit even if nothing has changed.'),
 
2227
             Option('file', type=str,
 
2228
                    short_name='F',
 
2229
                    argname='msgfile',
 
2230
                    help='Take commit message from this file.'),
 
2231
             Option('strict',
 
2232
                    help="Refuse to commit if there are unknown "
 
2233
                    "files in the working tree."),
 
2234
             ListOption('fixes', type=str,
 
2235
                    help="Mark a bug as being fixed by this revision."),
 
2236
             Option('author', type=unicode,
 
2237
                    help="Set the author's name, if it's different "
 
2238
                         "from the committer."),
 
2239
             Option('local',
 
2240
                    help="Perform a local commit in a bound "
 
2241
                         "branch.  Local commits are not pushed to "
 
2242
                         "the master branch until a normal commit "
 
2243
                         "is performed."
 
2244
                    ),
 
2245
              Option('show-diff',
 
2246
                     help='When no message is supplied, show the diff along'
 
2247
                     ' with the status summary in the message editor.'),
 
2248
             ]
 
2249
    aliases = ['ci', 'checkin']
 
2250
 
 
2251
    def _get_bug_fix_properties(self, fixes, branch):
 
2252
        properties = []
 
2253
        # Configure the properties for bug fixing attributes.
 
2254
        for fixed_bug in fixes:
 
2255
            tokens = fixed_bug.split(':')
 
2256
            if len(tokens) != 2:
 
2257
                raise errors.BzrCommandError(
 
2258
                    "Invalid bug %s. Must be in the form of 'tag:id'. "
 
2259
                    "Commit refused." % fixed_bug)
 
2260
            tag, bug_id = tokens
 
2261
            try:
 
2262
                bug_url = bugtracker.get_bug_url(tag, branch, bug_id)
 
2263
            except errors.UnknownBugTrackerAbbreviation:
 
2264
                raise errors.BzrCommandError(
 
2265
                    'Unrecognized bug %s. Commit refused.' % fixed_bug)
 
2266
            except errors.MalformedBugIdentifier:
 
2267
                raise errors.BzrCommandError(
 
2268
                    "Invalid bug identifier for %s. Commit refused."
 
2269
                    % fixed_bug)
 
2270
            properties.append('%s fixed' % bug_url)
 
2271
        return '\n'.join(properties)
 
2272
 
 
2273
    def run(self, message=None, file=None, verbose=False, selected_list=None,
 
2274
            unchanged=False, strict=False, local=False, fixes=None,
 
2275
            author=None, show_diff=False, exclude=None):
 
2276
        from bzrlib.errors import (
 
2277
            PointlessCommit,
 
2278
            ConflictsInTree,
 
2279
            StrictCommitFailed
 
2280
        )
 
2281
        from bzrlib.msgeditor import (
 
2282
            edit_commit_message_encoded,
 
2283
            make_commit_message_template_encoded
 
2284
        )
 
2285
 
 
2286
        # TODO: Need a blackbox test for invoking the external editor; may be
 
2287
        # slightly problematic to run this cross-platform.
 
2288
 
 
2289
        # TODO: do more checks that the commit will succeed before 
 
2290
        # spending the user's valuable time typing a commit message.
 
2291
 
 
2292
        properties = {}
 
2293
 
 
2294
        tree, selected_list = tree_files(selected_list)
 
2295
        if selected_list == ['']:
 
2296
            # workaround - commit of root of tree should be exactly the same
 
2297
            # as just default commit in that tree, and succeed even though
 
2298
            # selected-file merge commit is not done yet
 
2299
            selected_list = []
 
2300
 
 
2301
        if fixes is None:
 
2302
            fixes = []
 
2303
        bug_property = self._get_bug_fix_properties(fixes, tree.branch)
 
2304
        if bug_property:
 
2305
            properties['bugs'] = bug_property
 
2306
 
 
2307
        if local and not tree.branch.get_bound_location():
 
2308
            raise errors.LocalRequiresBoundBranch()
 
2309
 
 
2310
        def get_message(commit_obj):
 
2311
            """Callback to get commit message"""
 
2312
            my_message = message
 
2313
            if my_message is None and not file:
 
2314
                t = make_commit_message_template_encoded(tree,
 
2315
                        selected_list, diff=show_diff,
 
2316
                        output_encoding=bzrlib.user_encoding)
 
2317
                my_message = edit_commit_message_encoded(t)
 
2318
                if my_message is None:
 
2319
                    raise errors.BzrCommandError("please specify a commit"
 
2320
                        " message with either --message or --file")
 
2321
            elif my_message and file:
 
2322
                raise errors.BzrCommandError(
 
2323
                    "please specify either --message or --file")
 
2324
            if file:
 
2325
                my_message = codecs.open(file, 'rt',
 
2326
                                         bzrlib.user_encoding).read()
 
2327
            if my_message == "":
 
2328
                raise errors.BzrCommandError("empty commit message specified")
 
2329
            return my_message
 
2330
 
 
2331
        try:
 
2332
            tree.commit(message_callback=get_message,
 
2333
                        specific_files=selected_list,
 
2334
                        allow_pointless=unchanged, strict=strict, local=local,
 
2335
                        reporter=None, verbose=verbose, revprops=properties,
 
2336
                        author=author,
 
2337
                        exclude=safe_relpath_files(tree, exclude))
 
2338
        except PointlessCommit:
 
2339
            # FIXME: This should really happen before the file is read in;
 
2340
            # perhaps prepare the commit; get the message; then actually commit
 
2341
            raise errors.BzrCommandError("no changes to commit."
 
2342
                              " use --unchanged to commit anyhow")
 
2343
        except ConflictsInTree:
 
2344
            raise errors.BzrCommandError('Conflicts detected in working '
 
2345
                'tree.  Use "bzr conflicts" to list, "bzr resolve FILE" to'
 
2346
                ' resolve.')
 
2347
        except StrictCommitFailed:
 
2348
            raise errors.BzrCommandError("Commit refused because there are"
 
2349
                              " unknown files in the working tree.")
 
2350
        except errors.BoundBranchOutOfDate, e:
 
2351
            raise errors.BzrCommandError(str(e) + "\n"
 
2352
            'To commit to master branch, run update and then commit.\n'
 
2353
            'You can also pass --local to commit to continue working '
 
2354
            'disconnected.')
 
2355
 
 
2356
 
 
2357
class cmd_check(Command):
 
2358
    """Validate working tree structure, branch consistency and repository history.
 
2359
 
 
2360
    This command checks various invariants about branch and repository storage
 
2361
    to detect data corruption or bzr bugs.
 
2362
 
 
2363
    The working tree and branch checks will only give output if a problem is
 
2364
    detected. The output fields of the repository check are:
 
2365
 
 
2366
        revisions: This is just the number of revisions checked.  It doesn't
 
2367
            indicate a problem.
 
2368
        versionedfiles: This is just the number of versionedfiles checked.  It
 
2369
            doesn't indicate a problem.
 
2370
        unreferenced ancestors: Texts that are ancestors of other texts, but
 
2371
            are not properly referenced by the revision ancestry.  This is a
 
2372
            subtle problem that Bazaar can work around.
 
2373
        unique file texts: This is the total number of unique file contents
 
2374
            seen in the checked revisions.  It does not indicate a problem.
 
2375
        repeated file texts: This is the total number of repeated texts seen
 
2376
            in the checked revisions.  Texts can be repeated when their file
 
2377
            entries are modified, but the file contents are not.  It does not
 
2378
            indicate a problem.
 
2379
 
 
2380
    If no restrictions are specified, all Bazaar data that is found at the given
 
2381
    location will be checked.
 
2382
 
 
2383
    :Examples:
 
2384
 
 
2385
        Check the tree and branch at 'foo'::
 
2386
 
 
2387
            bzr check --tree --branch foo
 
2388
 
 
2389
        Check only the repository at 'bar'::
 
2390
 
 
2391
            bzr check --repo bar
 
2392
 
 
2393
        Check everything at 'baz'::
 
2394
 
 
2395
            bzr check baz
 
2396
    """
 
2397
 
 
2398
    _see_also = ['reconcile']
 
2399
    takes_args = ['path?']
 
2400
    takes_options = ['verbose',
 
2401
                     Option('branch', help="Check the branch related to the"
 
2402
                                           " current directory."),
 
2403
                     Option('repo', help="Check the repository related to the"
 
2404
                                         " current directory."),
 
2405
                     Option('tree', help="Check the working tree related to"
 
2406
                                         " the current directory.")]
 
2407
 
 
2408
    def run(self, path=None, verbose=False, branch=False, repo=False,
 
2409
            tree=False):
 
2410
        from bzrlib.check import check_dwim
 
2411
        if path is None:
 
2412
            path = '.'
 
2413
        if not branch and not repo and not tree:
 
2414
            branch = repo = tree = True
 
2415
        check_dwim(path, verbose, do_branch=branch, do_repo=repo, do_tree=tree)
 
2416
 
 
2417
 
 
2418
class cmd_upgrade(Command):
 
2419
    """Upgrade branch storage to current format.
 
2420
 
 
2421
    The check command or bzr developers may sometimes advise you to run
 
2422
    this command. When the default format has changed you may also be warned
 
2423
    during other operations to upgrade.
 
2424
    """
 
2425
 
 
2426
    _see_also = ['check']
 
2427
    takes_args = ['url?']
 
2428
    takes_options = [
 
2429
                    RegistryOption('format',
 
2430
                        help='Upgrade to a specific format.  See "bzr help'
 
2431
                             ' formats" for details.',
 
2432
                        registry=bzrdir.format_registry,
 
2433
                        converter=bzrdir.format_registry.make_bzrdir,
 
2434
                        value_switches=True, title='Branch format'),
 
2435
                    ]
 
2436
 
 
2437
    def run(self, url='.', format=None):
 
2438
        from bzrlib.upgrade import upgrade
 
2439
        if format is None:
 
2440
            format = bzrdir.format_registry.make_bzrdir('default')
 
2441
        upgrade(url, format)
 
2442
 
 
2443
 
 
2444
class cmd_whoami(Command):
 
2445
    """Show or set bzr user id.
 
2446
    
 
2447
    :Examples:
 
2448
        Show the email of the current user::
 
2449
 
 
2450
            bzr whoami --email
 
2451
 
 
2452
        Set the current user::
 
2453
 
 
2454
            bzr whoami "Frank Chu <fchu@example.com>"
 
2455
    """
 
2456
    takes_options = [ Option('email',
 
2457
                             help='Display email address only.'),
 
2458
                      Option('branch',
 
2459
                             help='Set identity for the current branch instead of '
 
2460
                                  'globally.'),
 
2461
                    ]
 
2462
    takes_args = ['name?']
 
2463
    encoding_type = 'replace'
 
2464
    
 
2465
    @display_command
 
2466
    def run(self, email=False, branch=False, name=None):
 
2467
        if name is None:
 
2468
            # use branch if we're inside one; otherwise global config
 
2469
            try:
 
2470
                c = Branch.open_containing('.')[0].get_config()
 
2471
            except errors.NotBranchError:
 
2472
                c = config.GlobalConfig()
 
2473
            if email:
 
2474
                self.outf.write(c.user_email() + '\n')
 
2475
            else:
 
2476
                self.outf.write(c.username() + '\n')
 
2477
            return
 
2478
 
 
2479
        # display a warning if an email address isn't included in the given name.
 
2480
        try:
 
2481
            config.extract_email_address(name)
 
2482
        except errors.NoEmailInUsername, e:
 
2483
            warning('"%s" does not seem to contain an email address.  '
 
2484
                    'This is allowed, but not recommended.', name)
 
2485
        
 
2486
        # use global config unless --branch given
 
2487
        if branch:
 
2488
            c = Branch.open_containing('.')[0].get_config()
 
2489
        else:
 
2490
            c = config.GlobalConfig()
 
2491
        c.set_user_option('email', name)
 
2492
 
 
2493
 
 
2494
class cmd_nick(Command):
 
2495
    """Print or set the branch nickname.  
 
2496
 
 
2497
    If unset, the tree root directory name is used as the nickname
 
2498
    To print the current nickname, execute with no argument.  
 
2499
    """
 
2500
 
 
2501
    _see_also = ['info']
 
2502
    takes_args = ['nickname?']
 
2503
    def run(self, nickname=None):
 
2504
        branch = Branch.open_containing(u'.')[0]
 
2505
        if nickname is None:
 
2506
            self.printme(branch)
 
2507
        else:
 
2508
            branch.nick = nickname
 
2509
 
 
2510
    @display_command
 
2511
    def printme(self, branch):
 
2512
        print branch.nick
 
2513
 
 
2514
 
 
2515
class cmd_alias(Command):
 
2516
    """Set/unset and display aliases.
 
2517
 
 
2518
    :Examples:
 
2519
        Show the current aliases::
 
2520
 
 
2521
            bzr alias
 
2522
 
 
2523
        Show the alias specified for 'll'::
 
2524
 
 
2525
            bzr alias ll
 
2526
 
 
2527
        Set an alias for 'll'::
 
2528
 
 
2529
            bzr alias ll="log --line -r-10..-1"
 
2530
 
 
2531
        To remove an alias for 'll'::
 
2532
 
 
2533
            bzr alias --remove ll
 
2534
 
 
2535
    """
 
2536
    takes_args = ['name?']
 
2537
    takes_options = [
 
2538
        Option('remove', help='Remove the alias.'),
 
2539
        ]
 
2540
 
 
2541
    def run(self, name=None, remove=False):
 
2542
        if remove:
 
2543
            self.remove_alias(name)
 
2544
        elif name is None:
 
2545
            self.print_aliases()
 
2546
        else:
 
2547
            equal_pos = name.find('=')
 
2548
            if equal_pos == -1:
 
2549
                self.print_alias(name)
 
2550
            else:
 
2551
                self.set_alias(name[:equal_pos], name[equal_pos+1:])
 
2552
 
 
2553
    def remove_alias(self, alias_name):
 
2554
        if alias_name is None:
 
2555
            raise errors.BzrCommandError(
 
2556
                'bzr alias --remove expects an alias to remove.')
 
2557
        # If alias is not found, print something like:
 
2558
        # unalias: foo: not found
 
2559
        c = config.GlobalConfig()
 
2560
        c.unset_alias(alias_name)
 
2561
 
 
2562
    @display_command
 
2563
    def print_aliases(self):
 
2564
        """Print out the defined aliases in a similar format to bash."""
 
2565
        aliases = config.GlobalConfig().get_aliases()
 
2566
        for key, value in sorted(aliases.iteritems()):
 
2567
            self.outf.write('bzr alias %s="%s"\n' % (key, value))
 
2568
 
 
2569
    @display_command
 
2570
    def print_alias(self, alias_name):
 
2571
        from bzrlib.commands import get_alias
 
2572
        alias = get_alias(alias_name)
 
2573
        if alias is None:
 
2574
            self.outf.write("bzr alias: %s: not found\n" % alias_name)
 
2575
        else:
 
2576
            self.outf.write(
 
2577
                'bzr alias %s="%s"\n' % (alias_name, ' '.join(alias)))
 
2578
 
 
2579
    def set_alias(self, alias_name, alias_command):
 
2580
        """Save the alias in the global config."""
 
2581
        c = config.GlobalConfig()
 
2582
        c.set_alias(alias_name, alias_command)
 
2583
 
 
2584
 
 
2585
class cmd_selftest(Command):
 
2586
    """Run internal test suite.
 
2587
    
 
2588
    If arguments are given, they are regular expressions that say which tests
 
2589
    should run.  Tests matching any expression are run, and other tests are
 
2590
    not run.
 
2591
 
 
2592
    Alternatively if --first is given, matching tests are run first and then
 
2593
    all other tests are run.  This is useful if you have been working in a
 
2594
    particular area, but want to make sure nothing else was broken.
 
2595
 
 
2596
    If --exclude is given, tests that match that regular expression are
 
2597
    excluded, regardless of whether they match --first or not.
 
2598
 
 
2599
    To help catch accidential dependencies between tests, the --randomize
 
2600
    option is useful. In most cases, the argument used is the word 'now'.
 
2601
    Note that the seed used for the random number generator is displayed
 
2602
    when this option is used. The seed can be explicitly passed as the
 
2603
    argument to this option if required. This enables reproduction of the
 
2604
    actual ordering used if and when an order sensitive problem is encountered.
 
2605
 
 
2606
    If --list-only is given, the tests that would be run are listed. This is
 
2607
    useful when combined with --first, --exclude and/or --randomize to
 
2608
    understand their impact. The test harness reports "Listed nn tests in ..."
 
2609
    instead of "Ran nn tests in ..." when list mode is enabled.
 
2610
 
 
2611
    If the global option '--no-plugins' is given, plugins are not loaded
 
2612
    before running the selftests.  This has two effects: features provided or
 
2613
    modified by plugins will not be tested, and tests provided by plugins will
 
2614
    not be run.
 
2615
 
 
2616
    Tests that need working space on disk use a common temporary directory, 
 
2617
    typically inside $TMPDIR or /tmp.
 
2618
 
 
2619
    :Examples:
 
2620
        Run only tests relating to 'ignore'::
 
2621
 
 
2622
            bzr selftest ignore
 
2623
 
 
2624
        Disable plugins and list tests as they're run::
 
2625
 
 
2626
            bzr --no-plugins selftest -v
 
2627
    """
 
2628
    # NB: this is used from the class without creating an instance, which is
 
2629
    # why it does not have a self parameter.
 
2630
    def get_transport_type(typestring):
 
2631
        """Parse and return a transport specifier."""
 
2632
        if typestring == "sftp":
 
2633
            from bzrlib.transport.sftp import SFTPAbsoluteServer
 
2634
            return SFTPAbsoluteServer
 
2635
        if typestring == "memory":
 
2636
            from bzrlib.transport.memory import MemoryServer
 
2637
            return MemoryServer
 
2638
        if typestring == "fakenfs":
 
2639
            from bzrlib.transport.fakenfs import FakeNFSServer
 
2640
            return FakeNFSServer
 
2641
        msg = "No known transport type %s. Supported types are: sftp\n" %\
 
2642
            (typestring)
 
2643
        raise errors.BzrCommandError(msg)
 
2644
 
 
2645
    hidden = True
 
2646
    takes_args = ['testspecs*']
 
2647
    takes_options = ['verbose',
 
2648
                     Option('one',
 
2649
                             help='Stop when one test fails.',
 
2650
                             short_name='1',
 
2651
                             ),
 
2652
                     Option('transport',
 
2653
                            help='Use a different transport by default '
 
2654
                                 'throughout the test suite.',
 
2655
                            type=get_transport_type),
 
2656
                     Option('benchmark',
 
2657
                            help='Run the benchmarks rather than selftests.'),
 
2658
                     Option('lsprof-timed',
 
2659
                            help='Generate lsprof output for benchmarked'
 
2660
                                 ' sections of code.'),
 
2661
                     Option('cache-dir', type=str,
 
2662
                            help='Cache intermediate benchmark output in this '
 
2663
                                 'directory.'),
 
2664
                     Option('first',
 
2665
                            help='Run all tests, but run specified tests first.',
 
2666
                            short_name='f',
 
2667
                            ),
 
2668
                     Option('list-only',
 
2669
                            help='List the tests instead of running them.'),
 
2670
                     Option('randomize', type=str, argname="SEED",
 
2671
                            help='Randomize the order of tests using the given'
 
2672
                                 ' seed or "now" for the current time.'),
 
2673
                     Option('exclude', type=str, argname="PATTERN",
 
2674
                            short_name='x',
 
2675
                            help='Exclude tests that match this regular'
 
2676
                                 ' expression.'),
 
2677
                     Option('strict', help='Fail on missing dependencies or '
 
2678
                            'known failures.'),
 
2679
                     Option('load-list', type=str, argname='TESTLISTFILE',
 
2680
                            help='Load a test id list from a text file.'),
 
2681
                     ListOption('debugflag', type=str, short_name='E',
 
2682
                                help='Turn on a selftest debug flag.'),
 
2683
                     ListOption('starting-with', type=str, argname='TESTID',
 
2684
                                param_name='starting_with', short_name='s',
 
2685
                                help=
 
2686
                                'Load only the tests starting with TESTID.'),
 
2687
                     ]
 
2688
    encoding_type = 'replace'
 
2689
 
 
2690
    def run(self, testspecs_list=None, verbose=False, one=False,
 
2691
            transport=None, benchmark=None,
 
2692
            lsprof_timed=None, cache_dir=None,
 
2693
            first=False, list_only=False,
 
2694
            randomize=None, exclude=None, strict=False,
 
2695
            load_list=None, debugflag=None, starting_with=None):
 
2696
        import bzrlib.ui
 
2697
        from bzrlib.tests import selftest
 
2698
        import bzrlib.benchmarks as benchmarks
 
2699
        from bzrlib.benchmarks import tree_creator
 
2700
 
 
2701
        # Make deprecation warnings visible, unless -Werror is set
 
2702
        symbol_versioning.activate_deprecation_warnings(override=False)
 
2703
 
 
2704
        if cache_dir is not None:
 
2705
            tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
 
2706
        if not list_only:
 
2707
            print 'testing: %s' % (osutils.realpath(sys.argv[0]),)
 
2708
            print '   %s (%s python%s)' % (
 
2709
                    bzrlib.__path__[0],
 
2710
                    bzrlib.version_string,
 
2711
                    bzrlib._format_version_tuple(sys.version_info),
 
2712
                    )
 
2713
        print
 
2714
        if testspecs_list is not None:
 
2715
            pattern = '|'.join(testspecs_list)
 
2716
        else:
 
2717
            pattern = ".*"
 
2718
        if benchmark:
 
2719
            test_suite_factory = benchmarks.test_suite
 
2720
            # Unless user explicitly asks for quiet, be verbose in benchmarks
 
2721
            verbose = not is_quiet()
 
2722
            # TODO: should possibly lock the history file...
 
2723
            benchfile = open(".perf_history", "at", buffering=1)
 
2724
        else:
 
2725
            test_suite_factory = None
 
2726
            benchfile = None
 
2727
        try:
 
2728
            result = selftest(verbose=verbose,
 
2729
                              pattern=pattern,
 
2730
                              stop_on_failure=one,
 
2731
                              transport=transport,
 
2732
                              test_suite_factory=test_suite_factory,
 
2733
                              lsprof_timed=lsprof_timed,
 
2734
                              bench_history=benchfile,
 
2735
                              matching_tests_first=first,
 
2736
                              list_only=list_only,
 
2737
                              random_seed=randomize,
 
2738
                              exclude_pattern=exclude,
 
2739
                              strict=strict,
 
2740
                              load_list=load_list,
 
2741
                              debug_flags=debugflag,
 
2742
                              starting_with=starting_with,
 
2743
                              )
 
2744
        finally:
 
2745
            if benchfile is not None:
 
2746
                benchfile.close()
 
2747
        if result:
 
2748
            note('tests passed')
 
2749
        else:
 
2750
            note('tests failed')
 
2751
        return int(not result)
 
2752
 
 
2753
 
 
2754
class cmd_version(Command):
 
2755
    """Show version of bzr."""
 
2756
 
 
2757
    encoding_type = 'replace'
 
2758
    takes_options = [
 
2759
        Option("short", help="Print just the version number."),
 
2760
        ]
 
2761
 
 
2762
    @display_command
 
2763
    def run(self, short=False):
 
2764
        from bzrlib.version import show_version
 
2765
        if short:
 
2766
            self.outf.write(bzrlib.version_string + '\n')
 
2767
        else:
 
2768
            show_version(to_file=self.outf)
 
2769
 
 
2770
 
 
2771
class cmd_rocks(Command):
 
2772
    """Statement of optimism."""
 
2773
 
 
2774
    hidden = True
 
2775
 
 
2776
    @display_command
 
2777
    def run(self):
 
2778
        print "It sure does!"
 
2779
 
 
2780
 
 
2781
class cmd_find_merge_base(Command):
 
2782
    """Find and print a base revision for merging two branches."""
 
2783
    # TODO: Options to specify revisions on either side, as if
 
2784
    #       merging only part of the history.
 
2785
    takes_args = ['branch', 'other']
 
2786
    hidden = True
 
2787
    
 
2788
    @display_command
 
2789
    def run(self, branch, other):
 
2790
        from bzrlib.revision import ensure_null
 
2791
        
 
2792
        branch1 = Branch.open_containing(branch)[0]
 
2793
        branch2 = Branch.open_containing(other)[0]
 
2794
        branch1.lock_read()
 
2795
        try:
 
2796
            branch2.lock_read()
 
2797
            try:
 
2798
                last1 = ensure_null(branch1.last_revision())
 
2799
                last2 = ensure_null(branch2.last_revision())
 
2800
 
 
2801
                graph = branch1.repository.get_graph(branch2.repository)
 
2802
                base_rev_id = graph.find_unique_lca(last1, last2)
 
2803
 
 
2804
                print 'merge base is revision %s' % base_rev_id
 
2805
            finally:
 
2806
                branch2.unlock()
 
2807
        finally:
 
2808
            branch1.unlock()
 
2809
 
 
2810
 
 
2811
class cmd_merge(Command):
 
2812
    """Perform a three-way merge.
 
2813
    
 
2814
    The source of the merge can be specified either in the form of a branch,
 
2815
    or in the form of a path to a file containing a merge directive generated
 
2816
    with bzr send. If neither is specified, the default is the upstream branch
 
2817
    or the branch most recently merged using --remember.
 
2818
 
 
2819
    When merging a branch, by default the tip will be merged. To pick a different
 
2820
    revision, pass --revision. If you specify two values, the first will be used as
 
2821
    BASE and the second one as OTHER. Merging individual revisions, or a subset of
 
2822
    available revisions, like this is commonly referred to as "cherrypicking".
 
2823
 
 
2824
    Revision numbers are always relative to the branch being merged.
 
2825
 
 
2826
    By default, bzr will try to merge in all new work from the other
 
2827
    branch, automatically determining an appropriate base.  If this
 
2828
    fails, you may need to give an explicit base.
 
2829
    
 
2830
    Merge will do its best to combine the changes in two branches, but there
 
2831
    are some kinds of problems only a human can fix.  When it encounters those,
 
2832
    it will mark a conflict.  A conflict means that you need to fix something,
 
2833
    before you should commit.
 
2834
 
 
2835
    Use bzr resolve when you have fixed a problem.  See also bzr conflicts.
 
2836
 
 
2837
    If there is no default branch set, the first merge will set it. After
 
2838
    that, you can omit the branch to use the default.  To change the
 
2839
    default, use --remember. The value will only be saved if the remote
 
2840
    location can be accessed.
 
2841
 
 
2842
    The results of the merge are placed into the destination working
 
2843
    directory, where they can be reviewed (with bzr diff), tested, and then
 
2844
    committed to record the result of the merge.
 
2845
    
 
2846
    merge refuses to run if there are any uncommitted changes, unless
 
2847
    --force is given.
 
2848
 
 
2849
    :Examples:
 
2850
        To merge the latest revision from bzr.dev::
 
2851
 
 
2852
            bzr merge ../bzr.dev
 
2853
 
 
2854
        To merge changes up to and including revision 82 from bzr.dev::
 
2855
 
 
2856
            bzr merge -r 82 ../bzr.dev
 
2857
 
 
2858
        To merge the changes introduced by 82, without previous changes::
 
2859
 
 
2860
            bzr merge -r 81..82 ../bzr.dev
 
2861
 
 
2862
        To apply a merge directive contained in in /tmp/merge:
 
2863
 
 
2864
            bzr merge /tmp/merge
 
2865
    """
 
2866
 
 
2867
    encoding_type = 'exact'
 
2868
    _see_also = ['update', 'remerge', 'status-flags']
 
2869
    takes_args = ['location?']
 
2870
    takes_options = [
 
2871
        'change',
 
2872
        'revision',
 
2873
        Option('force',
 
2874
               help='Merge even if the destination tree has uncommitted changes.'),
 
2875
        'merge-type',
 
2876
        'reprocess',
 
2877
        'remember',
 
2878
        Option('show-base', help="Show base revision text in "
 
2879
               "conflicts."),
 
2880
        Option('uncommitted', help='Apply uncommitted changes'
 
2881
               ' from a working copy, instead of branch changes.'),
 
2882
        Option('pull', help='If the destination is already'
 
2883
                ' completely merged into the source, pull from the'
 
2884
                ' source rather than merging.  When this happens,'
 
2885
                ' you do not need to commit the result.'),
 
2886
        Option('directory',
 
2887
               help='Branch to merge into, '
 
2888
                    'rather than the one containing the working directory.',
 
2889
               short_name='d',
 
2890
               type=unicode,
 
2891
               ),
 
2892
        Option('preview', help='Instead of merging, show a diff of the merge.')
 
2893
    ]
 
2894
 
 
2895
    def run(self, location=None, revision=None, force=False,
 
2896
            merge_type=None, show_base=False, reprocess=False, remember=False,
 
2897
            uncommitted=False, pull=False,
 
2898
            directory=None,
 
2899
            preview=False,
 
2900
            ):
 
2901
        if merge_type is None:
 
2902
            merge_type = _mod_merge.Merge3Merger
 
2903
 
 
2904
        if directory is None: directory = u'.'
 
2905
        possible_transports = []
 
2906
        merger = None
 
2907
        allow_pending = True
 
2908
        verified = 'inapplicable'
 
2909
        tree = WorkingTree.open_containing(directory)[0]
 
2910
        change_reporter = delta._ChangeReporter(
 
2911
            unversioned_filter=tree.is_ignored)
 
2912
        cleanups = []
 
2913
        try:
 
2914
            pb = ui.ui_factory.nested_progress_bar()
 
2915
            cleanups.append(pb.finished)
 
2916
            tree.lock_write()
 
2917
            cleanups.append(tree.unlock)
 
2918
            if location is not None:
 
2919
                try:
 
2920
                    mergeable = bundle.read_mergeable_from_url(location,
 
2921
                        possible_transports=possible_transports)
 
2922
                except errors.NotABundle:
 
2923
                    mergeable = None
 
2924
                else:
 
2925
                    if uncommitted:
 
2926
                        raise errors.BzrCommandError('Cannot use --uncommitted'
 
2927
                            ' with bundles or merge directives.')
 
2928
 
 
2929
                    if revision is not None:
 
2930
                        raise errors.BzrCommandError(
 
2931
                            'Cannot use -r with merge directives or bundles')
 
2932
                    merger, verified = _mod_merge.Merger.from_mergeable(tree,
 
2933
                       mergeable, pb)
 
2934
 
 
2935
            if merger is None and uncommitted:
 
2936
                if revision is not None and len(revision) > 0:
 
2937
                    raise errors.BzrCommandError('Cannot use --uncommitted and'
 
2938
                        ' --revision at the same time.')
 
2939
                location = self._select_branch_location(tree, location)[0]
 
2940
                other_tree, other_path = WorkingTree.open_containing(location)
 
2941
                merger = _mod_merge.Merger.from_uncommitted(tree, other_tree,
 
2942
                    pb)
 
2943
                allow_pending = False
 
2944
                if other_path != '':
 
2945
                    merger.interesting_files = [other_path]
 
2946
 
 
2947
            if merger is None:
 
2948
                merger, allow_pending = self._get_merger_from_branch(tree,
 
2949
                    location, revision, remember, possible_transports, pb)
 
2950
 
 
2951
            merger.merge_type = merge_type
 
2952
            merger.reprocess = reprocess
 
2953
            merger.show_base = show_base
 
2954
            self.sanity_check_merger(merger)
 
2955
            if (merger.base_rev_id == merger.other_rev_id and
 
2956
                merger.other_rev_id is not None):
 
2957
                note('Nothing to do.')
 
2958
                return 0
 
2959
            if pull:
 
2960
                if merger.interesting_files is not None:
 
2961
                    raise errors.BzrCommandError('Cannot pull individual files')
 
2962
                if (merger.base_rev_id == tree.last_revision()):
 
2963
                    result = tree.pull(merger.other_branch, False,
 
2964
                                       merger.other_rev_id)
 
2965
                    result.report(self.outf)
 
2966
                    return 0
 
2967
            merger.check_basis(not force)
 
2968
            if preview:
 
2969
                return self._do_preview(merger)
 
2970
            else:
 
2971
                return self._do_merge(merger, change_reporter, allow_pending,
 
2972
                                      verified)
 
2973
        finally:
 
2974
            for cleanup in reversed(cleanups):
 
2975
                cleanup()
 
2976
 
 
2977
    def _do_preview(self, merger):
 
2978
        from bzrlib.diff import show_diff_trees
 
2979
        tree_merger = merger.make_merger()
 
2980
        tt = tree_merger.make_preview_transform()
 
2981
        try:
 
2982
            result_tree = tt.get_preview_tree()
 
2983
            show_diff_trees(merger.this_tree, result_tree, self.outf,
 
2984
                            old_label='', new_label='')
 
2985
        finally:
 
2986
            tt.finalize()
 
2987
 
 
2988
    def _do_merge(self, merger, change_reporter, allow_pending, verified):
 
2989
        merger.change_reporter = change_reporter
 
2990
        conflict_count = merger.do_merge()
 
2991
        if allow_pending:
 
2992
            merger.set_pending()
 
2993
        if verified == 'failed':
 
2994
            warning('Preview patch does not match changes')
 
2995
        if conflict_count != 0:
 
2996
            return 1
 
2997
        else:
 
2998
            return 0
 
2999
 
 
3000
    def sanity_check_merger(self, merger):
 
3001
        if (merger.show_base and
 
3002
            not merger.merge_type is _mod_merge.Merge3Merger):
 
3003
            raise errors.BzrCommandError("Show-base is not supported for this"
 
3004
                                         " merge type. %s" % merger.merge_type)
 
3005
        if merger.reprocess and not merger.merge_type.supports_reprocess:
 
3006
            raise errors.BzrCommandError("Conflict reduction is not supported"
 
3007
                                         " for merge type %s." %
 
3008
                                         merger.merge_type)
 
3009
        if merger.reprocess and merger.show_base:
 
3010
            raise errors.BzrCommandError("Cannot do conflict reduction and"
 
3011
                                         " show base.")
 
3012
 
 
3013
    def _get_merger_from_branch(self, tree, location, revision, remember,
 
3014
                                possible_transports, pb):
 
3015
        """Produce a merger from a location, assuming it refers to a branch."""
 
3016
        from bzrlib.tag import _merge_tags_if_possible
 
3017
        # find the branch locations
 
3018
        other_loc, user_location = self._select_branch_location(tree, location,
 
3019
            revision, -1)
 
3020
        if revision is not None and len(revision) == 2:
 
3021
            base_loc, _unused = self._select_branch_location(tree,
 
3022
                location, revision, 0)
 
3023
        else:
 
3024
            base_loc = other_loc
 
3025
        # Open the branches
 
3026
        other_branch, other_path = Branch.open_containing(other_loc,
 
3027
            possible_transports)
 
3028
        if base_loc == other_loc:
 
3029
            base_branch = other_branch
 
3030
        else:
 
3031
            base_branch, base_path = Branch.open_containing(base_loc,
 
3032
                possible_transports)
 
3033
        # Find the revision ids
 
3034
        if revision is None or len(revision) < 1 or revision[-1] is None:
 
3035
            other_revision_id = _mod_revision.ensure_null(
 
3036
                other_branch.last_revision())
 
3037
        else:
 
3038
            other_revision_id = revision[-1].as_revision_id(other_branch)
 
3039
        if (revision is not None and len(revision) == 2
 
3040
            and revision[0] is not None):
 
3041
            base_revision_id = revision[0].as_revision_id(base_branch)
 
3042
        else:
 
3043
            base_revision_id = None
 
3044
        # Remember where we merge from
 
3045
        if ((remember or tree.branch.get_submit_branch() is None) and
 
3046
             user_location is not None):
 
3047
            tree.branch.set_submit_branch(other_branch.base)
 
3048
        _merge_tags_if_possible(other_branch, tree.branch)
 
3049
        merger = _mod_merge.Merger.from_revision_ids(pb, tree,
 
3050
            other_revision_id, base_revision_id, other_branch, base_branch)
 
3051
        if other_path != '':
 
3052
            allow_pending = False
 
3053
            merger.interesting_files = [other_path]
 
3054
        else:
 
3055
            allow_pending = True
 
3056
        return merger, allow_pending
 
3057
 
 
3058
    def _select_branch_location(self, tree, user_location, revision=None,
 
3059
                                index=None):
 
3060
        """Select a branch location, according to possible inputs.
 
3061
 
 
3062
        If provided, branches from ``revision`` are preferred.  (Both
 
3063
        ``revision`` and ``index`` must be supplied.)
 
3064
 
 
3065
        Otherwise, the ``location`` parameter is used.  If it is None, then the
 
3066
        ``submit`` or ``parent`` location is used, and a note is printed.
 
3067
 
 
3068
        :param tree: The working tree to select a branch for merging into
 
3069
        :param location: The location entered by the user
 
3070
        :param revision: The revision parameter to the command
 
3071
        :param index: The index to use for the revision parameter.  Negative
 
3072
            indices are permitted.
 
3073
        :return: (selected_location, user_location).  The default location
 
3074
            will be the user-entered location.
 
3075
        """
 
3076
        if (revision is not None and index is not None
 
3077
            and revision[index] is not None):
 
3078
            branch = revision[index].get_branch()
 
3079
            if branch is not None:
 
3080
                return branch, branch
 
3081
        if user_location is None:
 
3082
            location = self._get_remembered(tree, 'Merging from')
 
3083
        else:
 
3084
            location = user_location
 
3085
        return location, user_location
 
3086
 
 
3087
    def _get_remembered(self, tree, verb_string):
 
3088
        """Use tree.branch's parent if none was supplied.
 
3089
 
 
3090
        Report if the remembered location was used.
 
3091
        """
 
3092
        stored_location = tree.branch.get_submit_branch()
 
3093
        stored_location_type = "submit"
 
3094
        if stored_location is None:
 
3095
            stored_location = tree.branch.get_parent()
 
3096
            stored_location_type = "parent"
 
3097
        mutter("%s", stored_location)
 
3098
        if stored_location is None:
 
3099
            raise errors.BzrCommandError("No location specified or remembered")
 
3100
        display_url = urlutils.unescape_for_display(stored_location, 'utf-8')
 
3101
        note(u"%s remembered %s location %s", verb_string,
 
3102
                stored_location_type, display_url)
 
3103
        return stored_location
 
3104
 
 
3105
 
 
3106
class cmd_remerge(Command):
 
3107
    """Redo a merge.
 
3108
 
 
3109
    Use this if you want to try a different merge technique while resolving
 
3110
    conflicts.  Some merge techniques are better than others, and remerge 
 
3111
    lets you try different ones on different files.
 
3112
 
 
3113
    The options for remerge have the same meaning and defaults as the ones for
 
3114
    merge.  The difference is that remerge can (only) be run when there is a
 
3115
    pending merge, and it lets you specify particular files.
 
3116
 
 
3117
    :Examples:
 
3118
        Re-do the merge of all conflicted files, and show the base text in
 
3119
        conflict regions, in addition to the usual THIS and OTHER texts::
 
3120
      
 
3121
            bzr remerge --show-base
 
3122
 
 
3123
        Re-do the merge of "foobar", using the weave merge algorithm, with
 
3124
        additional processing to reduce the size of conflict regions::
 
3125
      
 
3126
            bzr remerge --merge-type weave --reprocess foobar
 
3127
    """
 
3128
    takes_args = ['file*']
 
3129
    takes_options = [
 
3130
            'merge-type',
 
3131
            'reprocess',
 
3132
            Option('show-base',
 
3133
                   help="Show base revision text in conflicts."),
 
3134
            ]
 
3135
 
 
3136
    def run(self, file_list=None, merge_type=None, show_base=False,
 
3137
            reprocess=False):
 
3138
        if merge_type is None:
 
3139
            merge_type = _mod_merge.Merge3Merger
 
3140
        tree, file_list = tree_files(file_list)
 
3141
        tree.lock_write()
 
3142
        try:
 
3143
            parents = tree.get_parent_ids()
 
3144
            if len(parents) != 2:
 
3145
                raise errors.BzrCommandError("Sorry, remerge only works after normal"
 
3146
                                             " merges.  Not cherrypicking or"
 
3147
                                             " multi-merges.")
 
3148
            repository = tree.branch.repository
 
3149
            interesting_ids = None
 
3150
            new_conflicts = []
 
3151
            conflicts = tree.conflicts()
 
3152
            if file_list is not None:
 
3153
                interesting_ids = set()
 
3154
                for filename in file_list:
 
3155
                    file_id = tree.path2id(filename)
 
3156
                    if file_id is None:
 
3157
                        raise errors.NotVersionedError(filename)
 
3158
                    interesting_ids.add(file_id)
 
3159
                    if tree.kind(file_id) != "directory":
 
3160
                        continue
 
3161
                    
 
3162
                    for name, ie in tree.inventory.iter_entries(file_id):
 
3163
                        interesting_ids.add(ie.file_id)
 
3164
                new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
 
3165
            else:
 
3166
                # Remerge only supports resolving contents conflicts
 
3167
                allowed_conflicts = ('text conflict', 'contents conflict')
 
3168
                restore_files = [c.path for c in conflicts
 
3169
                                 if c.typestring in allowed_conflicts]
 
3170
            _mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
 
3171
            tree.set_conflicts(ConflictList(new_conflicts))
 
3172
            if file_list is not None:
 
3173
                restore_files = file_list
 
3174
            for filename in restore_files:
 
3175
                try:
 
3176
                    restore(tree.abspath(filename))
 
3177
                except errors.NotConflicted:
 
3178
                    pass
 
3179
            # Disable pending merges, because the file texts we are remerging
 
3180
            # have not had those merges performed.  If we use the wrong parents
 
3181
            # list, we imply that the working tree text has seen and rejected
 
3182
            # all the changes from the other tree, when in fact those changes
 
3183
            # have not yet been seen.
 
3184
            pb = ui.ui_factory.nested_progress_bar()
 
3185
            tree.set_parent_ids(parents[:1])
 
3186
            try:
 
3187
                merger = _mod_merge.Merger.from_revision_ids(pb,
 
3188
                                                             tree, parents[1])
 
3189
                merger.interesting_ids = interesting_ids
 
3190
                merger.merge_type = merge_type
 
3191
                merger.show_base = show_base
 
3192
                merger.reprocess = reprocess
 
3193
                conflicts = merger.do_merge()
 
3194
            finally:
 
3195
                tree.set_parent_ids(parents)
 
3196
                pb.finished()
 
3197
        finally:
 
3198
            tree.unlock()
 
3199
        if conflicts > 0:
 
3200
            return 1
 
3201
        else:
 
3202
            return 0
 
3203
 
 
3204
 
 
3205
class cmd_revert(Command):
 
3206
    """Revert files to a previous revision.
 
3207
 
 
3208
    Giving a list of files will revert only those files.  Otherwise, all files
 
3209
    will be reverted.  If the revision is not specified with '--revision', the
 
3210
    last committed revision is used.
 
3211
 
 
3212
    To remove only some changes, without reverting to a prior version, use
 
3213
    merge instead.  For example, "merge . --revision -2..-3" will remove the
 
3214
    changes introduced by -2, without affecting the changes introduced by -1.
 
3215
    Or to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
 
3216
    
 
3217
    By default, any files that have been manually changed will be backed up
 
3218
    first.  (Files changed only by merge are not backed up.)  Backup files have
 
3219
    '.~#~' appended to their name, where # is a number.
 
3220
 
 
3221
    When you provide files, you can use their current pathname or the pathname
 
3222
    from the target revision.  So you can use revert to "undelete" a file by
 
3223
    name.  If you name a directory, all the contents of that directory will be
 
3224
    reverted.
 
3225
 
 
3226
    Any files that have been newly added since that revision will be deleted,
 
3227
    with a backup kept if appropriate.  Directories containing unknown files
 
3228
    will not be deleted.
 
3229
 
 
3230
    The working tree contains a list of pending merged revisions, which will
 
3231
    be included as parents in the next commit.  Normally, revert clears that
 
3232
    list as well as reverting the files.  If any files are specified, revert
 
3233
    leaves the pending merge list alone and reverts only the files.  Use "bzr
 
3234
    revert ." in the tree root to revert all files but keep the merge record,
 
3235
    and "bzr revert --forget-merges" to clear the pending merge list without
 
3236
    reverting any files.
 
3237
    """
 
3238
 
 
3239
    _see_also = ['cat', 'export']
 
3240
    takes_options = [
 
3241
        'revision',
 
3242
        Option('no-backup', "Do not save backups of reverted files."),
 
3243
        Option('forget-merges',
 
3244
               'Remove pending merge marker, without changing any files.'),
 
3245
        ]
 
3246
    takes_args = ['file*']
 
3247
 
 
3248
    def run(self, revision=None, no_backup=False, file_list=None,
 
3249
            forget_merges=None):
 
3250
        tree, file_list = tree_files(file_list)
 
3251
        if forget_merges:
 
3252
            tree.set_parent_ids(tree.get_parent_ids()[:1])
 
3253
        else:
 
3254
            self._revert_tree_to_revision(tree, revision, file_list, no_backup)
 
3255
 
 
3256
    @staticmethod
 
3257
    def _revert_tree_to_revision(tree, revision, file_list, no_backup):
 
3258
        rev_tree = _get_one_revision_tree('revert', revision, tree=tree)
 
3259
        pb = ui.ui_factory.nested_progress_bar()
 
3260
        try:
 
3261
            tree.revert(file_list, rev_tree, not no_backup, pb,
 
3262
                report_changes=True)
 
3263
        finally:
 
3264
            pb.finished()
 
3265
 
 
3266
 
 
3267
class cmd_assert_fail(Command):
 
3268
    """Test reporting of assertion failures"""
 
3269
    # intended just for use in testing
 
3270
 
 
3271
    hidden = True
 
3272
 
 
3273
    def run(self):
 
3274
        raise AssertionError("always fails")
 
3275
 
 
3276
 
 
3277
class cmd_help(Command):
 
3278
    """Show help on a command or other topic.
 
3279
    """
 
3280
 
 
3281
    _see_also = ['topics']
 
3282
    takes_options = [
 
3283
            Option('long', 'Show help on all commands.'),
 
3284
            ]
 
3285
    takes_args = ['topic?']
 
3286
    aliases = ['?', '--help', '-?', '-h']
 
3287
    
 
3288
    @display_command
 
3289
    def run(self, topic=None, long=False):
 
3290
        import bzrlib.help
 
3291
        if topic is None and long:
 
3292
            topic = "commands"
 
3293
        bzrlib.help.help(topic)
 
3294
 
 
3295
 
 
3296
class cmd_shell_complete(Command):
 
3297
    """Show appropriate completions for context.
 
3298
 
 
3299
    For a list of all available commands, say 'bzr shell-complete'.
 
3300
    """
 
3301
    takes_args = ['context?']
 
3302
    aliases = ['s-c']
 
3303
    hidden = True
 
3304
    
 
3305
    @display_command
 
3306
    def run(self, context=None):
 
3307
        import shellcomplete
 
3308
        shellcomplete.shellcomplete(context)
 
3309
 
 
3310
 
 
3311
class cmd_missing(Command):
 
3312
    """Show unmerged/unpulled revisions between two branches.
 
3313
    
 
3314
    OTHER_BRANCH may be local or remote.
 
3315
    """
 
3316
 
 
3317
    _see_also = ['merge', 'pull']
 
3318
    takes_args = ['other_branch?']
 
3319
    takes_options = [
 
3320
            Option('reverse', 'Reverse the order of revisions.'),
 
3321
            Option('mine-only',
 
3322
                   'Display changes in the local branch only.'),
 
3323
            Option('this' , 'Same as --mine-only.'),
 
3324
            Option('theirs-only',
 
3325
                   'Display changes in the remote branch only.'),
 
3326
            Option('other', 'Same as --theirs-only.'),
 
3327
            'log-format',
 
3328
            'show-ids',
 
3329
            'verbose',
 
3330
            Option('include-merges', 'Show merged revisions.'),
 
3331
            ]
 
3332
    encoding_type = 'replace'
 
3333
 
 
3334
    @display_command
 
3335
    def run(self, other_branch=None, reverse=False, mine_only=False,
 
3336
            theirs_only=False,
 
3337
            log_format=None, long=False, short=False, line=False,
 
3338
            show_ids=False, verbose=False, this=False, other=False,
 
3339
            include_merges=False):
 
3340
        from bzrlib.missing import find_unmerged, iter_log_revisions
 
3341
 
 
3342
        if this:
 
3343
            mine_only = this
 
3344
        if other:
 
3345
            theirs_only = other
 
3346
        # TODO: We should probably check that we don't have mine-only and
 
3347
        #       theirs-only set, but it gets complicated because we also have
 
3348
        #       this and other which could be used.
 
3349
        restrict = 'all'
 
3350
        if mine_only:
 
3351
            restrict = 'local'
 
3352
        elif theirs_only:
 
3353
            restrict = 'remote'
 
3354
 
 
3355
        local_branch = Branch.open_containing(u".")[0]
 
3356
        parent = local_branch.get_parent()
 
3357
        if other_branch is None:
 
3358
            other_branch = parent
 
3359
            if other_branch is None:
 
3360
                raise errors.BzrCommandError("No peer location known"
 
3361
                                             " or specified.")
 
3362
            display_url = urlutils.unescape_for_display(parent,
 
3363
                                                        self.outf.encoding)
 
3364
            self.outf.write("Using saved parent location: "
 
3365
                    + display_url + "\n")
 
3366
 
 
3367
        remote_branch = Branch.open(other_branch)
 
3368
        if remote_branch.base == local_branch.base:
 
3369
            remote_branch = local_branch
 
3370
        local_branch.lock_read()
 
3371
        try:
 
3372
            remote_branch.lock_read()
 
3373
            try:
 
3374
                local_extra, remote_extra = find_unmerged(
 
3375
                    local_branch, remote_branch, restrict,
 
3376
                    backward=not reverse,
 
3377
                    include_merges=include_merges)
 
3378
 
 
3379
                if log_format is None:
 
3380
                    registry = log.log_formatter_registry
 
3381
                    log_format = registry.get_default(local_branch)
 
3382
                lf = log_format(to_file=self.outf,
 
3383
                                show_ids=show_ids,
 
3384
                                show_timezone='original')
 
3385
 
 
3386
                status_code = 0
 
3387
                if local_extra and not theirs_only:
 
3388
                    self.outf.write("You have %d extra revision(s):\n" %
 
3389
                                    len(local_extra))
 
3390
                    for revision in iter_log_revisions(local_extra,
 
3391
                                        local_branch.repository,
 
3392
                                        verbose):
 
3393
                        lf.log_revision(revision)
 
3394
                    printed_local = True
 
3395
                    status_code = 1
 
3396
                else:
 
3397
                    printed_local = False
 
3398
 
 
3399
                if remote_extra and not mine_only:
 
3400
                    if printed_local is True:
 
3401
                        self.outf.write("\n\n\n")
 
3402
                    self.outf.write("You are missing %d revision(s):\n" %
 
3403
                                    len(remote_extra))
 
3404
                    for revision in iter_log_revisions(remote_extra,
 
3405
                                        remote_branch.repository,
 
3406
                                        verbose):
 
3407
                        lf.log_revision(revision)
 
3408
                    status_code = 1
 
3409
 
 
3410
                if mine_only and not local_extra:
 
3411
                    # We checked local, and found nothing extra
 
3412
                    self.outf.write('This branch is up to date.\n')
 
3413
                elif theirs_only and not remote_extra:
 
3414
                    # We checked remote, and found nothing extra
 
3415
                    self.outf.write('Other branch is up to date.\n')
 
3416
                elif not (mine_only or theirs_only or local_extra or
 
3417
                          remote_extra):
 
3418
                    # We checked both branches, and neither one had extra
 
3419
                    # revisions
 
3420
                    self.outf.write("Branches are up to date.\n")
 
3421
            finally:
 
3422
                remote_branch.unlock()
 
3423
        finally:
 
3424
            local_branch.unlock()
 
3425
        if not status_code and parent is None and other_branch is not None:
 
3426
            local_branch.lock_write()
 
3427
            try:
 
3428
                # handle race conditions - a parent might be set while we run.
 
3429
                if local_branch.get_parent() is None:
 
3430
                    local_branch.set_parent(remote_branch.base)
 
3431
            finally:
 
3432
                local_branch.unlock()
 
3433
        return status_code
 
3434
 
 
3435
 
 
3436
class cmd_pack(Command):
 
3437
    """Compress the data within a repository."""
 
3438
 
 
3439
    _see_also = ['repositories']
 
3440
    takes_args = ['branch_or_repo?']
 
3441
 
 
3442
    def run(self, branch_or_repo='.'):
 
3443
        dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
 
3444
        try:
 
3445
            branch = dir.open_branch()
 
3446
            repository = branch.repository
 
3447
        except errors.NotBranchError:
 
3448
            repository = dir.open_repository()
 
3449
        repository.pack()
 
3450
 
 
3451
 
 
3452
class cmd_plugins(Command):
 
3453
    """List the installed plugins.
 
3454
    
 
3455
    This command displays the list of installed plugins including
 
3456
    version of plugin and a short description of each.
 
3457
 
 
3458
    --verbose shows the path where each plugin is located.
 
3459
 
 
3460
    A plugin is an external component for Bazaar that extends the
 
3461
    revision control system, by adding or replacing code in Bazaar.
 
3462
    Plugins can do a variety of things, including overriding commands,
 
3463
    adding new commands, providing additional network transports and
 
3464
    customizing log output.
 
3465
 
 
3466
    See the Bazaar web site, http://bazaar-vcs.org, for further
 
3467
    information on plugins including where to find them and how to
 
3468
    install them. Instructions are also provided there on how to
 
3469
    write new plugins using the Python programming language.
 
3470
    """
 
3471
    takes_options = ['verbose']
 
3472
 
 
3473
    @display_command
 
3474
    def run(self, verbose=False):
 
3475
        import bzrlib.plugin
 
3476
        from inspect import getdoc
 
3477
        result = []
 
3478
        for name, plugin in bzrlib.plugin.plugins().items():
 
3479
            version = plugin.__version__
 
3480
            if version == 'unknown':
 
3481
                version = ''
 
3482
            name_ver = '%s %s' % (name, version)
 
3483
            d = getdoc(plugin.module)
 
3484
            if d:
 
3485
                doc = d.split('\n')[0]
 
3486
            else:
 
3487
                doc = '(no description)'
 
3488
            result.append((name_ver, doc, plugin.path()))
 
3489
        for name_ver, doc, path in sorted(result):
 
3490
            print name_ver
 
3491
            print '   ', doc
 
3492
            if verbose:
 
3493
                print '   ', path
 
3494
            print
 
3495
 
 
3496
 
 
3497
class cmd_testament(Command):
 
3498
    """Show testament (signing-form) of a revision."""
 
3499
    takes_options = [
 
3500
            'revision',
 
3501
            Option('long', help='Produce long-format testament.'),
 
3502
            Option('strict',
 
3503
                   help='Produce a strict-format testament.')]
 
3504
    takes_args = ['branch?']
 
3505
    @display_command
 
3506
    def run(self, branch=u'.', revision=None, long=False, strict=False):
 
3507
        from bzrlib.testament import Testament, StrictTestament
 
3508
        if strict is True:
 
3509
            testament_class = StrictTestament
 
3510
        else:
 
3511
            testament_class = Testament
 
3512
        if branch == '.':
 
3513
            b = Branch.open_containing(branch)[0]
 
3514
        else:
 
3515
            b = Branch.open(branch)
 
3516
        b.lock_read()
 
3517
        try:
 
3518
            if revision is None:
 
3519
                rev_id = b.last_revision()
 
3520
            else:
 
3521
                rev_id = revision[0].as_revision_id(b)
 
3522
            t = testament_class.from_revision(b.repository, rev_id)
 
3523
            if long:
 
3524
                sys.stdout.writelines(t.as_text_lines())
 
3525
            else:
 
3526
                sys.stdout.write(t.as_short_text())
 
3527
        finally:
 
3528
            b.unlock()
 
3529
 
 
3530
 
 
3531
class cmd_annotate(Command):
 
3532
    """Show the origin of each line in a file.
 
3533
 
 
3534
    This prints out the given file with an annotation on the left side
 
3535
    indicating which revision, author and date introduced the change.
 
3536
 
 
3537
    If the origin is the same for a run of consecutive lines, it is 
 
3538
    shown only at the top, unless the --all option is given.
 
3539
    """
 
3540
    # TODO: annotate directories; showing when each file was last changed
 
3541
    # TODO: if the working copy is modified, show annotations on that 
 
3542
    #       with new uncommitted lines marked
 
3543
    aliases = ['ann', 'blame', 'praise']
 
3544
    takes_args = ['filename']
 
3545
    takes_options = [Option('all', help='Show annotations on all lines.'),
 
3546
                     Option('long', help='Show commit date in annotations.'),
 
3547
                     'revision',
 
3548
                     'show-ids',
 
3549
                     ]
 
3550
    encoding_type = 'exact'
 
3551
 
 
3552
    @display_command
 
3553
    def run(self, filename, all=False, long=False, revision=None,
 
3554
            show_ids=False):
 
3555
        from bzrlib.annotate import annotate_file, annotate_file_tree
 
3556
        wt, branch, relpath = \
 
3557
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
 
3558
        if wt is not None:
 
3559
            wt.lock_read()
 
3560
        else:
 
3561
            branch.lock_read()
 
3562
        try:
 
3563
            tree = _get_one_revision_tree('annotate', revision, branch=branch)
 
3564
            if wt is not None:
 
3565
                file_id = wt.path2id(relpath)
 
3566
            else:
 
3567
                file_id = tree.path2id(relpath)
 
3568
            if file_id is None:
 
3569
                raise errors.NotVersionedError(filename)
 
3570
            file_version = tree.inventory[file_id].revision
 
3571
            if wt is not None and revision is None:
 
3572
                # If there is a tree and we're not annotating historical
 
3573
                # versions, annotate the working tree's content.
 
3574
                annotate_file_tree(wt, file_id, self.outf, long, all,
 
3575
                    show_ids=show_ids)
 
3576
            else:
 
3577
                annotate_file(branch, file_version, file_id, long, all, self.outf,
 
3578
                              show_ids=show_ids)
 
3579
        finally:
 
3580
            if wt is not None:
 
3581
                wt.unlock()
 
3582
            else:
 
3583
                branch.unlock()
 
3584
 
 
3585
 
 
3586
class cmd_re_sign(Command):
 
3587
    """Create a digital signature for an existing revision."""
 
3588
    # TODO be able to replace existing ones.
 
3589
 
 
3590
    hidden = True # is this right ?
 
3591
    takes_args = ['revision_id*']
 
3592
    takes_options = ['revision']
 
3593
    
 
3594
    def run(self, revision_id_list=None, revision=None):
 
3595
        if revision_id_list is not None and revision is not None:
 
3596
            raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
 
3597
        if revision_id_list is None and revision is None:
 
3598
            raise errors.BzrCommandError('You must supply either --revision or a revision_id')
 
3599
        b = WorkingTree.open_containing(u'.')[0].branch
 
3600
        b.lock_write()
 
3601
        try:
 
3602
            return self._run(b, revision_id_list, revision)
 
3603
        finally:
 
3604
            b.unlock()
 
3605
 
 
3606
    def _run(self, b, revision_id_list, revision):
 
3607
        import bzrlib.gpg as gpg
 
3608
        gpg_strategy = gpg.GPGStrategy(b.get_config())
 
3609
        if revision_id_list is not None:
 
3610
            b.repository.start_write_group()
 
3611
            try:
 
3612
                for revision_id in revision_id_list:
 
3613
                    b.repository.sign_revision(revision_id, gpg_strategy)
 
3614
            except:
 
3615
                b.repository.abort_write_group()
 
3616
                raise
 
3617
            else:
 
3618
                b.repository.commit_write_group()
 
3619
        elif revision is not None:
 
3620
            if len(revision) == 1:
 
3621
                revno, rev_id = revision[0].in_history(b)
 
3622
                b.repository.start_write_group()
 
3623
                try:
 
3624
                    b.repository.sign_revision(rev_id, gpg_strategy)
 
3625
                except:
 
3626
                    b.repository.abort_write_group()
 
3627
                    raise
 
3628
                else:
 
3629
                    b.repository.commit_write_group()
 
3630
            elif len(revision) == 2:
 
3631
                # are they both on rh- if so we can walk between them
 
3632
                # might be nice to have a range helper for arbitrary
 
3633
                # revision paths. hmm.
 
3634
                from_revno, from_revid = revision[0].in_history(b)
 
3635
                to_revno, to_revid = revision[1].in_history(b)
 
3636
                if to_revid is None:
 
3637
                    to_revno = b.revno()
 
3638
                if from_revno is None or to_revno is None:
 
3639
                    raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
 
3640
                b.repository.start_write_group()
 
3641
                try:
 
3642
                    for revno in range(from_revno, to_revno + 1):
 
3643
                        b.repository.sign_revision(b.get_rev_id(revno),
 
3644
                                                   gpg_strategy)
 
3645
                except:
 
3646
                    b.repository.abort_write_group()
 
3647
                    raise
 
3648
                else:
 
3649
                    b.repository.commit_write_group()
 
3650
            else:
 
3651
                raise errors.BzrCommandError('Please supply either one revision, or a range.')
 
3652
 
 
3653
 
 
3654
class cmd_bind(Command):
 
3655
    """Convert the current branch into a checkout of the supplied branch.
 
3656
 
 
3657
    Once converted into a checkout, commits must succeed on the master branch
 
3658
    before they will be applied to the local branch.
 
3659
    """
 
3660
 
 
3661
    _see_also = ['checkouts', 'unbind']
 
3662
    takes_args = ['location?']
 
3663
    takes_options = []
 
3664
 
 
3665
    def run(self, location=None):
 
3666
        b, relpath = Branch.open_containing(u'.')
 
3667
        if location is None:
 
3668
            try:
 
3669
                location = b.get_old_bound_location()
 
3670
            except errors.UpgradeRequired:
 
3671
                raise errors.BzrCommandError('No location supplied.  '
 
3672
                    'This format does not remember old locations.')
 
3673
            else:
 
3674
                if location is None:
 
3675
                    raise errors.BzrCommandError('No location supplied and no '
 
3676
                        'previous location known')
 
3677
        b_other = Branch.open(location)
 
3678
        try:
 
3679
            b.bind(b_other)
 
3680
        except errors.DivergedBranches:
 
3681
            raise errors.BzrCommandError('These branches have diverged.'
 
3682
                                         ' Try merging, and then bind again.')
 
3683
 
 
3684
 
 
3685
class cmd_unbind(Command):
 
3686
    """Convert the current checkout into a regular branch.
 
3687
 
 
3688
    After unbinding, the local branch is considered independent and subsequent
 
3689
    commits will be local only.
 
3690
    """
 
3691
 
 
3692
    _see_also = ['checkouts', 'bind']
 
3693
    takes_args = []
 
3694
    takes_options = []
 
3695
 
 
3696
    def run(self):
 
3697
        b, relpath = Branch.open_containing(u'.')
 
3698
        if not b.unbind():
 
3699
            raise errors.BzrCommandError('Local branch is not bound')
 
3700
 
 
3701
 
 
3702
class cmd_uncommit(Command):
 
3703
    """Remove the last committed revision.
 
3704
 
 
3705
    --verbose will print out what is being removed.
 
3706
    --dry-run will go through all the motions, but not actually
 
3707
    remove anything.
 
3708
 
 
3709
    If --revision is specified, uncommit revisions to leave the branch at the
 
3710
    specified revision.  For example, "bzr uncommit -r 15" will leave the
 
3711
    branch at revision 15.
 
3712
 
 
3713
    Uncommit leaves the working tree ready for a new commit.  The only change
 
3714
    it may make is to restore any pending merges that were present before
 
3715
    the commit.
 
3716
    """
 
3717
 
 
3718
    # TODO: jam 20060108 Add an option to allow uncommit to remove
 
3719
    # unreferenced information in 'branch-as-repository' branches.
 
3720
    # TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
 
3721
    # information in shared branches as well.
 
3722
    _see_also = ['commit']
 
3723
    takes_options = ['verbose', 'revision',
 
3724
                    Option('dry-run', help='Don\'t actually make changes.'),
 
3725
                    Option('force', help='Say yes to all questions.'),
 
3726
                    Option('local',
 
3727
                           help="Only remove the commits from the local branch"
 
3728
                                " when in a checkout."
 
3729
                           ),
 
3730
                    ]
 
3731
    takes_args = ['location?']
 
3732
    aliases = []
 
3733
    encoding_type = 'replace'
 
3734
 
 
3735
    def run(self, location=None,
 
3736
            dry_run=False, verbose=False,
 
3737
            revision=None, force=False, local=False):
 
3738
        if location is None:
 
3739
            location = u'.'
 
3740
        control, relpath = bzrdir.BzrDir.open_containing(location)
 
3741
        try:
 
3742
            tree = control.open_workingtree()
 
3743
            b = tree.branch
 
3744
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
3745
            tree = None
 
3746
            b = control.open_branch()
 
3747
 
 
3748
        if tree is not None:
 
3749
            tree.lock_write()
 
3750
        else:
 
3751
            b.lock_write()
 
3752
        try:
 
3753
            return self._run(b, tree, dry_run, verbose, revision, force,
 
3754
                             local=local)
 
3755
        finally:
 
3756
            if tree is not None:
 
3757
                tree.unlock()
 
3758
            else:
 
3759
                b.unlock()
 
3760
 
 
3761
    def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
 
3762
        from bzrlib.log import log_formatter, show_log
 
3763
        from bzrlib.uncommit import uncommit
 
3764
 
 
3765
        last_revno, last_rev_id = b.last_revision_info()
 
3766
 
 
3767
        rev_id = None
 
3768
        if revision is None:
 
3769
            revno = last_revno
 
3770
            rev_id = last_rev_id
 
3771
        else:
 
3772
            # 'bzr uncommit -r 10' actually means uncommit
 
3773
            # so that the final tree is at revno 10.
 
3774
            # but bzrlib.uncommit.uncommit() actually uncommits
 
3775
            # the revisions that are supplied.
 
3776
            # So we need to offset it by one
 
3777
            revno = revision[0].in_history(b).revno + 1
 
3778
            if revno <= last_revno:
 
3779
                rev_id = b.get_rev_id(revno)
 
3780
 
 
3781
        if rev_id is None or _mod_revision.is_null(rev_id):
 
3782
            self.outf.write('No revisions to uncommit.\n')
 
3783
            return 1
 
3784
 
 
3785
        lf = log_formatter('short',
 
3786
                           to_file=self.outf,
 
3787
                           show_timezone='original')
 
3788
 
 
3789
        show_log(b,
 
3790
                 lf,
 
3791
                 verbose=False,
 
3792
                 direction='forward',
 
3793
                 start_revision=revno,
 
3794
                 end_revision=last_revno)
 
3795
 
 
3796
        if dry_run:
 
3797
            print 'Dry-run, pretending to remove the above revisions.'
 
3798
            if not force:
 
3799
                val = raw_input('Press <enter> to continue')
 
3800
        else:
 
3801
            print 'The above revision(s) will be removed.'
 
3802
            if not force:
 
3803
                val = raw_input('Are you sure [y/N]? ')
 
3804
                if val.lower() not in ('y', 'yes'):
 
3805
                    print 'Canceled'
 
3806
                    return 0
 
3807
 
 
3808
        mutter('Uncommitting from {%s} to {%s}',
 
3809
               last_rev_id, rev_id)
 
3810
        uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
 
3811
                 revno=revno, local=local)
 
3812
        note('You can restore the old tip by running:\n'
 
3813
             '  bzr pull . -r revid:%s', last_rev_id)
 
3814
 
 
3815
 
 
3816
class cmd_break_lock(Command):
 
3817
    """Break a dead lock on a repository, branch or working directory.
 
3818
 
 
3819
    CAUTION: Locks should only be broken when you are sure that the process
 
3820
    holding the lock has been stopped.
 
3821
 
 
3822
    You can get information on what locks are open via the 'bzr info' command.
 
3823
    
 
3824
    :Examples:
 
3825
        bzr break-lock
 
3826
    """
 
3827
    takes_args = ['location?']
 
3828
 
 
3829
    def run(self, location=None, show=False):
 
3830
        if location is None:
 
3831
            location = u'.'
 
3832
        control, relpath = bzrdir.BzrDir.open_containing(location)
 
3833
        try:
 
3834
            control.break_lock()
 
3835
        except NotImplementedError:
 
3836
            pass
 
3837
        
 
3838
 
 
3839
class cmd_wait_until_signalled(Command):
 
3840
    """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
 
3841
 
 
3842
    This just prints a line to signal when it is ready, then blocks on stdin.
 
3843
    """
 
3844
 
 
3845
    hidden = True
 
3846
 
 
3847
    def run(self):
 
3848
        sys.stdout.write("running\n")
 
3849
        sys.stdout.flush()
 
3850
        sys.stdin.readline()
 
3851
 
 
3852
 
 
3853
class cmd_serve(Command):
 
3854
    """Run the bzr server."""
 
3855
 
 
3856
    aliases = ['server']
 
3857
 
 
3858
    takes_options = [
 
3859
        Option('inet',
 
3860
               help='Serve on stdin/out for use from inetd or sshd.'),
 
3861
        Option('port',
 
3862
               help='Listen for connections on nominated port of the form '
 
3863
                    '[hostname:]portnumber.  Passing 0 as the port number will '
 
3864
                    'result in a dynamically allocated port.  The default port is '
 
3865
                    '4155.',
 
3866
               type=str),
 
3867
        Option('directory',
 
3868
               help='Serve contents of this directory.',
 
3869
               type=unicode),
 
3870
        Option('allow-writes',
 
3871
               help='By default the server is a readonly server.  Supplying '
 
3872
                    '--allow-writes enables write access to the contents of '
 
3873
                    'the served directory and below.'
 
3874
                ),
 
3875
        ]
 
3876
 
 
3877
    def run(self, port=None, inet=False, directory=None, allow_writes=False):
 
3878
        from bzrlib import lockdir
 
3879
        from bzrlib.smart import medium, server
 
3880
        from bzrlib.transport import get_transport
 
3881
        from bzrlib.transport.chroot import ChrootServer
 
3882
        if directory is None:
 
3883
            directory = os.getcwd()
 
3884
        url = urlutils.local_path_to_url(directory)
 
3885
        if not allow_writes:
 
3886
            url = 'readonly+' + url
 
3887
        chroot_server = ChrootServer(get_transport(url))
 
3888
        chroot_server.setUp()
 
3889
        t = get_transport(chroot_server.get_url())
 
3890
        if inet:
 
3891
            smart_server = medium.SmartServerPipeStreamMedium(
 
3892
                sys.stdin, sys.stdout, t)
 
3893
        else:
 
3894
            host = medium.BZR_DEFAULT_INTERFACE
 
3895
            if port is None:
 
3896
                port = medium.BZR_DEFAULT_PORT
 
3897
            else:
 
3898
                if ':' in port:
 
3899
                    host, port = port.split(':')
 
3900
                port = int(port)
 
3901
            smart_server = server.SmartTCPServer(t, host=host, port=port)
 
3902
            print 'listening on port: ', smart_server.port
 
3903
            sys.stdout.flush()
 
3904
        # for the duration of this server, no UI output is permitted.
 
3905
        # note that this may cause problems with blackbox tests. This should
 
3906
        # be changed with care though, as we dont want to use bandwidth sending
 
3907
        # progress over stderr to smart server clients!
 
3908
        old_factory = ui.ui_factory
 
3909
        old_lockdir_timeout = lockdir._DEFAULT_TIMEOUT_SECONDS
 
3910
        try:
 
3911
            ui.ui_factory = ui.SilentUIFactory()
 
3912
            lockdir._DEFAULT_TIMEOUT_SECONDS = 0
 
3913
            smart_server.serve()
 
3914
        finally:
 
3915
            ui.ui_factory = old_factory
 
3916
            lockdir._DEFAULT_TIMEOUT_SECONDS = old_lockdir_timeout
 
3917
 
 
3918
 
 
3919
class cmd_join(Command):
 
3920
    """Combine a subtree into its containing tree.
 
3921
    
 
3922
    This command is for experimental use only.  It requires the target tree
 
3923
    to be in dirstate-with-subtree format, which cannot be converted into
 
3924
    earlier formats.
 
3925
 
 
3926
    The TREE argument should be an independent tree, inside another tree, but
 
3927
    not part of it.  (Such trees can be produced by "bzr split", but also by
 
3928
    running "bzr branch" with the target inside a tree.)
 
3929
 
 
3930
    The result is a combined tree, with the subtree no longer an independant
 
3931
    part.  This is marked as a merge of the subtree into the containing tree,
 
3932
    and all history is preserved.
 
3933
 
 
3934
    If --reference is specified, the subtree retains its independence.  It can
 
3935
    be branched by itself, and can be part of multiple projects at the same
 
3936
    time.  But operations performed in the containing tree, such as commit
 
3937
    and merge, will recurse into the subtree.
 
3938
    """
 
3939
 
 
3940
    _see_also = ['split']
 
3941
    takes_args = ['tree']
 
3942
    takes_options = [
 
3943
            Option('reference', help='Join by reference.'),
 
3944
            ]
 
3945
    hidden = True
 
3946
 
 
3947
    def run(self, tree, reference=False):
 
3948
        sub_tree = WorkingTree.open(tree)
 
3949
        parent_dir = osutils.dirname(sub_tree.basedir)
 
3950
        containing_tree = WorkingTree.open_containing(parent_dir)[0]
 
3951
        repo = containing_tree.branch.repository
 
3952
        if not repo.supports_rich_root():
 
3953
            raise errors.BzrCommandError(
 
3954
                "Can't join trees because %s doesn't support rich root data.\n"
 
3955
                "You can use bzr upgrade on the repository."
 
3956
                % (repo,))
 
3957
        if reference:
 
3958
            try:
 
3959
                containing_tree.add_reference(sub_tree)
 
3960
            except errors.BadReferenceTarget, e:
 
3961
                # XXX: Would be better to just raise a nicely printable
 
3962
                # exception from the real origin.  Also below.  mbp 20070306
 
3963
                raise errors.BzrCommandError("Cannot join %s.  %s" %
 
3964
                                             (tree, e.reason))
 
3965
        else:
 
3966
            try:
 
3967
                containing_tree.subsume(sub_tree)
 
3968
            except errors.BadSubsumeSource, e:
 
3969
                raise errors.BzrCommandError("Cannot join %s.  %s" % 
 
3970
                                             (tree, e.reason))
 
3971
 
 
3972
 
 
3973
class cmd_split(Command):
 
3974
    """Split a subdirectory of a tree into a separate tree.
 
3975
 
 
3976
    This command will produce a target tree in a format that supports
 
3977
    rich roots, like 'rich-root' or 'rich-root-pack'.  These formats cannot be
 
3978
    converted into earlier formats like 'dirstate-tags'.
 
3979
 
 
3980
    The TREE argument should be a subdirectory of a working tree.  That
 
3981
    subdirectory will be converted into an independent tree, with its own
 
3982
    branch.  Commits in the top-level tree will not apply to the new subtree.
 
3983
    """
 
3984
 
 
3985
    # join is not un-hidden yet
 
3986
    #_see_also = ['join']
 
3987
    takes_args = ['tree']
 
3988
 
 
3989
    def run(self, tree):
 
3990
        containing_tree, subdir = WorkingTree.open_containing(tree)
 
3991
        sub_id = containing_tree.path2id(subdir)
 
3992
        if sub_id is None:
 
3993
            raise errors.NotVersionedError(subdir)
 
3994
        try:
 
3995
            containing_tree.extract(sub_id)
 
3996
        except errors.RootNotRich:
 
3997
            raise errors.UpgradeRequired(containing_tree.branch.base)
 
3998
 
 
3999
 
 
4000
class cmd_merge_directive(Command):
 
4001
    """Generate a merge directive for auto-merge tools.
 
4002
 
 
4003
    A directive requests a merge to be performed, and also provides all the
 
4004
    information necessary to do so.  This means it must either include a
 
4005
    revision bundle, or the location of a branch containing the desired
 
4006
    revision.
 
4007
 
 
4008
    A submit branch (the location to merge into) must be supplied the first
 
4009
    time the command is issued.  After it has been supplied once, it will
 
4010
    be remembered as the default.
 
4011
 
 
4012
    A public branch is optional if a revision bundle is supplied, but required
 
4013
    if --diff or --plain is specified.  It will be remembered as the default
 
4014
    after the first use.
 
4015
    """
 
4016
 
 
4017
    takes_args = ['submit_branch?', 'public_branch?']
 
4018
 
 
4019
    hidden = True
 
4020
 
 
4021
    _see_also = ['send']
 
4022
 
 
4023
    takes_options = [
 
4024
        RegistryOption.from_kwargs('patch-type',
 
4025
            'The type of patch to include in the directive.',
 
4026
            title='Patch type',
 
4027
            value_switches=True,
 
4028
            enum_switch=False,
 
4029
            bundle='Bazaar revision bundle (default).',
 
4030
            diff='Normal unified diff.',
 
4031
            plain='No patch, just directive.'),
 
4032
        Option('sign', help='GPG-sign the directive.'), 'revision',
 
4033
        Option('mail-to', type=str,
 
4034
            help='Instead of printing the directive, email to this address.'),
 
4035
        Option('message', type=str, short_name='m',
 
4036
            help='Message to use when committing this merge.')
 
4037
        ]
 
4038
 
 
4039
    encoding_type = 'exact'
 
4040
 
 
4041
    def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
 
4042
            sign=False, revision=None, mail_to=None, message=None):
 
4043
        from bzrlib.revision import ensure_null, NULL_REVISION
 
4044
        include_patch, include_bundle = {
 
4045
            'plain': (False, False),
 
4046
            'diff': (True, False),
 
4047
            'bundle': (True, True),
 
4048
            }[patch_type]
 
4049
        branch = Branch.open('.')
 
4050
        stored_submit_branch = branch.get_submit_branch()
 
4051
        if submit_branch is None:
 
4052
            submit_branch = stored_submit_branch
 
4053
        else:
 
4054
            if stored_submit_branch is None:
 
4055
                branch.set_submit_branch(submit_branch)
 
4056
        if submit_branch is None:
 
4057
            submit_branch = branch.get_parent()
 
4058
        if submit_branch is None:
 
4059
            raise errors.BzrCommandError('No submit branch specified or known')
 
4060
 
 
4061
        stored_public_branch = branch.get_public_branch()
 
4062
        if public_branch is None:
 
4063
            public_branch = stored_public_branch
 
4064
        elif stored_public_branch is None:
 
4065
            branch.set_public_branch(public_branch)
 
4066
        if not include_bundle and public_branch is None:
 
4067
            raise errors.BzrCommandError('No public branch specified or'
 
4068
                                         ' known')
 
4069
        base_revision_id = None
 
4070
        if revision is not None:
 
4071
            if len(revision) > 2:
 
4072
                raise errors.BzrCommandError('bzr merge-directive takes '
 
4073
                    'at most two one revision identifiers')
 
4074
            revision_id = revision[-1].as_revision_id(branch)
 
4075
            if len(revision) == 2:
 
4076
                base_revision_id = revision[0].as_revision_id(branch)
 
4077
        else:
 
4078
            revision_id = branch.last_revision()
 
4079
        revision_id = ensure_null(revision_id)
 
4080
        if revision_id == NULL_REVISION:
 
4081
            raise errors.BzrCommandError('No revisions to bundle.')
 
4082
        directive = merge_directive.MergeDirective2.from_objects(
 
4083
            branch.repository, revision_id, time.time(),
 
4084
            osutils.local_time_offset(), submit_branch,
 
4085
            public_branch=public_branch, include_patch=include_patch,
 
4086
            include_bundle=include_bundle, message=message,
 
4087
            base_revision_id=base_revision_id)
 
4088
        if mail_to is None:
 
4089
            if sign:
 
4090
                self.outf.write(directive.to_signed(branch))
 
4091
            else:
 
4092
                self.outf.writelines(directive.to_lines())
 
4093
        else:
 
4094
            message = directive.to_email(mail_to, branch, sign)
 
4095
            s = SMTPConnection(branch.get_config())
 
4096
            s.send_email(message)
 
4097
 
 
4098
 
 
4099
class cmd_send(Command):
 
4100
    """Mail or create a merge-directive for submiting changes.
 
4101
 
 
4102
    A merge directive provides many things needed for requesting merges:
 
4103
 
 
4104
    * A machine-readable description of the merge to perform
 
4105
 
 
4106
    * An optional patch that is a preview of the changes requested
 
4107
 
 
4108
    * An optional bundle of revision data, so that the changes can be applied
 
4109
      directly from the merge directive, without retrieving data from a
 
4110
      branch.
 
4111
 
 
4112
    If --no-bundle is specified, then public_branch is needed (and must be
 
4113
    up-to-date), so that the receiver can perform the merge using the
 
4114
    public_branch.  The public_branch is always included if known, so that
 
4115
    people can check it later.
 
4116
 
 
4117
    The submit branch defaults to the parent, but can be overridden.  Both
 
4118
    submit branch and public branch will be remembered if supplied.
 
4119
 
 
4120
    If a public_branch is known for the submit_branch, that public submit
 
4121
    branch is used in the merge instructions.  This means that a local mirror
 
4122
    can be used as your actual submit branch, once you have set public_branch
 
4123
    for that mirror.
 
4124
 
 
4125
    Mail is sent using your preferred mail program.  This should be transparent
 
4126
    on Windows (it uses MAPI).  On Linux, it requires the xdg-email utility.
 
4127
    If the preferred client can't be found (or used), your editor will be used.
 
4128
    
 
4129
    To use a specific mail program, set the mail_client configuration option.
 
4130
    (For Thunderbird 1.5, this works around some bugs.)  Supported values for
 
4131
    specific clients are "evolution", "kmail", "mutt", and "thunderbird";
 
4132
    generic options are "default", "editor", "emacsclient", "mapi", and
 
4133
    "xdg-email".  Plugins may also add supported clients.
 
4134
 
 
4135
    If mail is being sent, a to address is required.  This can be supplied
 
4136
    either on the commandline, by setting the submit_to configuration
 
4137
    option in the branch itself or the child_submit_to configuration option 
 
4138
    in the submit branch.
 
4139
 
 
4140
    Two formats are currently supported: "4" uses revision bundle format 4 and
 
4141
    merge directive format 2.  It is significantly faster and smaller than
 
4142
    older formats.  It is compatible with Bazaar 0.19 and later.  It is the
 
4143
    default.  "0.9" uses revision bundle format 0.9 and merge directive
 
4144
    format 1.  It is compatible with Bazaar 0.12 - 0.18.
 
4145
    
 
4146
    Merge directives are applied using the merge command or the pull command.
 
4147
    """
 
4148
 
 
4149
    encoding_type = 'exact'
 
4150
 
 
4151
    _see_also = ['merge', 'pull']
 
4152
 
 
4153
    takes_args = ['submit_branch?', 'public_branch?']
 
4154
 
 
4155
    takes_options = [
 
4156
        Option('no-bundle',
 
4157
               help='Do not include a bundle in the merge directive.'),
 
4158
        Option('no-patch', help='Do not include a preview patch in the merge'
 
4159
               ' directive.'),
 
4160
        Option('remember',
 
4161
               help='Remember submit and public branch.'),
 
4162
        Option('from',
 
4163
               help='Branch to generate the submission from, '
 
4164
               'rather than the one containing the working directory.',
 
4165
               short_name='f',
 
4166
               type=unicode),
 
4167
        Option('output', short_name='o',
 
4168
               help='Write merge directive to this file; '
 
4169
                    'use - for stdout.',
 
4170
               type=unicode),
 
4171
        Option('mail-to', help='Mail the request to this address.',
 
4172
               type=unicode),
 
4173
        'revision',
 
4174
        'message',
 
4175
        RegistryOption.from_kwargs('format',
 
4176
        'Use the specified output format.',
 
4177
        **{'4': 'Bundle format 4, Merge Directive 2 (default)',
 
4178
           '0.9': 'Bundle format 0.9, Merge Directive 1',})
 
4179
        ]
 
4180
 
 
4181
    def run(self, submit_branch=None, public_branch=None, no_bundle=False,
 
4182
            no_patch=False, revision=None, remember=False, output=None,
 
4183
            format='4', mail_to=None, message=None, **kwargs):
 
4184
        return self._run(submit_branch, revision, public_branch, remember,
 
4185
                         format, no_bundle, no_patch, output,
 
4186
                         kwargs.get('from', '.'), mail_to, message)
 
4187
 
 
4188
    def _run(self, submit_branch, revision, public_branch, remember, format,
 
4189
             no_bundle, no_patch, output, from_, mail_to, message):
 
4190
        from bzrlib.revision import NULL_REVISION
 
4191
        branch = Branch.open_containing(from_)[0]
 
4192
        if output is None:
 
4193
            outfile = StringIO()
 
4194
        elif output == '-':
 
4195
            outfile = self.outf
 
4196
        else:
 
4197
            outfile = open(output, 'wb')
 
4198
        # we may need to write data into branch's repository to calculate
 
4199
        # the data to send.
 
4200
        branch.lock_write()
 
4201
        try:
 
4202
            if output is None:
 
4203
                config = branch.get_config()
 
4204
                if mail_to is None:
 
4205
                    mail_to = config.get_user_option('submit_to')
 
4206
                mail_client = config.get_mail_client()
 
4207
            if remember and submit_branch is None:
 
4208
                raise errors.BzrCommandError(
 
4209
                    '--remember requires a branch to be specified.')
 
4210
            stored_submit_branch = branch.get_submit_branch()
 
4211
            remembered_submit_branch = None
 
4212
            if submit_branch is None:
 
4213
                submit_branch = stored_submit_branch
 
4214
                remembered_submit_branch = "submit"
 
4215
            else:
 
4216
                if stored_submit_branch is None or remember:
 
4217
                    branch.set_submit_branch(submit_branch)
 
4218
            if submit_branch is None:
 
4219
                submit_branch = branch.get_parent()
 
4220
                remembered_submit_branch = "parent"
 
4221
            if submit_branch is None:
 
4222
                raise errors.BzrCommandError('No submit branch known or'
 
4223
                                             ' specified')
 
4224
            if remembered_submit_branch is not None:
 
4225
                note('Using saved %s location "%s" to determine what '
 
4226
                        'changes to submit.', remembered_submit_branch,
 
4227
                        submit_branch)
 
4228
 
 
4229
            if mail_to is None:
 
4230
                submit_config = Branch.open(submit_branch).get_config()
 
4231
                mail_to = submit_config.get_user_option("child_submit_to")
 
4232
 
 
4233
            stored_public_branch = branch.get_public_branch()
 
4234
            if public_branch is None:
 
4235
                public_branch = stored_public_branch
 
4236
            elif stored_public_branch is None or remember:
 
4237
                branch.set_public_branch(public_branch)
 
4238
            if no_bundle and public_branch is None:
 
4239
                raise errors.BzrCommandError('No public branch specified or'
 
4240
                                             ' known')
 
4241
            base_revision_id = None
 
4242
            revision_id = None
 
4243
            if revision is not None:
 
4244
                if len(revision) > 2:
 
4245
                    raise errors.BzrCommandError('bzr send takes '
 
4246
                        'at most two one revision identifiers')
 
4247
                revision_id = revision[-1].as_revision_id(branch)
 
4248
                if len(revision) == 2:
 
4249
                    base_revision_id = revision[0].as_revision_id(branch)
 
4250
            if revision_id is None:
 
4251
                revision_id = branch.last_revision()
 
4252
            if revision_id == NULL_REVISION:
 
4253
                raise errors.BzrCommandError('No revisions to submit.')
 
4254
            if format == '4':
 
4255
                directive = merge_directive.MergeDirective2.from_objects(
 
4256
                    branch.repository, revision_id, time.time(),
 
4257
                    osutils.local_time_offset(), submit_branch,
 
4258
                    public_branch=public_branch, include_patch=not no_patch,
 
4259
                    include_bundle=not no_bundle, message=message,
 
4260
                    base_revision_id=base_revision_id)
 
4261
            elif format == '0.9':
 
4262
                if not no_bundle:
 
4263
                    if not no_patch:
 
4264
                        patch_type = 'bundle'
 
4265
                    else:
 
4266
                        raise errors.BzrCommandError('Format 0.9 does not'
 
4267
                            ' permit bundle with no patch')
 
4268
                else:
 
4269
                    if not no_patch:
 
4270
                        patch_type = 'diff'
 
4271
                    else:
 
4272
                        patch_type = None
 
4273
                directive = merge_directive.MergeDirective.from_objects(
 
4274
                    branch.repository, revision_id, time.time(),
 
4275
                    osutils.local_time_offset(), submit_branch,
 
4276
                    public_branch=public_branch, patch_type=patch_type,
 
4277
                    message=message)
 
4278
 
 
4279
            outfile.writelines(directive.to_lines())
 
4280
            if output is None:
 
4281
                subject = '[MERGE] '
 
4282
                if message is not None:
 
4283
                    subject += message
 
4284
                else:
 
4285
                    revision = branch.repository.get_revision(revision_id)
 
4286
                    subject += revision.get_summary()
 
4287
                basename = directive.get_disk_name(branch)
 
4288
                mail_client.compose_merge_request(mail_to, subject,
 
4289
                                                  outfile.getvalue(), basename)
 
4290
        finally:
 
4291
            if output != '-':
 
4292
                outfile.close()
 
4293
            branch.unlock()
 
4294
 
 
4295
 
 
4296
class cmd_bundle_revisions(cmd_send):
 
4297
 
 
4298
    """Create a merge-directive for submiting changes.
 
4299
 
 
4300
    A merge directive provides many things needed for requesting merges:
 
4301
 
 
4302
    * A machine-readable description of the merge to perform
 
4303
 
 
4304
    * An optional patch that is a preview of the changes requested
 
4305
 
 
4306
    * An optional bundle of revision data, so that the changes can be applied
 
4307
      directly from the merge directive, without retrieving data from a
 
4308
      branch.
 
4309
 
 
4310
    If --no-bundle is specified, then public_branch is needed (and must be
 
4311
    up-to-date), so that the receiver can perform the merge using the
 
4312
    public_branch.  The public_branch is always included if known, so that
 
4313
    people can check it later.
 
4314
 
 
4315
    The submit branch defaults to the parent, but can be overridden.  Both
 
4316
    submit branch and public branch will be remembered if supplied.
 
4317
 
 
4318
    If a public_branch is known for the submit_branch, that public submit
 
4319
    branch is used in the merge instructions.  This means that a local mirror
 
4320
    can be used as your actual submit branch, once you have set public_branch
 
4321
    for that mirror.
 
4322
 
 
4323
    Two formats are currently supported: "4" uses revision bundle format 4 and
 
4324
    merge directive format 2.  It is significantly faster and smaller than
 
4325
    older formats.  It is compatible with Bazaar 0.19 and later.  It is the
 
4326
    default.  "0.9" uses revision bundle format 0.9 and merge directive
 
4327
    format 1.  It is compatible with Bazaar 0.12 - 0.18.
 
4328
    """
 
4329
 
 
4330
    takes_options = [
 
4331
        Option('no-bundle',
 
4332
               help='Do not include a bundle in the merge directive.'),
 
4333
        Option('no-patch', help='Do not include a preview patch in the merge'
 
4334
               ' directive.'),
 
4335
        Option('remember',
 
4336
               help='Remember submit and public branch.'),
 
4337
        Option('from',
 
4338
               help='Branch to generate the submission from, '
 
4339
               'rather than the one containing the working directory.',
 
4340
               short_name='f',
 
4341
               type=unicode),
 
4342
        Option('output', short_name='o', help='Write directive to this file.',
 
4343
               type=unicode),
 
4344
        'revision',
 
4345
        RegistryOption.from_kwargs('format',
 
4346
        'Use the specified output format.',
 
4347
        **{'4': 'Bundle format 4, Merge Directive 2 (default)',
 
4348
           '0.9': 'Bundle format 0.9, Merge Directive 1',})
 
4349
        ]
 
4350
    aliases = ['bundle']
 
4351
 
 
4352
    _see_also = ['send', 'merge']
 
4353
 
 
4354
    hidden = True
 
4355
 
 
4356
    def run(self, submit_branch=None, public_branch=None, no_bundle=False,
 
4357
            no_patch=False, revision=None, remember=False, output=None,
 
4358
            format='4', **kwargs):
 
4359
        if output is None:
 
4360
            output = '-'
 
4361
        return self._run(submit_branch, revision, public_branch, remember,
 
4362
                         format, no_bundle, no_patch, output,
 
4363
                         kwargs.get('from', '.'), None, None)
 
4364
 
 
4365
 
 
4366
class cmd_tag(Command):
 
4367
    """Create, remove or modify a tag naming a revision.
 
4368
    
 
4369
    Tags give human-meaningful names to revisions.  Commands that take a -r
 
4370
    (--revision) option can be given -rtag:X, where X is any previously
 
4371
    created tag.
 
4372
 
 
4373
    Tags are stored in the branch.  Tags are copied from one branch to another
 
4374
    along when you branch, push, pull or merge.
 
4375
 
 
4376
    It is an error to give a tag name that already exists unless you pass 
 
4377
    --force, in which case the tag is moved to point to the new revision.
 
4378
 
 
4379
    To rename a tag (change the name but keep it on the same revsion), run ``bzr
 
4380
    tag new-name -r tag:old-name`` and then ``bzr tag --delete oldname``.
 
4381
    """
 
4382
 
 
4383
    _see_also = ['commit', 'tags']
 
4384
    takes_args = ['tag_name']
 
4385
    takes_options = [
 
4386
        Option('delete',
 
4387
            help='Delete this tag rather than placing it.',
 
4388
            ),
 
4389
        Option('directory',
 
4390
            help='Branch in which to place the tag.',
 
4391
            short_name='d',
 
4392
            type=unicode,
 
4393
            ),
 
4394
        Option('force',
 
4395
            help='Replace existing tags.',
 
4396
            ),
 
4397
        'revision',
 
4398
        ]
 
4399
 
 
4400
    def run(self, tag_name,
 
4401
            delete=None,
 
4402
            directory='.',
 
4403
            force=None,
 
4404
            revision=None,
 
4405
            ):
 
4406
        branch, relpath = Branch.open_containing(directory)
 
4407
        branch.lock_write()
 
4408
        try:
 
4409
            if delete:
 
4410
                branch.tags.delete_tag(tag_name)
 
4411
                self.outf.write('Deleted tag %s.\n' % tag_name)
 
4412
            else:
 
4413
                if revision:
 
4414
                    if len(revision) != 1:
 
4415
                        raise errors.BzrCommandError(
 
4416
                            "Tags can only be placed on a single revision, "
 
4417
                            "not on a range")
 
4418
                    revision_id = revision[0].as_revision_id(branch)
 
4419
                else:
 
4420
                    revision_id = branch.last_revision()
 
4421
                if (not force) and branch.tags.has_tag(tag_name):
 
4422
                    raise errors.TagAlreadyExists(tag_name)
 
4423
                branch.tags.set_tag(tag_name, revision_id)
 
4424
                self.outf.write('Created tag %s.\n' % tag_name)
 
4425
        finally:
 
4426
            branch.unlock()
 
4427
 
 
4428
 
 
4429
class cmd_tags(Command):
 
4430
    """List tags.
 
4431
 
 
4432
    This command shows a table of tag names and the revisions they reference.
 
4433
    """
 
4434
 
 
4435
    _see_also = ['tag']
 
4436
    takes_options = [
 
4437
        Option('directory',
 
4438
            help='Branch whose tags should be displayed.',
 
4439
            short_name='d',
 
4440
            type=unicode,
 
4441
            ),
 
4442
        RegistryOption.from_kwargs('sort',
 
4443
            'Sort tags by different criteria.', title='Sorting',
 
4444
            alpha='Sort tags lexicographically (default).',
 
4445
            time='Sort tags chronologically.',
 
4446
            ),
 
4447
        'show-ids',
 
4448
    ]
 
4449
 
 
4450
    @display_command
 
4451
    def run(self,
 
4452
            directory='.',
 
4453
            sort='alpha',
 
4454
            show_ids=False,
 
4455
            ):
 
4456
        branch, relpath = Branch.open_containing(directory)
 
4457
        tags = branch.tags.get_tag_dict().items()
 
4458
        if not tags:
 
4459
            return
 
4460
        if sort == 'alpha':
 
4461
            tags.sort()
 
4462
        elif sort == 'time':
 
4463
            timestamps = {}
 
4464
            for tag, revid in tags:
 
4465
                try:
 
4466
                    revobj = branch.repository.get_revision(revid)
 
4467
                except errors.NoSuchRevision:
 
4468
                    timestamp = sys.maxint # place them at the end
 
4469
                else:
 
4470
                    timestamp = revobj.timestamp
 
4471
                timestamps[revid] = timestamp
 
4472
            tags.sort(key=lambda x: timestamps[x[1]])
 
4473
        if not show_ids:
 
4474
            # [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
 
4475
            revno_map = branch.get_revision_id_to_revno_map()
 
4476
            tags = [ (tag, '.'.join(map(str, revno_map.get(revid, ('?',)))))
 
4477
                        for tag, revid in tags ]
 
4478
        for tag, revspec in tags:
 
4479
            self.outf.write('%-20s %s\n' % (tag, revspec))
 
4480
 
 
4481
 
 
4482
class cmd_reconfigure(Command):
 
4483
    """Reconfigure the type of a bzr directory.
 
4484
 
 
4485
    A target configuration must be specified.
 
4486
 
 
4487
    For checkouts, the bind-to location will be auto-detected if not specified.
 
4488
    The order of preference is
 
4489
    1. For a lightweight checkout, the current bound location.
 
4490
    2. For branches that used to be checkouts, the previously-bound location.
 
4491
    3. The push location.
 
4492
    4. The parent location.
 
4493
    If none of these is available, --bind-to must be specified.
 
4494
    """
 
4495
 
 
4496
    _see_also = ['branches', 'checkouts', 'standalone-trees', 'working-trees']
 
4497
    takes_args = ['location?']
 
4498
    takes_options = [RegistryOption.from_kwargs('target_type',
 
4499
                     title='Target type',
 
4500
                     help='The type to reconfigure the directory to.',
 
4501
                     value_switches=True, enum_switch=False,
 
4502
                     branch='Reconfigure to be an unbound branch '
 
4503
                        'with no working tree.',
 
4504
                     tree='Reconfigure to be an unbound branch '
 
4505
                        'with a working tree.',
 
4506
                     checkout='Reconfigure to be a bound branch '
 
4507
                        'with a working tree.',
 
4508
                     lightweight_checkout='Reconfigure to be a lightweight'
 
4509
                     ' checkout (with no local history).',
 
4510
                     standalone='Reconfigure to be a standalone branch '
 
4511
                        '(i.e. stop using shared repository).',
 
4512
                     use_shared='Reconfigure to use a shared repository.'),
 
4513
                     Option('bind-to', help='Branch to bind checkout to.',
 
4514
                            type=str),
 
4515
                     Option('force',
 
4516
                        help='Perform reconfiguration even if local changes'
 
4517
                        ' will be lost.')
 
4518
                     ]
 
4519
 
 
4520
    def run(self, location=None, target_type=None, bind_to=None, force=False):
 
4521
        directory = bzrdir.BzrDir.open(location)
 
4522
        if target_type is None:
 
4523
            raise errors.BzrCommandError('No target configuration specified')
 
4524
        elif target_type == 'branch':
 
4525
            reconfiguration = reconfigure.Reconfigure.to_branch(directory)
 
4526
        elif target_type == 'tree':
 
4527
            reconfiguration = reconfigure.Reconfigure.to_tree(directory)
 
4528
        elif target_type == 'checkout':
 
4529
            reconfiguration = reconfigure.Reconfigure.to_checkout(directory,
 
4530
                                                                  bind_to)
 
4531
        elif target_type == 'lightweight-checkout':
 
4532
            reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
 
4533
                directory, bind_to)
 
4534
        elif target_type == 'use-shared':
 
4535
            reconfiguration = reconfigure.Reconfigure.to_use_shared(directory)
 
4536
        elif target_type == 'standalone':
 
4537
            reconfiguration = reconfigure.Reconfigure.to_standalone(directory)
 
4538
        reconfiguration.apply(force)
 
4539
 
 
4540
 
 
4541
class cmd_switch(Command):
 
4542
    """Set the branch of a checkout and update.
 
4543
    
 
4544
    For lightweight checkouts, this changes the branch being referenced.
 
4545
    For heavyweight checkouts, this checks that there are no local commits
 
4546
    versus the current bound branch, then it makes the local branch a mirror
 
4547
    of the new location and binds to it.
 
4548
    
 
4549
    In both cases, the working tree is updated and uncommitted changes
 
4550
    are merged. The user can commit or revert these as they desire.
 
4551
 
 
4552
    Pending merges need to be committed or reverted before using switch.
 
4553
 
 
4554
    The path to the branch to switch to can be specified relative to the parent
 
4555
    directory of the current branch. For example, if you are currently in a
 
4556
    checkout of /path/to/branch, specifying 'newbranch' will find a branch at
 
4557
    /path/to/newbranch.
 
4558
    """
 
4559
 
 
4560
    takes_args = ['to_location']
 
4561
    takes_options = [Option('force',
 
4562
                        help='Switch even if local commits will be lost.')
 
4563
                     ]
 
4564
 
 
4565
    def run(self, to_location, force=False):
 
4566
        from bzrlib import switch
 
4567
        tree_location = '.'
 
4568
        control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
 
4569
        try:
 
4570
            to_branch = Branch.open(to_location)
 
4571
        except errors.NotBranchError:
 
4572
            this_branch = control_dir.open_branch()
 
4573
            # This may be a heavy checkout, where we want the master branch
 
4574
            this_url = this_branch.get_bound_location()
 
4575
            # If not, use a local sibling
 
4576
            if this_url is None:
 
4577
                this_url = this_branch.base
 
4578
            to_branch = Branch.open(
 
4579
                urlutils.join(this_url, '..', to_location))
 
4580
        switch.switch(control_dir, to_branch, force)
 
4581
        note('Switched to branch: %s',
 
4582
            urlutils.unescape_for_display(to_branch.base, 'utf-8'))
 
4583
 
 
4584
 
 
4585
class cmd_hooks(Command):
 
4586
    """Show a branch's currently registered hooks.
 
4587
    """
 
4588
 
 
4589
    hidden = True
 
4590
    takes_args = ['path?']
 
4591
 
 
4592
    def run(self, path=None):
 
4593
        if path is None:
 
4594
            path = '.'
 
4595
        branch_hooks = Branch.open(path).hooks
 
4596
        for hook_type in branch_hooks:
 
4597
            hooks = branch_hooks[hook_type]
 
4598
            self.outf.write("%s:\n" % (hook_type,))
 
4599
            if hooks:
 
4600
                for hook in hooks:
 
4601
                    self.outf.write("  %s\n" %
 
4602
                                    (branch_hooks.get_hook_name(hook),))
 
4603
            else:
 
4604
                self.outf.write("  <no hooks installed>\n")
 
4605
 
 
4606
 
 
4607
def _create_prefix(cur_transport):
 
4608
    needed = [cur_transport]
 
4609
    # Recurse upwards until we can create a directory successfully
 
4610
    while True:
 
4611
        new_transport = cur_transport.clone('..')
 
4612
        if new_transport.base == cur_transport.base:
 
4613
            raise errors.BzrCommandError(
 
4614
                "Failed to create path prefix for %s."
 
4615
                % cur_transport.base)
 
4616
        try:
 
4617
            new_transport.mkdir('.')
 
4618
        except errors.NoSuchFile:
 
4619
            needed.append(new_transport)
 
4620
            cur_transport = new_transport
 
4621
        else:
 
4622
            break
 
4623
    # Now we only need to create child directories
 
4624
    while needed:
 
4625
        cur_transport = needed.pop()
 
4626
        cur_transport.ensure_base()
 
4627
 
 
4628
 
 
4629
# these get imported and then picked up by the scan for cmd_*
 
4630
# TODO: Some more consistent way to split command definitions across files;
 
4631
# we do need to load at least some information about them to know of 
 
4632
# aliases.  ideally we would avoid loading the implementation until the
 
4633
# details were needed.
 
4634
from bzrlib.cmd_version_info import cmd_version_info
 
4635
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
 
4636
from bzrlib.bundle.commands import (
 
4637
    cmd_bundle_info,
 
4638
    )
 
4639
from bzrlib.sign_my_commits import cmd_sign_my_commits
 
4640
from bzrlib.weave_commands import cmd_versionedfile_list, \
 
4641
        cmd_weave_plan_merge, cmd_weave_merge_text