/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

1st cut merge of bzr.dev r3907

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